@cryptotaxi247 / netdata-1 / commits / cd3c31157

Format ebpf (#19553)

* format_ebpf: Format ebpf.[ch] * format_ebpf: Format ebpf_apps.[ch] * format_ebpf: Format ebpf_cachestat.[ch] * format_ebpf: Format ebpf_cgroup.[ch] * format_ebpf: Format ebpf_dcstat.[ch] * format_ebpf: Format ebpf_disk.[ch] * format_ebpf: Format ebpf_fd.[ch] * format_ebpf: Format ebpf_filesystem.[ch] * format_ebpf: Format ebpf_functions.[ch] * format_ebpf: Format ebpf_hardirq.[ch] * format_ebpf: Format ebpf_mdflush.[c] * format_ebpf: Format ebpf_mount.[ch] * format_ebpf: Format ebpf_oomkill.[c] * format_ebpf: Format ebpf_process.[ch] * format_ebpf: Format ebpf_shm.[ch] * format_ebpf: Format ebpf_socket.[ch] * format_ebpf: Format ebpf_softirq.[c] * format_ebpf: Format ebpf_swap.[ch] * format_ebpf: Format ebpf_sync.[ch] * format_ebpf: Format ebpf_unittest.[ch] * format_ebpf: Format ebpf_vfs.[ch]

thiagoftsm committed Feb 1, 2025 at 15:08 UTC cd3c31157aef543e8266bf66aa5d3951548c770c

39 files changed +7792 -6347

src/collectors/ebpf.plugin/ebpf.c

+1399 -1173

@@ -18,7 +18,7 @@

18 char *ebpf_plugin_dir = PLUGINS_DIR;

19 static char *ebpf_configured_log_dir = LOG_DIR;

21 -char *ebpf_algorithms[] = { EBPF_CHART_ALGORITHM_ABSOLUTE, EBPF_CHART_ALGORITHM_INCREMENTAL};

21 +char *ebpf_algorithms[] = {EBPF_CHART_ALGORITHM_ABSOLUTE, EBPF_CHART_ALGORITHM_INCREMENTAL};

22 struct config collector_config = APPCONFIG_INITIALIZER;

24 int running_on_kernel = 0;

@@ -42,588 +42,757 @@ struct netdata_static_thread cgroup_integration_thread = {

42 .enabled = 1,

43 .thread = NULL,

44 .init_routine = NULL,

45 - .start_routine = NULL

46 -};

45 + .start_routine = NULL};

47 ebpf_module_t ebpf_modules[] = {

49 - { .info = {.thread_name = "process",

50 - .config_name = "process",

51 - .thread_description = NETDATA_EBPF_MODULE_PROCESS_DESC},

52 - .functions = {.start_routine = ebpf_process_thread,

53 - .apps_routine = ebpf_process_create_apps_charts,

54 - .fnct_routine = NULL},

55 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

56 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

57 - .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

58 - .maps = NULL, .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &process_config,

59 - .config_file = NETDATA_PROCESS_CONFIG_FILE,

61 - NETDATA_V5_14,

62 - .load = EBPF_LOAD_LEGACY, .targets = NULL, .probe_links = NULL, .objects = NULL,

63 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0 },

64 - { .info = {.thread_name = "socket",

65 - .config_name = "socket",

66 - .thread_description = NETDATA_EBPF_SOCKET_MODULE_DESC},

67 - .functions = {.start_routine = ebpf_socket_thread,

68 - .apps_routine = ebpf_socket_create_apps_charts,

69 - .fnct_routine = ebpf_socket_read_open_connections,

70 - .fcnt_name = EBPF_FUNCTION_SOCKET,

71 - .fcnt_desc = EBPF_PLUGIN_SOCKET_FUNCTION_DESCRIPTION,

72 - .fcnt_thread_chart_name = NULL,

73 - .fcnt_thread_lifetime_name = NULL},

74 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

75 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

76 - .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

77 - .maps = NULL,

78 - .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &socket_config,

79 - .config_file = NETDATA_NETWORK_CONFIG_FILE,

81 - .load = EBPF_LOAD_LEGACY, .targets = socket_targets, .probe_links = NULL, .objects = NULL,

82 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

83 - { .info = {.thread_name = "cachestat", .config_name = "cachestat", .thread_description = NETDATA_EBPF_CACHESTAT_MODULE_DESC},

84 - .functions = {.start_routine = ebpf_cachestat_thread,

85 - .apps_routine = ebpf_cachestat_create_apps_charts,

86 - .fnct_routine = NULL},

87 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

88 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

89 - .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

90 - .maps = cachestat_maps, .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &cachestat_config,

91 - .config_file = NETDATA_CACHESTAT_CONFIG_FILE,

92 - .kernels = NETDATA_V3_10 | NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18|

93 - NETDATA_V5_4 | NETDATA_V5_14 | NETDATA_V5_15 | NETDATA_V5_16,

94 - .load = EBPF_LOAD_LEGACY, .targets = cachestat_targets, .probe_links = NULL, .objects = NULL,

95 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

96 - { .info = {.thread_name = "sync",

97 - .config_name = "sync",

98 - .thread_description = NETDATA_EBPF_SYNC_MODULE_DESC},

99 - .functions = {.start_routine = ebpf_sync_thread,

100 - .apps_routine = NULL,

101 - .fnct_routine = NULL},

102 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING, .maps = NULL,

103 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

104 - .apps_level = NETDATA_APPS_NOT_SET, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

105 - .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &sync_config,

106 - .config_file = NETDATA_SYNC_CONFIG_FILE,

107 - // All syscalls have the same kernels

109 - .load = EBPF_LOAD_LEGACY, .targets = sync_targets, .probe_links = NULL, .objects = NULL,

110 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

111 - { .info = {.thread_name = "dc",

112 - .config_name = "dc",

113 - .thread_description = NETDATA_EBPF_DC_MODULE_DESC},

114 - .functions = {.start_routine = ebpf_dcstat_thread,

115 - .apps_routine = ebpf_dcstat_create_apps_charts,

116 - .fnct_routine = NULL},

117 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

118 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

119 - .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

120 - .maps = dcstat_maps,

121 - .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &dcstat_config,

122 - .config_file = NETDATA_DIRECTORY_DCSTAT_CONFIG_FILE,

124 - .load = EBPF_LOAD_LEGACY, .targets = dc_targets, .probe_links = NULL, .objects = NULL,

125 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

126 - { .info = {.thread_name = "swap", .config_name = "swap", .thread_description = NETDATA_EBPF_SWAP_MODULE_DESC},

127 - .functions = {.start_routine = ebpf_swap_thread,

128 - .apps_routine = ebpf_swap_create_apps_charts,

129 - .fnct_routine = NULL},

130 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

131 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

132 - .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

133 - .maps = NULL,

134 - .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &swap_config,

135 - .config_file = NETDATA_DIRECTORY_SWAP_CONFIG_FILE,

137 - .load = EBPF_LOAD_LEGACY, .targets = swap_targets, .probe_links = NULL, .objects = NULL,

138 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

139 - { .info = {.thread_name = "vfs",

140 - .config_name = "vfs",

141 - .thread_description = NETDATA_EBPF_VFS_MODULE_DESC},

142 - .functions = {.start_routine = ebpf_vfs_thread,

143 - .apps_routine = ebpf_vfs_create_apps_charts,

144 - .fnct_routine = NULL},

145 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

146 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

147 - .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

148 - .maps = NULL,

149 - .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &vfs_config,

150 - .config_file = NETDATA_DIRECTORY_VFS_CONFIG_FILE,

152 - .load = EBPF_LOAD_LEGACY, .targets = vfs_targets, .probe_links = NULL, .objects = NULL,

153 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

154 - { .info = {.thread_name = "filesystem", .config_name = "filesystem", .thread_description = NETDATA_EBPF_FS_MODULE_DESC},

155 - .functions = {.start_routine = ebpf_filesystem_thread,

156 - .apps_routine = NULL,

157 - .fnct_routine = NULL},

158 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

159 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

160 - .apps_level = NETDATA_APPS_NOT_SET, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

161 - .maps = NULL, .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &fs_config,

162 - .config_file = NETDATA_FILESYSTEM_CONFIG_FILE,

163 - //We are setting kernels as zero, because we load eBPF programs according the kernel running.

164 - .kernels = 0, .load = EBPF_LOAD_LEGACY, .targets = NULL, .probe_links = NULL, .objects = NULL,

165 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

166 - { .info = {.thread_name = "disk",

167 - .config_name = "disk",

168 - .thread_description = NETDATA_EBPF_DISK_MODULE_DESC},

169 - .functions = {.start_routine = ebpf_disk_thread,

170 - .apps_routine = NULL,

171 - .fnct_routine = NULL},

172 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

173 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

174 - .apps_level = NETDATA_APPS_NOT_SET, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

175 - .maps = NULL, .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &disk_config,

176 - .config_file = NETDATA_DISK_CONFIG_FILE,

178 - .load = EBPF_LOAD_LEGACY, .targets = NULL, .probe_links = NULL, .objects = NULL,

179 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

180 - { .info = {.thread_name = "mount",

181 - .config_name = "mount",

182 - .thread_description = NETDATA_EBPF_MOUNT_MODULE_DESC},

183 - .functions = {.start_routine = ebpf_mount_thread,

184 - .apps_routine = NULL,

185 - .fnct_routine = NULL},

186 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

187 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

188 - .apps_level = NETDATA_APPS_NOT_SET, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

189 - .maps = NULL, .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &mount_config,

190 - .config_file = NETDATA_MOUNT_CONFIG_FILE,

192 - .load = EBPF_LOAD_LEGACY, .targets = mount_targets, .probe_links = NULL, .objects = NULL,

193 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

194 - { .info = { .thread_name = "fd",

195 - .config_name = "fd",

196 - .thread_description = NETDATA_EBPF_FD_MODULE_DESC},

197 - .functions = {.start_routine = ebpf_fd_thread,

198 - .apps_routine = ebpf_fd_create_apps_charts,

199 - .fnct_routine = NULL},

200 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

201 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

202 - .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

203 - .maps = NULL,

204 - .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &fd_config,

205 - .config_file = NETDATA_FD_CONFIG_FILE,

207 - NETDATA_V5_14,

208 - .load = EBPF_LOAD_LEGACY, .targets = fd_targets, .probe_links = NULL, .objects = NULL,

209 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

210 - { .info = { .thread_name = "hardirq",

211 - .config_name = "hardirq",

212 - .thread_description = NETDATA_EBPF_HARDIRQ_MODULE_DESC},

213 - .functions = {.start_routine = ebpf_hardirq_thread,

214 - .apps_routine = NULL,

215 - .fnct_routine = NULL},

216 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

217 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

218 - .apps_level = NETDATA_APPS_NOT_SET, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

219 - .maps = NULL, .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &hardirq_config,

220 - .config_file = NETDATA_HARDIRQ_CONFIG_FILE,

222 - .load = EBPF_LOAD_LEGACY, .targets = NULL, .probe_links = NULL, .objects = NULL,

223 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

224 - { .info = { .thread_name = "softirq",

225 - .config_name = "softirq",

226 - .thread_description = NETDATA_EBPF_SOFTIRQ_MODULE_DESC},

227 - .functions = {.start_routine = ebpf_softirq_thread,

228 - .apps_routine = NULL,

229 - .fnct_routine = NULL },

230 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

231 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

232 - .apps_level = NETDATA_APPS_NOT_SET, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

233 - .maps = NULL, .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &softirq_config,

234 - .config_file = NETDATA_SOFTIRQ_CONFIG_FILE,

236 - .load = EBPF_LOAD_LEGACY, .targets = NULL, .probe_links = NULL, .objects = NULL,

237 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

238 - { .info = {.thread_name = "oomkill",

239 - .config_name = "oomkill",

240 - .thread_description = NETDATA_EBPF_OOMKILL_MODULE_DESC},

241 - .functions = {.start_routine = ebpf_oomkill_thread,

242 - .apps_routine = ebpf_oomkill_create_apps_charts,

243 - .fnct_routine = NULL},.enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

244 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

245 - .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

246 - .maps = NULL,

247 - .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &oomkill_config,

248 - .config_file = NETDATA_OOMKILL_CONFIG_FILE,

249 - .kernels = NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4 | NETDATA_V5_14,

250 - .load = EBPF_LOAD_LEGACY, .targets = NULL, .probe_links = NULL, .objects = NULL,

251 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

252 - { .info = {.thread_name = "shm",

253 - .config_name = "shm",

254 - .thread_description = NETDATA_EBPF_SHM_MODULE_DESC},

255 - .functions = {.start_routine = ebpf_shm_thread,

256 - .apps_routine = ebpf_shm_create_apps_charts,

257 - .fnct_routine = NULL},

258 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

259 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

260 - .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

261 - .maps = NULL,

262 - .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &shm_config,

263 - .config_file = NETDATA_DIRECTORY_SHM_CONFIG_FILE,

265 - .load = EBPF_LOAD_LEGACY, .targets = shm_targets, .probe_links = NULL, .objects = NULL,

266 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

267 - { .info = { .thread_name = "mdflush",

268 - .config_name = "mdflush",

269 - .thread_description = NETDATA_EBPF_MD_MODULE_DESC},

270 - .functions = {.start_routine = ebpf_mdflush_thread,

271 - .apps_routine = NULL,

272 - .fnct_routine = NULL},

273 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

274 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

275 - .apps_level = NETDATA_APPS_NOT_SET, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

276 - .maps = NULL, .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = &mdflush_config,

277 - .config_file = NETDATA_DIRECTORY_MDFLUSH_CONFIG_FILE,

279 - .load = EBPF_LOAD_LEGACY, .targets = mdflush_targets, .probe_links = NULL, .objects = NULL,

280 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

281 - { .info = { .thread_name = "functions",

282 - .config_name = "functions",

283 - .thread_description = NETDATA_EBPF_FUNCTIONS_MODULE_DESC},

284 - .functions = {.start_routine = ebpf_function_thread,

285 - .apps_routine = NULL,

286 - .fnct_routine = NULL},

287 - .enabled = NETDATA_THREAD_EBPF_RUNNING,

288 - .update_every = EBPF_DEFAULT_UPDATE_EVERY, .global_charts = 1, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

289 - .apps_level = NETDATA_APPS_NOT_SET, .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0,

290 - .maps = NULL, .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL, .cfg = NULL,

291 - .config_file = NETDATA_DIRECTORY_FUNCTIONS_CONFIG_FILE,

293 - .load = EBPF_LOAD_LEGACY, .targets = NULL, .probe_links = NULL, .objects = NULL,

294 - .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES, .lifetime = EBPF_DEFAULT_LIFETIME, .running_time = 0},

295 - { .info = {.thread_name = NULL, .config_name = NULL},

296 - .functions = {.start_routine = NULL, .apps_routine = NULL, .fnct_routine = NULL},

297 - .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING, .update_every = EBPF_DEFAULT_UPDATE_EVERY,

298 - .global_charts = 0, .apps_charts = NETDATA_EBPF_APPS_FLAG_NO, .apps_level = NETDATA_APPS_NOT_SET,

299 - .cgroup_charts = CONFIG_BOOLEAN_NO, .mode = MODE_ENTRY, .optional = 0, .maps = NULL,

300 - .pid_map_size = 0, .names = NULL, .cfg = NULL, .kernels = 0, .load = EBPF_LOAD_LEGACY,

301 - .targets = NULL, .probe_links = NULL, .objects = NULL, .thread = NULL, .maps_per_core = CONFIG_BOOLEAN_YES},

48 + {.info =

49 + {.thread_name = "process", .config_name = "process", .thread_description = NETDATA_EBPF_MODULE_PROCESS_DESC},

50 + .functions =

51 + {.start_routine = ebpf_process_thread, .apps_routine = ebpf_process_create_apps_charts, .fnct_routine = NULL},

52 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

53 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

54 + .global_charts = 1,

55 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

56 + .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT,

57 + .cgroup_charts = CONFIG_BOOLEAN_NO,

58 + .mode = MODE_ENTRY,

59 + .optional = 0,

60 + .maps = NULL,

61 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

62 + .names = NULL,

63 + .cfg = &process_config,

64 + .config_file = NETDATA_PROCESS_CONFIG_FILE,

65 + .kernels =

67 + .load = EBPF_LOAD_LEGACY,

68 + .targets = NULL,

69 + .probe_links = NULL,

70 + .objects = NULL,

71 + .thread = NULL,

72 + .maps_per_core = CONFIG_BOOLEAN_YES,

73 + .lifetime = EBPF_DEFAULT_LIFETIME,

74 + .running_time = 0},

75 + {.info = {.thread_name = "socket", .config_name = "socket", .thread_description = NETDATA_EBPF_SOCKET_MODULE_DESC},

76 + .functions =

77 + {.start_routine = ebpf_socket_thread,

78 + .apps_routine = ebpf_socket_create_apps_charts,

79 + .fnct_routine = ebpf_socket_read_open_connections,

80 + .fcnt_name = EBPF_FUNCTION_SOCKET,

81 + .fcnt_desc = EBPF_PLUGIN_SOCKET_FUNCTION_DESCRIPTION,

82 + .fcnt_thread_chart_name = NULL,

83 + .fcnt_thread_lifetime_name = NULL},

84 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

85 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

86 + .global_charts = 1,

87 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

88 + .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT,

89 + .cgroup_charts = CONFIG_BOOLEAN_NO,

90 + .mode = MODE_ENTRY,

91 + .optional = 0,

92 + .maps = NULL,

93 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

94 + .names = NULL,

95 + .cfg = &socket_config,

96 + .config_file = NETDATA_NETWORK_CONFIG_FILE,

98 + .load = EBPF_LOAD_LEGACY,

99 + .targets = socket_targets,

100 + .probe_links = NULL,

101 + .objects = NULL,

102 + .thread = NULL,

103 + .maps_per_core = CONFIG_BOOLEAN_YES,

104 + .lifetime = EBPF_DEFAULT_LIFETIME,

105 + .running_time = 0},

106 + {.info =

107 + {.thread_name = "cachestat",

108 + .config_name = "cachestat",

109 + .thread_description = NETDATA_EBPF_CACHESTAT_MODULE_DESC},

110 + .functions =

111 + {.start_routine = ebpf_cachestat_thread,

112 + .apps_routine = ebpf_cachestat_create_apps_charts,

113 + .fnct_routine = NULL},

114 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

115 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

116 + .global_charts = 1,

117 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

118 + .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT,

119 + .cgroup_charts = CONFIG_BOOLEAN_NO,

120 + .mode = MODE_ENTRY,

121 + .optional = 0,

122 + .maps = cachestat_maps,

123 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

124 + .names = NULL,

125 + .cfg = &cachestat_config,

126 + .config_file = NETDATA_CACHESTAT_CONFIG_FILE,

128 + NETDATA_V5_15 | NETDATA_V5_16,

129 + .load = EBPF_LOAD_LEGACY,

130 + .targets = cachestat_targets,

131 + .probe_links = NULL,

132 + .objects = NULL,

133 + .thread = NULL,

134 + .maps_per_core = CONFIG_BOOLEAN_YES,

135 + .lifetime = EBPF_DEFAULT_LIFETIME,

136 + .running_time = 0},

137 + {.info = {.thread_name = "sync", .config_name = "sync", .thread_description = NETDATA_EBPF_SYNC_MODULE_DESC},

138 + .functions = {.start_routine = ebpf_sync_thread, .apps_routine = NULL, .fnct_routine = NULL},

139 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

140 + .maps = NULL,

141 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

142 + .global_charts = 1,

143 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

144 + .apps_level = NETDATA_APPS_NOT_SET,

145 + .cgroup_charts = CONFIG_BOOLEAN_NO,

146 + .mode = MODE_ENTRY,

147 + .optional = 0,

148 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

149 + .names = NULL,

150 + .cfg = &sync_config,

151 + .config_file = NETDATA_SYNC_CONFIG_FILE,

152 + // All syscalls have the same kernels

154 + .load = EBPF_LOAD_LEGACY,

155 + .targets = sync_targets,

156 + .probe_links = NULL,

157 + .objects = NULL,

158 + .thread = NULL,

159 + .maps_per_core = CONFIG_BOOLEAN_YES,

160 + .lifetime = EBPF_DEFAULT_LIFETIME,

161 + .running_time = 0},

162 + {.info = {.thread_name = "dc", .config_name = "dc", .thread_description = NETDATA_EBPF_DC_MODULE_DESC},

163 + .functions =

164 + {.start_routine = ebpf_dcstat_thread, .apps_routine = ebpf_dcstat_create_apps_charts, .fnct_routine = NULL},

165 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

166 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

167 + .global_charts = 1,

168 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

169 + .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT,

170 + .cgroup_charts = CONFIG_BOOLEAN_NO,

171 + .mode = MODE_ENTRY,

172 + .optional = 0,

173 + .maps = dcstat_maps,

174 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

175 + .names = NULL,

176 + .cfg = &dcstat_config,

177 + .config_file = NETDATA_DIRECTORY_DCSTAT_CONFIG_FILE,

179 + .load = EBPF_LOAD_LEGACY,

180 + .targets = dc_targets,

181 + .probe_links = NULL,

182 + .objects = NULL,

183 + .thread = NULL,

184 + .maps_per_core = CONFIG_BOOLEAN_YES,

185 + .lifetime = EBPF_DEFAULT_LIFETIME,

186 + .running_time = 0},

187 + {.info = {.thread_name = "swap", .config_name = "swap", .thread_description = NETDATA_EBPF_SWAP_MODULE_DESC},

188 + .functions =

189 + {.start_routine = ebpf_swap_thread, .apps_routine = ebpf_swap_create_apps_charts, .fnct_routine = NULL},

190 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

191 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

192 + .global_charts = 1,

193 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

194 + .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT,

195 + .cgroup_charts = CONFIG_BOOLEAN_NO,

196 + .mode = MODE_ENTRY,

197 + .optional = 0,

198 + .maps = NULL,

199 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

200 + .names = NULL,

201 + .cfg = &swap_config,

202 + .config_file = NETDATA_DIRECTORY_SWAP_CONFIG_FILE,

203 + .kernels =

205 + .load = EBPF_LOAD_LEGACY,

206 + .targets = swap_targets,

207 + .probe_links = NULL,

208 + .objects = NULL,

209 + .thread = NULL,

210 + .maps_per_core = CONFIG_BOOLEAN_YES,

211 + .lifetime = EBPF_DEFAULT_LIFETIME,

212 + .running_time = 0},

213 + {.info = {.thread_name = "vfs", .config_name = "vfs", .thread_description = NETDATA_EBPF_VFS_MODULE_DESC},

214 + .functions = {.start_routine = ebpf_vfs_thread, .apps_routine = ebpf_vfs_create_apps_charts, .fnct_routine = NULL},

215 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

216 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

217 + .global_charts = 1,

218 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

219 + .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT,

220 + .cgroup_charts = CONFIG_BOOLEAN_NO,

221 + .mode = MODE_ENTRY,

222 + .optional = 0,

223 + .maps = NULL,

224 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

225 + .names = NULL,

226 + .cfg = &vfs_config,

227 + .config_file = NETDATA_DIRECTORY_VFS_CONFIG_FILE,

229 + .load = EBPF_LOAD_LEGACY,

230 + .targets = vfs_targets,

231 + .probe_links = NULL,

232 + .objects = NULL,

233 + .thread = NULL,

234 + .maps_per_core = CONFIG_BOOLEAN_YES,

235 + .lifetime = EBPF_DEFAULT_LIFETIME,

236 + .running_time = 0},

237 + {.info =

238 + {.thread_name = "filesystem", .config_name = "filesystem", .thread_description = NETDATA_EBPF_FS_MODULE_DESC},

239 + .functions = {.start_routine = ebpf_filesystem_thread, .apps_routine = NULL, .fnct_routine = NULL},

240 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

241 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

242 + .global_charts = 1,

243 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

244 + .apps_level = NETDATA_APPS_NOT_SET,

245 + .cgroup_charts = CONFIG_BOOLEAN_NO,

246 + .mode = MODE_ENTRY,

247 + .optional = 0,

248 + .maps = NULL,

249 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

250 + .names = NULL,

251 + .cfg = &fs_config,

252 + .config_file = NETDATA_FILESYSTEM_CONFIG_FILE,

253 + //We are setting kernels as zero, because we load eBPF programs according the kernel running.

254 + .kernels = 0,

255 + .load = EBPF_LOAD_LEGACY,

256 + .targets = NULL,

257 + .probe_links = NULL,

258 + .objects = NULL,

259 + .thread = NULL,

260 + .maps_per_core = CONFIG_BOOLEAN_YES,

261 + .lifetime = EBPF_DEFAULT_LIFETIME,

262 + .running_time = 0},

263 + {.info = {.thread_name = "disk", .config_name = "disk", .thread_description = NETDATA_EBPF_DISK_MODULE_DESC},

264 + .functions = {.start_routine = ebpf_disk_thread, .apps_routine = NULL, .fnct_routine = NULL},

265 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

266 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

267 + .global_charts = 1,

268 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

269 + .apps_level = NETDATA_APPS_NOT_SET,

270 + .cgroup_charts = CONFIG_BOOLEAN_NO,

271 + .mode = MODE_ENTRY,

272 + .optional = 0,

273 + .maps = NULL,

274 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

275 + .names = NULL,

276 + .cfg = &disk_config,

277 + .config_file = NETDATA_DISK_CONFIG_FILE,

279 + .load = EBPF_LOAD_LEGACY,

280 + .targets = NULL,

281 + .probe_links = NULL,

282 + .objects = NULL,

283 + .thread = NULL,

284 + .maps_per_core = CONFIG_BOOLEAN_YES,

285 + .lifetime = EBPF_DEFAULT_LIFETIME,

286 + .running_time = 0},

287 + {.info = {.thread_name = "mount", .config_name = "mount", .thread_description = NETDATA_EBPF_MOUNT_MODULE_DESC},

288 + .functions = {.start_routine = ebpf_mount_thread, .apps_routine = NULL, .fnct_routine = NULL},

289 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

290 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

291 + .global_charts = 1,

292 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

293 + .apps_level = NETDATA_APPS_NOT_SET,

294 + .cgroup_charts = CONFIG_BOOLEAN_NO,

295 + .mode = MODE_ENTRY,

296 + .optional = 0,

297 + .maps = NULL,

298 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

299 + .names = NULL,

300 + .cfg = &mount_config,

301 + .config_file = NETDATA_MOUNT_CONFIG_FILE,

303 + .load = EBPF_LOAD_LEGACY,

304 + .targets = mount_targets,

305 + .probe_links = NULL,

306 + .objects = NULL,

307 + .thread = NULL,

308 + .maps_per_core = CONFIG_BOOLEAN_YES,

309 + .lifetime = EBPF_DEFAULT_LIFETIME,

310 + .running_time = 0},

311 + {.info = {.thread_name = "fd", .config_name = "fd", .thread_description = NETDATA_EBPF_FD_MODULE_DESC},

312 + .functions = {.start_routine = ebpf_fd_thread, .apps_routine = ebpf_fd_create_apps_charts, .fnct_routine = NULL},

313 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

314 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

315 + .global_charts = 1,

316 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

317 + .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT,

318 + .cgroup_charts = CONFIG_BOOLEAN_NO,

319 + .mode = MODE_ENTRY,

320 + .optional = 0,

321 + .maps = NULL,

322 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

323 + .names = NULL,

324 + .cfg = &fd_config,

325 + .config_file = NETDATA_FD_CONFIG_FILE,

326 + .kernels =

328 + .load = EBPF_LOAD_LEGACY,

329 + .targets = fd_targets,

330 + .probe_links = NULL,

331 + .objects = NULL,

332 + .thread = NULL,

333 + .maps_per_core = CONFIG_BOOLEAN_YES,

334 + .lifetime = EBPF_DEFAULT_LIFETIME,

335 + .running_time = 0},

336 + {.info =

337 + {.thread_name = "hardirq", .config_name = "hardirq", .thread_description = NETDATA_EBPF_HARDIRQ_MODULE_DESC},

338 + .functions = {.start_routine = ebpf_hardirq_thread, .apps_routine = NULL, .fnct_routine = NULL},

339 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

340 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

341 + .global_charts = 1,

342 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

343 + .apps_level = NETDATA_APPS_NOT_SET,

344 + .cgroup_charts = CONFIG_BOOLEAN_NO,

345 + .mode = MODE_ENTRY,

346 + .optional = 0,

347 + .maps = NULL,

348 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

349 + .names = NULL,

350 + .cfg = &hardirq_config,

351 + .config_file = NETDATA_HARDIRQ_CONFIG_FILE,

353 + .load = EBPF_LOAD_LEGACY,

354 + .targets = NULL,

355 + .probe_links = NULL,

356 + .objects = NULL,

357 + .thread = NULL,

358 + .maps_per_core = CONFIG_BOOLEAN_YES,

359 + .lifetime = EBPF_DEFAULT_LIFETIME,

360 + .running_time = 0},

361 + {.info =

362 + {.thread_name = "softirq", .config_name = "softirq", .thread_description = NETDATA_EBPF_SOFTIRQ_MODULE_DESC},

363 + .functions = {.start_routine = ebpf_softirq_thread, .apps_routine = NULL, .fnct_routine = NULL},

364 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

365 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

366 + .global_charts = 1,

367 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

368 + .apps_level = NETDATA_APPS_NOT_SET,

369 + .cgroup_charts = CONFIG_BOOLEAN_NO,

370 + .mode = MODE_ENTRY,

371 + .optional = 0,

372 + .maps = NULL,

373 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

374 + .names = NULL,

375 + .cfg = &softirq_config,

376 + .config_file = NETDATA_SOFTIRQ_CONFIG_FILE,

378 + .load = EBPF_LOAD_LEGACY,

379 + .targets = NULL,

380 + .probe_links = NULL,

381 + .objects = NULL,

382 + .thread = NULL,

383 + .maps_per_core = CONFIG_BOOLEAN_YES,

384 + .lifetime = EBPF_DEFAULT_LIFETIME,

385 + .running_time = 0},

386 + {.info =

387 + {.thread_name = "oomkill", .config_name = "oomkill", .thread_description = NETDATA_EBPF_OOMKILL_MODULE_DESC},

388 + .functions =

389 + {.start_routine = ebpf_oomkill_thread, .apps_routine = ebpf_oomkill_create_apps_charts, .fnct_routine = NULL},

390 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

391 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

392 + .global_charts = 1,

393 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

394 + .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT,

395 + .cgroup_charts = CONFIG_BOOLEAN_NO,

396 + .mode = MODE_ENTRY,

397 + .optional = 0,

398 + .maps = NULL,

399 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

400 + .names = NULL,

401 + .cfg = &oomkill_config,

402 + .config_file = NETDATA_OOMKILL_CONFIG_FILE,

403 + .kernels = NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4 | NETDATA_V5_14,

404 + .load = EBPF_LOAD_LEGACY,

405 + .targets = NULL,

406 + .probe_links = NULL,

407 + .objects = NULL,

408 + .thread = NULL,

409 + .maps_per_core = CONFIG_BOOLEAN_YES,

410 + .lifetime = EBPF_DEFAULT_LIFETIME,

411 + .running_time = 0},

412 + {.info = {.thread_name = "shm", .config_name = "shm", .thread_description = NETDATA_EBPF_SHM_MODULE_DESC},

413 + .functions = {.start_routine = ebpf_shm_thread, .apps_routine = ebpf_shm_create_apps_charts, .fnct_routine = NULL},

414 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

415 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

416 + .global_charts = 1,

417 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

418 + .apps_level = NETDATA_APPS_LEVEL_REAL_PARENT,

419 + .cgroup_charts = CONFIG_BOOLEAN_NO,

420 + .mode = MODE_ENTRY,

421 + .optional = 0,

422 + .maps = NULL,

423 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

424 + .names = NULL,

425 + .cfg = &shm_config,

426 + .config_file = NETDATA_DIRECTORY_SHM_CONFIG_FILE,

428 + .load = EBPF_LOAD_LEGACY,

429 + .targets = shm_targets,

430 + .probe_links = NULL,

431 + .objects = NULL,

432 + .thread = NULL,

433 + .maps_per_core = CONFIG_BOOLEAN_YES,

434 + .lifetime = EBPF_DEFAULT_LIFETIME,

435 + .running_time = 0},

436 + {.info = {.thread_name = "mdflush", .config_name = "mdflush", .thread_description = NETDATA_EBPF_MD_MODULE_DESC},

437 + .functions = {.start_routine = ebpf_mdflush_thread, .apps_routine = NULL, .fnct_routine = NULL},

438 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

439 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

440 + .global_charts = 1,

441 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

442 + .apps_level = NETDATA_APPS_NOT_SET,

443 + .cgroup_charts = CONFIG_BOOLEAN_NO,

444 + .mode = MODE_ENTRY,

445 + .optional = 0,

446 + .maps = NULL,

447 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

448 + .names = NULL,

449 + .cfg = &mdflush_config,

450 + .config_file = NETDATA_DIRECTORY_MDFLUSH_CONFIG_FILE,

452 + .load = EBPF_LOAD_LEGACY,

453 + .targets = mdflush_targets,

454 + .probe_links = NULL,

455 + .objects = NULL,

456 + .thread = NULL,

457 + .maps_per_core = CONFIG_BOOLEAN_YES,

458 + .lifetime = EBPF_DEFAULT_LIFETIME,

459 + .running_time = 0},

460 + {.info =

461 + {.thread_name = "functions",

462 + .config_name = "functions",

463 + .thread_description = NETDATA_EBPF_FUNCTIONS_MODULE_DESC},

464 + .functions = {.start_routine = ebpf_function_thread, .apps_routine = NULL, .fnct_routine = NULL},

465 + .enabled = NETDATA_THREAD_EBPF_RUNNING,

466 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

467 + .global_charts = 1,

468 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

469 + .apps_level = NETDATA_APPS_NOT_SET,

470 + .cgroup_charts = CONFIG_BOOLEAN_NO,

471 + .mode = MODE_ENTRY,

472 + .optional = 0,

473 + .maps = NULL,

474 + .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE,

475 + .names = NULL,

476 + .cfg = NULL,

477 + .config_file = NETDATA_DIRECTORY_FUNCTIONS_CONFIG_FILE,

479 + .load = EBPF_LOAD_LEGACY,

480 + .targets = NULL,

481 + .probe_links = NULL,

482 + .objects = NULL,

483 + .thread = NULL,

484 + .maps_per_core = CONFIG_BOOLEAN_YES,

485 + .lifetime = EBPF_DEFAULT_LIFETIME,

486 + .running_time = 0},

487 + {.info = {.thread_name = NULL, .config_name = NULL},

488 + .functions = {.start_routine = NULL, .apps_routine = NULL, .fnct_routine = NULL},

489 + .enabled = NETDATA_THREAD_EBPF_NOT_RUNNING,

490 + .update_every = EBPF_DEFAULT_UPDATE_EVERY,

491 + .global_charts = 0,

492 + .apps_charts = NETDATA_EBPF_APPS_FLAG_NO,

493 + .apps_level = NETDATA_APPS_NOT_SET,

494 + .cgroup_charts = CONFIG_BOOLEAN_NO,

495 + .mode = MODE_ENTRY,

496 + .optional = 0,

497 + .maps = NULL,

498 + .pid_map_size = 0,

499 + .names = NULL,

500 + .cfg = NULL,

501 + .kernels = 0,

502 + .load = EBPF_LOAD_LEGACY,

503 + .targets = NULL,

504 + .probe_links = NULL,

505 + .objects = NULL,

506 + .thread = NULL,

507 + .maps_per_core = CONFIG_BOOLEAN_YES},

508 };

509

510 struct netdata_static_thread ebpf_threads[] = {

305 - {

306 - .name = "EBPF PROCESS",

307 - .config_section = NULL,

308 - .config_name = NULL,

309 - .env_name = NULL,

310 - .enabled = 1,

311 - .thread = NULL,

312 - .init_routine = NULL,

313 - .start_routine = NULL

314 - },

315 - {

316 - .name = "EBPF SOCKET",

317 - .config_section = NULL,

318 - .config_name = NULL,

319 - .env_name = NULL,

320 - .enabled = 1,

321 - .thread = NULL,

322 - .init_routine = NULL,

323 - .start_routine = NULL

324 - },

325 - {

326 - .name = "EBPF CACHESTAT",

327 - .config_section = NULL,

328 - .config_name = NULL,

329 - .env_name = NULL,

330 - .enabled = 1,

331 - .thread = NULL,

332 - .init_routine = NULL,

333 - .start_routine = NULL

334 - },

335 - {

336 - .name = "EBPF SYNC",

337 - .config_section = NULL,

338 - .config_name = NULL,

339 - .env_name = NULL,

340 - .enabled = 1,

341 - .thread = NULL,

342 - .init_routine = NULL,

343 - .start_routine = NULL

344 - },

345 - {

346 - .name = "EBPF DCSTAT",

347 - .config_section = NULL,

348 - .config_name = NULL,

349 - .env_name = NULL,

350 - .enabled = 1,

351 - .thread = NULL,

352 - .init_routine = NULL,

353 - .start_routine = NULL

354 - },

355 - {

356 - .name = "EBPF SWAP",

357 - .config_section = NULL,

358 - .config_name = NULL,

359 - .env_name = NULL,

360 - .enabled = 1,

361 - .thread = NULL,

362 - .init_routine = NULL,

363 - .start_routine = NULL

364 - },

365 - {

366 - .name = "EBPF VFS",

367 - .config_section = NULL,

368 - .config_name = NULL,

369 - .env_name = NULL,

370 - .enabled = 1,

371 - .thread = NULL,

372 - .init_routine = NULL,

373 - .start_routine = NULL

374 - },

375 - {

376 - .name = "EBPF FILESYSTEM",

377 - .config_section = NULL,

378 - .config_name = NULL,

379 - .env_name = NULL,

380 - .enabled = 1,

381 - .thread = NULL,

382 - .init_routine = NULL,

383 - .start_routine = NULL

384 - },

385 - {

386 - .name = "EBPF DISK",

387 - .config_section = NULL,

388 - .config_name = NULL,

389 - .env_name = NULL,

390 - .enabled = 1,

391 - .thread = NULL,

392 - .init_routine = NULL,

393 - .start_routine = NULL

394 - },

395 - {

396 - .name = "EBPF MOUNT",

397 - .config_section = NULL,

398 - .config_name = NULL,

399 - .env_name = NULL,

400 - .enabled = 1,

401 - .thread = NULL,

402 - .init_routine = NULL,

403 - .start_routine = NULL

404 - },

405 - {

406 - .name = "EBPF FD",

407 - .config_section = NULL,

408 - .config_name = NULL,

409 - .env_name = NULL,

410 - .enabled = 1,

411 - .thread = NULL,

412 - .init_routine = NULL,

413 - .start_routine = NULL

414 - },

415 - {

416 - .name = "EBPF HARDIRQ",

417 - .config_section = NULL,

418 - .config_name = NULL,

419 - .env_name = NULL,

420 - .enabled = 1,

421 - .thread = NULL,

422 - .init_routine = NULL,

423 - .start_routine = NULL

424 - },

425 - {

426 - .name = "EBPF SOFTIRQ",

427 - .config_section = NULL,

428 - .config_name = NULL,

429 - .env_name = NULL,

430 - .enabled = 1,

431 - .thread = NULL,

432 - .init_routine = NULL,

433 - .start_routine = NULL

434 - },

435 - {

436 - .name = "EBPF OOMKILL",

437 - .config_section = NULL,

438 - .config_name = NULL,

439 - .env_name = NULL,

440 - .enabled = 1,

441 - .thread = NULL,

442 - .init_routine = NULL,

443 - .start_routine = NULL

444 - },

445 - {

446 - .name = "EBPF SHM",

447 - .config_section = NULL,

448 - .config_name = NULL,

449 - .env_name = NULL,

450 - .enabled = 1,

451 - .thread = NULL,

452 - .init_routine = NULL,

453 - .start_routine = NULL

454 - },

455 - {

456 - .name = "EBPF MDFLUSH",

457 - .config_section = NULL,

458 - .config_name = NULL,

459 - .env_name = NULL,

460 - .enabled = 1,

461 - .thread = NULL,

462 - .init_routine = NULL,

463 - .start_routine = NULL

464 - },

465 - {

466 - .name = "EBPF FUNCTIONS",

467 - .config_section = NULL,

468 - .config_name = NULL,

469 - .env_name = NULL,

511 + {.name = "EBPF PROCESS",

512 + .config_section = NULL,

513 + .config_name = NULL,

514 + .env_name = NULL,

515 + .enabled = 1,

516 + .thread = NULL,

517 + .init_routine = NULL,

518 + .start_routine = NULL},

519 + {.name = "EBPF SOCKET",

520 + .config_section = NULL,

521 + .config_name = NULL,

522 + .env_name = NULL,

523 + .enabled = 1,

524 + .thread = NULL,

525 + .init_routine = NULL,

526 + .start_routine = NULL},

527 + {.name = "EBPF CACHESTAT",

528 + .config_section = NULL,

529 + .config_name = NULL,

530 + .env_name = NULL,

531 + .enabled = 1,

532 + .thread = NULL,

533 + .init_routine = NULL,

534 + .start_routine = NULL},

535 + {.name = "EBPF SYNC",

536 + .config_section = NULL,

537 + .config_name = NULL,

538 + .env_name = NULL,

539 + .enabled = 1,

540 + .thread = NULL,

541 + .init_routine = NULL,

542 + .start_routine = NULL},

543 + {.name = "EBPF DCSTAT",

544 + .config_section = NULL,

545 + .config_name = NULL,

546 + .env_name = NULL,

547 + .enabled = 1,

548 + .thread = NULL,

549 + .init_routine = NULL,

550 + .start_routine = NULL},

551 + {.name = "EBPF SWAP",

552 + .config_section = NULL,

553 + .config_name = NULL,

554 + .env_name = NULL,

555 + .enabled = 1,

556 + .thread = NULL,

557 + .init_routine = NULL,

558 + .start_routine = NULL},

559 + {.name = "EBPF VFS",

560 + .config_section = NULL,

561 + .config_name = NULL,

562 + .env_name = NULL,

563 + .enabled = 1,

564 + .thread = NULL,

565 + .init_routine = NULL,

566 + .start_routine = NULL},

567 + {.name = "EBPF FILESYSTEM",

568 + .config_section = NULL,

569 + .config_name = NULL,

570 + .env_name = NULL,

571 + .enabled = 1,

572 + .thread = NULL,

573 + .init_routine = NULL,

574 + .start_routine = NULL},

575 + {.name = "EBPF DISK",

576 + .config_section = NULL,

577 + .config_name = NULL,

578 + .env_name = NULL,

579 + .enabled = 1,

580 + .thread = NULL,

581 + .init_routine = NULL,

582 + .start_routine = NULL},

583 + {.name = "EBPF MOUNT",

584 + .config_section = NULL,

585 + .config_name = NULL,

586 + .env_name = NULL,

587 + .enabled = 1,

588 + .thread = NULL,

589 + .init_routine = NULL,

590 + .start_routine = NULL},

591 + {.name = "EBPF FD",

592 + .config_section = NULL,

593 + .config_name = NULL,

594 + .env_name = NULL,

595 + .enabled = 1,

596 + .thread = NULL,

597 + .init_routine = NULL,

598 + .start_routine = NULL},

599 + {.name = "EBPF HARDIRQ",

600 + .config_section = NULL,

601 + .config_name = NULL,

602 + .env_name = NULL,

603 + .enabled = 1,

604 + .thread = NULL,

605 + .init_routine = NULL,

606 + .start_routine = NULL},

607 + {.name = "EBPF SOFTIRQ",

608 + .config_section = NULL,

609 + .config_name = NULL,

610 + .env_name = NULL,

611 + .enabled = 1,

612 + .thread = NULL,

613 + .init_routine = NULL,

614 + .start_routine = NULL},

615 + {.name = "EBPF OOMKILL",

616 + .config_section = NULL,

617 + .config_name = NULL,

618 + .env_name = NULL,

619 + .enabled = 1,

620 + .thread = NULL,

621 + .init_routine = NULL,

622 + .start_routine = NULL},

623 + {.name = "EBPF SHM",

624 + .config_section = NULL,

625 + .config_name = NULL,

626 + .env_name = NULL,

627 + .enabled = 1,

628 + .thread = NULL,

629 + .init_routine = NULL,

630 + .start_routine = NULL},

631 + {.name = "EBPF MDFLUSH",

632 + .config_section = NULL,

633 + .config_name = NULL,

634 + .env_name = NULL,

635 + .enabled = 1,

636 + .thread = NULL,

637 + .init_routine = NULL,

638 + .start_routine = NULL},

639 + {.name = "EBPF FUNCTIONS",

640 + .config_section = NULL,

641 + .config_name = NULL,

642 + .env_name = NULL,

643 #ifdef NETDATA_DEV_MODE

471 - .enabled = 1,

644 + .enabled = 1,

645 #else

473 - .enabled = 0,

646 + .enabled = 0,

647 #endif

475 - .thread = NULL,

476 - .init_routine = NULL,

477 - .start_routine = NULL

478 - },

479 - {

480 - .name = NULL,

481 - .config_section = NULL,

482 - .config_name = NULL,

483 - .env_name = NULL,

484 - .enabled = 0,

485 - .thread = NULL,

486 - .init_routine = NULL,

487 - .start_routine = NULL

488 - },

648 + .thread = NULL,

649 + .init_routine = NULL,

650 + .start_routine = NULL},

651 + {.name = NULL,

652 + .config_section = NULL,

653 + .config_name = NULL,

654 + .env_name = NULL,

655 + .enabled = 0,

656 + .thread = NULL,

657 + .init_routine = NULL,

658 + .start_routine = NULL},

659 };

660

491 -ebpf_filesystem_partitions_t localfs[] =

492 - {{.filesystem = "ext4",

493 - .optional_filesystem = NULL,

494 - .family = "ext4",

495 - .objects = NULL,

496 - .probe_links = NULL,

497 - .flags = NETDATA_FILESYSTEM_FLAG_NO_PARTITION,

498 - .enabled = CONFIG_BOOLEAN_YES,

499 - .addresses = {.function = NULL, .addr = 0},

500 - .kernels = NETDATA_V3_10 | NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4,

501 - .fs_maps = NULL,

502 - .fs_obj = NULL,

503 - .functions = { "ext4_file_read_iter",

504 - "ext4_file_write_iter",

505 - "ext4_file_open",

506 - "ext4_sync_file",

507 - NULL }},

508 - {.filesystem = "xfs",

509 - .optional_filesystem = NULL,

510 - .family = "xfs",

511 - .objects = NULL,

512 - .probe_links = NULL,

513 - .flags = NETDATA_FILESYSTEM_FLAG_NO_PARTITION,

514 - .enabled = CONFIG_BOOLEAN_YES,

515 - .addresses = {.function = NULL, .addr = 0},

516 - .kernels = NETDATA_V3_10 | NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4,

517 - .fs_maps = NULL,

518 - .fs_obj = NULL,

519 - .functions = { "xfs_file_read_iter",

520 - "xfs_file_write_iter",

521 - "xfs_file_open",

522 - "xfs_file_fsync",

523 - NULL }},

524 - {.filesystem = "nfs",

525 - .optional_filesystem = "nfs4",

526 - .family = "nfs",

527 - .objects = NULL,

528 - .probe_links = NULL,

529 - .flags = NETDATA_FILESYSTEM_ATTR_CHARTS,

530 - .enabled = CONFIG_BOOLEAN_YES,

531 - .addresses = {.function = NULL, .addr = 0},

532 - .kernels = NETDATA_V3_10 | NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4,

533 - .fs_maps = NULL,

534 - .fs_obj = NULL,

535 - .functions = { "nfs_file_read",

536 - "nfs_file_write",

537 - "nfs_open",

538 - "nfs_getattr",

539 - NULL }}, // // "nfs4_file_open" - not present on all kernels

540 - {.filesystem = "zfs",

541 - .optional_filesystem = NULL,

542 - .family = "zfs",

543 - .objects = NULL,

544 - .probe_links = NULL,

545 - .flags = NETDATA_FILESYSTEM_FLAG_NO_PARTITION,

546 - .enabled = CONFIG_BOOLEAN_YES,

547 - .addresses = {.function = NULL, .addr = 0},

548 - .kernels = NETDATA_V3_10 | NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4,

549 - .fs_maps = NULL,

550 - .fs_obj = NULL,

551 - .functions = { "zpl_iter_read",

552 - "zpl_iter_write",

553 - "zpl_open",

554 - "zpl_fsync",

555 - NULL }},

556 - {.filesystem = "btrfs",

557 - .optional_filesystem = NULL,

558 - .family = "btrfs",

559 - .objects = NULL,

560 - .probe_links = NULL,

561 - .flags = NETDATA_FILESYSTEM_FILL_ADDRESS_TABLE,

562 - .enabled = CONFIG_BOOLEAN_YES,

563 - .addresses = {.function = "btrfs_file_operations", .addr = 0},

565 - .fs_maps = NULL,

566 - .fs_obj = NULL,

567 - .functions = { "btrfs_file_read_iter",

568 - "btrfs_file_write_iter",

569 - "btrfs_file_open",

570 - "btrfs_sync_file",

571 - NULL }},

572 - {.filesystem = NULL,

573 - .optional_filesystem = NULL,

574 - .family = NULL,

575 - .objects = NULL,

576 - .probe_links = NULL,

577 - .flags = NETDATA_FILESYSTEM_FLAG_NO_PARTITION,

578 - .enabled = CONFIG_BOOLEAN_YES,

579 - .addresses = {.function = NULL, .addr = 0},

580 - .kernels = 0, .fs_maps = NULL, .fs_obj = NULL}};

661 +ebpf_filesystem_partitions_t localfs[] = {

662 + {.filesystem = "ext4",

663 + .optional_filesystem = NULL,

664 + .family = "ext4",

665 + .objects = NULL,

666 + .probe_links = NULL,

667 + .flags = NETDATA_FILESYSTEM_FLAG_NO_PARTITION,

668 + .enabled = CONFIG_BOOLEAN_YES,

669 + .addresses = {.function = NULL, .addr = 0},

670 + .kernels = NETDATA_V3_10 | NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4,

671 + .fs_maps = NULL,

672 + .fs_obj = NULL,

673 + .functions = {"ext4_file_read_iter", "ext4_file_write_iter", "ext4_file_open", "ext4_sync_file", NULL}},

674 + {.filesystem = "xfs",

675 + .optional_filesystem = NULL,

676 + .family = "xfs",

677 + .objects = NULL,

678 + .probe_links = NULL,

679 + .flags = NETDATA_FILESYSTEM_FLAG_NO_PARTITION,

680 + .enabled = CONFIG_BOOLEAN_YES,

681 + .addresses = {.function = NULL, .addr = 0},

682 + .kernels = NETDATA_V3_10 | NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4,

683 + .fs_maps = NULL,

684 + .fs_obj = NULL,

685 + .functions = {"xfs_file_read_iter", "xfs_file_write_iter", "xfs_file_open", "xfs_file_fsync", NULL}},

686 + {.filesystem = "nfs",

687 + .optional_filesystem = "nfs4",

688 + .family = "nfs",

689 + .objects = NULL,

690 + .probe_links = NULL,

691 + .flags = NETDATA_FILESYSTEM_ATTR_CHARTS,

692 + .enabled = CONFIG_BOOLEAN_YES,

693 + .addresses = {.function = NULL, .addr = 0},

694 + .kernels = NETDATA_V3_10 | NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4,

695 + .fs_maps = NULL,

696 + .fs_obj = NULL,

697 + .functions =

698 + {"nfs_file_read",

699 + "nfs_file_write",

700 + "nfs_open",

701 + "nfs_getattr",

702 + NULL}}, // // "nfs4_file_open" - not present on all kernels

703 + {.filesystem = "zfs",

704 + .optional_filesystem = NULL,

705 + .family = "zfs",

706 + .objects = NULL,

707 + .probe_links = NULL,

708 + .flags = NETDATA_FILESYSTEM_FLAG_NO_PARTITION,

709 + .enabled = CONFIG_BOOLEAN_YES,

710 + .addresses = {.function = NULL, .addr = 0},

711 + .kernels = NETDATA_V3_10 | NETDATA_V4_14 | NETDATA_V4_16 | NETDATA_V4_18 | NETDATA_V5_4,

712 + .fs_maps = NULL,

713 + .fs_obj = NULL,

714 + .functions = {"zpl_iter_read", "zpl_iter_write", "zpl_open", "zpl_fsync", NULL}},

715 + {.filesystem = "btrfs",

716 + .optional_filesystem = NULL,

717 + .family = "btrfs",

718 + .objects = NULL,

719 + .probe_links = NULL,

720 + .flags = NETDATA_FILESYSTEM_FILL_ADDRESS_TABLE,

721 + .enabled = CONFIG_BOOLEAN_YES,

722 + .addresses = {.function = "btrfs_file_operations", .addr = 0},

724 + .fs_maps = NULL,

725 + .fs_obj = NULL,

726 + .functions = {"btrfs_file_read_iter", "btrfs_file_write_iter", "btrfs_file_open", "btrfs_sync_file", NULL}},

727 + {.filesystem = NULL,

728 + .optional_filesystem = NULL,

729 + .family = NULL,

730 + .objects = NULL,

731 + .probe_links = NULL,

732 + .flags = NETDATA_FILESYSTEM_FLAG_NO_PARTITION,

733 + .enabled = CONFIG_BOOLEAN_YES,

734 + .addresses = {.function = NULL, .addr = 0},

735 + .kernels = 0,

736 + .fs_maps = NULL,

737 + .fs_obj = NULL}};

738

739 ebpf_sync_syscalls_t local_syscalls[] = {

583 - {.syscall = NETDATA_SYSCALLS_SYNC, .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL,

740 + {.syscall = NETDATA_SYSCALLS_SYNC,

741 + .enabled = CONFIG_BOOLEAN_YES,

742 + .objects = NULL,

743 + .probe_links = NULL,

744 #ifdef LIBBPF_MAJOR_VERSION

745 .sync_obj = NULL,

746 #endif

587 - .sync_maps = NULL

588 - },

589 - {.syscall = NETDATA_SYSCALLS_SYNCFS, .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL,

747 + .sync_maps = NULL},

748 + {.syscall = NETDATA_SYSCALLS_SYNCFS,

749 + .enabled = CONFIG_BOOLEAN_YES,

750 + .objects = NULL,

751 + .probe_links = NULL,

752 #ifdef LIBBPF_MAJOR_VERSION

753 .sync_obj = NULL,

754 #endif

593 - .sync_maps = NULL

594 - },

595 - {.syscall = NETDATA_SYSCALLS_MSYNC, .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL,

755 + .sync_maps = NULL},

756 + {.syscall = NETDATA_SYSCALLS_MSYNC,

757 + .enabled = CONFIG_BOOLEAN_YES,

758 + .objects = NULL,

759 + .probe_links = NULL,

760 #ifdef LIBBPF_MAJOR_VERSION

761 .sync_obj = NULL,

762 #endif

599 - .sync_maps = NULL

600 - },

601 - {.syscall = NETDATA_SYSCALLS_FSYNC, .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL,

763 + .sync_maps = NULL},

764 + {.syscall = NETDATA_SYSCALLS_FSYNC,

765 + .enabled = CONFIG_BOOLEAN_YES,

766 + .objects = NULL,

767 + .probe_links = NULL,

768 #ifdef LIBBPF_MAJOR_VERSION

769 .sync_obj = NULL,

770 #endif

605 - .sync_maps = NULL

606 - },

607 - {.syscall = NETDATA_SYSCALLS_FDATASYNC, .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL,

771 + .sync_maps = NULL},

772 + {.syscall = NETDATA_SYSCALLS_FDATASYNC,

773 + .enabled = CONFIG_BOOLEAN_YES,

774 + .objects = NULL,

775 + .probe_links = NULL,

776 #ifdef LIBBPF_MAJOR_VERSION

777 .sync_obj = NULL,

778 #endif

611 - .sync_maps = NULL

612 - },

613 - {.syscall = NETDATA_SYSCALLS_SYNC_FILE_RANGE, .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL,

779 + .sync_maps = NULL},

780 + {.syscall = NETDATA_SYSCALLS_SYNC_FILE_RANGE,

781 + .enabled = CONFIG_BOOLEAN_YES,

782 + .objects = NULL,

783 + .probe_links = NULL,

784 #ifdef LIBBPF_MAJOR_VERSION

785 .sync_obj = NULL,

786 #endif

617 - .sync_maps = NULL

618 - },

619 - {.syscall = NULL, .enabled = CONFIG_BOOLEAN_NO, .objects = NULL, .probe_links = NULL,

787 + .sync_maps = NULL},

788 + {.syscall = NULL,

789 + .enabled = CONFIG_BOOLEAN_NO,

790 + .objects = NULL,

791 + .probe_links = NULL,

792 #ifdef LIBBPF_MAJOR_VERSION

793 .sync_obj = NULL,

794 #endif

623 - .sync_maps = NULL

624 - }

625 -};

626 -

795 + .sync_maps = NULL}};

796

797 // Link with cgroup.plugin

798 netdata_ebpf_cgroup_shm_t shm_ebpf_cgroup = {NULL, NULL};

@@ -635,9 +804,17 @@ pthread_mutex_t mutex_cgroup_shm;

804 ebpf_network_viewer_options_t network_viewer_opt;

805

806 // Statistic

638 -ebpf_plugin_stats_t plugin_statistics = {.core = 0, .legacy = 0, .running = 0, .threads = 0, .tracepoints = 0,

639 - .probes = 0, .retprobes = 0, .trampolines = 0, .memlock_kern = 0,

640 - .hash_tables = 0};

807 +ebpf_plugin_stats_t plugin_statistics = {

808 + .core = 0,

809 + .legacy = 0,

810 + .running = 0,

811 + .threads = 0,

812 + .tracepoints = 0,

813 + .probes = 0,

814 + .retprobes = 0,

815 + .trampolines = 0,

816 + .memlock_kern = 0,

817 + .hash_tables = 0};

818 netdata_ebpf_judy_pid_t ebpf_judy_pid = {.pid_table = NULL, .index = {.JudyLArray = NULL}};

819 bool ebpf_plugin_exit = false;

820

@@ -680,8 +857,8 @@ void **ebpf_judy_insert_unsafe(PPvoid_t arr, Word_t key)

857 JError_t J_Error;

858 Pvoid_t *idx = JudyLIns(arr, key, &J_Error);

859 if (unlikely(idx == PJERR)) {

683 - netdata_log_error("Cannot add PID to JudyL, JU_ERRNO_* == %u, ID == %d",

684 - JU_ERRNO(&J_Error), JU_ERRID(&J_Error));

860 + netdata_log_error(

861 + "Cannot add PID to JudyL, JU_ERRNO_* == %u, ID == %d", JU_ERRNO(&J_Error), JU_ERRID(&J_Error));

862 }

863

864 return idx;

@@ -734,14 +911,12 @@ ARAL *ebpf_allocate_pid_aral(char *name, size_t size)

911 {

912 static size_t max_elements = NETDATA_EBPF_ALLOC_MAX_PID;

913 if (max_elements < NETDATA_EBPF_ALLOC_MIN_ELEMENTS) {

737 - netdata_log_error("Number of elements given is too small, adjusting it for %d", NETDATA_EBPF_ALLOC_MIN_ELEMENTS);

914 + netdata_log_error(

915 + "Number of elements given is too small, adjusting it for %d", NETDATA_EBPF_ALLOC_MIN_ELEMENTS);

916 max_elements = NETDATA_EBPF_ALLOC_MIN_ELEMENTS;

917 }

918

741 - return aral_create(name, size,

742 - 0, 0,

743 - NULL, NULL, NULL,

744 - false, false, false);

919 + return aral_create(name, size, 0, 0, NULL, NULL, NULL, false, false, false);

920 }

921

922 /*****************************************************************

@@ -823,8 +998,9 @@ void ebpf_unload_legacy_code(struct bpf_object *objects, struct bpf_link **probe

998 return;

999

1000 struct bpf_program *prog;

826 - size_t j = 0 ;

827 - bpf_object__for_each_program(prog, objects) {

1001 + size_t j = 0;

1002 + bpf_object__for_each_program(prog, objects)

1003 + {

1004 bpf_link__destroy(probe_links[j]);

1005 j++;

1006 }

@@ -848,8 +1024,8 @@ static void ebpf_unload_unique_maps()

1024

1025 if (ebpf_modules[i].enabled != NETDATA_THREAD_EBPF_STOPPED) {

1026 if (ebpf_modules[i].enabled != NETDATA_THREAD_EBPF_NOT_RUNNING)

851 - netdata_log_error("Cannot unload maps for thread %s, because it is not stopped.",

852 - ebpf_modules[i].info.thread_name);

1027 + netdata_log_error(

1028 + "Cannot unload maps for thread %s, because it is not stopped.", ebpf_modules[i].info.thread_name);

1029

1030 continue;

1031 }

@@ -895,7 +1071,7 @@ static void ebpf_unload_filesystems()

1071 static void ebpf_unload_sync()

1072 {

1073 if (ebpf_modules[EBPF_MODULE_SYNC_IDX].enabled == NETDATA_THREAD_EBPF_NOT_RUNNING ||

898 - ebpf_modules[EBPF_MODULE_SYNC_IDX].enabled < NETDATA_THREAD_EBPF_STOPPING)

1074 + ebpf_modules[EBPF_MODULE_SYNC_IDX].enabled < NETDATA_THREAD_EBPF_STOPPING)

1075 return;

1076

1077 int i;

@@ -980,7 +1156,8 @@ void ebpf_stop_threads(int sig)

1156 * @param em the module main structure.

1157 * @param root a pointer for the targets.

1158 */

983 -static inline void ebpf_create_apps_for_module(ebpf_module_t *em, struct ebpf_target *root) {

1159 +static inline void ebpf_create_apps_for_module(ebpf_module_t *em, struct ebpf_target *root)

1160 +{

1161 if (em->enabled < NETDATA_THREAD_EBPF_STOPPING && em->apps_charts && em->functions.apps_routine)

1162 em->functions.apps_routine(em, root);

1163 }

@@ -994,8 +1171,8 @@ static inline void ebpf_create_apps_for_module(ebpf_module_t *em, struct ebpf_ta

1171 */

1172 static void ebpf_create_apps_charts(struct ebpf_target *root)

1173 {

997 -// if (unlikely(!ebpf_pids))

998 -// return;

1174 + // if (unlikely(!ebpf_pids))

1175 + // return;

1176

1177 struct ebpf_target *w;

1178 int newly_added = 0;

@@ -1008,7 +1185,10 @@ static void ebpf_create_apps_charts(struct ebpf_target *root)

1185 struct ebpf_pid_on_target *pid_on_target;

1186

1187 fprintf(

1011 - stderr, "ebpf.plugin: target '%s' has aggregated %u process%s:", w->name, w->processes,

1188 + stderr,

1189 + "ebpf.plugin: target '%s' has aggregated %u process%s:",

1190 + w->name,

1191 + w->processes,

1192 (w->processes == 1) ? "" : "es");

1193

1194 for (pid_on_target = w->root_pid; pid_on_target; pid_on_target = pid_on_target->next) {

@@ -1028,8 +1208,8 @@ static void ebpf_create_apps_charts(struct ebpf_target *root)

1208

1209 if (newly_added) {

1210 int i;

1031 - for (i = 0; i < EBPF_MODULE_FUNCTION_IDX ; i++) {

1032 - if (!(collect_pids & (1<<i)))

1211 + for (i = 0; i < EBPF_MODULE_FUNCTION_IDX; i++) {

1212 + if (!(collect_pids & (1 << i)))

1213 continue;

1214

1215 ebpf_module_t *current = &ebpf_modules[i];

@@ -1171,21 +1351,32 @@ void write_io_chart(char *chart, char *family, char *dwrite, long long vwrite, c

1351 * @param update_every update interval used by plugin

1352 * @param module chart module name, this is the eBPF thread.

1353 */

1174 -void ebpf_write_chart_cmd(char *type, char *id, char *suffix, char *title, char *units, char *family,

1175 - char *charttype, char *context, int order, int update_every, char *module)

1354 +void ebpf_write_chart_cmd(

1355 + char *type,

1356 + char *id,

1357 + char *suffix,

1358 + char *title,

1359 + char *units,

1360 + char *family,

1361 + char *charttype,

1362 + char *context,

1363 + int order,

1364 + int update_every,

1365 + char *module)

1366 {

1177 - printf("CHART %s.%s%s '' '%s' '%s' '%s' '%s' '%s' %d %d '' 'ebpf.plugin' '%s'\n",

1178 - type,

1179 - id,

1180 - suffix,

1181 - title,

1182 - units,

1183 - (family)?family:"",

1184 - (context)?context:"",

1185 - (charttype)?charttype:"",

1186 - order,

1187 - update_every,

1188 - module);

1367 + printf(

1368 + "CHART %s.%s%s '' '%s' '%s' '%s' '%s' '%s' %d %d '' 'ebpf.plugin' '%s'\n",

1369 + type,

1370 + id,

1371 + suffix,

1372 + title,

1373 + units,

1374 + (family) ? family : "",

1375 + (context) ? context : "",

1376 + (charttype) ? charttype : "",

1377 + order,

1378 + update_every,

1379 + module);

1380 }

1381

1382 /**

@@ -1202,20 +1393,30 @@ void ebpf_write_chart_cmd(char *type, char *id, char *suffix, char *title, char

1393 * @param order chart order

1394 * @param update_every value to overwrite the update frequency set by the server.

1395 */

1205 -void ebpf_write_chart_obsolete(char *type, char *id, char *suffix, char *title, char *units, char *family,

1206 - char *charttype, char *context, int order, int update_every)

1396 +void ebpf_write_chart_obsolete(

1397 + char *type,

1398 + char *id,

1399 + char *suffix,

1400 + char *title,

1401 + char *units,

1402 + char *family,

1403 + char *charttype,

1404 + char *context,

1405 + int order,

1406 + int update_every)

1407 {

1208 - printf("CHART %s.%s%s '' '%s' '%s' '%s' '%s' '%s' %d %d 'obsolete'\n",

1209 - type,

1210 - id,

1211 - suffix,

1212 - title,

1213 - units,

1214 - (family)?family:"",

1215 - (context)?context:"",

1216 - (charttype)?charttype:"",

1217 - order,

1218 - update_every);

1408 + printf(

1409 + "CHART %s.%s%s '' '%s' '%s' '%s' '%s' '%s' %d %d 'obsolete'\n",

1410 + type,

1411 + id,

1412 + suffix,

1413 + title,

1414 + units,

1415 + (family) ? family : "",

1416 + (context) ? context : "",

1417 + (charttype) ? charttype : "",

1418 + order,

1419 + update_every);

1420 }

1421

1422 /**

@@ -1266,19 +1467,20 @@ void ebpf_create_global_dimension(void *ptr, int end)

1467 * @param update_every update interval used with chart.

1468 * @param module chart module name, this is the eBPF thread.

1469 */

1269 -void ebpf_create_chart(char *type,

1270 - char *id,

1271 - char *title,

1272 - char *units,

1273 - char *family,

1274 - char *context,

1275 - char *charttype,

1276 - int order,

1277 - void (*ncd)(void *, int),

1278 - void *move,

1279 - int end,

1280 - int update_every,

1281 - char *module)

1470 +void ebpf_create_chart(

1471 + char *type,

1472 + char *id,

1473 + char *title,

1474 + char *units,

1475 + char *family,

1476 + char *context,

1477 + char *charttype,

1478 + int order,

1479 + void (*ncd)(void *, int),

1480 + void *move,

1481 + int end,

1482 + int update_every,

1483 + char *module)

1484 {

1485 ebpf_write_chart_cmd(type, id, "", title, units, family, charttype, context, order, update_every, module);

1486

@@ -1304,7 +1506,7 @@ void write_histogram_chart(char *family, char *name, const netdata_idx_t *hist,

1506

1507 uint32_t i;

1508 for (i = 0; i < end; i++) {

1307 - write_chart_dimension(dimensions[i], (long long) hist[i]);

1509 + write_chart_dimension(dimensions[i], (long long)hist[i]);

1510 }

1511

1512 ebpf_write_end_chart();

@@ -1324,43 +1526,41 @@ void write_histogram_chart(char *family, char *name, const netdata_idx_t *hist,

1526 int ebpf_statistic_create_aral_chart(char *name, ebpf_module_t *em)

1527 {

1528 static int priority = NETATA_EBPF_ORDER_STAT_ARAL_BEGIN;

1327 - char *mem = { NETDATA_EBPF_STAT_DIMENSION_MEMORY };

1328 - char *aral = { NETDATA_EBPF_STAT_DIMENSION_ARAL };

1329 -

1330 - snprintfz(em->memory_usage, NETDATA_EBPF_CHART_MEM_LENGTH -1, "aral_%s_size", name);

1331 - snprintfz(em->memory_allocations, NETDATA_EBPF_CHART_MEM_LENGTH -1, "aral_%s_alloc", name);

1332 -

1333 - ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,

1334 - em->memory_usage,

1335 - "",

1336 - "Bytes allocated for ARAL.",

1337 - "bytes",

1338 - NETDATA_EBPF_FAMILY,

1339 - NETDATA_EBPF_CHART_TYPE_STACKED,

1340 - "netdata.ebpf_aral_stat_size",

1341 - priority++,

1342 - em->update_every,

1343 - NETDATA_EBPF_MODULE_NAME_PROCESS);

1344 -

1345 - ebpf_write_global_dimension(mem,

1346 - mem,

1347 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

1348 -

1349 - ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,

1350 - em->memory_allocations,

1351 - "",

1352 - "Calls to allocate memory.",

1353 - "calls",

1354 - NETDATA_EBPF_FAMILY,

1355 - NETDATA_EBPF_CHART_TYPE_STACKED,

1356 - "netdata.ebpf_aral_stat_alloc",

1357 - priority++,

1358 - em->update_every,

1359 - NETDATA_EBPF_MODULE_NAME_PROCESS);

1360 -

1361 - ebpf_write_global_dimension(aral,

1362 - aral,

1363 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

1529 + char *mem = {NETDATA_EBPF_STAT_DIMENSION_MEMORY};

1530 + char *aral = {NETDATA_EBPF_STAT_DIMENSION_ARAL};

1531 +

1532 + snprintfz(em->memory_usage, NETDATA_EBPF_CHART_MEM_LENGTH - 1, "aral_%s_size", name);

1533 + snprintfz(em->memory_allocations, NETDATA_EBPF_CHART_MEM_LENGTH - 1, "aral_%s_alloc", name);

1534 +

1535 + ebpf_write_chart_cmd(

1536 + NETDATA_MONITORING_FAMILY,

1537 + em->memory_usage,

1538 + "",

1539 + "Bytes allocated for ARAL.",

1540 + "bytes",

1541 + NETDATA_EBPF_FAMILY,

1542 + NETDATA_EBPF_CHART_TYPE_STACKED,

1543 + "netdata.ebpf_aral_stat_size",

1544 + priority++,

1545 + em->update_every,

1546 + NETDATA_EBPF_MODULE_NAME_PROCESS);

1547 +

1548 + ebpf_write_global_dimension(mem, mem, ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

1549 +

1550 + ebpf_write_chart_cmd(

1551 + NETDATA_MONITORING_FAMILY,

1552 + em->memory_allocations,

1553 + "",

1554 + "Calls to allocate memory.",

1555 + "calls",

1556 + NETDATA_EBPF_FAMILY,

1557 + NETDATA_EBPF_CHART_TYPE_STACKED,

1558 + "netdata.ebpf_aral_stat_alloc",

1559 + priority++,

1560 + em->update_every,

1561 + NETDATA_EBPF_MODULE_NAME_PROCESS);

1562 +

1563 + ebpf_write_global_dimension(aral, aral, ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

1564

1565 return priority - 2;

1566 }

@@ -1376,27 +1576,29 @@ int ebpf_statistic_create_aral_chart(char *name, ebpf_module_t *em)

1576 */

1577 void ebpf_statistic_obsolete_aral_chart(ebpf_module_t *em, int prio)

1578 {

1379 - ebpf_write_chart_obsolete(NETDATA_MONITORING_FAMILY,

1380 - em->memory_allocations,

1381 - "",

1382 - "Calls to allocate memory.",

1383 - "calls",

1384 - NETDATA_EBPF_FAMILY,

1385 - NETDATA_EBPF_CHART_TYPE_STACKED,

1386 - "netdata.ebpf_aral_stat_alloc",

1387 - prio++,

1388 - em->update_every);

1389 -

1390 - ebpf_write_chart_obsolete(NETDATA_MONITORING_FAMILY,

1391 - em->memory_allocations,

1392 - "",

1393 - "Calls to allocate memory.",

1394 - "calls",

1395 - NETDATA_EBPF_FAMILY,

1396 - NETDATA_EBPF_CHART_TYPE_STACKED,

1397 - "netdata.ebpf_aral_stat_alloc",

1398 - prio++,

1399 - em->update_every);

1579 + ebpf_write_chart_obsolete(

1580 + NETDATA_MONITORING_FAMILY,

1581 + em->memory_allocations,

1582 + "",

1583 + "Calls to allocate memory.",

1584 + "calls",

1585 + NETDATA_EBPF_FAMILY,

1586 + NETDATA_EBPF_CHART_TYPE_STACKED,

1587 + "netdata.ebpf_aral_stat_alloc",

1588 + prio++,

1589 + em->update_every);

1590 +

1591 + ebpf_write_chart_obsolete(

1592 + NETDATA_MONITORING_FAMILY,

1593 + em->memory_allocations,

1594 + "",

1595 + "Calls to allocate memory.",

1596 + "calls",

1597 + NETDATA_EBPF_FAMILY,

1598 + NETDATA_EBPF_CHART_TYPE_STACKED,

1599 + "netdata.ebpf_aral_stat_alloc",

1600 + prio++,

1601 + em->update_every);

1602 }

1603

1604 /**

@@ -1409,8 +1611,8 @@ void ebpf_statistic_obsolete_aral_chart(ebpf_module_t *em, int prio)

1611 */

1612 void ebpf_send_data_aral_chart(ARAL *memory, ebpf_module_t *em)

1613 {

1412 - char *mem = { NETDATA_EBPF_STAT_DIMENSION_MEMORY };

1413 - char *aral = { NETDATA_EBPF_STAT_DIMENSION_ARAL };

1614 + char *mem = {NETDATA_EBPF_STAT_DIMENSION_MEMORY};

1615 + char *aral = {NETDATA_EBPF_STAT_DIMENSION_ARAL};

1616

1617 struct aral_statistics *stats = aral_get_statistics(memory);

1618

@@ -1444,19 +1646,20 @@ void ebpf_send_data_aral_chart(ARAL *memory, ebpf_module_t *em)

1646 * @param begin initial value to query hash table

1647 * @param end last value that will not be used.

1648 */

1447 -void ebpf_read_global_table_stats(netdata_idx_t *stats,

1448 - netdata_idx_t *values,

1449 - int map_fd,

1450 - int maps_per_core,

1451 - uint32_t begin,

1452 - uint32_t end)

1649 +void ebpf_read_global_table_stats(

1650 + netdata_idx_t *stats,

1651 + netdata_idx_t *values,

1652 + int map_fd,

1653 + int maps_per_core,

1654 + uint32_t begin,

1655 + uint32_t end)

1656 {

1657 uint32_t idx, order;

1658

1659 for (idx = begin, order = 0; idx < end; idx++, order++) {

1660 if (!bpf_map_lookup_elem(map_fd, &idx, values)) {

1661 int i;

1459 - int before = (maps_per_core) ? ebpf_nprocs: 1;

1662 + int before = (maps_per_core) ? ebpf_nprocs : 1;

1663 netdata_idx_t total = 0;

1664 for (i = 0; i < before; i++)

1665 total += values[i];

@@ -1481,13 +1684,12 @@ void ebpf_read_global_table_stats(netdata_idx_t *stats,

1684 *

1685 * @return

1686 */

1484 -static inline in_addr_t ebpf_netmask(int prefix) {

1485 -

1687 +static inline in_addr_t ebpf_netmask(int prefix)

1688 +{

1689 if (prefix == 0)

1487 - return (~((in_addr_t) - 1));

1690 + return (~((in_addr_t)-1));

1691 else

1692 return (in_addr_t)(~((1 << (32 - prefix)) - 1));

1490 -

1693 }

1694

1695 /**

@@ -1529,7 +1731,7 @@ static inline in_addr_t ebpf_ipv4_network(in_addr_t addr, int prefix)

1731 */

1732 static void get_ipv6_first_addr(union netdata_ip_t *out, union netdata_ip_t *in, uint64_t prefix)

1733 {

1532 - uint64_t mask,tmp;

1734 + uint64_t mask, tmp;

1735 uint64_t ret[2];

1736

1737 memcpy(ret, in->addr32, sizeof(union netdata_ip_t));

@@ -1567,7 +1769,7 @@ static void get_ipv6_first_addr(union netdata_ip_t *out, union netdata_ip_t *in,

1769 */

1770 static void get_ipv6_last_addr(union netdata_ip_t *out, union netdata_ip_t *in, uint64_t prefix)

1771 {

1570 - uint64_t mask,tmp;

1772 + uint64_t mask, tmp;

1773 uint64_t ret[2];

1774 memcpy(ret, in->addr32, sizeof(union netdata_ip_t));

1775

@@ -1668,10 +1870,10 @@ static void ebpf_parse_ip_list_unsafe(void **out, const char *ip)

1870 ebpf_network_viewer_ip_list_t **list = (ebpf_network_viewer_ip_list_t **)out;

1871

1872 char *ipdup = strdupz(ip);

1671 - union netdata_ip_t first = { };

1672 - union netdata_ip_t last = { };

1873 + union netdata_ip_t first = {};

1874 + union netdata_ip_t last = {};

1875 const char *is_ipv6;

1674 - if (*ip == '*' && *(ip+1) == '\0') {

1876 + if (*ip == '*' && *(ip + 1) == '\0') {

1877 memset(first.addr8, 0, sizeof(first.addr8));

1878 memset(last.addr8, 0xFF, sizeof(last.addr8));

1879

@@ -1684,7 +1886,8 @@ static void ebpf_parse_ip_list_unsafe(void **out, const char *ip)

1886 char *enddup = strdupz(ip);

1887 char *end = enddup;

1888 // Move while I cannot find a separator

1687 - while (*end && *end != '/' && *end != '-') end++;

1889 + while (*end && *end != '/' && *end != '-')

1890 + end++;

1891

1892 // We will use only the classic IPV6 for while, but we could consider the base 85 in a near future

1893 // https://tools.ietf.org/html/rfc1924

@@ -1704,7 +1907,7 @@ static void ebpf_parse_ip_list_unsafe(void **out, const char *ip)

1907 if (select)

1908 goto cleanipdup;

1909

1707 - select = (int) str2i(end);

1910 + select = (int)str2i(end);

1911 if (select < NETDATA_MINIMUM_IPV4_CIDR || select > NETDATA_MAXIMUM_IPV4_CIDR) {

1912 netdata_log_info("The specified CIDR %s is not valid, the IP %s will be ignored.", end, ip);

1913 goto cleanipdup;

@@ -1721,7 +1924,7 @@ static void ebpf_parse_ip_list_unsafe(void **out, const char *ip)

1924 struct in_addr ipv4_convert;

1925 ipv4_convert.s_addr = ipv4_test;

1926 char ipv4_msg[INET_ADDRSTRLEN];

1724 - if(inet_ntop(AF_INET, &ipv4_convert, ipv4_msg, INET_ADDRSTRLEN))

1927 + if (inet_ntop(AF_INET, &ipv4_convert, ipv4_msg, INET_ADDRSTRLEN))

1928 netdata_log_info("The network value of CIDR %s was updated for %s .", ipdup, ipv4_msg);

1929 }

1930 } else { // Range

@@ -1735,12 +1938,13 @@ static void ebpf_parse_ip_list_unsafe(void **out, const char *ip)

1938 }

1939

1940 if (htonl(first.addr32[0]) > htonl(last.addr32[0])) {

1738 - netdata_log_info("The specified range %s is invalid, the second address is smallest than the first, it will be ignored.",

1739 - ipdup);

1941 + netdata_log_info(

1942 + "The specified range %s is invalid, the second address is smallest than the first, it will be ignored.",

1943 + ipdup);

1944 goto cleanipdup;

1945 }

1946 } else if (is_ipv6) { // IPV6

1743 - if (!*end) { // Unique

1947 + if (!*end) { // Unique

1948 select = ebpf_ip2nl(first.addr8, ip, AF_INET6, ipdup);

1949 if (select)

1950 goto cleanipdup;

@@ -1749,7 +1953,8 @@ static void ebpf_parse_ip_list_unsafe(void **out, const char *ip)

1953 } else if (*end == '-') {

1954 *end++ = 0x00;

1955 if (*end == '!') {

1752 - netdata_log_info("The exclusion cannot be in the second part of the range %s, it will be ignored.", ipdup);

1956 + netdata_log_info(

1957 + "The exclusion cannot be in the second part of the range %s, it will be ignored.", ipdup);

1958 goto cleanipdup;

1959 }

1960

@@ -1763,7 +1968,8 @@ static void ebpf_parse_ip_list_unsafe(void **out, const char *ip)

1968 } else { // CIDR

1969 *end++ = 0x00;

1970 if (*end == '!') {

1766 - netdata_log_info("The exclusion cannot be in the second part of the range %s, it will be ignored.", ipdup);

1971 + netdata_log_info(

1972 + "The exclusion cannot be in the second part of the range %s, it will be ignored.", ipdup);

1973 goto cleanipdup;

1974 }

1975

@@ -1787,19 +1993,20 @@ static void ebpf_parse_ip_list_unsafe(void **out, const char *ip)

1993 memcpy(first.addr8, ipv6_test.addr8, sizeof(union netdata_ip_t));

1994

1995 struct in6_addr ipv6_convert;

1790 - memcpy(ipv6_convert.s6_addr, ipv6_test.addr8, sizeof(union netdata_ip_t));

1996 + memcpy(ipv6_convert.s6_addr, ipv6_test.addr8, sizeof(union netdata_ip_t));

1997

1998 char ipv6_msg[INET6_ADDRSTRLEN];

1793 - if(inet_ntop(AF_INET6, &ipv6_convert, ipv6_msg, INET6_ADDRSTRLEN))

1999 + if (inet_ntop(AF_INET6, &ipv6_convert, ipv6_msg, INET6_ADDRSTRLEN))

2000 netdata_log_info("The network value of CIDR %s was updated for %s .", ipdup, ipv6_msg);

2001 }

2002 }

2003

2004 if ((be64toh(*(uint64_t *)&first.addr64[1]) > be64toh(*(uint64_t *)&last.addr64[1]) &&

2005 !memcmp(first.addr64, last.addr64, sizeof(uint64_t))) ||

1800 - (be64toh(*(uint64_t *)&first.addr64) > be64toh(*(uint64_t *)&last.addr64)) ) {

1801 - netdata_log_info("The specified range %s is invalid, the second address is smallest than the first, it will be ignored.",

1802 - ipdup);

2006 + (be64toh(*(uint64_t *)&first.addr64) > be64toh(*(uint64_t *)&last.addr64))) {

2007 + netdata_log_info(

2008 + "The specified range %s is invalid, the second address is smallest than the first, it will be ignored.",

2009 + ipdup);

2010 goto cleanipdup;

2011 }

2012 } else { // Unique ip

@@ -1816,7 +2023,7 @@ storethisip:

2023 store = callocz(1, sizeof(ebpf_network_viewer_ip_list_t));

2024 store->value = ipdup;

2025 store->hash = simple_hash(ipdup);

1819 - store->ver = (uint8_t)(!is_ipv6)?AF_INET:AF_INET6;

2026 + store->ver = (uint8_t)(!is_ipv6) ? AF_INET : AF_INET6;

2027 memcpy(store->first.addr8, first.addr8, sizeof(first.addr8));

2028 memcpy(store->last.addr8, last.addr8, sizeof(last.addr8));

2029

@@ -1843,7 +2050,8 @@ void ebpf_parse_ips_unsafe(const char *ptr)

2050

2051 while (likely(ptr)) {

2052 // Move forward until next valid character

1846 - while (isspace(*ptr)) ptr++;

2053 + while (isspace(*ptr))

2054 + ptr++;

2055

2056 // No valid value found

2057 if (unlikely(!*ptr))

@@ -1885,17 +2093,23 @@ static inline void fill_port_list(ebpf_network_viewer_port_list_t **out, ebpf_ne

2093 while (move) {

2094 uint16_t cmp_first = ntohs(move->first);

2095 uint16_t cmp_last = ntohs(move->last);

1888 - if (cmp_first <= first && first <= cmp_last &&

1889 - cmp_first <= last && last <= cmp_last ) {

1890 - netdata_log_info("The range/value (%u, %u) is inside the range/value (%u, %u) already inserted, it will be ignored.",

1891 - first, last, cmp_first, cmp_last);

2096 + if (cmp_first <= first && first <= cmp_last && cmp_first <= last && last <= cmp_last) {

2097 + netdata_log_info(

2098 + "The range/value (%u, %u) is inside the range/value (%u, %u) already inserted, it will be ignored.",

2099 + first,

2100 + last,

2101 + cmp_first,

2102 + cmp_last);

2103 freez(in->value);

2104 freez(in);

2105 return;

1895 - } else if (first <= cmp_first && cmp_first <= last &&

1896 - first <= cmp_last && cmp_last <= last) {

1897 - netdata_log_info("The range (%u, %u) is bigger than previous range (%u, %u) already inserted, the previous will be ignored.",

1898 - first, last, cmp_first, cmp_last);

2106 + } else if (first <= cmp_first && cmp_first <= last && first <= cmp_last && cmp_last <= last) {

2107 + netdata_log_info(

2108 + "The range (%u, %u) is bigger than previous range (%u, %u) already inserted, the previous will be ignored.",

2109 + first,

2110 + last,

2111 + cmp_first,

2112 + cmp_last);

2113 freez(move->value);

2114 move->value = in->value;

2115 move->first = in->first;

@@ -1914,9 +2128,12 @@ static inline void fill_port_list(ebpf_network_viewer_port_list_t **out, ebpf_ne

2128 }

2129

2130 #ifdef NETDATA_INTERNAL_CHECKS

1917 - netdata_log_info("Adding values %s( %u, %u) to %s port list used on network viewer",

1918 - in->value, in->first, in->last,

1919 - (*out == network_viewer_opt.included_port)?"included":"excluded");

2131 + netdata_log_info(

2132 + "Adding values %s( %u, %u) to %s port list used on network viewer",

2133 + in->value,

2134 + in->first,

2135 + in->last,

2136 + (*out == network_viewer_opt.included_port) ? "included" : "excluded");

2137 #endif

2138 }

2139

@@ -1955,7 +2172,8 @@ static void ebpf_parse_service_list(void **out, const char *service)

2172 * @param out a pointer to store the link list

2173 * @param range the informed range for the user.

2174 */

1958 -static void ebpf_parse_port_list(void **out, const char *range_param) {

2175 +static void ebpf_parse_port_list(void **out, const char *range_param)

2176 +{

2177 char range[strlen(range_param) + 1];

2178 strncpyz(range, range_param, strlen(range_param));

2179

@@ -1963,7 +2181,7 @@ static void ebpf_parse_port_list(void **out, const char *range_param) {

2181 ebpf_network_viewer_port_list_t **list = (ebpf_network_viewer_port_list_t **)out;

2182

2183 char *copied = strdupz(range);

1966 - if (*range == '*' && *(range+1) == '\0') {

2184 + if (*range == '*' && *(range + 1) == '\0') {

2185 first = 1;

2186 last = 65535;

2187

@@ -1973,13 +2191,15 @@ static void ebpf_parse_port_list(void **out, const char *range_param) {

2191

2192 char *end = range;

2193 //Move while I cannot find a separator

1976 - while (*end && *end != ':' && *end != '-') end++;

2194 + while (*end && *end != ':' && *end != '-')

2195 + end++;

2196

2197 //It has a range

2198 if (likely(*end)) {

2199 *end++ = '\0';

2200 if (*end == '!') {

1982 - netdata_log_info("The exclusion cannot be in the second part of the range, the range %s will be ignored.", copied);

2201 + netdata_log_info(

2202 + "The exclusion cannot be in the second part of the range, the range %s will be ignored.", copied);

2203 freez(copied);

2204 return;

2205 }

@@ -1999,19 +2219,21 @@ static void ebpf_parse_port_list(void **out, const char *range_param) {

2219 last = first;

2220

2221 if (last < NETDATA_MINIMUM_PORT_VALUE || last > NETDATA_MAXIMUM_PORT_VALUE) {

2002 - netdata_log_info("The second port %d of the range \"%s\" is invalid and the whole range will be ignored!", last, copied);

2222 + netdata_log_info(

2223 + "The second port %d of the range \"%s\" is invalid and the whole range will be ignored!", last, copied);

2224 freez(copied);

2225 return;

2226 }

2227

2228 if (first > last) {

2008 - netdata_log_info("The specified order %s is wrong, the smallest value is always the first, it will be ignored!", copied);

2229 + netdata_log_info(

2230 + "The specified order %s is wrong, the smallest value is always the first, it will be ignored!", copied);

2231 freez(copied);

2232 return;

2233 }

2234

2235 ebpf_network_viewer_port_list_t *w;

2014 - fillenvpl:

2236 +fillenvpl:

2237 w = callocz(1, sizeof(ebpf_network_viewer_port_list_t));

2238 w->value = copied;

2239 w->hash = simple_hash(copied);

@@ -2038,7 +2260,8 @@ void ebpf_parse_ports(const char *ptr)

2260

2261 while (likely(ptr)) {

2262 // Move forward until next valid character

2041 - while (isspace(*ptr)) ptr++;

2263 + while (isspace(*ptr))

2264 + ptr++;

2265

2266 // No valid value found

2267 if (unlikely(!*ptr))

@@ -2087,8 +2310,13 @@ void ebpf_parse_ports(const char *ptr)

2310 * @param algorithm a vector with the algorithms used to make the charts

2311 * @param end the number of elements in the previous 4 arguments.

2312 */

2090 -void ebpf_global_labels(netdata_syscall_stat_t *is, netdata_publish_syscall_t *pio, char **dim,

2091 - char **name, int *algorithm, int end)

2313 +void ebpf_global_labels(

2314 + netdata_syscall_stat_t *is,

2315 + netdata_publish_syscall_t *pio,

2316 + char **dim,

2317 + char **name,

2318 + int *algorithm,

2319 + int end)

2320 {

2321 int i;

2322

@@ -2202,63 +2430,64 @@ void ebpf_update_disabled_plugin_stats(ebpf_module_t *em)

2430 */

2431 void ebpf_print_help()

2432 {

2205 - fprintf(stderr,

2206 - "\n"

2207 - " Netdata ebpf.plugin %s\n"

2209 - " Released under GNU General Public License v3 or later.\n"

2210 - "\n"

2211 - " This eBPF.plugin is a data collector plugin for netdata.\n"

2212 - "\n"

2213 - " This plugin only accepts long options with one or two dashes. The available command line options are:\n"

2214 - "\n"

2215 - " SECONDS Set the data collection frequency.\n"

2216 - "\n"

2217 - " [-]-help Show this help.\n"

2218 - "\n"

2219 - " [-]-version Show software version.\n"

2220 - "\n"

2221 - " [-]-global Disable charts per application and cgroup.\n"

2222 - "\n"

2223 - " [-]-all Enable all chart groups (global, apps, and cgroup), unless -g is also given.\n"

2224 - "\n"

2225 - " [-]-cachestat Enable charts related to process run time.\n"

2226 - "\n"

2227 - " [-]-dcstat Enable charts related to directory cache.\n"

2228 - "\n"

2229 - " [-]-disk Enable charts related to disk monitoring.\n"

2230 - "\n"

2231 - " [-]-filesystem Enable chart related to filesystem run time.\n"

2232 - "\n"

2233 - " [-]-hardirq Enable chart related to hard IRQ latency.\n"

2234 - "\n"

2235 - " [-]-mdflush Enable charts related to multi-device flush.\n"

2236 - "\n"

2237 - " [-]-mount Enable charts related to mount monitoring.\n"

2238 - "\n"

2239 - " [-]-net Enable network viewer charts.\n"

2240 - "\n"

2241 - " [-]-oomkill Enable chart related to OOM kill tracking.\n"

2242 - "\n"

2243 - " [-]-process Enable charts related to process run time.\n"

2244 - "\n"

2245 - " [-]-return Run the collector in return mode.\n"

2246 - "\n"

2247 - " [-]-shm Enable chart related to shared memory tracking.\n"

2248 - "\n"

2249 - " [-]-softirq Enable chart related to soft IRQ latency.\n"

2250 - "\n"

2251 - " [-]-sync Enable chart related to sync run time.\n"

2252 - "\n"

2253 - " [-]-swap Enable chart related to swap run time.\n"

2254 - "\n"

2255 - " [-]-vfs Enable chart related to vfs run time.\n"

2256 - "\n"

2257 - " [-]-legacy Load legacy eBPF programs.\n"

2258 - "\n"

2259 - " [-]-core Use CO-RE when available(Working in progress).\n"

2260 - "\n",

2261 - NETDATA_VERSION);

2433 + fprintf(

2434 + stderr,

2435 + "\n"

2436 + " Netdata ebpf.plugin %s\n"

2438 + " Released under GNU General Public License v3 or later.\n"

2439 + "\n"

2440 + " This eBPF.plugin is a data collector plugin for netdata.\n"

2441 + "\n"

2442 + " This plugin only accepts long options with one or two dashes. The available command line options are:\n"

2443 + "\n"

2444 + " SECONDS Set the data collection frequency.\n"

2445 + "\n"

2446 + " [-]-help Show this help.\n"

2447 + "\n"

2448 + " [-]-version Show software version.\n"

2449 + "\n"

2450 + " [-]-global Disable charts per application and cgroup.\n"

2451 + "\n"

2452 + " [-]-all Enable all chart groups (global, apps, and cgroup), unless -g is also given.\n"

2453 + "\n"

2454 + " [-]-cachestat Enable charts related to process run time.\n"

2455 + "\n"

2456 + " [-]-dcstat Enable charts related to directory cache.\n"

2457 + "\n"

2458 + " [-]-disk Enable charts related to disk monitoring.\n"

2459 + "\n"

2460 + " [-]-filesystem Enable chart related to filesystem run time.\n"

2461 + "\n"

2462 + " [-]-hardirq Enable chart related to hard IRQ latency.\n"

2463 + "\n"

2464 + " [-]-mdflush Enable charts related to multi-device flush.\n"

2465 + "\n"

2466 + " [-]-mount Enable charts related to mount monitoring.\n"

2467 + "\n"

2468 + " [-]-net Enable network viewer charts.\n"

2469 + "\n"

2470 + " [-]-oomkill Enable chart related to OOM kill tracking.\n"

2471 + "\n"

2472 + " [-]-process Enable charts related to process run time.\n"

2473 + "\n"

2474 + " [-]-return Run the collector in return mode.\n"

2475 + "\n"

2476 + " [-]-shm Enable chart related to shared memory tracking.\n"

2477 + "\n"

2478 + " [-]-softirq Enable chart related to soft IRQ latency.\n"

2479 + "\n"

2480 + " [-]-sync Enable chart related to sync run time.\n"

2481 + "\n"

2482 + " [-]-swap Enable chart related to swap run time.\n"

2483 + "\n"

2484 + " [-]-vfs Enable chart related to vfs run time.\n"

2485 + "\n"

2486 + " [-]-legacy Load legacy eBPF programs.\n"

2487 + "\n"

2488 + " [-]-core Use CO-RE when available(Working in progress).\n"

2489 + "\n",

2490 + NETDATA_VERSION);

2491 }

2492

2493 /*****************************************************************

@@ -2333,8 +2562,7 @@ uint32_t ebpf_enable_tracepoints(ebpf_tracepoint_t *tps)

2562 for (int i = 0; tps[i].class != NULL; i++) {

2563 if (ebpf_enable_tracepoint(&tps[i]) == -1) {

2564 netdata_log_error("Failed to enable tracepoint %s:%s", tps[i].class, tps[i].event);

2336 - }

2337 - else {

2565 + } else {

2566 cnt += 1;

2567 }

2568 }

@@ -2360,8 +2588,12 @@ uint32_t ebpf_enable_tracepoints(ebpf_tracepoint_t *tps)

2588 *

2589 * @return It returns 1 if the IP is inside the range and 0 otherwise

2590 */

2363 -static int ebpf_is_ip_inside_range(union netdata_ip_t *rfirst, union netdata_ip_t *rlast,

2364 - union netdata_ip_t *cmpfirst, union netdata_ip_t *cmplast, int family)

2591 +static int ebpf_is_ip_inside_range(

2592 + union netdata_ip_t *rfirst,

2593 + union netdata_ip_t *rlast,

2594 + union netdata_ip_t *cmpfirst,

2595 + union netdata_ip_t *cmplast,

2596 + int family)

2597 {

2598 if (family == AF_INET) {

2599 if ((rfirst->addr32[0] <= cmpfirst->addr32[0]) && (rlast->addr32[0] >= cmplast->addr32[0]))

@@ -2371,7 +2603,6 @@ static int ebpf_is_ip_inside_range(union netdata_ip_t *rfirst, union netdata_ip_

2603 memcmp(rlast->addr8, cmplast->addr8, sizeof(union netdata_ip_t)) >= 0) {

2604 return 1;

2605 }

2374 -

2606 }

2607 return 0;

2608 }

@@ -2383,8 +2614,10 @@ static int ebpf_is_ip_inside_range(union netdata_ip_t *rfirst, union netdata_ip_

2614 * @param in the structure that will be linked.

2615 * @param table the modified table.

2616 */

2386 -void ebpf_fill_ip_list_unsafe(ebpf_network_viewer_ip_list_t **out, ebpf_network_viewer_ip_list_t *in,

2387 - char *table __maybe_unused)

2617 +void ebpf_fill_ip_list_unsafe(

2618 + ebpf_network_viewer_ip_list_t **out,

2619 + ebpf_network_viewer_ip_list_t *in,

2620 + char *table __maybe_unused)

2621 {

2622 if (in->ver == AF_INET) { // It is simpler to compare using host order

2623 in->first.addr32[0] = ntohl(in->first.addr32[0]);

@@ -2396,8 +2629,10 @@ void ebpf_fill_ip_list_unsafe(ebpf_network_viewer_ip_list_t **out, ebpf_network_

2629 if (in->ver == move->ver &&

2630 ebpf_is_ip_inside_range(&move->first, &move->last, &in->first, &in->last, in->ver)) {

2631 #ifdef NETDATA_DEV_MODE

2399 - netdata_log_info("The range/value (%s) is inside the range/value (%s) already inserted, it will be ignored.",

2400 - in->value, move->value);

2632 + netdata_log_info(

2633 + "The range/value (%s) is inside the range/value (%s) already inserted, it will be ignored.",

2634 + in->value,

2635 + move->value);

2636 #endif

2637 freez(in->value);

2638 freez(in);

@@ -2414,19 +2649,24 @@ void ebpf_fill_ip_list_unsafe(ebpf_network_viewer_ip_list_t **out, ebpf_network_

2649

2650 #ifdef NETDATA_DEV_MODE

2651 char first[256], last[512];

2417 - if (in->ver == AF_INET) {

2418 - netdata_log_info("Adding values %s: (%u - %u) to %s IP list \"%s\" used on network viewer",

2419 - in->value, in->first.addr32[0], in->last.addr32[0],

2420 - (*out == network_viewer_opt.included_ips)?"included":"excluded",

2421 - table);

2422 - } else {

2423 - if (inet_ntop(AF_INET6, in->first.addr8, first, INET6_ADDRSTRLEN) &&

2424 - inet_ntop(AF_INET6, in->last.addr8, last, INET6_ADDRSTRLEN))

2425 - netdata_log_info("Adding values %s - %s to %s IP list \"%s\" used on network viewer",

2426 - first, last,

2427 - (*out == network_viewer_opt.included_ips)?"included":"excluded",

2428 - table);

2429 - }

2652 + if (in->ver == AF_INET) {

2653 + netdata_log_info(

2654 + "Adding values %s: (%u - %u) to %s IP list \"%s\" used on network viewer",

2655 + in->value,

2656 + in->first.addr32[0],

2657 + in->last.addr32[0],

2658 + (*out == network_viewer_opt.included_ips) ? "included" : "excluded",

2659 + table);

2660 + } else {

2661 + if (inet_ntop(AF_INET6, in->first.addr8, first, INET6_ADDRSTRLEN) &&

2662 + inet_ntop(AF_INET6, in->last.addr8, last, INET6_ADDRSTRLEN))

2663 + netdata_log_info(

2664 + "Adding values %s - %s to %s IP list \"%s\" used on network viewer",

2665 + first,

2666 + last,

2667 + (*out == network_viewer_opt.included_ips) ? "included" : "excluded",

2668 + table);

2669 + }

2670 #endif

2671 }

2672

@@ -2440,7 +2680,7 @@ static void ebpf_link_hostname(ebpf_network_viewer_hostname_list_t **out, ebpf_n

2680 {

2681 if (likely(*out)) {

2682 ebpf_network_viewer_hostname_list_t *move = *out;

2443 - for (; move->next ; move = move->next ) {

2683 + for (; move->next; move = move->next) {

2684 if (move->hash == in->hash && !strcmp(move->value, in->value)) {

2685 netdata_log_info("The hostname %s was already inserted, it will be ignored.", in->value);

2686 freez(in->value);

@@ -2455,9 +2695,10 @@ static void ebpf_link_hostname(ebpf_network_viewer_hostname_list_t **out, ebpf_n

2695 *out = in;

2696 }

2697 #ifdef NETDATA_INTERNAL_CHECKS

2458 - netdata_log_info("Adding value %s to %s hostname list used on network viewer",

2459 - in->value,

2460 - (*out == network_viewer_opt.included_hostnames)?"included":"excluded");

2698 + netdata_log_info(

2699 + "Adding value %s to %s hostname list used on network viewer",

2700 + in->value,

2701 + (*out == network_viewer_opt.included_hostnames) ? "included" : "excluded");

2702 #endif

2703 }

2704

@@ -2478,7 +2719,8 @@ static void ebpf_link_hostnames(const char *parse)

2719

2720 while (likely(parse)) {

2721 // Find the first valid value

2481 - while (isspace(*parse)) parse++;

2722 + while (isspace(*parse))

2723 + parse++;

2724

2725 // No valid value found

2726 if (unlikely(!*parse))

@@ -2496,14 +2738,13 @@ static void ebpf_link_hostnames(const char *parse)

2738 parse++;

2739 }

2740

2499 - ebpf_network_viewer_hostname_list_t *hostname = callocz(1 , sizeof(ebpf_network_viewer_hostname_list_t));

2741 + ebpf_network_viewer_hostname_list_t *hostname = callocz(1, sizeof(ebpf_network_viewer_hostname_list_t));

2742 hostname->value = strdupz(parse);

2743 hostname->hash = simple_hash(parse);

2744 hostname->value_pattern = simple_pattern_create(parse, NULL, SIMPLE_PATTERN_EXACT, true);

2745

2504 - ebpf_link_hostname((!neg) ? &network_viewer_opt.included_hostnames :

2505 - &network_viewer_opt.excluded_hostnames,

2506 - hostname);

2746 + ebpf_link_hostname(

2747 + (!neg) ? &network_viewer_opt.included_hostnames : &network_viewer_opt.excluded_hostnames, hostname);

2748

2749 parse = end;

2750 }

@@ -2516,15 +2757,11 @@ static void ebpf_link_hostnames(const char *parse)

2757 */

2758 void parse_network_viewer_section(struct config *cfg)

2759 {

2519 - network_viewer_opt.hostname_resolution_enabled = appconfig_get_boolean(cfg,

2520 - EBPF_NETWORK_VIEWER_SECTION,

2521 - EBPF_CONFIG_RESOLVE_HOSTNAME,

2522 - CONFIG_BOOLEAN_NO);

2760 + network_viewer_opt.hostname_resolution_enabled =

2761 + appconfig_get_boolean(cfg, EBPF_NETWORK_VIEWER_SECTION, EBPF_CONFIG_RESOLVE_HOSTNAME, CONFIG_BOOLEAN_NO);

2762

2524 - network_viewer_opt.service_resolution_enabled = appconfig_get_boolean(cfg,

2525 - EBPF_NETWORK_VIEWER_SECTION,

2526 - EBPF_CONFIG_RESOLVE_SERVICE,

2527 - CONFIG_BOOLEAN_YES);

2763 + network_viewer_opt.service_resolution_enabled =

2764 + appconfig_get_boolean(cfg, EBPF_NETWORK_VIEWER_SECTION, EBPF_CONFIG_RESOLVE_SERVICE, CONFIG_BOOLEAN_YES);

2765

2766 const char *value = appconfig_get(cfg, EBPF_NETWORK_VIEWER_SECTION, EBPF_CONFIG_PORTS, NULL);

2767 ebpf_parse_ports(value);

@@ -2536,11 +2773,8 @@ void parse_network_viewer_section(struct config *cfg)

2773 netdata_log_info("Name resolution is disabled, collector will not parse \"hostnames\" list.");

2774 }

2775

2539 - value = appconfig_get(cfg,

2540 - EBPF_NETWORK_VIEWER_SECTION,

2541 - "ips",

2542 - NULL);

2543 - //"ips", "!127.0.0.1/8 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 fc00::/7 !::1/128");

2776 + value = appconfig_get(cfg, EBPF_NETWORK_VIEWER_SECTION, "ips", NULL);

2777 + //"ips", "!127.0.0.1/8 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 fc00::/7 !::1/128");

2778 ebpf_parse_ips_unsafe(value);

2779 }

2780

@@ -2564,7 +2798,7 @@ static void read_local_ports(char *filename, uint8_t proto)

2798

2799 size_t lines = procfile_lines(ff), l;

2800 netdata_passive_connection_t values = {.counter = 0, .tgid = 0, .pid = 0};

2567 - for(l = 0; l < lines ;l++) {

2801 + for (l = 0; l < lines; l++) {

2802 size_t words = procfile_linewords(ff, l);

2803 // This is header or end of file

2804 if (unlikely(words < 14))

@@ -2592,11 +2826,12 @@ void ebpf_read_local_addresses_unsafe()

2826 {

2827 struct ifaddrs *ifaddr, *ifa;

2828 if (getifaddrs(&ifaddr) == -1) {

2595 - netdata_log_error("Cannot get the local IP addresses, it is no possible to do separation between inbound and outbound connections");

2829 + netdata_log_error(

2830 + "Cannot get the local IP addresses, it is no possible to do separation between inbound and outbound connections");

2831 return;

2832 }

2833

2599 - char *notext = { "No text representation" };

2834 + char *notext = {"No text representation"};

2835 for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {

2836 if (ifa->ifa_addr == NULL)

2837 continue;

@@ -2607,10 +2842,10 @@ void ebpf_read_local_addresses_unsafe()

2842 ebpf_network_viewer_ip_list_t *w = callocz(1, sizeof(ebpf_network_viewer_ip_list_t));

2843

2844 int family = ifa->ifa_addr->sa_family;

2610 - w->ver = (uint8_t) family;

2845 + w->ver = (uint8_t)family;

2846 char text[INET6_ADDRSTRLEN];

2847 if (family == AF_INET) {

2613 - struct sockaddr_in *in = (struct sockaddr_in*) ifa->ifa_addr;

2848 + struct sockaddr_in *in = (struct sockaddr_in *)ifa->ifa_addr;

2849

2850 w->first.addr32[0] = in->sin_addr.s_addr;

2851 w->last.addr32[0] = in->sin_addr.s_addr;

@@ -2623,7 +2858,7 @@ void ebpf_read_local_addresses_unsafe()

2858 w->hash = simple_hash(notext);

2859 }

2860 } else {

2626 - struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa->ifa_addr;

2861 + struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)ifa->ifa_addr;

2862

2863 memcpy(w->first.addr8, (void *)&in6->sin6_addr, sizeof(struct in6_addr));

2864 memcpy(w->last.addr8, (void *)&in6->sin6_addr, sizeof(struct in6_addr));

@@ -2663,9 +2898,9 @@ void ebpf_start_pthread_variables()

2898 */

2899 static void ebpf_allocate_common_vectors()

2900 {

2666 - ebpf_judy_pid.pid_table = ebpf_allocate_pid_aral(NETDATA_EBPF_PID_SOCKET_ARAL_TABLE_NAME,

2667 - sizeof(netdata_ebpf_judy_pid_stats_t));

2668 -// ebpf_pids = callocz((size_t)pid_max, sizeof(ebpf_pid_data_t));

2901 + ebpf_judy_pid.pid_table =

2902 + ebpf_allocate_pid_aral(NETDATA_EBPF_PID_SOCKET_ARAL_TABLE_NAME, sizeof(netdata_ebpf_judy_pid_stats_t));

2903 + // ebpf_pids = callocz((size_t)pid_max, sizeof(ebpf_pid_data_t));

2904 ebpf_aral_init();

2905 }

2906

@@ -2697,7 +2932,6 @@ static inline void ebpf_set_apps_mode(netdata_apps_integration_flags_t value)

2932 }

2933 }

2934

2700 -

2935 /**

2936 * Update interval

2937 *

@@ -2708,8 +2942,7 @@ static inline void ebpf_set_apps_mode(netdata_apps_integration_flags_t value)

2942 static void ebpf_update_interval(int update_every)

2943 {

2944 int i;

2711 - int value = (int) appconfig_get_number(&collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_UPDATE_EVERY,

2712 - update_every);

2945 + int value = (int)appconfig_get_number(&collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_UPDATE_EVERY, update_every);

2946 for (i = 0; ebpf_modules[i].info.thread_name; i++) {

2947 ebpf_modules[i].update_every = value;

2948 }

@@ -2723,8 +2956,8 @@ static void ebpf_update_interval(int update_every)

2956 static void ebpf_update_table_size()

2957 {

2958 int i;

2726 - uint32_t value = (uint32_t) appconfig_get_number(&collector_config, EBPF_GLOBAL_SECTION,

2727 - EBPF_CFG_PID_SIZE, ND_EBPF_DEFAULT_PID_SIZE);

2959 + uint32_t value = (uint32_t)appconfig_get_number(

2960 + &collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_PID_SIZE, ND_EBPF_DEFAULT_PID_SIZE);

2961 for (i = 0; ebpf_modules[i].info.thread_name; i++) {

2962 ebpf_modules[i].pid_map_size = value;

2963 }

@@ -2738,8 +2971,8 @@ static void ebpf_update_table_size()

2971 static void ebpf_update_lifetime()

2972 {

2973 int i;

2741 - uint32_t value = (uint32_t) appconfig_get_number(&collector_config, EBPF_GLOBAL_SECTION,

2742 - EBPF_CFG_LIFETIME, EBPF_DEFAULT_LIFETIME);

2974 + uint32_t value = (uint32_t)appconfig_get_number(

2975 + &collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_LIFETIME, EBPF_DEFAULT_LIFETIME);

2976 for (i = 0; ebpf_modules[i].info.thread_name; i++) {

2977 ebpf_modules[i].lifetime = value;

2978 }

@@ -2755,7 +2988,7 @@ static inline void ebpf_set_load_mode(netdata_ebpf_load_mode_t load, netdata_ebp

2988 int i;

2989 for (i = 0; ebpf_modules[i].info.thread_name; i++) {

2990 ebpf_modules[i].load &= ~NETDATA_EBPF_LOAD_METHODS;

2758 - ebpf_modules[i].load |= load | origin ;

2991 + ebpf_modules[i].load |= load | origin;

2992 }

2993 }

2994

@@ -2780,8 +3013,8 @@ static inline void epbf_update_load_mode(const char *str, netdata_ebpf_load_mode

3013 static void ebpf_update_map_per_core()

3014 {

3015 int i;

2783 - int value = appconfig_get_boolean(&collector_config, EBPF_GLOBAL_SECTION,

2784 - EBPF_CFG_MAPS_PER_CORE, CONFIG_BOOLEAN_YES);

3016 + int value =

3017 + appconfig_get_boolean(&collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_MAPS_PER_CORE, CONFIG_BOOLEAN_YES);

3018 for (i = 0; ebpf_modules[i].info.thread_name; i++) {

3019 ebpf_modules[i].maps_per_core = value;

3020 }

@@ -2794,22 +3027,18 @@ static void ebpf_update_map_per_core()

3027 * @param update_every value to overwrite the update frequency set by the server.

3028 * @param origin specify the configuration file loaded

3029 */

2797 -static void read_collector_values(int *disable_cgroups,

2798 - int update_every, netdata_ebpf_load_mode_t origin)

3030 +static void read_collector_values(int *disable_cgroups, int update_every, netdata_ebpf_load_mode_t origin)

3031 {

3032 // Read global section

3033 const char *value;

3034 if (appconfig_exists(&collector_config, EBPF_GLOBAL_SECTION, "load")) // Backward compatibility

2803 - value = appconfig_get(&collector_config, EBPF_GLOBAL_SECTION, "load",

2804 - EBPF_CFG_LOAD_MODE_DEFAULT);

3035 + value = appconfig_get(&collector_config, EBPF_GLOBAL_SECTION, "load", EBPF_CFG_LOAD_MODE_DEFAULT);

3036 else

2806 - value = appconfig_get(&collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_LOAD_MODE,

2807 - EBPF_CFG_LOAD_MODE_DEFAULT);

3037 + value = appconfig_get(&collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_LOAD_MODE, EBPF_CFG_LOAD_MODE_DEFAULT);

3038

3039 ebpf_how_to_load(value);

3040

2811 - btf_path = appconfig_get(&collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_PROGRAM_PATH,

2812 - EBPF_DEFAULT_BTF_PATH);

3041 + btf_path = appconfig_get(&collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_PROGRAM_PATH, EBPF_DEFAULT_BTF_PATH);

3042

3043 #ifdef LIBBPF_MAJOR_VERSION

3044 default_btf = ebpf_load_btf_file(btf_path, EBPF_DEFAULT_BTF_FILE);

@@ -2826,13 +3055,12 @@ static void read_collector_values(int *disable_cgroups,

3055 ebpf_update_lifetime();

3056

3057 // This is kept to keep compatibility

2829 - uint32_t enabled = appconfig_get_boolean(&collector_config, EBPF_GLOBAL_SECTION, "disable apps",

2830 - CONFIG_BOOLEAN_NO);

3058 + uint32_t enabled = appconfig_get_boolean(&collector_config, EBPF_GLOBAL_SECTION, "disable apps", CONFIG_BOOLEAN_NO);

3059 if (!enabled) {

3060 // Apps is a positive sentence, so we need to invert the values to disable apps.

2833 - enabled = appconfig_get_boolean(&collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_APPLICATION,

2834 - CONFIG_BOOLEAN_YES);

2835 - enabled = (enabled == CONFIG_BOOLEAN_NO)?CONFIG_BOOLEAN_YES:CONFIG_BOOLEAN_NO;

3061 + enabled =

3062 + appconfig_get_boolean(&collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_APPLICATION, CONFIG_BOOLEAN_YES);

3063 + enabled = (enabled == CONFIG_BOOLEAN_NO) ? CONFIG_BOOLEAN_YES : CONFIG_BOOLEAN_NO;

3064 }

3065

3066 ebpf_set_apps_mode(!enabled);

@@ -2840,34 +3068,38 @@ static void read_collector_values(int *disable_cgroups,

3068 // Cgroup is a positive sentence, so we need to invert the values to disable apps.

3069 // We are using the same pattern for cgroup and apps

3070 enabled = appconfig_get_boolean(&collector_config, EBPF_GLOBAL_SECTION, EBPF_CFG_CGROUP, CONFIG_BOOLEAN_NO);

2843 - *disable_cgroups = (enabled == CONFIG_BOOLEAN_NO)?CONFIG_BOOLEAN_YES:CONFIG_BOOLEAN_NO;

3071 + *disable_cgroups = (enabled == CONFIG_BOOLEAN_NO) ? CONFIG_BOOLEAN_YES : CONFIG_BOOLEAN_NO;

3072

3073 ebpf_update_map_per_core();

3074

3075 // Read ebpf programs section

2848 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION,

2849 - ebpf_modules[EBPF_MODULE_PROCESS_IDX].info.config_name, CONFIG_BOOLEAN_YES);

3076 + enabled = appconfig_get_boolean(

3077 + &collector_config,

3078 + EBPF_PROGRAMS_SECTION,

3079 + ebpf_modules[EBPF_MODULE_PROCESS_IDX].info.config_name,

3080 + CONFIG_BOOLEAN_YES);

3081 if (enabled) {

3082 ebpf_enable_chart(EBPF_MODULE_PROCESS_IDX, *disable_cgroups);

3083 }

3084

3085 // This is kept to keep compatibility

2855 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "network viewer",

2856 - CONFIG_BOOLEAN_NO);

3086 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "network viewer", CONFIG_BOOLEAN_NO);

3087 if (!enabled)

2858 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION,

2859 - ebpf_modules[EBPF_MODULE_SOCKET_IDX].info.config_name,

2860 - CONFIG_BOOLEAN_NO);

3088 + enabled = appconfig_get_boolean(

3089 + &collector_config,

3090 + EBPF_PROGRAMS_SECTION,

3091 + ebpf_modules[EBPF_MODULE_SOCKET_IDX].info.config_name,

3092 + CONFIG_BOOLEAN_NO);

3093 if (enabled) {

3094 ebpf_enable_chart(EBPF_MODULE_SOCKET_IDX, *disable_cgroups);

3095 }

3096

3097 // This is kept to keep compatibility

2866 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "network connection monitoring",

2867 - CONFIG_BOOLEAN_YES);

3098 + enabled = appconfig_get_boolean(

3099 + &collector_config, EBPF_PROGRAMS_SECTION, "network connection monitoring", CONFIG_BOOLEAN_YES);

3100 if (!enabled)

2869 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "network connections",

2870 - CONFIG_BOOLEAN_YES);

3101 + enabled =

3102 + appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "network connections", CONFIG_BOOLEAN_YES);

3103

3104 network_viewer_opt.enabled = enabled;

3105 if (enabled) {

@@ -2880,88 +3112,74 @@ static void read_collector_values(int *disable_cgroups,

3112 ebpf_parse_service_name_section(&collector_config);

3113 }

3114

2883 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "cachestat",

2884 - CONFIG_BOOLEAN_NO);

3115 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "cachestat", CONFIG_BOOLEAN_NO);

3116

3117 if (enabled) {

3118 ebpf_enable_chart(EBPF_MODULE_CACHESTAT_IDX, *disable_cgroups);

3119 }

3120

2890 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "sync",

2891 - CONFIG_BOOLEAN_YES);

3121 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "sync", CONFIG_BOOLEAN_YES);

3122

3123 if (enabled) {

3124 ebpf_enable_chart(EBPF_MODULE_SYNC_IDX, *disable_cgroups);

3125 }

3126

2897 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "dcstat",

2898 - CONFIG_BOOLEAN_NO);

3127 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "dcstat", CONFIG_BOOLEAN_NO);

3128 if (enabled) {

3129 ebpf_enable_chart(EBPF_MODULE_DCSTAT_IDX, *disable_cgroups);

3130 }

3131

2903 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "swap",

2904 - CONFIG_BOOLEAN_NO);

3132 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "swap", CONFIG_BOOLEAN_NO);

3133 if (enabled) {

3134 ebpf_enable_chart(EBPF_MODULE_SWAP_IDX, *disable_cgroups);

3135 }

3136

2909 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "vfs",

2910 - CONFIG_BOOLEAN_NO);

3137 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "vfs", CONFIG_BOOLEAN_NO);

3138 if (enabled) {

3139 ebpf_enable_chart(EBPF_MODULE_VFS_IDX, *disable_cgroups);

3140 }

3141

2915 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "filesystem",

2916 - CONFIG_BOOLEAN_NO);

3142 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "filesystem", CONFIG_BOOLEAN_NO);

3143 if (enabled) {

3144 ebpf_enable_chart(EBPF_MODULE_FILESYSTEM_IDX, *disable_cgroups);

3145 }

3146

2921 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "disk",

2922 - CONFIG_BOOLEAN_NO);

3147 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "disk", CONFIG_BOOLEAN_NO);

3148 if (enabled) {

3149 ebpf_enable_chart(EBPF_MODULE_DISK_IDX, *disable_cgroups);

3150 }

3151

2927 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "mount",

2928 - CONFIG_BOOLEAN_YES);

3152 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "mount", CONFIG_BOOLEAN_YES);

3153 if (enabled) {

3154 ebpf_enable_chart(EBPF_MODULE_MOUNT_IDX, *disable_cgroups);

3155 }

3156

2933 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "fd",

2934 - CONFIG_BOOLEAN_YES);

3157 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "fd", CONFIG_BOOLEAN_YES);

3158 if (enabled) {

3159 ebpf_enable_chart(EBPF_MODULE_FD_IDX, *disable_cgroups);

3160 }

3161

2939 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "hardirq",

2940 - CONFIG_BOOLEAN_YES);

3162 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "hardirq", CONFIG_BOOLEAN_YES);

3163 if (enabled) {

3164 ebpf_enable_chart(EBPF_MODULE_HARDIRQ_IDX, *disable_cgroups);

3165 }

3166

2945 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "softirq",

2946 - CONFIG_BOOLEAN_YES);

3167 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "softirq", CONFIG_BOOLEAN_YES);

3168 if (enabled) {

3169 ebpf_enable_chart(EBPF_MODULE_SOFTIRQ_IDX, *disable_cgroups);

3170 }

3171

2951 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "oomkill",

2952 - CONFIG_BOOLEAN_YES);

3172 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "oomkill", CONFIG_BOOLEAN_YES);

3173 if (enabled) {

3174 ebpf_enable_chart(EBPF_MODULE_OOMKILL_IDX, *disable_cgroups);

3175 }

3176

2957 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "shm",

2958 - CONFIG_BOOLEAN_YES);

3177 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "shm", CONFIG_BOOLEAN_YES);

3178 if (enabled) {

3179 ebpf_enable_chart(EBPF_MODULE_SHM_IDX, *disable_cgroups);

3180 }

3181

2963 - enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "mdflush",

2964 - CONFIG_BOOLEAN_NO);

3182 + enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "mdflush", CONFIG_BOOLEAN_NO);

3183 if (enabled) {

3184 ebpf_enable_chart(EBPF_MODULE_MDFLUSH_IDX, *disable_cgroups);

3185 }

@@ -3054,33 +3272,32 @@ static void ebpf_parse_args(int argc, char **argv)

3272 int option_index = 0;

3273 uint64_t select_threads = 0;

3274 static struct option long_options[] = {

3057 - {"process", no_argument, 0, 0 },

3058 - {"net", no_argument, 0, 0 },

3059 - {"cachestat", no_argument, 0, 0 },

3060 - {"sync", no_argument, 0, 0 },

3061 - {"dcstat", no_argument, 0, 0 },

3062 - {"swap", no_argument, 0, 0 },

3063 - {"vfs", no_argument, 0, 0 },

3064 - {"filesystem", no_argument, 0, 0 },

3065 - {"disk", no_argument, 0, 0 },

3066 - {"mount", no_argument, 0, 0 },

3067 - {"filedescriptor", no_argument, 0, 0 },

3068 - {"hardirq", no_argument, 0, 0 },

3069 - {"softirq", no_argument, 0, 0 },

3070 - {"oomkill", no_argument, 0, 0 },

3071 - {"shm", no_argument, 0, 0 },

3072 - {"mdflush", no_argument, 0, 0 },

3275 + {"process", no_argument, 0, 0},

3276 + {"net", no_argument, 0, 0},

3277 + {"cachestat", no_argument, 0, 0},

3278 + {"sync", no_argument, 0, 0},

3279 + {"dcstat", no_argument, 0, 0},

3280 + {"swap", no_argument, 0, 0},

3281 + {"vfs", no_argument, 0, 0},

3282 + {"filesystem", no_argument, 0, 0},

3283 + {"disk", no_argument, 0, 0},

3284 + {"mount", no_argument, 0, 0},

3285 + {"filedescriptor", no_argument, 0, 0},

3286 + {"hardirq", no_argument, 0, 0},

3287 + {"softirq", no_argument, 0, 0},

3288 + {"oomkill", no_argument, 0, 0},

3289 + {"shm", no_argument, 0, 0},

3290 + {"mdflush", no_argument, 0, 0},

3291 /* INSERT NEW THREADS BEFORE THIS COMMENT TO KEEP COMPATIBILITY WITH enum ebpf_module_indexes */

3074 - {"all", no_argument, 0, 0 },

3075 - {"version", no_argument, 0, 0 },

3076 - {"help", no_argument, 0, 0 },

3077 - {"global", no_argument, 0, 0 },

3078 - {"return", no_argument, 0, 0 },

3079 - {"legacy", no_argument, 0, 0 },

3080 - {"core", no_argument, 0, 0 },

3081 - {"unittest", no_argument, 0, 0 },

3082 - {0, 0, 0, 0}

3083 - };

3292 + {"all", no_argument, 0, 0},

3293 + {"version", no_argument, 0, 0},

3294 + {"help", no_argument, 0, 0},

3295 + {"global", no_argument, 0, 0},

3296 + {"return", no_argument, 0, 0},

3297 + {"legacy", no_argument, 0, 0},

3298 + {"core", no_argument, 0, 0},

3299 + {"unittest", no_argument, 0, 0},

3300 + {0, 0, 0, 0}};

3301

3302 memset(&network_viewer_opt, 0, sizeof(network_viewer_opt));

3303 rw_spinlock_init(&network_viewer_opt.rw_spinlock);

@@ -3115,114 +3332,124 @@ static void ebpf_parse_args(int argc, char **argv)

3332

3333 switch (option_index) {

3334 case EBPF_MODULE_PROCESS_IDX: {

3118 - select_threads |= 1<<EBPF_MODULE_PROCESS_IDX;

3335 + select_threads |= 1 << EBPF_MODULE_PROCESS_IDX;

3336 #ifdef NETDATA_INTERNAL_CHECKS

3120 - netdata_log_info("EBPF enabling \"PROCESS\" charts, because it was started with the option \"[-]-process\".");

3337 + netdata_log_info(

3338 + "EBPF enabling \"PROCESS\" charts, because it was started with the option \"[-]-process\".");

3339 #endif

3340 break;

3341 }

3342 case EBPF_MODULE_SOCKET_IDX: {

3125 - select_threads |= 1<<EBPF_MODULE_SOCKET_IDX;

3343 + select_threads |= 1 << EBPF_MODULE_SOCKET_IDX;

3344 #ifdef NETDATA_INTERNAL_CHECKS

3345 netdata_log_info("EBPF enabling \"NET\" charts, because it was started with the option \"[-]-net\".");

3346 #endif

3347 break;

3348 }

3349 case EBPF_MODULE_CACHESTAT_IDX: {

3132 - select_threads |= 1<<EBPF_MODULE_CACHESTAT_IDX;

3350 + select_threads |= 1 << EBPF_MODULE_CACHESTAT_IDX;

3351 #ifdef NETDATA_INTERNAL_CHECKS

3134 - netdata_log_info("EBPF enabling \"CACHESTAT\" charts, because it was started with the option \"[-]-cachestat\".");

3352 + netdata_log_info(

3353 + "EBPF enabling \"CACHESTAT\" charts, because it was started with the option \"[-]-cachestat\".");

3354 #endif

3355 break;

3356 }

3357 case EBPF_MODULE_SYNC_IDX: {

3139 - select_threads |= 1<<EBPF_MODULE_SYNC_IDX;

3358 + select_threads |= 1 << EBPF_MODULE_SYNC_IDX;

3359 #ifdef NETDATA_INTERNAL_CHECKS

3360 netdata_log_info("EBPF enabling \"SYNC\" chart, because it was started with the option \"[-]-sync\".");

3361 #endif

3362 break;

3363 }

3364 case EBPF_MODULE_DCSTAT_IDX: {

3146 - select_threads |= 1<<EBPF_MODULE_DCSTAT_IDX;

3365 + select_threads |= 1 << EBPF_MODULE_DCSTAT_IDX;

3366 #ifdef NETDATA_INTERNAL_CHECKS

3148 - netdata_log_info("EBPF enabling \"DCSTAT\" charts, because it was started with the option \"[-]-dcstat\".");

3367 + netdata_log_info(

3368 + "EBPF enabling \"DCSTAT\" charts, because it was started with the option \"[-]-dcstat\".");

3369 #endif

3370 break;

3371 }

3372 case EBPF_MODULE_SWAP_IDX: {

3153 - select_threads |= 1<<EBPF_MODULE_SWAP_IDX;

3373 + select_threads |= 1 << EBPF_MODULE_SWAP_IDX;

3374 #ifdef NETDATA_INTERNAL_CHECKS

3375 netdata_log_info("EBPF enabling \"SWAP\" chart, because it was started with the option \"[-]-swap\".");

3376 #endif

3377 break;

3378 }

3379 case EBPF_MODULE_VFS_IDX: {

3160 - select_threads |= 1<<EBPF_MODULE_VFS_IDX;

3380 + select_threads |= 1 << EBPF_MODULE_VFS_IDX;

3381 #ifdef NETDATA_INTERNAL_CHECKS

3382 netdata_log_info("EBPF enabling \"VFS\" chart, because it was started with the option \"[-]-vfs\".");

3383 #endif

3384 break;

3385 }

3386 case EBPF_MODULE_FILESYSTEM_IDX: {

3167 - select_threads |= 1<<EBPF_MODULE_FILESYSTEM_IDX;

3387 + select_threads |= 1 << EBPF_MODULE_FILESYSTEM_IDX;

3388 #ifdef NETDATA_INTERNAL_CHECKS

3169 - netdata_log_info("EBPF enabling \"FILESYSTEM\" chart, because it was started with the option \"[-]-filesystem\".");

3389 + netdata_log_info(

3390 + "EBPF enabling \"FILESYSTEM\" chart, because it was started with the option \"[-]-filesystem\".");

3391 #endif

3392 break;

3393 }

3394 case EBPF_MODULE_DISK_IDX: {

3174 - select_threads |= 1<<EBPF_MODULE_DISK_IDX;

3395 + select_threads |= 1 << EBPF_MODULE_DISK_IDX;

3396 #ifdef NETDATA_INTERNAL_CHECKS

3397 netdata_log_info("EBPF enabling \"DISK\" chart, because it was started with the option \"[-]-disk\".");

3398 #endif

3399 break;

3400 }

3401 case EBPF_MODULE_MOUNT_IDX: {

3181 - select_threads |= 1<<EBPF_MODULE_MOUNT_IDX;

3402 + select_threads |= 1 << EBPF_MODULE_MOUNT_IDX;

3403 #ifdef NETDATA_INTERNAL_CHECKS

3183 - netdata_log_info("EBPF enabling \"MOUNT\" chart, because it was started with the option \"[-]-mount\".");

3404 + netdata_log_info(

3405 + "EBPF enabling \"MOUNT\" chart, because it was started with the option \"[-]-mount\".");

3406 #endif

3407 break;

3408 }

3409 case EBPF_MODULE_FD_IDX: {

3188 - select_threads |= 1<<EBPF_MODULE_FD_IDX;

3410 + select_threads |= 1 << EBPF_MODULE_FD_IDX;

3411 #ifdef NETDATA_INTERNAL_CHECKS

3190 - netdata_log_info("EBPF enabling \"FILEDESCRIPTOR\" chart, because it was started with the option \"[-]-filedescriptor\".");

3412 + netdata_log_info(

3413 + "EBPF enabling \"FILEDESCRIPTOR\" chart, because it was started with the option \"[-]-filedescriptor\".");

3414 #endif

3415 break;

3416 }

3417 case EBPF_MODULE_HARDIRQ_IDX: {

3195 - select_threads |= 1<<EBPF_MODULE_HARDIRQ_IDX;

3418 + select_threads |= 1 << EBPF_MODULE_HARDIRQ_IDX;

3419 #ifdef NETDATA_INTERNAL_CHECKS

3197 - netdata_log_info("EBPF enabling \"HARDIRQ\" chart, because it was started with the option \"[-]-hardirq\".");

3420 + netdata_log_info(

3421 + "EBPF enabling \"HARDIRQ\" chart, because it was started with the option \"[-]-hardirq\".");

3422 #endif

3423 break;

3424 }

3425 case EBPF_MODULE_SOFTIRQ_IDX: {

3202 - select_threads |= 1<<EBPF_MODULE_SOFTIRQ_IDX;

3426 + select_threads |= 1 << EBPF_MODULE_SOFTIRQ_IDX;

3427 #ifdef NETDATA_INTERNAL_CHECKS

3204 - netdata_log_info("EBPF enabling \"SOFTIRQ\" chart, because it was started with the option \"[-]-softirq\".");

3428 + netdata_log_info(

3429 + "EBPF enabling \"SOFTIRQ\" chart, because it was started with the option \"[-]-softirq\".");

3430 #endif

3431 break;

3432 }

3433 case EBPF_MODULE_OOMKILL_IDX: {

3209 - select_threads |= 1<<EBPF_MODULE_OOMKILL_IDX;

3434 + select_threads |= 1 << EBPF_MODULE_OOMKILL_IDX;

3435 #ifdef NETDATA_INTERNAL_CHECKS

3211 - netdata_log_info("EBPF enabling \"OOMKILL\" chart, because it was started with the option \"[-]-oomkill\".");

3436 + netdata_log_info(

3437 + "EBPF enabling \"OOMKILL\" chart, because it was started with the option \"[-]-oomkill\".");

3438 #endif

3439 break;

3440 }

3441 case EBPF_MODULE_SHM_IDX: {

3216 - select_threads |= 1<<EBPF_MODULE_SHM_IDX;

3442 + select_threads |= 1 << EBPF_MODULE_SHM_IDX;

3443 #ifdef NETDATA_INTERNAL_CHECKS

3444 netdata_log_info("EBPF enabling \"SHM\" chart, because it was started with the option \"[-]-shm\".");

3445 #endif

3446 break;

3447 }

3448 case EBPF_MODULE_MDFLUSH_IDX: {

3223 - select_threads |= 1<<EBPF_MODULE_MDFLUSH_IDX;

3449 + select_threads |= 1 << EBPF_MODULE_MDFLUSH_IDX;

3450 #ifdef NETDATA_INTERNAL_CHECKS

3225 - netdata_log_info("EBPF enabling \"MDFLUSH\" chart, because it was started with the option \"[-]-mdflush\".");

3451 + netdata_log_info(

3452 + "EBPF enabling \"MDFLUSH\" chart, because it was started with the option \"[-]-mdflush\".");

3453 #endif

3454 break;

3455 }

@@ -3230,7 +3457,8 @@ static void ebpf_parse_args(int argc, char **argv)

3457 ebpf_set_apps_mode(NETDATA_EBPF_APPS_FLAG_YES);

3458 disable_cgroups = 0;

3459 #ifdef NETDATA_INTERNAL_CHECKS

3233 - netdata_log_info("EBPF running with all chart groups, because it was started with the option \"[-]-all\".");

3460 + netdata_log_info(

3461 + "EBPF running with all chart groups, because it was started with the option \"[-]-all\".");

3462 #endif

3463 break;

3464 }

@@ -3245,28 +3473,32 @@ static void ebpf_parse_args(int argc, char **argv)

3473 case EBPF_OPTION_GLOBAL_CHART: {

3474 disable_cgroups = 1;

3475 #ifdef NETDATA_INTERNAL_CHECKS

3248 - netdata_log_info("EBPF running with global chart group, because it was started with the option \"[-]-global\".");

3476 + netdata_log_info(

3477 + "EBPF running with global chart group, because it was started with the option \"[-]-global\".");

3478 #endif

3479 break;

3480 }

3481 case EBPF_OPTION_RETURN_MODE: {

3482 ebpf_set_thread_mode(MODE_RETURN);

3483 #ifdef NETDATA_INTERNAL_CHECKS

3255 - netdata_log_info("EBPF running in \"RETURN\" mode, because it was started with the option \"[-]-return\".");

3484 + netdata_log_info(

3485 + "EBPF running in \"RETURN\" mode, because it was started with the option \"[-]-return\".");

3486 #endif

3487 break;

3488 }

3489 case EBPF_OPTION_LEGACY: {

3490 ebpf_set_load_mode(EBPF_LOAD_LEGACY, EBPF_LOADED_FROM_USER);

3491 #ifdef NETDATA_INTERNAL_CHECKS

3262 - netdata_log_info("EBPF running with \"LEGACY\" code, because it was started with the option \"[-]-legacy\".");

3492 + netdata_log_info(

3493 + "EBPF running with \"LEGACY\" code, because it was started with the option \"[-]-legacy\".");

3494 #endif

3495 break;

3496 }

3497 case EBPF_OPTION_CORE: {

3498 ebpf_set_load_mode(EBPF_LOAD_CORE, EBPF_LOADED_FROM_USER);

3499 #ifdef NETDATA_INTERNAL_CHECKS

3269 - netdata_log_info("EBPF running with \"CO-RE\" code, because it was started with the option \"[-]-core\".");

3500 + netdata_log_info(

3501 + "EBPF running with \"CO-RE\" code, because it was started with the option \"[-]-core\".");

3502 #endif

3503 break;

3504 }

@@ -3294,7 +3526,7 @@ static void ebpf_parse_args(int argc, char **argv)

3526 ebpf_ut_cleanup_memory();

3527

3528 exit_code = 0;

3297 -unittest:

3529 + unittest:

3530 exit(exit_code);

3531 }

3532 default: {

@@ -3311,7 +3543,7 @@ unittest:

3543 disable_all_global_charts();

3544 uint64_t idx;

3545 for (idx = 0; idx < EBPF_OPTION_ALL_CHARTS; idx++) {

3314 - if (select_threads & 1<<idx)

3546 + if (select_threads & 1 << idx)

3547 ebpf_enable_specific_chart(&ebpf_modules[idx], disable_cgroups);

3548 }

3549 }

@@ -3319,12 +3551,15 @@ unittest:

3551 // Load apps_groups.conf

3552 if (ebpf_read_apps_groups_conf(

3553 &apps_groups_default_target, &apps_groups_root_target, ebpf_user_config_dir, "groups")) {

3322 - netdata_log_info("Cannot read process groups configuration file '%s/apps_groups.conf'. Will try '%s/apps_groups.conf'",

3323 - ebpf_user_config_dir, ebpf_stock_config_dir);

3554 + netdata_log_info(

3555 + "Cannot read process groups configuration file '%s/apps_groups.conf'. Will try '%s/apps_groups.conf'",

3556 + ebpf_user_config_dir,

3557 + ebpf_stock_config_dir);

3558 if (ebpf_read_apps_groups_conf(

3559 &apps_groups_default_target, &apps_groups_root_target, ebpf_stock_config_dir, "groups")) {

3326 - netdata_log_error("Cannot read process groups '%s/apps_groups.conf'. There are no internal defaults. Failing.",

3327 - ebpf_stock_config_dir);

3560 + netdata_log_error(

3561 + "Cannot read process groups '%s/apps_groups.conf'. There are no internal defaults. Failing.",

3562 + ebpf_stock_config_dir);

3563 ebpf_exit();

3564 }

3565 } else

@@ -3357,10 +3592,9 @@ static inline void ebpf_send_hash_table_pid_data(char *chart, uint32_t idx)

3592 for (i = 0; i < EBPF_MODULE_FUNCTION_IDX; i++) {

3593 ebpf_module_t *wem = &ebpf_modules[i];

3594 if (wem->functions.apps_routine)

3360 - write_chart_dimension((char *)wem->info.thread_name,

3361 - (wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ?

3362 - wem->hash_table_stats[idx]:

3363 - 0);

3595 + write_chart_dimension(

3596 + (char *)wem->info.thread_name,

3597 + (wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ? wem->hash_table_stats[idx] : 0);

3598 }

3599 ebpf_write_end_chart();

3600 }

@@ -3377,8 +3611,8 @@ static inline void ebpf_send_global_hash_table_data()

3611 ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_HASH_TABLES_GLOBAL_ELEMENTS, "");

3612 for (i = 0; i < EBPF_MODULE_FUNCTION_IDX; i++) {

3613 ebpf_module_t *wem = &ebpf_modules[i];

3380 - write_chart_dimension((char *)wem->info.thread_name,

3381 - (wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ? NETDATA_CONTROLLER_END: 0);

3614 + write_chart_dimension(

3615 + (char *)wem->info.thread_name, (wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ? NETDATA_CONTROLLER_END : 0);

3616 }

3617 ebpf_write_end_chart();

3618 }

@@ -3410,17 +3644,18 @@ void ebpf_send_statistic_data()

3644 ebpf_write_end_chart();

3645

3646 ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_LIFE_TIME, "");

3413 - for (i = 0; i < EBPF_MODULE_FUNCTION_IDX ; i++) {

3647 + for (i = 0; i < EBPF_MODULE_FUNCTION_IDX; i++) {

3648 ebpf_module_t *wem = &ebpf_modules[i];

3649 // Threads like VFS is slow to load and this can create an invalid number, this is the motive

3650 // we are also testing wem->lifetime value.

3651 if (wem->functions.fnct_routine)

3652 continue;

3653

3420 - write_chart_dimension((char *)wem->info.thread_name,

3421 - (wem->lifetime && wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ?

3422 - (long long) (wem->lifetime - wem->running_time):

3423 - 0) ;

3654 + write_chart_dimension(

3655 + (char *)wem->info.thread_name,

3656 + (wem->lifetime && wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ?

3657 + (long long)(wem->lifetime - wem->running_time) :

3658 + 0);

3659 }

3660 ebpf_write_end_chart();

3661

@@ -3444,8 +3679,10 @@ void ebpf_send_statistic_data()

3679

3680 ebpf_send_global_hash_table_data();

3681

3447 - ebpf_send_hash_table_pid_data(NETDATA_EBPF_HASH_TABLES_INSERT_PID_ELEMENTS, NETDATA_EBPF_GLOBAL_TABLE_PID_TABLE_ADD);

3448 - ebpf_send_hash_table_pid_data(NETDATA_EBPF_HASH_TABLES_REMOVE_PID_ELEMENTS, NETDATA_EBPF_GLOBAL_TABLE_PID_TABLE_DEL);

3682 + ebpf_send_hash_table_pid_data(

3683 + NETDATA_EBPF_HASH_TABLES_INSERT_PID_ELEMENTS, NETDATA_EBPF_GLOBAL_TABLE_PID_TABLE_ADD);

3684 + ebpf_send_hash_table_pid_data(

3685 + NETDATA_EBPF_HASH_TABLES_REMOVE_PID_ELEMENTS, NETDATA_EBPF_GLOBAL_TABLE_PID_TABLE_DEL);

3686

3687 for (i = 0; i < EBPF_MODULE_FUNCTION_IDX; i++) {

3688 ebpf_module_t *wem = &ebpf_modules[i];

@@ -3457,10 +3694,11 @@ void ebpf_send_statistic_data()

3694 ebpf_write_end_chart();

3695

3696 ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, (char *)wem->functions.fcnt_thread_lifetime_name, "");

3460 - write_chart_dimension((char *)wem->info.thread_name,

3461 - (wem->lifetime && wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ?

3462 - (long long) (wem->lifetime - wem->running_time):

3463 - 0) ;

3697 + write_chart_dimension(

3698 + (char *)wem->info.thread_name,

3699 + (wem->lifetime && wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ?

3700 + (long long)(wem->lifetime - wem->running_time) :

3701 + 0);

3702 ebpf_write_end_chart();

3703 }

3704 }

@@ -3490,25 +3728,22 @@ static void update_internal_metric_variable()

3728 */

3729 static void ebpf_create_pids_chart(int order, int update_every)

3730 {

3493 - ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,

3494 - "monitoring_pid",

3495 - "",

3496 - "Total number of monitored PIDs",

3497 - "pids",

3498 - NETDATA_EBPF_FAMILY,

3499 - NETDATA_EBPF_CHART_TYPE_LINE,

3500 - "netdata.ebpf_pids",

3501 - order,

3502 - update_every,

3503 - "main");

3504 -

3505 - ebpf_write_global_dimension("user",

3506 - "user",

3507 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3508 -

3509 - ebpf_write_global_dimension("kernel",

3510 - "kernel",

3511 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3731 + ebpf_write_chart_cmd(

3732 + NETDATA_MONITORING_FAMILY,

3733 + "monitoring_pid",

3734 + "",

3735 + "Total number of monitored PIDs",

3736 + "pids",

3737 + NETDATA_EBPF_FAMILY,

3738 + NETDATA_EBPF_CHART_TYPE_LINE,

3739 + "netdata.ebpf_pids",

3740 + order,

3741 + update_every,

3742 + "main");

3743 +

3744 + ebpf_write_global_dimension("user", "user", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3745 +

3746 + ebpf_write_global_dimension("kernel", "kernel", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3747 }

3748

3749 /**

@@ -3523,30 +3758,28 @@ static void ebpf_create_pids_chart(int order, int update_every)

3758 * @param update_every time used to update charts

3759 * @param module a module to create a specific chart.

3760 */

3526 -static void ebpf_create_thread_chart(char *name,

3527 - char *title,

3528 - char *units,

3529 - int order,

3530 - int update_every,

3531 - ebpf_module_t *module)

3761 +static void

3762 +ebpf_create_thread_chart(char *name, char *title, char *units, int order, int update_every, ebpf_module_t *module)

3763 {

3764 // common call for specific and all charts.

3534 - ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,

3535 - name,

3536 - "",

3537 - title,

3538 - units,

3539 - NETDATA_EBPF_FAMILY,

3540 - NETDATA_EBPF_CHART_TYPE_LINE,

3541 - NULL,

3542 - order,

3543 - update_every,

3544 - "main");

3765 + ebpf_write_chart_cmd(

3766 + NETDATA_MONITORING_FAMILY,

3767 + name,

3768 + "",

3769 + title,

3770 + units,

3771 + NETDATA_EBPF_FAMILY,

3772 + NETDATA_EBPF_CHART_TYPE_LINE,

3773 + NULL,

3774 + order,

3775 + update_every,

3776 + "main");

3777

3778 if (module) {

3547 - ebpf_write_global_dimension((char *)module->info.thread_name,

3548 - (char *)module->info.thread_name,

3549 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3779 + ebpf_write_global_dimension(

3780 + (char *)module->info.thread_name,

3781 + (char *)module->info.thread_name,

3782 + ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3783 return;

3784 }

3785

@@ -3556,11 +3789,10 @@ static void ebpf_create_thread_chart(char *name,

3789 if (em->functions.fnct_routine)

3790 continue;

3791

3559 - ebpf_write_global_dimension((char *)em->info.thread_name,

3560 - (char *)em->info.thread_name,

3561 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3792 + ebpf_write_global_dimension(

3793 + (char *)em->info.thread_name, (char *)em->info.thread_name, ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3794 }

3563 - }

3795 +}

3796

3797 /**

3798 * Create chart for Load Thread

@@ -3571,25 +3803,28 @@ static void ebpf_create_thread_chart(char *name,

3803 */

3804 static inline void ebpf_create_statistic_load_chart(int update_every)

3805 {

3574 - ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,

3575 - NETDATA_EBPF_LOAD_METHOD,

3576 - "",

3577 - "Load info.",

3578 - "methods",

3579 - NETDATA_EBPF_FAMILY,

3580 - NETDATA_EBPF_CHART_TYPE_LINE,

3581 - NULL,

3582 - NETDATA_EBPF_ORDER_STAT_LOAD_METHOD,

3583 - update_every,

3584 - NETDATA_EBPF_MODULE_NAME_PROCESS);

3585 -

3586 - ebpf_write_global_dimension(load_event_stat[NETDATA_EBPF_LOAD_STAT_LEGACY],

3587 - load_event_stat[NETDATA_EBPF_LOAD_STAT_LEGACY],

3588 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3589 -

3590 - ebpf_write_global_dimension(load_event_stat[NETDATA_EBPF_LOAD_STAT_CORE],

3591 - load_event_stat[NETDATA_EBPF_LOAD_STAT_CORE],

3592 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3806 + ebpf_write_chart_cmd(

3807 + NETDATA_MONITORING_FAMILY,

3808 + NETDATA_EBPF_LOAD_METHOD,

3809 + "",

3810 + "Load info.",

3811 + "methods",

3812 + NETDATA_EBPF_FAMILY,

3813 + NETDATA_EBPF_CHART_TYPE_LINE,

3814 + NULL,

3815 + NETDATA_EBPF_ORDER_STAT_LOAD_METHOD,

3816 + update_every,

3817 + NETDATA_EBPF_MODULE_NAME_PROCESS);

3818 +

3819 + ebpf_write_global_dimension(

3820 + load_event_stat[NETDATA_EBPF_LOAD_STAT_LEGACY],

3821 + load_event_stat[NETDATA_EBPF_LOAD_STAT_LEGACY],

3822 + ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3823 +

3824 + ebpf_write_global_dimension(

3825 + load_event_stat[NETDATA_EBPF_LOAD_STAT_CORE],

3826 + load_event_stat[NETDATA_EBPF_LOAD_STAT_CORE],

3827 + ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3828 }

3829

3830 /**

@@ -3601,21 +3836,20 @@ static inline void ebpf_create_statistic_load_chart(int update_every)

3836 */

3837 static inline void ebpf_create_statistic_kernel_memory(int update_every)

3838 {

3604 - ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,

3605 - NETDATA_EBPF_KERNEL_MEMORY,

3606 - "",

3607 - "Memory allocated for hash tables.",

3608 - "bytes",

3609 - NETDATA_EBPF_FAMILY,

3610 - NETDATA_EBPF_CHART_TYPE_LINE,

3611 - NULL,

3612 - NETDATA_EBPF_ORDER_STAT_KERNEL_MEMORY,

3613 - update_every,

3614 - NETDATA_EBPF_MODULE_NAME_PROCESS);

3615 -

3616 - ebpf_write_global_dimension(memlock_stat,

3617 - memlock_stat,

3618 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3839 + ebpf_write_chart_cmd(

3840 + NETDATA_MONITORING_FAMILY,

3841 + NETDATA_EBPF_KERNEL_MEMORY,

3842 + "",

3843 + "Memory allocated for hash tables.",

3844 + "bytes",

3845 + NETDATA_EBPF_FAMILY,

3846 + NETDATA_EBPF_CHART_TYPE_LINE,

3847 + NULL,

3848 + NETDATA_EBPF_ORDER_STAT_KERNEL_MEMORY,

3849 + update_every,

3850 + NETDATA_EBPF_MODULE_NAME_PROCESS);

3851 +

3852 + ebpf_write_global_dimension(memlock_stat, memlock_stat, ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3853 }

3854

3855 /**

@@ -3627,21 +3861,20 @@ static inline void ebpf_create_statistic_kernel_memory(int update_every)

3861 */

3862 static inline void ebpf_create_statistic_hash_tables(int update_every)

3863 {

3630 - ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,

3631 - NETDATA_EBPF_HASH_TABLES_LOADED,

3632 - "",

3633 - "Number of hash tables loaded.",

3634 - "hash tables",

3635 - NETDATA_EBPF_FAMILY,

3636 - NETDATA_EBPF_CHART_TYPE_LINE,

3637 - NULL,

3638 - NETDATA_EBPF_ORDER_STAT_HASH_TABLES,

3639 - update_every,

3640 - NETDATA_EBPF_MODULE_NAME_PROCESS);

3641 -

3642 - ebpf_write_global_dimension(hash_table_stat,

3643 - hash_table_stat,

3644 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3864 + ebpf_write_chart_cmd(

3865 + NETDATA_MONITORING_FAMILY,

3866 + NETDATA_EBPF_HASH_TABLES_LOADED,

3867 + "",

3868 + "Number of hash tables loaded.",

3869 + "hash tables",

3870 + NETDATA_EBPF_FAMILY,

3871 + NETDATA_EBPF_CHART_TYPE_LINE,

3872 + NULL,

3873 + NETDATA_EBPF_ORDER_STAT_HASH_TABLES,

3874 + update_every,

3875 + NETDATA_EBPF_MODULE_NAME_PROCESS);

3876 +

3877 + ebpf_write_global_dimension(hash_table_stat, hash_table_stat, ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3878 }

3879

3880 /**

@@ -3653,25 +3886,28 @@ static inline void ebpf_create_statistic_hash_tables(int update_every)

3886 */

3887 static inline void ebpf_create_statistic_hash_per_core(int update_every)

3888 {

3656 - ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,

3657 - NETDATA_EBPF_HASH_TABLES_PER_CORE,

3658 - "",

3659 - "How threads are loading hash/array tables.",

3660 - "threads",

3661 - NETDATA_EBPF_FAMILY,

3662 - NETDATA_EBPF_CHART_TYPE_LINE,

3663 - NULL,

3664 - NETDATA_EBPF_ORDER_STAT_HASH_CORE,

3665 - update_every,

3666 - NETDATA_EBPF_MODULE_NAME_PROCESS);

3667 -

3668 - ebpf_write_global_dimension(hash_table_core[NETDATA_EBPF_THREAD_PER_CORE],

3669 - hash_table_core[NETDATA_EBPF_THREAD_PER_CORE],

3670 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3671 -

3672 - ebpf_write_global_dimension(hash_table_core[NETDATA_EBPF_THREAD_UNIQUE],

3673 - hash_table_core[NETDATA_EBPF_THREAD_UNIQUE],

3674 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3889 + ebpf_write_chart_cmd(

3890 + NETDATA_MONITORING_FAMILY,

3891 + NETDATA_EBPF_HASH_TABLES_PER_CORE,

3892 + "",

3893 + "How threads are loading hash/array tables.",

3894 + "threads",

3895 + NETDATA_EBPF_FAMILY,

3896 + NETDATA_EBPF_CHART_TYPE_LINE,

3897 + NULL,

3898 + NETDATA_EBPF_ORDER_STAT_HASH_CORE,

3899 + update_every,

3900 + NETDATA_EBPF_MODULE_NAME_PROCESS);

3901 +

3902 + ebpf_write_global_dimension(

3903 + hash_table_core[NETDATA_EBPF_THREAD_PER_CORE],

3904 + hash_table_core[NETDATA_EBPF_THREAD_PER_CORE],

3905 + ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3906 +

3907 + ebpf_write_global_dimension(

3908 + hash_table_core[NETDATA_EBPF_THREAD_UNIQUE],

3909 + hash_table_core[NETDATA_EBPF_THREAD_UNIQUE],

3910 + ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3911 }

3912

3913 /**

@@ -3683,23 +3919,25 @@ static inline void ebpf_create_statistic_hash_per_core(int update_every)

3919 */

3920 static void ebpf_create_statistic_hash_global_elements(int update_every)

3921 {

3686 - ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,

3687 - NETDATA_EBPF_HASH_TABLES_GLOBAL_ELEMENTS,

3688 - "",

3689 - "Controllers inside global table",

3690 - "rows",

3691 - NETDATA_EBPF_FAMILY,

3692 - NETDATA_EBPF_CHART_TYPE_LINE,

3693 - NULL,

3694 - NETDATA_EBPF_ORDER_STAT_HASH_GLOBAL_TABLE_TOTAL,

3695 - update_every,

3696 - NETDATA_EBPF_MODULE_NAME_PROCESS);

3922 + ebpf_write_chart_cmd(

3923 + NETDATA_MONITORING_FAMILY,

3924 + NETDATA_EBPF_HASH_TABLES_GLOBAL_ELEMENTS,

3925 + "",

3926 + "Controllers inside global table",

3927 + "rows",

3928 + NETDATA_EBPF_FAMILY,

3929 + NETDATA_EBPF_CHART_TYPE_LINE,

3930 + NULL,

3931 + NETDATA_EBPF_ORDER_STAT_HASH_GLOBAL_TABLE_TOTAL,

3932 + update_every,

3933 + NETDATA_EBPF_MODULE_NAME_PROCESS);

3934

3935 int i;

3936 for (i = 0; i < EBPF_MODULE_FUNCTION_IDX; i++) {

3700 - ebpf_write_global_dimension((char *)ebpf_modules[i].info.thread_name,

3701 - (char *)ebpf_modules[i].info.thread_name,

3702 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3937 + ebpf_write_global_dimension(

3938 + (char *)ebpf_modules[i].info.thread_name,

3939 + (char *)ebpf_modules[i].info.thread_name,

3940 + ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

3941 }

3942 }

3943

@@ -3715,25 +3953,27 @@ static void ebpf_create_statistic_hash_global_elements(int update_every)

3953 */

3954 static void ebpf_create_statistic_hash_pid_table(int update_every, char *id, char *title, int order)

3955 {

3718 - ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,

3719 - id,

3720 - "",

3721 - title,

3722 - "rows",

3723 - NETDATA_EBPF_FAMILY,

3724 - NETDATA_EBPF_CHART_TYPE_LINE,

3725 - NULL,

3726 - order,

3727 - update_every,

3728 - NETDATA_EBPF_MODULE_NAME_PROCESS);

3956 + ebpf_write_chart_cmd(

3957 + NETDATA_MONITORING_FAMILY,

3958 + id,

3959 + "",

3960 + title,

3961 + "rows",

3962 + NETDATA_EBPF_FAMILY,

3963 + NETDATA_EBPF_CHART_TYPE_LINE,

3964 + NULL,

3965 + order,

3966 + update_every,

3967 + NETDATA_EBPF_MODULE_NAME_PROCESS);

3968

3969 int i;

3970 for (i = 0; i < EBPF_MODULE_FUNCTION_IDX; i++) {

3971 ebpf_module_t *wem = &ebpf_modules[i];

3972 if (wem->functions.apps_routine)

3734 - ebpf_write_global_dimension((char *)wem->info.thread_name,

3735 - (char *)wem->info.thread_name,

3736 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

3973 + ebpf_write_global_dimension(

3974 + (char *)wem->info.thread_name,

3975 + (char *)wem->info.thread_name,

3976 + ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

3977 }

3978 }

3979

@@ -3756,23 +3996,20 @@ static void ebpf_create_statistic_charts(int update_every)

3996

3997 create_charts = 0;

3998

3759 - ebpf_create_thread_chart(NETDATA_EBPF_THREADS,

3760 - "Threads running.",

3761 - "boolean",

3762 - NETDATA_EBPF_ORDER_STAT_THREADS,

3763 - update_every,

3764 - NULL);

3999 + ebpf_create_thread_chart(

4000 + NETDATA_EBPF_THREADS, "Threads running.", "boolean", NETDATA_EBPF_ORDER_STAT_THREADS, update_every, NULL);

4001

4002 ebpf_create_pids_chart(NETDATA_EBPF_ORDER_PIDS, update_every);

4003

3768 - ebpf_create_thread_chart(NETDATA_EBPF_LIFE_TIME,

3769 - "Time remaining for thread.",

3770 - "seconds",

3771 - NETDATA_EBPF_ORDER_STAT_LIFE_TIME,

3772 - update_every,

3773 - NULL);

4004 + ebpf_create_thread_chart(

4005 + NETDATA_EBPF_LIFE_TIME,

4006 + "Time remaining for thread.",

4007 + "seconds",

4008 + NETDATA_EBPF_ORDER_STAT_LIFE_TIME,

4009 + update_every,

4010 + NULL);

4011

3775 - int i,j;

4012 + int i, j;

4013 char name[256];

4014 for (i = 0, j = NETDATA_EBPF_ORDER_FUNCTION_PER_THREAD; i < EBPF_MODULE_FUNCTION_IDX; i++) {

4015 ebpf_module_t *em = &ebpf_modules[i];

@@ -3782,22 +4019,12 @@ static void ebpf_create_statistic_charts(int update_every)

4019 em->functions.order_thread_chart = j;

4020 snprintfz(name, sizeof(name) - 1, "%s_%s", NETDATA_EBPF_THREADS, em->info.thread_name);

4021 em->functions.fcnt_thread_chart_name = strdupz(name);

3785 - ebpf_create_thread_chart(name,

3786 - "Threads running.",

3787 - "boolean",

3788 - j++,

3789 - update_every,

3790 - em);

4022 + ebpf_create_thread_chart(name, "Threads running.", "boolean", j++, update_every, em);

4023

4024 em->functions.order_thread_lifetime = j;

4025 snprintfz(name, sizeof(name) - 1, "%s_%s", NETDATA_EBPF_LIFE_TIME, em->info.thread_name);

4026 em->functions.fcnt_thread_lifetime_name = strdupz(name);

3795 - ebpf_create_thread_chart(name,

3796 - "Time remaining for thread.",

3797 - "seconds",

3798 - j++,

3799 - update_every,

3800 - em);

4027 + ebpf_create_thread_chart(name, "Time remaining for thread.", "seconds", j++, update_every, em);

4028 }

4029

4030 ebpf_create_statistic_load_chart(update_every);

@@ -3810,15 +4037,17 @@ static void ebpf_create_statistic_charts(int update_every)

4037

4038 ebpf_create_statistic_hash_global_elements(update_every);

4039

3813 - ebpf_create_statistic_hash_pid_table(update_every,

3814 - NETDATA_EBPF_HASH_TABLES_INSERT_PID_ELEMENTS,

3815 - "Elements inserted into PID table",

3816 - NETDATA_EBPF_ORDER_STAT_HASH_PID_TABLE_ADDED);

4040 + ebpf_create_statistic_hash_pid_table(

4041 + update_every,

4042 + NETDATA_EBPF_HASH_TABLES_INSERT_PID_ELEMENTS,

4043 + "Elements inserted into PID table",

4044 + NETDATA_EBPF_ORDER_STAT_HASH_PID_TABLE_ADDED);

4045

3818 - ebpf_create_statistic_hash_pid_table(update_every,

3819 - NETDATA_EBPF_HASH_TABLES_REMOVE_PID_ELEMENTS,

3820 - "Elements removed from PID table",

3821 - NETDATA_EBPF_ORDER_STAT_HASH_PID_TABLE_REMOVED);

4046 + ebpf_create_statistic_hash_pid_table(

4047 + update_every,

4048 + NETDATA_EBPF_HASH_TABLES_REMOVE_PID_ELEMENTS,

4049 + "Elements removed from PID table",

4050 + NETDATA_EBPF_ORDER_STAT_HASH_PID_TABLE_REMOVED);

4051

4052 fflush(stdout);

4053 }

@@ -3861,17 +4090,17 @@ static char *ebpf_get_process_name(pid_t pid)

4090 snprintfz(filename, FILENAME_MAX, "/proc/%d/status", pid);

4091

4092 procfile *ff = procfile_open(filename, " \t", PROCFILE_FLAG_DEFAULT);

3864 - if(unlikely(!ff)) {

4093 + if (unlikely(!ff)) {

4094 netdata_log_error("Cannot open %s", filename);

4095 return name;

4096 }

4097

4098 ff = procfile_readall(ff);

3870 - if(unlikely(!ff))

4099 + if (unlikely(!ff))

4100 return name;

4101

4102 unsigned long i, lines = procfile_lines(ff);

3874 - for(i = 0; i < lines ; i++) {

4103 + for (i = 0; i < lines; i++) {

4104 char *cmp = procfile_lineword(ff, i, 0);

4105 if (!strcmp(cmp, "Name:")) {

4106 name = strdupz(procfile_lineword(ff, i, 1));

@@ -3905,7 +4134,7 @@ static pid_t ebpf_read_previous_pid(char *filename)

4134 length = 63;

4135

4136 buffer[length] = '\0';

3908 - old_pid = (pid_t) str2uint32_t(buffer, NULL);

4137 + old_pid = (pid_t)str2uint32_t(buffer, NULL);

4138 }

4139 fclose(fp);

4140

@@ -3922,16 +4151,16 @@ static pid_t ebpf_read_previous_pid(char *filename)

4151 */

4152 static void ebpf_kill_previous_process(char *filename, pid_t pid)

4153 {

3925 - pid_t old_pid = ebpf_read_previous_pid(filename);

4154 + pid_t old_pid = ebpf_read_previous_pid(filename);

4155 if (!old_pid)

4156 return;

4157

4158 // Process is not running

3930 - char *prev_name = ebpf_get_process_name(old_pid);

4159 + char *prev_name = ebpf_get_process_name(old_pid);

4160 if (!prev_name)

4161 return;

4162

3934 - char *current_name = ebpf_get_process_name(pid);

4163 + char *current_name = ebpf_get_process_name(pid);

4164

4165 if (!strcmp(prev_name, current_name))

4166 kill(old_pid, SIGKILL);

@@ -3977,13 +4206,13 @@ static void ebpf_manage_pid(pid_t pid)

4206 *

4207 * Set static routine before threads to be created.

4208 */

3980 - static void ebpf_set_static_routine()

3981 - {

3982 - int i;

3983 - for (i = 0; ebpf_modules[i].info.thread_name; i++) {

3984 - ebpf_threads[i].start_routine = ebpf_modules[i].functions.start_routine;

3985 - }

3986 - }

4209 +static void ebpf_set_static_routine()

4210 +{

4211 + int i;

4212 + for (i = 0; ebpf_modules[i].info.thread_name; i++) {

4213 + ebpf_threads[i].start_routine = ebpf_modules[i].functions.start_routine;

4214 + }

4215 +}

4216

4217 /**

4218 * Entry point

@@ -4018,7 +4247,7 @@ int main(int argc, char **argv)

4247 ebpf_start_pthread_variables();

4248

4249 netdata_configured_host_prefix = getenv("NETDATA_HOST_PREFIX");

4021 - if(verify_netdata_host_prefix(true) == -1)

4250 + if (verify_netdata_host_prefix(true) == -1)

4251 ebpf_exit();

4252

4253 ebpf_allocate_common_vectors();

@@ -4041,11 +4270,8 @@ int main(int argc, char **argv)

4270

4271 cgroup_integration_thread.start_routine = ebpf_cgroup_integration;

4272

4044 - cgroup_integration_thread.thread = nd_thread_create(

4045 - cgroup_integration_thread.name,

4046 - NETDATA_THREAD_OPTION_DEFAULT,

4047 - ebpf_cgroup_integration,

4048 - NULL);

4273 + cgroup_integration_thread.thread =

4274 + nd_thread_create(cgroup_integration_thread.name, NETDATA_THREAD_OPTION_DEFAULT, ebpf_cgroup_integration, NULL);

4275

4276 uint32_t i;

4277 for (i = 0; ebpf_threads[i].name != NULL; i++) {

@@ -4059,7 +4285,7 @@ int main(int argc, char **argv)

4285 em->lifetime = EBPF_NON_FUNCTION_LIFE_TIME;

4286

4287 if (em->functions.apps_routine && (em->apps_charts || em->cgroup_charts)) {

4062 - collect_pids |= 1<<i;

4288 + collect_pids |= 1 << i;

4289 }

4290 st->thread = nd_thread_create(st->name, NETDATA_THREAD_OPTION_JOINABLE, st->start_routine, em);

4291 } else {

@@ -4069,11 +4295,11 @@ int main(int argc, char **argv)

4295

4296 heartbeat_t hb;

4297 heartbeat_init(&hb, USEC_PER_SEC);

4072 - int update_apps_every = (int) EBPF_CFG_UPDATE_APPS_EVERY_DEFAULT;

4298 + int update_apps_every = (int)EBPF_CFG_UPDATE_APPS_EVERY_DEFAULT;

4299 int update_apps_list = update_apps_every - 1;

4300 int process_maps_per_core = ebpf_modules[EBPF_MODULE_PROCESS_IDX].maps_per_core;

4301 //Plugin will be killed when it receives a signal

4076 - for ( ; !ebpf_plugin_stop(); global_iterations_counter++) {

4302 + for (; !ebpf_plugin_stop(); global_iterations_counter++) {

4303 (void)heartbeat_next(&hb);

4304

4305 if (global_iterations_counter % EBPF_DEFAULT_UPDATE_EVERY == 0) {

@@ -4091,7 +4317,7 @@ int main(int argc, char **argv)

4317 if (collect_pids) {

4318 pthread_mutex_lock(&collect_data_mutex);

4319 ebpf_parse_proc_files();

4094 - if (collect_pids & (1<<EBPF_MODULE_PROCESS_IDX)) {

4320 + if (collect_pids & (1 << EBPF_MODULE_PROCESS_IDX)) {

4321 collect_data_for_all_processes(process_pid_fd, process_maps_per_core);

4322 }

4323

src/collectors/ebpf.plugin/ebpf.h

+62 -48

@@ -99,9 +99,9 @@ typedef struct netdata_ebpf_judy_pid {

99 ARAL *pid_table;

100

101 // Index for PIDs

102 - struct { // support for multiple indexing engines

103 - Pvoid_t JudyLArray; // the hash table

104 - RW_SPINLOCK rw_spinlock; // protect the index

102 + struct { // support for multiple indexing engines

103 + Pvoid_t JudyLArray; // the hash table

104 + RW_SPINLOCK rw_spinlock; // protect the index

105 } index;

106 } netdata_ebpf_judy_pid_t;

107

@@ -109,9 +109,9 @@ typedef struct netdata_ebpf_judy_pid_stats {

109 char *cmdline;

110

111 // Index for Socket timestamp

112 - struct { // support for multiple indexing engines

113 - Pvoid_t JudyLArray; // the hash table

114 - RW_SPINLOCK rw_spinlock; // protect the index

112 + struct { // support for multiple indexing engines

113 + Pvoid_t JudyLArray; // the hash table

114 + RW_SPINLOCK rw_spinlock; // protect the index

115 } socket_stats;

116 } netdata_ebpf_judy_pid_stats_t;

117

@@ -175,10 +175,7 @@ typedef struct ebpf_tracepoint {

175

176 #define EBPF_DEFAULT_UPDATE_EVERY 10

177

178 -enum ebpf_algorithms_list {

179 - NETDATA_EBPF_ABSOLUTE_IDX,

180 - NETDATA_EBPF_INCREMENTAL_IDX

181 -};

178 +enum ebpf_algorithms_list { NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_INCREMENTAL_IDX };

179

180 // Threads

181 void *ebpf_process_thread(void *ptr);

@@ -196,42 +193,45 @@ extern int process_pid_fd;

193 extern pthread_mutex_t collect_data_mutex;

194

195 // Common functions

199 -void ebpf_global_labels(netdata_syscall_stat_t *is,

200 - netdata_publish_syscall_t *pio,

201 - char **dim,

202 - char **name,

203 - int *algorithm,

204 - int end);

205 -

206 -void ebpf_write_chart_cmd(char *type,

207 - char *id,

208 - char *suffix,

209 - char *title,

210 - char *units,

211 - char *family,

212 - char *charttype,

213 - char *context,

214 - int order,

215 - int update_every,

216 - char *module);

196 +void ebpf_global_labels(

197 + netdata_syscall_stat_t *is,

198 + netdata_publish_syscall_t *pio,

199 + char **dim,

200 + char **name,

201 + int *algorithm,

202 + int end);

203 +

204 +void ebpf_write_chart_cmd(

205 + char *type,

206 + char *id,

207 + char *suffix,

208 + char *title,

209 + char *units,

210 + char *family,

211 + char *charttype,

212 + char *context,

213 + int order,

214 + int update_every,

215 + char *module);

216

217 void ebpf_write_global_dimension(char *name, char *id, char *algorithm);

218

219 void ebpf_create_global_dimension(void *ptr, int end);

220

222 -void ebpf_create_chart(char *type,

223 - char *id,

224 - char *title,

225 - char *units,

226 - char *family,

227 - char *context,

228 - char *charttype,

229 - int order,

230 - void (*ncd)(void *, int),

231 - void *move,

232 - int end,

233 - int update_every,

234 - char *module);

221 +void ebpf_create_chart(

222 + char *type,

223 + char *id,

224 + char *title,

225 + char *units,

226 + char *family,

227 + char *context,

228 + char *charttype,

229 + int order,

230 + void (*ncd)(void *, int),

231 + void *move,

232 + int end,

233 + int update_every,

234 + char *module);

235

236 void write_chart_dimension(char *dim, long long value);

237

@@ -239,8 +239,7 @@ void write_count_chart(char *name, char *family, netdata_publish_syscall_t *move

239

240 void write_err_chart(char *name, char *family, netdata_publish_syscall_t *move, int end);

241

242 -void write_io_chart(char *chart, char *family, char *dwrite, long long vwrite,

243 - char *dread, long long vread);

242 +void write_io_chart(char *chart, char *family, char *dwrite, long long vwrite, char *dread, long long vread);

243

244 /**

245 * Create Chart labels

@@ -326,15 +325,29 @@ void ebpf_cachestat_create_apps_charts(struct ebpf_module *em, void *root);

325 void ebpf_one_dimension_write_charts(char *family, char *chart, char *dim, long long v1);

326 collected_number get_value_from_structure(char *basis, size_t offset);

327 void ebpf_update_pid_table(ebpf_local_maps_t *pid, ebpf_module_t *em);

329 -void ebpf_write_chart_obsolete(char *type, char *id, char *suffix, char *title, char *units, char *family,

330 - char *charttype, char *context, int order, int update_every);

328 +void ebpf_write_chart_obsolete(

329 + char *type,

330 + char *id,

331 + char *suffix,

332 + char *title,

333 + char *units,

334 + char *family,

335 + char *charttype,

336 + char *context,

337 + int order,

338 + int update_every);

339 void write_histogram_chart(char *family, char *name, const netdata_idx_t *hist, char **dimensions, uint32_t end);

340 void ebpf_update_disabled_plugin_stats(ebpf_module_t *em);

341 ARAL *ebpf_allocate_pid_aral(char *name, size_t size);

342 void ebpf_unload_legacy_code(struct bpf_object *objects, struct bpf_link **probe_links);

343

336 -void ebpf_read_global_table_stats(netdata_idx_t *stats, netdata_idx_t *values, int map_fd,

337 - int maps_per_core, uint32_t begin, uint32_t end);

344 +void ebpf_read_global_table_stats(

345 + netdata_idx_t *stats,

346 + netdata_idx_t *values,

347 + int map_fd,

348 + int maps_per_core,

349 + uint32_t begin,

350 + uint32_t end);

351 void **ebpf_judy_insert_unsafe(PPvoid_t arr, Word_t key);

352 netdata_ebpf_judy_pid_stats_t *ebpf_get_pid_from_judy_unsafe(PPvoid_t judy_array, uint32_t pid);

353

@@ -348,7 +361,8 @@ extern ebpf_sync_syscalls_t local_syscalls[];

361 extern bool ebpf_plugin_exit;

362 extern uint64_t collect_pids;

363

351 -static inline bool ebpf_plugin_stop(void) {

364 +static inline bool ebpf_plugin_stop(void)

365 +{

366 return ebpf_plugin_exit || nd_thread_signaled_to_cancel();

367 }

368

src/collectors/ebpf.plugin/ebpf_apps.c

+55 -34

@@ -17,7 +17,8 @@ void ebpf_aral_init(void)

17 {

18 size_t max_elements = NETDATA_EBPF_ALLOC_MAX_PID;

19 if (max_elements < NETDATA_EBPF_ALLOC_MIN_ELEMENTS) {

20 - netdata_log_error("Number of elements given is too small, adjusting it for %d", NETDATA_EBPF_ALLOC_MIN_ELEMENTS);

20 + netdata_log_error(

21 + "Number of elements given is too small, adjusting it for %d", NETDATA_EBPF_ALLOC_MIN_ELEMENTS);

22 max_elements = NETDATA_EBPF_ALLOC_MIN_ELEMENTS;

23 }

@@ -122,7 +123,8 @@ void clean_apps_groups_target(struct ebpf_target *agrt)

123 *

124 * @return It returns the target on success and NULL otherwise

125 */

125 -struct ebpf_target *get_apps_groups_target(struct ebpf_target **agrt, const char *id, struct ebpf_target *target, const char *name)

126 +struct ebpf_target *

127 +get_apps_groups_target(struct ebpf_target **agrt, const char *id, struct ebpf_target *target, const char *name)

128 {

129 int tdebug = 0, thidden = target ? target->hidden : 0, ends_with = 0;

130 const char *nid = id;

@@ -164,8 +166,10 @@ struct ebpf_target *get_apps_groups_target(struct ebpf_target **agrt, const char

166

167 if (target && target->target)

168 fatal(

167 - "Internal Error: request to link process '%s' to target '%s' which is linked to target '%s'", id,

168 - target->id, target->target->id);

169 + "Internal Error: request to link process '%s' to target '%s' which is linked to target '%s'",

170 + id,

171 + target->id,

172 + target->target->id);

173

174 w = callocz(1, sizeof(struct ebpf_target));

175 strncpyz(w->id, nid, EBPF_MAX_NAME);

@@ -312,20 +316,19 @@ SPINLOCK ebpf_pid_spinlock = SPINLOCK_INITIALIZER;

316 void ebpf_pid_del(pid_t pid)

317 {

318 spinlock_lock(&ebpf_pid_spinlock);

315 - (void) JudyLDel(&ebpf_pid_judyL, (Word_t) pid, PJE0);

319 + (void)JudyLDel(&ebpf_pid_judyL, (Word_t)pid, PJE0);

320 spinlock_unlock(&ebpf_pid_spinlock);

321 }

322

323 static ebpf_pid_data_t *ebpf_find_pid_data_unsafe(pid_t pid)

324 {

325 ebpf_pid_data_t *pid_data = NULL;

322 - Pvoid_t *Pvalue = JudyLGet(ebpf_pid_judyL, (Word_t) pid, PJE0);

326 + Pvoid_t *Pvalue = JudyLGet(ebpf_pid_judyL, (Word_t)pid, PJE0);

327 if (Pvalue)

328 pid_data = *Pvalue;

329 return pid_data;

330 }

331

328 -

332 ebpf_pid_data_t *ebpf_find_pid_data(pid_t pid)

333 {

334 spinlock_lock(&ebpf_pid_spinlock);

@@ -339,7 +342,7 @@ ebpf_pid_data_t *ebpf_find_or_create_pid_data(pid_t pid)

342 spinlock_lock(&ebpf_pid_spinlock);

343 ebpf_pid_data_t *pid_data = ebpf_find_pid_data_unsafe(pid);

344 if (!pid_data) {

342 - Pvoid_t *Pvalue = JudyLIns(&ebpf_pid_judyL, (Word_t) pid, PJE0);

345 + Pvoid_t *Pvalue = JudyLIns(&ebpf_pid_judyL, (Word_t)pid, PJE0);

346 internal_fatal(!Pvalue || Pvalue == PJERR, "EBPF: pid judy array");

347 if (likely(!*Pvalue))

348 *Pvalue = pid_data = callocz(1, sizeof(*pid_data));

@@ -352,16 +355,15 @@ ebpf_pid_data_t *ebpf_find_or_create_pid_data(pid_t pid)

355 }

356

357 //ebpf_pid_data_t *ebpf_pids = NULL; // to avoid allocations, we pre-allocate the entire pid space.

355 -ebpf_pid_data_t *ebpf_pids_link_list = NULL; // global list of all processes running

358 +ebpf_pid_data_t *ebpf_pids_link_list = NULL; // global list of all processes running

359

357 -size_t ebpf_all_pids_count = 0; // the number of processes running read from /proc

360 +size_t ebpf_all_pids_count = 0; // the number of processes running read from /proc

361 size_t ebpf_hash_table_pids_count = 0; // the number of tasks in our hash tables

362

360 -struct ebpf_target

361 - *apps_groups_default_target = NULL, // the default target

362 - *apps_groups_root_target = NULL, // apps_groups.conf defined

363 - *users_root_target = NULL, // users

364 - *groups_root_target = NULL; // user groups

363 +struct ebpf_target *apps_groups_default_target = NULL, // the default target

364 + *apps_groups_root_target = NULL, // apps_groups.conf defined

365 + *users_root_target = NULL, // users

366 + *groups_root_target = NULL; // user groups

367

368 size_t apps_groups_targets_count = 0; // # of apps_groups.conf targets

369

@@ -435,8 +437,10 @@ static inline void assign_target_to_pid(ebpf_pid_data_t *p)

437 if (unlikely(

438 ((!w->starts_with && !w->ends_with && w->comparehash == hash && !strcmp(w->compare, p->comm)) ||

439 (w->starts_with && !w->ends_with && !strncmp(w->compare, p->comm, w->comparelen)) ||

438 - (!w->starts_with && w->ends_with && pclen >= w->comparelen && !strcmp(w->compare, &p->comm[pclen - w->comparelen])) ||

439 - (proc_pid_cmdline_is_needed && w->starts_with && w->ends_with && p->cmdline && strstr(p->cmdline, w->compare))))) {

440 + (!w->starts_with && w->ends_with && pclen >= w->comparelen &&

441 + !strcmp(w->compare, &p->comm[pclen - w->comparelen])) ||

442 + (proc_pid_cmdline_is_needed && w->starts_with && w->ends_with && p->cmdline &&

443 + strstr(p->cmdline, w->compare))))) {

444 if (w->target)

445 p->target = w->target;

446 else

@@ -561,7 +565,10 @@ static inline int read_proc_pid_stat(ebpf_pid_data_t *p)

565 if (unlikely(debug_enabled || (p->target && p->target->debug_enabled)))

566 debug_log_int(

567 "READ PROC/PID/STAT: %s/proc/%d/stat, process: '%s' on target '%s'",

564 - netdata_configured_host_prefix, p->pid, p->comm, (p->target) ? p->target->name : "UNSET");

568 + netdata_configured_host_prefix,

569 + p->pid,

570 + p->comm,

571 + (p->target) ? p->target->name : "UNSET");

572

573 without_cmdline_target:

574 p->has_proc_file = 1;

@@ -591,7 +598,7 @@ static inline int ebpf_collect_data_for_pid(pid_t pid)

598 read_proc_pid_stat(p);

599

600 // check its parent pid

594 - if (unlikely( p->ppid > (uint32_t)pid_max)) {

601 + if (unlikely(p->ppid > (uint32_t)pid_max)) {

602 netdata_log_error("Pid %d (command '%s') states invalid parent pid %u. Using 0.", pid, p->comm, p->ppid);

603 p->ppid = 0;

604 }

@@ -618,7 +625,7 @@ static inline void link_all_processes_to_their_parents(void)

625 continue;

626 }

627

621 -// pp = &ebpf_pids[p->ppid];

628 + // pp = &ebpf_pids[p->ppid];

629 pp = ebpf_find_pid_data(p->ppid);

630 if (likely(pp && pp->pid)) {

631 p->parent = pp;

@@ -626,8 +633,12 @@ static inline void link_all_processes_to_their_parents(void)

633

634 if (unlikely(debug_enabled || (p->target && p->target->debug_enabled)))

635 debug_log_int(

629 - "child %d (%s) on target '%s' has parent %d (%s).", p->pid, p->comm,

630 - (p->target) ? p->target->name : "UNSET", pp->pid, pp->comm);

636 + "child %d (%s) on target '%s' has parent %d (%s).",

637 + p->pid,

638 + p->comm,

639 + (p->target) ? p->target->name : "UNSET",

640 + pp->pid,

641 + pp->comm);

642 } else {

643 p->parent = NULL;

644 debug_log("pid %d %s states parent %d, but the later does not exist.", p->pid, p->comm, p->ppid);

@@ -660,8 +671,12 @@ static void apply_apps_groups_targets_inheritance(void)

671

672 if (debug_enabled || (p->target && p->target->debug_enabled))

673 debug_log_int(

663 - "TARGET INHERITANCE: %s is inherited by %u (%s) from its parent %d (%s).", p->target->name,

664 - p->pid, p->comm, p->parent->pid, p->parent->comm);

674 + "TARGET INHERITANCE: %s is inherited by %u (%s) from its parent %d (%s).",

675 + p->target->name,

676 + p->pid,

677 + p->comm,

678 + p->parent->pid,

679 + p->parent->comm);

680 }

681 }

682 }

@@ -699,8 +714,12 @@ static void apply_apps_groups_targets_inheritance(void)

714

715 if (debug_enabled || (p->target && p->target->debug_enabled))

716 debug_log_int(

702 - "TARGET INHERITANCE: %s is inherited by %d (%s) from its child %d (%s).", p->target->name,

703 - p->parent->pid, p->parent->comm, p->pid, p->comm);

717 + "TARGET INHERITANCE: %s is inherited by %d (%s) from its child %d (%s).",

718 + p->target->name,

719 + p->parent->pid,

720 + p->parent->comm,

721 + p->pid,

722 + p->comm);

723 }

724

725 found++;

@@ -713,7 +732,7 @@ static void apply_apps_groups_targets_inheritance(void)

732 // init goes always to default target

733 ebpf_pid_data_t *pid_entry = ebpf_find_or_create_pid_data(INIT_PID);

734 pid_entry->target = apps_groups_default_target;

716 -// ebpf_pids[INIT_PID].target = apps_groups_default_target;

735 + // ebpf_pids[INIT_PID].target = apps_groups_default_target;

736

737 // pid 0 goes always to default target

738 pid_entry = ebpf_find_or_create_pid_data(0);

@@ -752,7 +771,11 @@ static void apply_apps_groups_targets_inheritance(void)

771 if (debug_enabled || (p->target && p->target->debug_enabled))

772 debug_log_int(

773 "TARGET INHERITANCE: %s is inherited by %d (%s) from its parent %d (%s) at phase 2.",

755 - p->target->name, p->pid, p->comm, p->parent->pid, p->parent->comm);

774 + p->target->name,

775 + p->pid,

776 + p->comm,

777 + p->parent->pid,

778 + p->parent->comm);

779 }

780 }

781 }

@@ -786,7 +809,6 @@ static inline void post_aggregate_targets(struct ebpf_target *root)

809 */

810 void ebpf_del_pid_entry(pid_t pid)

811 {

789 -

812 //ebpf_pid_data_t *p = &ebpf_pids[pid];

813 ebpf_pid_data_t *p = ebpf_find_pid_data(pid);

814

@@ -810,7 +832,8 @@ void ebpf_del_pid_entry(pid_t pid)

832 Word_t local_socket = 0;

833 Pvoid_t *socket_value;

834 bool first_socket = true;

813 - while ((socket_value = JudyLFirstThenNext(pid_ptr->socket_stats.JudyLArray, &local_socket, &first_socket))) {

835 + while (

836 + (socket_value = JudyLFirstThenNext(pid_ptr->socket_stats.JudyLArray, &local_socket, &first_socket))) {

837 netdata_socket_plus_t *socket_clean = *socket_value;

838 aral_freez(aral_socket_table, socket_clean);

839 }

@@ -968,12 +991,11 @@ void collect_data_for_all_processes(int tbl_pid_stats_fd, int maps_per_core)

991 return;

992

993 pids_fd[NETDATA_EBPF_PIDS_PROCESS_IDX] = tbl_pid_stats_fd;

971 - size_t length = sizeof(ebpf_process_stat_t);

994 + size_t length = sizeof(ebpf_process_stat_t);

995 if (maps_per_core)

996 length *= ebpf_nprocs;

997

998 if (tbl_pid_stats_fd != -1) {

976 -

999 uint32_t key = 0, next_key = 0;

1000 while (bpf_map_get_next_key(tbl_pid_stats_fd, &key, &next_key) == 0) {

1001 if (bpf_map_lookup_elem(tbl_pid_stats_fd, &key, process_stat_vector)) {

@@ -1005,7 +1027,7 @@ void collect_data_for_all_processes(int tbl_pid_stats_fd, int maps_per_core)

1027 }

1028 }

1029

1008 -end_process_loop:

1030 + end_process_loop:

1031 memset(process_stat_vector, 0, length);

1032 key = next_key;

1033 }

@@ -1018,7 +1040,6 @@ end_process_loop:

1040

1041 ebpf_process_sum_values_for_pids(&w->process, w->root_pid);

1042 }

1021 -

1043 }

1044

1045 /**

src/collectors/ebpf.plugin/ebpf_apps.h

+13 -12

@@ -146,7 +146,7 @@ typedef struct __attribute__((packed)) ebpf_pid_data {

146

147 uint32_t has_proc_file;

148 uint32_t not_updated;

149 - int children_count; // number of processes directly referencing this

149 + int children_count; // number of processes directly referencing this

150 int merged;

151 int sortlist; // higher numbers = top on the process tree

152

@@ -270,10 +270,11 @@ static inline void ebpf_process_release_publish(ebpf_publish_process_t *ptr)

270

271 ebpf_pid_data_t *ebpf_find_or_create_pid_data(pid_t pid);

272

273 -static inline ebpf_pid_data_t *ebpf_get_pid_data(uint32_t pid, uint32_t tgid, char *name, uint32_t idx) {

274 -// ebpf_pid_data_t *ptr = &ebpf_pids[pid];

273 +static inline ebpf_pid_data_t *ebpf_get_pid_data(uint32_t pid, uint32_t tgid, char *name, uint32_t idx)

274 +{

275 + // ebpf_pid_data_t *ptr = &ebpf_pids[pid];

276 ebpf_pid_data_t *ptr = ebpf_find_or_create_pid_data(pid);

276 - ptr->thread_collecting |= 1<<idx;

277 + ptr->thread_collecting |= 1 << idx;

278 // The caller is getting data to work.

279 if (!name && idx != NETDATA_EBPF_PIDS_PROC_FILE)

280 return ptr;

@@ -305,7 +306,7 @@ static inline void ebpf_release_pid_data(ebpf_pid_data_t *eps, int fd, uint32_t

306 if (fd) {

307 bpf_map_delete_elem(fd, &key);

308 }

308 - eps->thread_collecting &= ~(1<<idx);

309 + eps->thread_collecting &= ~(1 << idx);

310 if (!eps->thread_collecting && !eps->has_proc_file) {

311 ebpf_del_pid_entry((pid_t)key);

312 }

@@ -316,7 +317,7 @@ static inline void ebpf_reset_specific_pid_data(ebpf_pid_data_t *ptr)

317 int idx;

318 uint32_t pid = ptr->pid;

319 for (idx = NETDATA_EBPF_PIDS_PROCESS_IDX; idx < NETDATA_EBPF_PIDS_PROC_FILE; idx++) {

319 - if (!(ptr->thread_collecting & (1<<idx))) {

320 + if (!(ptr->thread_collecting & (1 << idx))) {

321 continue;

322 }

323 // Check if we still have the map loaded

@@ -361,7 +362,6 @@ static inline void ebpf_reset_specific_pid_data(ebpf_pid_data_t *ptr)

362 ebpf_del_pid_entry(pid);

363 }

364

364 -

365 typedef struct ebpf_pid_stat {

366 uint32_t pid;

367 uint64_t thread_collecting;

@@ -448,10 +448,11 @@ static inline void debug_log_int(const char *fmt, ...)

448 // ----------------------------------------------------------------------------

449 // Exported variabled and functions

450 //

451 -int ebpf_read_apps_groups_conf(struct ebpf_target **apps_groups_default_target,

452 - struct ebpf_target **apps_groups_root_target,

453 - const char *path,

454 - const char *file);

451 +int ebpf_read_apps_groups_conf(

452 + struct ebpf_target **apps_groups_default_target,

453 + struct ebpf_target **apps_groups_root_target,

454 + const char *path,

455 + const char *file);

456

457 void clean_apps_groups_target(struct ebpf_target *apps_groups_root_target);

458

@@ -469,7 +470,7 @@ void ebpf_process_apps_accumulator(ebpf_process_stat_t *out, int maps_per_core);

470 // The default value is at least 32 times smaller than maximum number of PIDs allowed on system,

471 // this is only possible because we are using ARAL (https://github.com/netdata/netdata/tree/master/src/libnetdata/aral).

472 #ifndef NETDATA_EBPF_ALLOC_MAX_PID

472 -# define NETDATA_EBPF_ALLOC_MAX_PID 1024

473 +#define NETDATA_EBPF_ALLOC_MAX_PID 1024

474 #endif

475 #define NETDATA_EBPF_ALLOC_MIN_ELEMENTS 256

476

src/collectors/ebpf.plugin/ebpf_cachestat.c

+542 -421

@@ -3,8 +3,7 @@

3 #include "ebpf.h"

4 #include "ebpf_cachestat.h"

6 -static char *cachestat_counter_dimension_name[NETDATA_CACHESTAT_END] = { "ratio", "dirty", "hit",

7 - "miss" };

6 +static char *cachestat_counter_dimension_name[NETDATA_CACHESTAT_END] = {"ratio", "dirty", "hit", "miss"};

7 static netdata_syscall_stat_t cachestat_counter_aggregated_data[NETDATA_CACHESTAT_END];

8 static netdata_publish_syscall_t cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_END];

@@ -13,46 +12,57 @@ netdata_cachestat_pid_t *cachestat_vector = NULL;

12 static netdata_idx_t cachestat_hash_values[NETDATA_CACHESTAT_END];

13 static netdata_idx_t *cachestat_values = NULL;

16 -ebpf_local_maps_t cachestat_maps[] = {{.name = "cstat_global", .internal_input = NETDATA_CACHESTAT_END,

17 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

18 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

15 +ebpf_local_maps_t cachestat_maps[] = {

16 + {.name = "cstat_global",

17 + .internal_input = NETDATA_CACHESTAT_END,

18 + .user_input = 0,

19 + .type = NETDATA_EBPF_MAP_STATIC,

20 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

21 #ifdef LIBBPF_MAJOR_VERSION

20 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

22 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

23 #endif

22 - },

23 - {.name = "cstat_pid", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

24 - .user_input = 0,

25 - .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

26 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

24 + },

25 + {.name = "cstat_pid",

26 + .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

27 + .user_input = 0,

28 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

29 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

30 #ifdef LIBBPF_MAJOR_VERSION

28 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

31 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

32 #endif

30 - },

31 - {.name = "cstat_ctrl", .internal_input = NETDATA_CONTROLLER_END,

32 - .user_input = 0,

33 - .type = NETDATA_EBPF_MAP_CONTROLLER,

34 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

33 + },

34 + {.name = "cstat_ctrl",

35 + .internal_input = NETDATA_CONTROLLER_END,

36 + .user_input = 0,

37 + .type = NETDATA_EBPF_MAP_CONTROLLER,

38 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

39 #ifdef LIBBPF_MAJOR_VERSION

36 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

40 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

41 #endif

38 - },

39 - {.name = NULL, .internal_input = 0, .user_input = 0,

40 - .type = NETDATA_EBPF_MAP_CONTROLLER,

41 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

42 + },

43 + {

44 + .name = NULL,

45 + .internal_input = 0,

46 + .user_input = 0,

47 + .type = NETDATA_EBPF_MAP_CONTROLLER,

48 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

49 #ifdef LIBBPF_MAJOR_VERSION

50 #endif

44 - }};

51 + }};

53 struct config cachestat_config = APPCONFIG_INITIALIZER;

48 -netdata_ebpf_targets_t cachestat_targets[] = { {.name = "add_to_page_cache_lru", .mode = EBPF_LOAD_TRAMPOLINE},

49 - {.name = "mark_page_accessed", .mode = EBPF_LOAD_TRAMPOLINE},

50 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE},

51 - {.name = "mark_buffer_dirty", .mode = EBPF_LOAD_TRAMPOLINE},

52 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

55 +netdata_ebpf_targets_t cachestat_targets[] = {

56 + {.name = "add_to_page_cache_lru", .mode = EBPF_LOAD_TRAMPOLINE},

57 + {.name = "mark_page_accessed", .mode = EBPF_LOAD_TRAMPOLINE},

58 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE},

59 + {.name = "mark_buffer_dirty", .mode = EBPF_LOAD_TRAMPOLINE},

60 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

54 -static char *account_page[NETDATA_CACHESTAT_ACCOUNT_DIRTY_END] ={ "account_page_dirtied",

55 - "__set_page_dirty", "__folio_mark_dirty" };

62 +static char *account_page[NETDATA_CACHESTAT_ACCOUNT_DIRTY_END] = {

63 + "account_page_dirtied",

64 + "__set_page_dirty",

65 + "__folio_mark_dirty"};

67 struct netdata_static_thread ebpf_read_cachestat = {

68 .name = "EBPF_READ_CACHESTAT",

@@ -62,8 +72,7 @@ struct netdata_static_thread ebpf_read_cachestat = {

72 .enabled = 1,

73 .thread = NULL,

74 .init_routine = NULL,

65 - .start_routine = NULL

66 -};

75 + .start_routine = NULL};

77 #ifdef LIBBPF_MAJOR_VERSION

78 /**

@@ -92,12 +101,14 @@ static void ebpf_cachestat_disable_probe(struct cachestat_bpf *obj)

101 */

102 static void ebpf_cachestat_disable_specific_probe(struct cachestat_bpf *obj)

103 {

95 - if (!strcmp(cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

96 - account_page[NETDATA_CACHESTAT_FOLIO_DIRTY])) {

104 + if (!strcmp(

105 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

106 + account_page[NETDATA_CACHESTAT_FOLIO_DIRTY])) {

107 bpf_program__set_autoload(obj->progs.netdata_account_page_dirtied_kprobe, false);

108 bpf_program__set_autoload(obj->progs.netdata_set_page_dirty_kprobe, false);

99 - } else if (!strcmp(cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

100 - account_page[NETDATA_CACHESTAT_SET_PAGE_DIRTY])) {

109 + } else if (!strcmp(

110 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

111 + account_page[NETDATA_CACHESTAT_SET_PAGE_DIRTY])) {

112 bpf_program__set_autoload(obj->progs.netdata_folio_mark_dirty_kprobe, false);

113 bpf_program__set_autoload(obj->progs.netdata_account_page_dirtied_kprobe, false);

114 } else {

@@ -132,12 +143,14 @@ static void ebpf_cachestat_disable_trampoline(struct cachestat_bpf *obj)

143 */

144 static void ebpf_cachestat_disable_specific_trampoline(struct cachestat_bpf *obj)

145 {

135 - if (!strcmp(cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

136 - account_page[NETDATA_CACHESTAT_FOLIO_DIRTY])) {

146 + if (!strcmp(

147 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

148 + account_page[NETDATA_CACHESTAT_FOLIO_DIRTY])) {

149 bpf_program__set_autoload(obj->progs.netdata_account_page_dirtied_fentry, false);

150 bpf_program__set_autoload(obj->progs.netdata_set_page_dirty_fentry, false);

139 - } else if (!strcmp(cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

140 - account_page[NETDATA_CACHESTAT_SET_PAGE_DIRTY])) {

151 + } else if (!strcmp(

152 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

153 + account_page[NETDATA_CACHESTAT_SET_PAGE_DIRTY])) {

154 bpf_program__set_autoload(obj->progs.netdata_folio_mark_dirty_fentry, false);

155 bpf_program__set_autoload(obj->progs.netdata_account_page_dirtied_fentry, false);

156 } else {

@@ -155,27 +168,37 @@ static void ebpf_cachestat_disable_specific_trampoline(struct cachestat_bpf *obj

168 */

169 static inline void netdata_set_trampoline_target(struct cachestat_bpf *obj)

170 {

158 - bpf_program__set_attach_target(obj->progs.netdata_add_to_page_cache_lru_fentry, 0,

159 - cachestat_targets[NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU].name);

160 -

161 - bpf_program__set_attach_target(obj->progs.netdata_mark_page_accessed_fentry, 0,

162 - cachestat_targets[NETDATA_KEY_CALLS_MARK_PAGE_ACCESSED].name);

163 -

164 - if (!strcmp(cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

165 - account_page[NETDATA_CACHESTAT_FOLIO_DIRTY])) {

166 - bpf_program__set_attach_target(obj->progs.netdata_folio_mark_dirty_fentry, 0,

167 - cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

168 - } else if (!strcmp(cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

169 - account_page[NETDATA_CACHESTAT_SET_PAGE_DIRTY])) {

170 - bpf_program__set_attach_target(obj->progs.netdata_set_page_dirty_fentry, 0,

171 - cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

171 + bpf_program__set_attach_target(

172 + obj->progs.netdata_add_to_page_cache_lru_fentry,

173 + 0,

174 + cachestat_targets[NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU].name);

175 +

176 + bpf_program__set_attach_target(

177 + obj->progs.netdata_mark_page_accessed_fentry, 0, cachestat_targets[NETDATA_KEY_CALLS_MARK_PAGE_ACCESSED].name);

178 +

179 + if (!strcmp(

180 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

181 + account_page[NETDATA_CACHESTAT_FOLIO_DIRTY])) {

182 + bpf_program__set_attach_target(

183 + obj->progs.netdata_folio_mark_dirty_fentry,

184 + 0,

185 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

186 + } else if (!strcmp(

187 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

188 + account_page[NETDATA_CACHESTAT_SET_PAGE_DIRTY])) {

189 + bpf_program__set_attach_target(

190 + obj->progs.netdata_set_page_dirty_fentry,

191 + 0,

192 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

193 } else {

173 - bpf_program__set_attach_target(obj->progs.netdata_account_page_dirtied_fentry, 0,

174 - cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

194 + bpf_program__set_attach_target(

195 + obj->progs.netdata_account_page_dirtied_fentry,

196 + 0,

197 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

198 }

199

177 - bpf_program__set_attach_target(obj->progs.netdata_mark_buffer_dirty_fentry, 0,

178 - cachestat_targets[NETDATA_KEY_CALLS_MARK_BUFFER_DIRTY].name);

200 + bpf_program__set_attach_target(

201 + obj->progs.netdata_mark_buffer_dirty_fentry, 0, cachestat_targets[NETDATA_KEY_CALLS_MARK_BUFFER_DIRTY].name);

202 }

203

204 /**

@@ -189,45 +212,53 @@ static inline void netdata_set_trampoline_target(struct cachestat_bpf *obj)

212 */

213 static int ebpf_cachestat_attach_probe(struct cachestat_bpf *obj)

214 {

192 - obj->links.netdata_add_to_page_cache_lru_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_add_to_page_cache_lru_kprobe,

193 - false,

194 - cachestat_targets[NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU].name);

215 + obj->links.netdata_add_to_page_cache_lru_kprobe = bpf_program__attach_kprobe(

216 + obj->progs.netdata_add_to_page_cache_lru_kprobe,

217 + false,

218 + cachestat_targets[NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU].name);

219 long ret = libbpf_get_error(obj->links.netdata_add_to_page_cache_lru_kprobe);

220 if (ret)

221 return -1;

222

199 - obj->links.netdata_mark_page_accessed_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_mark_page_accessed_kprobe,

200 - false,

201 - cachestat_targets[NETDATA_KEY_CALLS_MARK_PAGE_ACCESSED].name);

223 + obj->links.netdata_mark_page_accessed_kprobe = bpf_program__attach_kprobe(

224 + obj->progs.netdata_mark_page_accessed_kprobe,

225 + false,

226 + cachestat_targets[NETDATA_KEY_CALLS_MARK_PAGE_ACCESSED].name);

227 ret = libbpf_get_error(obj->links.netdata_mark_page_accessed_kprobe);

228 if (ret)

229 return -1;

230

206 - if (!strcmp(cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

207 - account_page[NETDATA_CACHESTAT_FOLIO_DIRTY])) {

208 - obj->links.netdata_folio_mark_dirty_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_folio_mark_dirty_kprobe,

209 - false,

210 - cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

231 + if (!strcmp(

232 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

233 + account_page[NETDATA_CACHESTAT_FOLIO_DIRTY])) {

234 + obj->links.netdata_folio_mark_dirty_kprobe = bpf_program__attach_kprobe(

235 + obj->progs.netdata_folio_mark_dirty_kprobe,

236 + false,

237 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

238 ret = libbpf_get_error(obj->links.netdata_folio_mark_dirty_kprobe);

212 - } else if (!strcmp(cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

213 - account_page[NETDATA_CACHESTAT_SET_PAGE_DIRTY])) {

214 - obj->links.netdata_set_page_dirty_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_set_page_dirty_kprobe,

215 - false,

216 - cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

239 + } else if (!strcmp(

240 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name,

241 + account_page[NETDATA_CACHESTAT_SET_PAGE_DIRTY])) {

242 + obj->links.netdata_set_page_dirty_kprobe = bpf_program__attach_kprobe(

243 + obj->progs.netdata_set_page_dirty_kprobe,

244 + false,

245 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

246 ret = libbpf_get_error(obj->links.netdata_set_page_dirty_kprobe);

247 } else {

219 - obj->links.netdata_account_page_dirtied_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_account_page_dirtied_kprobe,

220 - false,

221 - cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

248 + obj->links.netdata_account_page_dirtied_kprobe = bpf_program__attach_kprobe(

249 + obj->progs.netdata_account_page_dirtied_kprobe,

250 + false,

251 + cachestat_targets[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED].name);

252 ret = libbpf_get_error(obj->links.netdata_account_page_dirtied_kprobe);

253 }

254

255 if (ret)

256 return -1;

257

228 - obj->links.netdata_mark_buffer_dirty_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_mark_buffer_dirty_kprobe,

229 - false,

230 - cachestat_targets[NETDATA_KEY_CALLS_MARK_BUFFER_DIRTY].name);

258 + obj->links.netdata_mark_buffer_dirty_kprobe = bpf_program__attach_kprobe(

259 + obj->progs.netdata_mark_buffer_dirty_kprobe,

260 + false,

261 + cachestat_targets[NETDATA_KEY_CALLS_MARK_BUFFER_DIRTY].name);

262 ret = libbpf_get_error(obj->links.netdata_mark_buffer_dirty_kprobe);

263 if (ret)

264 return -1;

@@ -245,8 +276,8 @@ static int ebpf_cachestat_attach_probe(struct cachestat_bpf *obj)

276 */

277 static void ebpf_cachestat_adjust_map(struct cachestat_bpf *obj, ebpf_module_t *em)

278 {

248 - ebpf_update_map_size(obj->maps.cstat_pid, &cachestat_maps[NETDATA_CACHESTAT_PID_STATS],

249 - em, bpf_map__name(obj->maps.cstat_pid));

279 + ebpf_update_map_size(

280 + obj->maps.cstat_pid, &cachestat_maps[NETDATA_CACHESTAT_PID_STATS], em, bpf_map__name(obj->maps.cstat_pid));

281

282 ebpf_update_map_type(obj->maps.cstat_global, &cachestat_maps[NETDATA_CACHESTAT_GLOBAL_STATS]);

283 ebpf_update_map_type(obj->maps.cstat_pid, &cachestat_maps[NETDATA_CACHESTAT_PID_STATS]);

@@ -326,49 +357,53 @@ static void ebpf_obsolete_specific_cachestat_charts(char *type, int update_every

357 */

358 static void ebpf_obsolete_cachestat_services(ebpf_module_t *em, char *id)

359 {

329 - ebpf_write_chart_obsolete(id,

330 - NETDATA_CACHESTAT_HIT_RATIO_CHART,

331 - "",

332 - "Hit ratio",

333 - EBPF_COMMON_UNITS_PERCENTAGE,

334 - NETDATA_CACHESTAT_SUBMENU,

335 - NETDATA_EBPF_CHART_TYPE_LINE,

336 - NETDATA_SYSTEMD_CACHESTAT_HIT_RATIO_CONTEXT,

337 - 21100,

338 - em->update_every);

339 -

340 - ebpf_write_chart_obsolete(id,

341 - NETDATA_CACHESTAT_DIRTY_CHART,

342 - "",

343 - "Number of dirty pages",

344 - EBPF_CACHESTAT_UNITS_PAGE,

345 - NETDATA_CACHESTAT_SUBMENU,

346 - NETDATA_EBPF_CHART_TYPE_LINE,

347 - NETDATA_SYSTEMD_CACHESTAT_MODIFIED_CACHE_CONTEXT,

348 - 21101,

349 - em->update_every);

350 -

351 - ebpf_write_chart_obsolete(id,

352 - NETDATA_CACHESTAT_HIT_CHART,

353 - "",

354 - "Number of accessed files",

355 - EBPF_CACHESTAT_UNITS_HITS,

356 - NETDATA_CACHESTAT_SUBMENU,

357 - NETDATA_EBPF_CHART_TYPE_LINE,

358 - NETDATA_SYSTEMD_CACHESTAT_HIT_FILE_CONTEXT,

359 - 21102,

360 - em->update_every);

361 -

362 - ebpf_write_chart_obsolete(id,

363 - NETDATA_CACHESTAT_MISSES_CHART,

364 - "",

365 - "Files out of page cache",

366 - EBPF_CACHESTAT_UNITS_MISSES,

367 - NETDATA_CACHESTAT_SUBMENU,

368 - NETDATA_EBPF_CHART_TYPE_LINE,

369 - NETDATA_SYSTEMD_CACHESTAT_MISS_FILES_CONTEXT,

370 - 21103,

371 - em->update_every);

360 + ebpf_write_chart_obsolete(

361 + id,

362 + NETDATA_CACHESTAT_HIT_RATIO_CHART,

363 + "",

364 + "Hit ratio",

365 + EBPF_COMMON_UNITS_PERCENTAGE,

366 + NETDATA_CACHESTAT_SUBMENU,

367 + NETDATA_EBPF_CHART_TYPE_LINE,

368 + NETDATA_SYSTEMD_CACHESTAT_HIT_RATIO_CONTEXT,

369 + 21100,

370 + em->update_every);

371 +

372 + ebpf_write_chart_obsolete(

373 + id,

374 + NETDATA_CACHESTAT_DIRTY_CHART,

375 + "",

376 + "Number of dirty pages",

377 + EBPF_CACHESTAT_UNITS_PAGE,

378 + NETDATA_CACHESTAT_SUBMENU,

379 + NETDATA_EBPF_CHART_TYPE_LINE,

380 + NETDATA_SYSTEMD_CACHESTAT_MODIFIED_CACHE_CONTEXT,

381 + 21101,

382 + em->update_every);

383 +

384 + ebpf_write_chart_obsolete(

385 + id,

386 + NETDATA_CACHESTAT_HIT_CHART,

387 + "",

388 + "Number of accessed files",

389 + EBPF_CACHESTAT_UNITS_HITS,

390 + NETDATA_CACHESTAT_SUBMENU,

391 + NETDATA_EBPF_CHART_TYPE_LINE,

392 + NETDATA_SYSTEMD_CACHESTAT_HIT_FILE_CONTEXT,

393 + 21102,

394 + em->update_every);

395 +

396 + ebpf_write_chart_obsolete(

397 + id,

398 + NETDATA_CACHESTAT_MISSES_CHART,

399 + "",

400 + "Files out of page cache",

401 + EBPF_CACHESTAT_UNITS_MISSES,

402 + NETDATA_CACHESTAT_SUBMENU,

403 + NETDATA_EBPF_CHART_TYPE_LINE,

404 + NETDATA_SYSTEMD_CACHESTAT_MISS_FILES_CONTEXT,

405 + 21103,

406 + em->update_every);

407 }

408

409 /**

@@ -378,11 +413,12 @@ static void ebpf_obsolete_cachestat_services(ebpf_module_t *em, char *id)

413 *

414 * @param em a pointer to `struct ebpf_module`

415 */

381 -static inline void ebpf_obsolete_cachestat_cgroup_charts(ebpf_module_t *em) {

416 +static inline void ebpf_obsolete_cachestat_cgroup_charts(ebpf_module_t *em)

417 +{

418 pthread_mutex_lock(&mutex_cgroup_shm);

419

420 ebpf_cgroup_target_t *ect;

385 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

421 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

422 if (ect->systemd) {

423 ebpf_obsolete_cachestat_services(em, ect->name);

424

@@ -403,49 +439,53 @@ static inline void ebpf_obsolete_cachestat_cgroup_charts(ebpf_module_t *em) {

439 */

440 static void ebpf_obsolete_cachestat_global(ebpf_module_t *em)

441 {

406 - ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,

407 - NETDATA_CACHESTAT_HIT_RATIO_CHART,

408 - "",

409 - "Hit ratio",

410 - EBPF_COMMON_UNITS_PERCENTAGE,

411 - NETDATA_CACHESTAT_SUBMENU,

412 - NETDATA_EBPF_CHART_TYPE_LINE,

413 - NETDATA_MEM_CACHESTAT_HIT_RATIO_CONTEXT,

414 - 21100,

415 - em->update_every);

416 -

417 - ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,

418 - NETDATA_CACHESTAT_DIRTY_CHART,

419 - "",

420 - "Number of dirty pages",

421 - EBPF_CACHESTAT_UNITS_PAGE,

422 - NETDATA_CACHESTAT_SUBMENU,

423 - NETDATA_EBPF_CHART_TYPE_LINE,

424 - NETDATA_MEM_CACHESTAT_MODIFIED_CACHE_CONTEXT,

425 - 21101,

426 - em->update_every);

427 -

428 - ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,

429 - NETDATA_CACHESTAT_HIT_CHART,

430 - "",

431 - "Number of accessed files",

432 - EBPF_CACHESTAT_UNITS_HITS,

433 - NETDATA_CACHESTAT_SUBMENU,

434 - NETDATA_EBPF_CHART_TYPE_LINE,

435 - NETDATA_MEM_CACHESTAT_HIT_FILES_CONTEXT,

436 - 21102,

437 - em->update_every);

438 -

439 - ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,

440 - NETDATA_CACHESTAT_MISSES_CHART,

441 - "",

442 - "Files out of page cache",

443 - EBPF_CACHESTAT_UNITS_MISSES,

444 - NETDATA_CACHESTAT_SUBMENU,

445 - NETDATA_EBPF_CHART_TYPE_LINE,

446 - NETDATA_MEM_CACHESTAT_MISS_FILES_CONTEXT,

447 - 21103,

448 - em->update_every);

442 + ebpf_write_chart_obsolete(

443 + NETDATA_EBPF_MEMORY_GROUP,

444 + NETDATA_CACHESTAT_HIT_RATIO_CHART,

445 + "",

446 + "Hit ratio",

447 + EBPF_COMMON_UNITS_PERCENTAGE,

448 + NETDATA_CACHESTAT_SUBMENU,

449 + NETDATA_EBPF_CHART_TYPE_LINE,

450 + NETDATA_MEM_CACHESTAT_HIT_RATIO_CONTEXT,

451 + 21100,

452 + em->update_every);

453 +

454 + ebpf_write_chart_obsolete(

455 + NETDATA_EBPF_MEMORY_GROUP,

456 + NETDATA_CACHESTAT_DIRTY_CHART,

457 + "",

458 + "Number of dirty pages",

459 + EBPF_CACHESTAT_UNITS_PAGE,

460 + NETDATA_CACHESTAT_SUBMENU,

461 + NETDATA_EBPF_CHART_TYPE_LINE,

462 + NETDATA_MEM_CACHESTAT_MODIFIED_CACHE_CONTEXT,

463 + 21101,

464 + em->update_every);

465 +

466 + ebpf_write_chart_obsolete(

467 + NETDATA_EBPF_MEMORY_GROUP,

468 + NETDATA_CACHESTAT_HIT_CHART,

469 + "",

470 + "Number of accessed files",

471 + EBPF_CACHESTAT_UNITS_HITS,

472 + NETDATA_CACHESTAT_SUBMENU,

473 + NETDATA_EBPF_CHART_TYPE_LINE,

474 + NETDATA_MEM_CACHESTAT_HIT_FILES_CONTEXT,

475 + 21102,

476 + em->update_every);

477 +

478 + ebpf_write_chart_obsolete(

479 + NETDATA_EBPF_MEMORY_GROUP,

480 + NETDATA_CACHESTAT_MISSES_CHART,

481 + "",

482 + "Files out of page cache",

483 + EBPF_CACHESTAT_UNITS_MISSES,

484 + NETDATA_CACHESTAT_SUBMENU,

485 + NETDATA_EBPF_CHART_TYPE_LINE,

486 + NETDATA_MEM_CACHESTAT_MISS_FILES_CONTEXT,

487 + 21103,

488 + em->update_every);

489 }

490

491 /**

@@ -461,53 +501,57 @@ void ebpf_obsolete_cachestat_apps_charts(struct ebpf_module *em)

501 int update_every = em->update_every;

502 pthread_mutex_lock(&collect_data_mutex);

503 for (w = apps_groups_root_target; w; w = w->next) {

464 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_CACHESTAT_IDX))))

504 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_CACHESTAT_IDX))))

505 continue;

506

467 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

468 - w->clean_name,

469 - "_ebpf_cachestat_hit_ratio",

470 - "Hit ratio",

471 - EBPF_COMMON_UNITS_PERCENTAGE,

472 - NETDATA_CACHESTAT_SUBMENU,

473 - NETDATA_EBPF_CHART_TYPE_LINE,

474 - "app.ebpf_cachestat_hit_ratio",

475 - 20260,

476 - update_every);

477 -

478 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

479 - w->clean_name,

480 - "_ebpf_cachestat_dirty_pages",

481 - "Number of dirty pages",

482 - EBPF_CACHESTAT_UNITS_PAGE,

483 - NETDATA_CACHESTAT_SUBMENU,

484 - NETDATA_EBPF_CHART_TYPE_STACKED,

485 - "app.ebpf_cachestat_dirty_pages",

486 - 20261,

487 - update_every);

488 -

489 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

490 - w->clean_name,

491 - "_ebpf_cachestat_access",

492 - "Number of accessed files",

493 - EBPF_CACHESTAT_UNITS_HITS,

494 - NETDATA_CACHESTAT_SUBMENU,

495 - NETDATA_EBPF_CHART_TYPE_STACKED,

496 - "app.ebpf_cachestat_access",

497 - 20262,

498 - update_every);

499 -

500 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

501 - w->clean_name,

502 - "_ebpf_cachestat_misses",

503 - "Files out of page cache",

504 - EBPF_CACHESTAT_UNITS_MISSES,

505 - NETDATA_CACHESTAT_SUBMENU,

506 - NETDATA_EBPF_CHART_TYPE_STACKED,

507 - "app.ebpf_cachestat_misses",

508 - 20263,

509 - update_every);

510 - w->charts_created &= ~(1<<EBPF_MODULE_CACHESTAT_IDX);

507 + ebpf_write_chart_obsolete(

508 + NETDATA_APP_FAMILY,

509 + w->clean_name,

510 + "_ebpf_cachestat_hit_ratio",

511 + "Hit ratio",

512 + EBPF_COMMON_UNITS_PERCENTAGE,

513 + NETDATA_CACHESTAT_SUBMENU,

514 + NETDATA_EBPF_CHART_TYPE_LINE,

515 + "app.ebpf_cachestat_hit_ratio",

516 + 20260,

517 + update_every);

518 +

519 + ebpf_write_chart_obsolete(

520 + NETDATA_APP_FAMILY,

521 + w->clean_name,

522 + "_ebpf_cachestat_dirty_pages",

523 + "Number of dirty pages",

524 + EBPF_CACHESTAT_UNITS_PAGE,

525 + NETDATA_CACHESTAT_SUBMENU,

526 + NETDATA_EBPF_CHART_TYPE_STACKED,

527 + "app.ebpf_cachestat_dirty_pages",

528 + 20261,

529 + update_every);

530 +

531 + ebpf_write_chart_obsolete(

532 + NETDATA_APP_FAMILY,

533 + w->clean_name,

534 + "_ebpf_cachestat_access",

535 + "Number of accessed files",

536 + EBPF_CACHESTAT_UNITS_HITS,

537 + NETDATA_CACHESTAT_SUBMENU,

538 + NETDATA_EBPF_CHART_TYPE_STACKED,

539 + "app.ebpf_cachestat_access",

540 + 20262,

541 + update_every);

542 +

543 + ebpf_write_chart_obsolete(

544 + NETDATA_APP_FAMILY,

545 + w->clean_name,

546 + "_ebpf_cachestat_misses",

547 + "Files out of page cache",

548 + EBPF_CACHESTAT_UNITS_MISSES,

549 + NETDATA_CACHESTAT_SUBMENU,

550 + NETDATA_EBPF_CHART_TYPE_STACKED,

551 + "app.ebpf_cachestat_misses",

552 + 20263,

553 + update_every);

554 + w->charts_created &= ~(1 << EBPF_MODULE_CACHESTAT_IDX);

555 }

556 pthread_mutex_unlock(&collect_data_mutex);

557 }

@@ -523,10 +567,11 @@ static void ebpf_cachestat_exit(void *pptr)

567 {

568 pids_fd[NETDATA_EBPF_PIDS_CACHESTAT_IDX] = -1;

569 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

526 - if(!em) return;

570 + if (!em)

571 + return;

572

573 pthread_mutex_lock(&lock);

529 - collect_pids &= ~(1<<EBPF_MODULE_CACHESTAT_IDX);

574 + collect_pids &= ~(1 << EBPF_MODULE_CACHESTAT_IDX);

575 pthread_mutex_unlock(&lock);

576

577 if (ebpf_read_cachestat.thread)

@@ -587,29 +632,28 @@ static void ebpf_cachestat_exit(void *pptr)

632 * @param apcl calls for add_to_page_cache_lru during the last second.

633 * @param apd calls for account_page_dirtied during the last second.

634 */

590 -void cachestat_update_publish(netdata_publish_cachestat_t *out, uint64_t mpa, uint64_t mbd,

591 - uint64_t apcl, uint64_t apd)

635 +void cachestat_update_publish(netdata_publish_cachestat_t *out, uint64_t mpa, uint64_t mbd, uint64_t apcl, uint64_t apd)

636 {

637 // Adapted algorithm from https://github.com/iovisor/bcc/blob/master/tools/cachestat.py#L126-L138

594 - NETDATA_DOUBLE total = (NETDATA_DOUBLE) (((long long)mpa) - ((long long)mbd));

638 + NETDATA_DOUBLE total = (NETDATA_DOUBLE)(((long long)mpa) - ((long long)mbd));

639 if (total < 0)

640 total = 0;

641

598 - NETDATA_DOUBLE misses = (NETDATA_DOUBLE) ( ((long long) apcl) - ((long long) apd) );

642 + NETDATA_DOUBLE misses = (NETDATA_DOUBLE)(((long long)apcl) - ((long long)apd));

643 if (misses < 0)

644 misses = 0;

645

646 // If hits are < 0, then its possible misses are overestimate due to possibly page cache read ahead adding

647 // more pages than needed. In this case just assume misses as total and reset hits.

648 NETDATA_DOUBLE hits = total - misses;

605 - if (hits < 0 ) {

649 + if (hits < 0) {

650 misses = total;

651 hits = 0;

652 }

653

610 - NETDATA_DOUBLE ratio = (total > 0) ? hits/total : 1;

654 + NETDATA_DOUBLE ratio = (total > 0) ? hits / total : 1;

655

612 - out->ratio = (long long )(ratio*100);

656 + out->ratio = (long long)(ratio * 100);

657 out->hit = (long long)hits;

658 out->miss = (long long)misses;

659 }

@@ -621,7 +665,8 @@ void cachestat_update_publish(netdata_publish_cachestat_t *out, uint64_t mpa, ui

665 *

666 * @param publish

667 */

624 -static void save_previous_values(netdata_publish_cachestat_t *publish) {

668 +static void save_previous_values(netdata_publish_cachestat_t *publish)

669 +{

670 publish->prev.mark_page_accessed = cachestat_hash_values[NETDATA_KEY_CALLS_MARK_PAGE_ACCESSED];

671 publish->prev.account_page_dirtied = cachestat_hash_values[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED];

672 publish->prev.add_to_page_cache_lru = cachestat_hash_values[NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU];

@@ -633,7 +678,8 @@ static void save_previous_values(netdata_publish_cachestat_t *publish) {

678 *

679 * @param publish the structure where we will store the data.

680 */

636 -static void calculate_stats(netdata_publish_cachestat_t *publish) {

681 +static void calculate_stats(netdata_publish_cachestat_t *publish)

682 +{

683 if (!publish->prev.mark_page_accessed) {

684 save_previous_values(publish);

685 return;

@@ -641,7 +687,8 @@ static void calculate_stats(netdata_publish_cachestat_t *publish) {

687

688 uint64_t mpa = cachestat_hash_values[NETDATA_KEY_CALLS_MARK_PAGE_ACCESSED] - publish->prev.mark_page_accessed;

689 uint64_t mbd = cachestat_hash_values[NETDATA_KEY_CALLS_MARK_BUFFER_DIRTY] - publish->prev.mark_buffer_dirty;

644 - uint64_t apcl = cachestat_hash_values[NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU] - publish->prev.add_to_page_cache_lru;

690 + uint64_t apcl =

691 + cachestat_hash_values[NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU] - publish->prev.add_to_page_cache_lru;

692 uint64_t apd = cachestat_hash_values[NETDATA_KEY_CALLS_ACCOUNT_PAGE_DIRTIED] - publish->prev.account_page_dirtied;

693

694 save_previous_values(publish);

@@ -650,7 +697,6 @@ static void calculate_stats(netdata_publish_cachestat_t *publish) {

697 cachestat_update_publish(publish, mpa, mbd, apcl, apd);

698 }

699

653 -

700 /*****************************************************************

701 *

702 * APPS

@@ -734,7 +780,7 @@ static void ebpf_read_cachestat_apps_table(int maps_per_core)

780 if (!publish)

781 local_pid->cachestat = publish = ebpf_cachestat_allocate_publish();

782

737 - if (!publish->ct || publish->ct != cv->ct){

783 + if (!publish->ct || publish->ct != cv->ct) {

784 cachestat_save_pid_values(publish, cv);

785 local_pid->not_updated = 0;

786 } else {

@@ -747,7 +793,7 @@ static void ebpf_read_cachestat_apps_table(int maps_per_core)

793 }

794 }

795

750 -end_cachestat_loop:

796 + end_cachestat_loop:

797 // We are cleaning to avoid passing data read from one process to other.

798 memset(cv, 0, length);

799 key = next_key;

@@ -792,7 +838,7 @@ static void ebpf_update_cachestat_cgroup()

838 */

839 void ebpf_cachestat_sum_pids(netdata_publish_cachestat_t *publish, struct ebpf_pid_on_target *root)

840 {

795 - memcpy(&publish->prev, &publish->current,sizeof(publish->current));

841 + memcpy(&publish->prev, &publish->current, sizeof(publish->current));

842 memset(&publish->current, 0, sizeof(publish->current));

843

844 netdata_cachestat_t *dst = &publish->current;

@@ -890,67 +936,70 @@ void ebpf_cachestat_create_apps_charts(struct ebpf_module *em, void *ptr)

936 if (unlikely(!w->exposed))

937 continue;

938

893 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

894 - w->clean_name,

895 - "_ebpf_cachestat_hit_ratio",

896 - "Hit ratio",

897 - EBPF_COMMON_UNITS_PERCENTAGE,

898 - NETDATA_CACHESTAT_SUBMENU,

899 - NETDATA_EBPF_CHART_TYPE_LINE,

900 - "app.ebpf_cachestat_hit_ratio",

901 - 20260,

902 - update_every,

903 - NETDATA_EBPF_MODULE_NAME_CACHESTAT);

939 + ebpf_write_chart_cmd(

940 + NETDATA_APP_FAMILY,

941 + w->clean_name,

942 + "_ebpf_cachestat_hit_ratio",

943 + "Hit ratio",

944 + EBPF_COMMON_UNITS_PERCENTAGE,

945 + NETDATA_CACHESTAT_SUBMENU,

946 + NETDATA_EBPF_CHART_TYPE_LINE,

947 + "app.ebpf_cachestat_hit_ratio",

948 + 20260,

949 + update_every,

950 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

951 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

952 ebpf_commit_label();

953 fprintf(stdout, "DIMENSION ratio '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

954

908 -

909 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

910 - w->clean_name,

911 - "_ebpf_cachestat_dirty_pages",

912 - "Number of dirty pages",

913 - EBPF_CACHESTAT_UNITS_PAGE,

914 - NETDATA_CACHESTAT_SUBMENU,

915 - NETDATA_EBPF_CHART_TYPE_LINE,

916 - "app.ebpf_cachestat_dirty_pages",

917 - 20261,

918 - update_every,

919 - NETDATA_EBPF_MODULE_NAME_CACHESTAT);

955 + ebpf_write_chart_cmd(

956 + NETDATA_APP_FAMILY,

957 + w->clean_name,

958 + "_ebpf_cachestat_dirty_pages",

959 + "Number of dirty pages",

960 + EBPF_CACHESTAT_UNITS_PAGE,

961 + NETDATA_CACHESTAT_SUBMENU,

962 + NETDATA_EBPF_CHART_TYPE_LINE,

963 + "app.ebpf_cachestat_dirty_pages",

964 + 20261,

965 + update_every,

966 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

967 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

968 ebpf_commit_label();

969 fprintf(stdout, "DIMENSION pages '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

970

924 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

925 - w->clean_name,

926 - "_ebpf_cachestat_access",

927 - "Number of accessed files",

928 - EBPF_CACHESTAT_UNITS_HITS,

929 - NETDATA_CACHESTAT_SUBMENU,

930 - NETDATA_EBPF_CHART_TYPE_STACKED,

931 - "app.ebpf_cachestat_access",

932 - 20262,

933 - update_every,

934 - NETDATA_EBPF_MODULE_NAME_CACHESTAT);

971 + ebpf_write_chart_cmd(

972 + NETDATA_APP_FAMILY,

973 + w->clean_name,

974 + "_ebpf_cachestat_access",

975 + "Number of accessed files",

976 + EBPF_CACHESTAT_UNITS_HITS,

977 + NETDATA_CACHESTAT_SUBMENU,

978 + NETDATA_EBPF_CHART_TYPE_STACKED,

979 + "app.ebpf_cachestat_access",

980 + 20262,

981 + update_every,

982 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

983 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

984 ebpf_commit_label();

985 fprintf(stdout, "DIMENSION hits '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

986

939 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

940 - w->clean_name,

941 - "_ebpf_cachestat_misses",

942 - "Files out of page cache",

943 - EBPF_CACHESTAT_UNITS_MISSES,

944 - NETDATA_CACHESTAT_SUBMENU,

945 - NETDATA_EBPF_CHART_TYPE_STACKED,

946 - "app.ebpf_cachestat_misses",

947 - 20263,

948 - update_every,

949 - NETDATA_EBPF_MODULE_NAME_CACHESTAT);

987 + ebpf_write_chart_cmd(

988 + NETDATA_APP_FAMILY,

989 + w->clean_name,

990 + "_ebpf_cachestat_misses",

991 + "Files out of page cache",

992 + EBPF_CACHESTAT_UNITS_MISSES,

993 + NETDATA_CACHESTAT_SUBMENU,

994 + NETDATA_EBPF_CHART_TYPE_STACKED,

995 + "app.ebpf_cachestat_misses",

996 + 20263,

997 + update_every,

998 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

999 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1000 ebpf_commit_label();

1001 fprintf(stdout, "DIMENSION misses '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

953 - w->charts_created |= 1<<EBPF_MODULE_CACHESTAT_IDX;

1002 + w->charts_created |= 1 << EBPF_MODULE_CACHESTAT_IDX;

1003 }

1004

1005 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;

@@ -972,19 +1021,21 @@ void ebpf_cachestat_create_apps_charts(struct ebpf_module *em, void *ptr)

1021 */

1022 static void ebpf_cachestat_read_global_tables(netdata_idx_t *stats, int maps_per_core)

1023 {

975 - ebpf_read_global_table_stats(cachestat_hash_values,

976 - cachestat_values,

977 - cachestat_maps[NETDATA_CACHESTAT_GLOBAL_STATS].map_fd,

978 - maps_per_core,

979 - NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU,

980 - NETDATA_CACHESTAT_END);

981 -

982 - ebpf_read_global_table_stats(stats,

983 - cachestat_values,

984 - cachestat_maps[NETDATA_CACHESTAT_CTRL].map_fd,

985 - maps_per_core,

986 - NETDATA_CONTROLLER_PID_TABLE_ADD,

987 - NETDATA_CONTROLLER_END);

1024 + ebpf_read_global_table_stats(

1025 + cachestat_hash_values,

1026 + cachestat_values,

1027 + cachestat_maps[NETDATA_CACHESTAT_GLOBAL_STATS].map_fd,

1028 + maps_per_core,

1029 + NETDATA_KEY_CALLS_ADD_TO_PAGE_CACHE_LRU,

1030 + NETDATA_CACHESTAT_END);

1031 +

1032 + ebpf_read_global_table_stats(

1033 + stats,

1034 + cachestat_values,

1035 + cachestat_maps[NETDATA_CACHESTAT_CTRL].map_fd,

1036 + maps_per_core,

1037 + NETDATA_CONTROLLER_PID_TABLE_ADD,

1038 + NETDATA_CONTROLLER_END);

1039 }

1040

1041 /**

@@ -998,18 +1049,24 @@ static void cachestat_send_global(netdata_publish_cachestat_t *publish)

1049

1050 netdata_publish_syscall_t *ptr = cachestat_counter_publish_aggregated;

1051 ebpf_one_dimension_write_charts(

1001 - NETDATA_EBPF_MEMORY_GROUP, NETDATA_CACHESTAT_HIT_RATIO_CHART, ptr[NETDATA_CACHESTAT_IDX_RATIO].dimension,

1052 + NETDATA_EBPF_MEMORY_GROUP,

1053 + NETDATA_CACHESTAT_HIT_RATIO_CHART,

1054 + ptr[NETDATA_CACHESTAT_IDX_RATIO].dimension,

1055 publish->ratio);

1056

1057 ebpf_one_dimension_write_charts(

1005 - NETDATA_EBPF_MEMORY_GROUP, NETDATA_CACHESTAT_DIRTY_CHART, ptr[NETDATA_CACHESTAT_IDX_DIRTY].dimension,

1058 + NETDATA_EBPF_MEMORY_GROUP,

1059 + NETDATA_CACHESTAT_DIRTY_CHART,

1060 + ptr[NETDATA_CACHESTAT_IDX_DIRTY].dimension,

1061 (long long)cachestat_hash_values[NETDATA_KEY_CALLS_MARK_BUFFER_DIRTY]);

1062

1063 ebpf_one_dimension_write_charts(

1064 NETDATA_EBPF_MEMORY_GROUP, NETDATA_CACHESTAT_HIT_CHART, ptr[NETDATA_CACHESTAT_IDX_HIT].dimension, publish->hit);

1065

1066 ebpf_one_dimension_write_charts(

1012 - NETDATA_EBPF_MEMORY_GROUP, NETDATA_CACHESTAT_MISSES_CHART, ptr[NETDATA_CACHESTAT_IDX_MISS].dimension,

1067 + NETDATA_EBPF_MEMORY_GROUP,

1068 + NETDATA_CACHESTAT_MISSES_CHART,

1069 + ptr[NETDATA_CACHESTAT_IDX_MISS].dimension,

1070 publish->miss);

1071 }

1072

@@ -1025,7 +1082,7 @@ void ebpf_cache_send_apps_data(struct ebpf_target *root)

1082

1083 pthread_mutex_lock(&collect_data_mutex);

1084 for (w = root; w; w = w->next) {

1028 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_CACHESTAT_IDX))))

1085 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_CACHESTAT_IDX))))

1086 continue;

1087

1088 netdata_cachestat_t *current = &w->cachestat.current;

@@ -1039,22 +1096,22 @@ void ebpf_cache_send_apps_data(struct ebpf_target *root)

1096

1097 cachestat_update_publish(&w->cachestat, mpa, mbd, apcl, apd);

1098

1042 - value = (collected_number) w->cachestat.ratio;

1099 + value = (collected_number)w->cachestat.ratio;

1100 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_cachestat_hit_ratio");

1101 write_chart_dimension("ratio", value);

1102 ebpf_write_end_chart();

1103

1047 - value = (collected_number) w->cachestat.dirty;

1104 + value = (collected_number)w->cachestat.dirty;

1105 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_cachestat_dirty_pages");

1106 write_chart_dimension("pages", value);

1107 ebpf_write_end_chart();

1108

1052 - value = (collected_number) w->cachestat.hit;

1109 + value = (collected_number)w->cachestat.hit;

1110 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_cachestat_access");

1111 write_chart_dimension("hits", value);

1112 ebpf_write_end_chart();

1113

1057 - value = (collected_number) w->cachestat.miss;

1114 + value = (collected_number)w->cachestat.miss;

1115 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_cachestat_misses");

1116 write_chart_dimension("misses", value);

1117 ebpf_write_end_chart();

@@ -1072,7 +1129,7 @@ void ebpf_cache_send_apps_data(struct ebpf_target *root)

1129 */

1130 void ebpf_cachestat_sum_cgroup_pids(netdata_publish_cachestat_t *publish, struct pid_on_target2 *root)

1131 {

1075 - memcpy(&publish->prev, &publish->current,sizeof(publish->current));

1132 + memcpy(&publish->prev, &publish->current, sizeof(publish->current));

1133 memset(&publish->current, 0, sizeof(publish->current));

1134

1135 netdata_cachestat_t *dst = &publish->current;

@@ -1094,7 +1151,7 @@ void ebpf_cachestat_sum_cgroup_pids(netdata_publish_cachestat_t *publish, struct

1151 void ebpf_cachestat_calc_chart_values()

1152 {

1153 ebpf_cgroup_target_t *ect;

1097 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1154 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1155 ebpf_cachestat_sum_cgroup_pids(&ect->publish_cachestat, ect->pids);

1156

1157 netdata_cachestat_t *current = &ect->publish_cachestat.current;

@@ -1130,8 +1187,7 @@ static void ebpf_create_systemd_cachestat_charts(int update_every)

1187 .module = NETDATA_EBPF_MODULE_NAME_CACHESTAT,

1188 .update_every = 0,

1189 .suffix = NETDATA_CACHESTAT_HIT_RATIO_CHART,

1133 - .dimension = "percentage"

1134 - };

1190 + .dimension = "percentage"};

1191

1192 static ebpf_systemd_args_t data_dirty = {

1193 .title = "Number of dirty pages",

@@ -1144,8 +1200,7 @@ static void ebpf_create_systemd_cachestat_charts(int update_every)

1200 .module = NETDATA_EBPF_MODULE_NAME_CACHESTAT,

1201 .update_every = 0,

1202 .suffix = NETDATA_CACHESTAT_DIRTY_CHART,

1147 - .dimension = "pages"

1148 - };

1203 + .dimension = "pages"};

1204

1205 static ebpf_systemd_args_t data_hit = {

1206 .title = "Number of accessed files",

@@ -1158,8 +1213,7 @@ static void ebpf_create_systemd_cachestat_charts(int update_every)

1213 .module = NETDATA_EBPF_MODULE_NAME_CACHESTAT,

1214 .update_every = 0,

1215 .suffix = NETDATA_CACHESTAT_HIT_CHART,

1161 - .dimension = "hits"

1162 - };

1216 + .dimension = "hits"};

1217

1218 static ebpf_systemd_args_t data_miss = {

1219 .title = "Files out of page cache",

@@ -1172,12 +1226,11 @@ static void ebpf_create_systemd_cachestat_charts(int update_every)

1226 .module = NETDATA_EBPF_MODULE_NAME_CACHESTAT,

1227 .update_every = 0,

1228 .suffix = NETDATA_CACHESTAT_MISSES_CHART,

1175 - .dimension = "misses"

1176 - };

1229 + .dimension = "misses"};

1230

1231 if (!data_miss.update_every)

1179 - data_hit_ratio.update_every = data_dirty.update_every =

1180 - data_hit.update_every = data_miss.update_every = update_every;

1232 + data_hit_ratio.update_every = data_dirty.update_every = data_hit.update_every = data_miss.update_every =

1233 + update_every;

1234

1235 ebpf_cgroup_target_t *w;

1236 for (w = ebpf_cgroup_pids; w; w = w->next) {

@@ -1207,7 +1260,7 @@ static void ebpf_send_systemd_cachestat_charts()

1260 ebpf_cgroup_target_t *ect;

1261

1262 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1210 - if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_CACHESTAT_CHART)) ) {

1263 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_CACHESTAT_CHART))) {

1264 continue;

1265 }

1266

@@ -1237,11 +1290,13 @@ static void ebpf_send_systemd_cachestat_charts()

1290 static void ebpf_send_specific_cachestat_data(char *type, netdata_publish_cachestat_t *npc)

1291 {

1292 ebpf_write_begin_chart(type, NETDATA_CACHESTAT_HIT_RATIO_CHART, "");

1240 - write_chart_dimension(cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_RATIO].name, (long long)npc->ratio);

1293 + write_chart_dimension(

1294 + cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_RATIO].name, (long long)npc->ratio);

1295 ebpf_write_end_chart();

1296

1297 ebpf_write_begin_chart(type, NETDATA_CACHESTAT_DIRTY_CHART, "");

1244 - write_chart_dimension(cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_DIRTY].name, (long long)npc->dirty);

1298 + write_chart_dimension(

1299 + cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_DIRTY].name, (long long)npc->dirty);

1300 ebpf_write_end_chart();

1301

1302 ebpf_write_begin_chart(type, NETDATA_CACHESTAT_HIT_CHART, "");

@@ -1264,46 +1319,71 @@ static void ebpf_send_specific_cachestat_data(char *type, netdata_publish_caches

1319 static void ebpf_create_specific_cachestat_charts(char *type, int update_every)

1320 {

1321 char *label = (!strncmp(type, "cgroup_", 7)) ? &type[7] : type;

1267 - ebpf_create_chart(type, NETDATA_CACHESTAT_HIT_RATIO_CHART,

1268 - "Hit ratio",

1269 - EBPF_COMMON_UNITS_PERCENTAGE, NETDATA_CACHESTAT_SUBMENU,

1270 - NETDATA_CGROUP_CACHESTAT_HIT_RATIO_CONTEXT,

1271 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5200,

1272 - ebpf_create_global_dimension,

1273 - cachestat_counter_publish_aggregated, 1, update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1322 + ebpf_create_chart(

1323 + type,

1324 + NETDATA_CACHESTAT_HIT_RATIO_CHART,

1325 + "Hit ratio",

1326 + EBPF_COMMON_UNITS_PERCENTAGE,

1327 + NETDATA_CACHESTAT_SUBMENU,

1328 + NETDATA_CGROUP_CACHESTAT_HIT_RATIO_CONTEXT,

1329 + NETDATA_EBPF_CHART_TYPE_LINE,

1330 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5200,

1331 + ebpf_create_global_dimension,

1332 + cachestat_counter_publish_aggregated,

1333 + 1,

1334 + update_every,

1335 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1336 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1337 ebpf_commit_label();

1338

1277 - ebpf_create_chart(type, NETDATA_CACHESTAT_DIRTY_CHART,

1278 - "Number of dirty pages",

1279 - EBPF_CACHESTAT_UNITS_PAGE, NETDATA_CACHESTAT_SUBMENU,

1280 - NETDATA_CGROUP_CACHESTAT_MODIFIED_CACHE_CONTEXT,

1281 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5201,

1282 - ebpf_create_global_dimension,

1283 - &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_DIRTY], 1,

1284 - update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1339 + ebpf_create_chart(

1340 + type,

1341 + NETDATA_CACHESTAT_DIRTY_CHART,

1342 + "Number of dirty pages",

1343 + EBPF_CACHESTAT_UNITS_PAGE,

1344 + NETDATA_CACHESTAT_SUBMENU,

1345 + NETDATA_CGROUP_CACHESTAT_MODIFIED_CACHE_CONTEXT,

1346 + NETDATA_EBPF_CHART_TYPE_LINE,

1347 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5201,

1348 + ebpf_create_global_dimension,

1349 + &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_DIRTY],

1350 + 1,

1351 + update_every,

1352 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1353 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1354 ebpf_commit_label();

1355

1288 - ebpf_create_chart(type, NETDATA_CACHESTAT_HIT_CHART,

1289 - "Number of accessed files",

1290 - EBPF_CACHESTAT_UNITS_HITS, NETDATA_CACHESTAT_SUBMENU,

1291 - NETDATA_CGROUP_CACHESTAT_HIT_FILES_CONTEXT,

1292 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5202,

1293 - ebpf_create_global_dimension,

1294 - &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_HIT], 1,

1295 - update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1356 + ebpf_create_chart(

1357 + type,

1358 + NETDATA_CACHESTAT_HIT_CHART,

1359 + "Number of accessed files",

1360 + EBPF_CACHESTAT_UNITS_HITS,

1361 + NETDATA_CACHESTAT_SUBMENU,

1362 + NETDATA_CGROUP_CACHESTAT_HIT_FILES_CONTEXT,

1363 + NETDATA_EBPF_CHART_TYPE_LINE,

1364 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5202,

1365 + ebpf_create_global_dimension,

1366 + &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_HIT],

1367 + 1,

1368 + update_every,

1369 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1370 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1371 ebpf_commit_label();

1372

1299 - ebpf_create_chart(type, NETDATA_CACHESTAT_MISSES_CHART,

1300 - "Files out of page cache",

1301 - EBPF_CACHESTAT_UNITS_MISSES, NETDATA_CACHESTAT_SUBMENU,

1302 - NETDATA_CGROUP_CACHESTAT_MISS_FILES_CONTEXT,

1303 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5203,

1304 - ebpf_create_global_dimension,

1305 - &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_MISS], 1,

1306 - update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1373 + ebpf_create_chart(

1374 + type,

1375 + NETDATA_CACHESTAT_MISSES_CHART,

1376 + "Files out of page cache",

1377 + EBPF_CACHESTAT_UNITS_MISSES,

1378 + NETDATA_CACHESTAT_SUBMENU,

1379 + NETDATA_CGROUP_CACHESTAT_MISS_FILES_CONTEXT,

1380 + NETDATA_EBPF_CHART_TYPE_LINE,

1381 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5203,

1382 + ebpf_create_global_dimension,

1383 + &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_MISS],

1384 + 1,

1385 + update_every,

1386 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1387 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1388 ebpf_commit_label();

1389 }

@@ -1318,33 +1398,53 @@ static void ebpf_create_specific_cachestat_charts(char *type, int update_every)

1398 */

1399 static void ebpf_obsolete_specific_cachestat_charts(char *type, int update_every)

1400 {

1321 - ebpf_write_chart_obsolete(type, NETDATA_CACHESTAT_HIT_RATIO_CHART,

1322 - "",

1323 - "Hit ratio",

1324 - EBPF_COMMON_UNITS_PERCENTAGE, NETDATA_CACHESTAT_SUBMENU,

1325 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_CACHESTAT_HIT_RATIO_CONTEXT,

1326 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5200, update_every);

1327 -

1328 - ebpf_write_chart_obsolete(type, NETDATA_CACHESTAT_DIRTY_CHART,

1329 - "",

1330 - "Number of dirty pages",

1331 - EBPF_CACHESTAT_UNITS_PAGE, NETDATA_CACHESTAT_SUBMENU,

1332 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_CACHESTAT_MODIFIED_CACHE_CONTEXT,

1333 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5201, update_every);

1334 -

1335 - ebpf_write_chart_obsolete(type, NETDATA_CACHESTAT_HIT_CHART,

1336 - "",

1337 - "Number of accessed files",

1338 - EBPF_CACHESTAT_UNITS_HITS, NETDATA_CACHESTAT_SUBMENU,

1339 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_CACHESTAT_HIT_FILES_CONTEXT,

1340 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5202, update_every);

1341 -

1342 - ebpf_write_chart_obsolete(type, NETDATA_CACHESTAT_MISSES_CHART,

1343 - "",

1344 - "Files out of page cache",

1345 - EBPF_CACHESTAT_UNITS_MISSES, NETDATA_CACHESTAT_SUBMENU,

1346 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_CACHESTAT_MISS_FILES_CONTEXT,

1347 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5203, update_every);

1401 + ebpf_write_chart_obsolete(

1402 + type,

1403 + NETDATA_CACHESTAT_HIT_RATIO_CHART,

1404 + "",

1405 + "Hit ratio",

1406 + EBPF_COMMON_UNITS_PERCENTAGE,

1407 + NETDATA_CACHESTAT_SUBMENU,

1408 + NETDATA_EBPF_CHART_TYPE_LINE,

1409 + NETDATA_CGROUP_CACHESTAT_HIT_RATIO_CONTEXT,

1410 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5200,

1411 + update_every);

1412 +

1413 + ebpf_write_chart_obsolete(

1414 + type,

1415 + NETDATA_CACHESTAT_DIRTY_CHART,

1416 + "",

1417 + "Number of dirty pages",

1418 + EBPF_CACHESTAT_UNITS_PAGE,

1419 + NETDATA_CACHESTAT_SUBMENU,

1420 + NETDATA_EBPF_CHART_TYPE_LINE,

1421 + NETDATA_CGROUP_CACHESTAT_MODIFIED_CACHE_CONTEXT,

1422 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5201,

1423 + update_every);

1424 +

1425 + ebpf_write_chart_obsolete(

1426 + type,

1427 + NETDATA_CACHESTAT_HIT_CHART,

1428 + "",

1429 + "Number of accessed files",

1430 + EBPF_CACHESTAT_UNITS_HITS,

1431 + NETDATA_CACHESTAT_SUBMENU,

1432 + NETDATA_EBPF_CHART_TYPE_LINE,

1433 + NETDATA_CGROUP_CACHESTAT_HIT_FILES_CONTEXT,

1434 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5202,

1435 + update_every);

1436 +

1437 + ebpf_write_chart_obsolete(

1438 + type,

1439 + NETDATA_CACHESTAT_MISSES_CHART,

1440 + "",

1441 + "Files out of page cache",

1442 + EBPF_CACHESTAT_UNITS_MISSES,

1443 + NETDATA_CACHESTAT_SUBMENU,

1444 + NETDATA_EBPF_CHART_TYPE_LINE,

1445 + NETDATA_CGROUP_CACHESTAT_MISS_FILES_CONTEXT,

1446 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5203,

1447 + update_every);

1448 }

1449

1450 /**

@@ -1366,7 +1466,7 @@ void ebpf_cachestat_send_cgroup_data(int update_every)

1466 ebpf_send_systemd_cachestat_charts();

1467 }

1468

1369 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1469 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1470 if (ect->systemd)

1471 continue;

1472

@@ -1457,44 +1557,65 @@ static void cachestat_collector(ebpf_module_t *em)

1557 */

1558 static void ebpf_create_memory_charts(ebpf_module_t *em)

1559 {

1460 - ebpf_create_chart(NETDATA_EBPF_MEMORY_GROUP, NETDATA_CACHESTAT_HIT_RATIO_CHART,

1461 - "Hit ratio",

1462 - EBPF_COMMON_UNITS_PERCENTAGE, NETDATA_CACHESTAT_SUBMENU,

1463 - NETDATA_MEM_CACHESTAT_HIT_RATIO_CONTEXT,

1464 - NETDATA_EBPF_CHART_TYPE_LINE,

1465 - 21100,

1466 - ebpf_create_global_dimension,

1467 - cachestat_counter_publish_aggregated, 1, em->update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1468 -

1469 - ebpf_create_chart(NETDATA_EBPF_MEMORY_GROUP, NETDATA_CACHESTAT_DIRTY_CHART,

1470 - "Number of dirty pages",

1471 - EBPF_CACHESTAT_UNITS_PAGE, NETDATA_CACHESTAT_SUBMENU,

1472 - NETDATA_MEM_CACHESTAT_MODIFIED_CACHE_CONTEXT,

1473 - NETDATA_EBPF_CHART_TYPE_LINE,

1474 - 21101,

1475 - ebpf_create_global_dimension,

1476 - &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_DIRTY], 1,

1477 - em->update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1478 -

1479 - ebpf_create_chart(NETDATA_EBPF_MEMORY_GROUP, NETDATA_CACHESTAT_HIT_CHART,

1480 - "Number of accessed files",

1481 - EBPF_CACHESTAT_UNITS_HITS, NETDATA_CACHESTAT_SUBMENU,

1482 - NETDATA_MEM_CACHESTAT_HIT_FILES_CONTEXT,

1483 - NETDATA_EBPF_CHART_TYPE_LINE,

1484 - 21102,

1485 - ebpf_create_global_dimension,

1486 - &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_HIT], 1,

1487 - em->update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1488 -

1489 - ebpf_create_chart(NETDATA_EBPF_MEMORY_GROUP, NETDATA_CACHESTAT_MISSES_CHART,

1490 - "Files out of page cache",

1491 - EBPF_CACHESTAT_UNITS_MISSES, NETDATA_CACHESTAT_SUBMENU,

1492 - NETDATA_MEM_CACHESTAT_MISS_FILES_CONTEXT,

1493 - NETDATA_EBPF_CHART_TYPE_LINE,

1494 - 21103,

1495 - ebpf_create_global_dimension,

1496 - &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_MISS], 1,

1497 - em->update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1560 + ebpf_create_chart(

1561 + NETDATA_EBPF_MEMORY_GROUP,

1562 + NETDATA_CACHESTAT_HIT_RATIO_CHART,

1563 + "Hit ratio",

1564 + EBPF_COMMON_UNITS_PERCENTAGE,

1565 + NETDATA_CACHESTAT_SUBMENU,

1566 + NETDATA_MEM_CACHESTAT_HIT_RATIO_CONTEXT,

1567 + NETDATA_EBPF_CHART_TYPE_LINE,

1568 + 21100,

1569 + ebpf_create_global_dimension,

1570 + cachestat_counter_publish_aggregated,

1571 + 1,

1572 + em->update_every,

1573 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1574 +

1575 + ebpf_create_chart(

1576 + NETDATA_EBPF_MEMORY_GROUP,

1577 + NETDATA_CACHESTAT_DIRTY_CHART,

1578 + "Number of dirty pages",

1579 + EBPF_CACHESTAT_UNITS_PAGE,

1580 + NETDATA_CACHESTAT_SUBMENU,

1581 + NETDATA_MEM_CACHESTAT_MODIFIED_CACHE_CONTEXT,

1582 + NETDATA_EBPF_CHART_TYPE_LINE,

1583 + 21101,

1584 + ebpf_create_global_dimension,

1585 + &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_DIRTY],

1586 + 1,

1587 + em->update_every,

1588 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1589 +

1590 + ebpf_create_chart(

1591 + NETDATA_EBPF_MEMORY_GROUP,

1592 + NETDATA_CACHESTAT_HIT_CHART,

1593 + "Number of accessed files",

1594 + EBPF_CACHESTAT_UNITS_HITS,

1595 + NETDATA_CACHESTAT_SUBMENU,

1596 + NETDATA_MEM_CACHESTAT_HIT_FILES_CONTEXT,

1597 + NETDATA_EBPF_CHART_TYPE_LINE,

1598 + 21102,

1599 + ebpf_create_global_dimension,

1600 + &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_HIT],

1601 + 1,

1602 + em->update_every,

1603 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1604 +

1605 + ebpf_create_chart(

1606 + NETDATA_EBPF_MEMORY_GROUP,

1607 + NETDATA_CACHESTAT_MISSES_CHART,

1608 + "Files out of page cache",

1609 + EBPF_CACHESTAT_UNITS_MISSES,

1610 + NETDATA_CACHESTAT_SUBMENU,

1611 + NETDATA_MEM_CACHESTAT_MISS_FILES_CONTEXT,

1612 + NETDATA_EBPF_CHART_TYPE_LINE,

1613 + 21103,

1614 + ebpf_create_global_dimension,

1615 + &cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_MISS],

1616 + 1,

1617 + em->update_every,

1618 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);

1619

1620 fflush(stdout);

1621 }

@@ -1532,7 +1653,7 @@ static int ebpf_cachestat_set_internal_value()

1653 {

1654 ebpf_addresses_t address = {.function = NULL, .hash = 0, .addr = 0};

1655 int i;

1535 - for (i = 0; i < NETDATA_CACHESTAT_ACCOUNT_DIRTY_END ; i++) {

1656 + for (i = 0; i < NETDATA_CACHESTAT_ACCOUNT_DIRTY_END; i++) {

1657 address.function = account_page[i];

1658 ebpf_load_addresses(&address, -1);

1659 if (address.addr)

@@ -1619,12 +1740,15 @@ void *ebpf_cachestat_thread(void *ptr)

1740 ebpf_cachestat_allocate_global_vectors();

1741

1742 int algorithms[NETDATA_CACHESTAT_END] = {

1622 - NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX

1623 - };

1743 + NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX};

1744

1625 - ebpf_global_labels(cachestat_counter_aggregated_data, cachestat_counter_publish_aggregated,

1626 - cachestat_counter_dimension_name, cachestat_counter_dimension_name,

1627 - algorithms, NETDATA_CACHESTAT_END);

1745 + ebpf_global_labels(

1746 + cachestat_counter_aggregated_data,

1747 + cachestat_counter_publish_aggregated,

1748 + cachestat_counter_dimension_name,

1749 + cachestat_counter_dimension_name,

1750 + algorithms,

1751 + NETDATA_CACHESTAT_END);

1752

1753 pthread_mutex_lock(&lock);

1754 ebpf_update_stats(&plugin_statistics, em);

@@ -1633,11 +1757,8 @@ void *ebpf_cachestat_thread(void *ptr)

1757

1758 pthread_mutex_unlock(&lock);

1759

1636 - ebpf_read_cachestat.thread = nd_thread_create(

1637 - ebpf_read_cachestat.name,

1638 - NETDATA_THREAD_OPTION_DEFAULT,

1639 - ebpf_read_cachestat_thread,

1640 - em);

1760 + ebpf_read_cachestat.thread =

1761 + nd_thread_create(ebpf_read_cachestat.name, NETDATA_THREAD_OPTION_DEFAULT, ebpf_read_cachestat_thread, em);

1762

1763 cachestat_collector(em);

1764

src/collectors/ebpf.plugin/ebpf_cachestat.h

+3 -6

@@ -5,7 +5,8 @@

6 // Module name & description

7 #define NETDATA_EBPF_MODULE_NAME_CACHESTAT "cachestat"

8 -#define NETDATA_EBPF_CACHESTAT_MODULE_DESC "Monitor Linux page cache internal functions. This thread is integrated with apps and cgroup."

8 +#define NETDATA_EBPF_CACHESTAT_MODULE_DESC \

9 + "Monitor Linux page cache internal functions. This thread is integrated with apps and cgroup."

11 // charts

12 #define NETDATA_CACHESTAT_HIT_RATIO_CHART "cachestat_ratio"

@@ -63,11 +64,7 @@ enum cachestat_indexes {

64 NETDATA_CACHESTAT_IDX_MISS

65 };

66 -enum cachestat_tables {

67 - NETDATA_CACHESTAT_GLOBAL_STATS,

68 - NETDATA_CACHESTAT_PID_STATS,

69 - NETDATA_CACHESTAT_CTRL

70 -};

67 +enum cachestat_tables { NETDATA_CACHESTAT_GLOBAL_STATS, NETDATA_CACHESTAT_PID_STATS, NETDATA_CACHESTAT_CTRL };

69 typedef struct __attribute__((packed)) netdata_cachestat {

70 uint32_t add_to_page_cache_lru;

src/collectors/ebpf.plugin/ebpf_cgroup.c

+33 -28

@@ -26,9 +26,10 @@ static inline void *ebpf_cgroup_map_shm_locally(int fd, size_t length)

26 {

27 void *value;

29 - value = nd_mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

29 + value = nd_mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

30 if (!value) {

31 - netdata_log_error("Cannot map shared memory used between eBPF and cgroup, integration between processes won't happen");

31 + netdata_log_error(

32 + "Cannot map shared memory used between eBPF and cgroup, integration between processes won't happen");

33 close(shm_fd_ebpf_cgroup);

34 shm_fd_ebpf_cgroup = -1;

35 shm_unlink(NETDATA_SHARED_MEMORY_EBPF_CGROUP_NAME);

@@ -78,14 +79,14 @@ void ebpf_map_cgroup_shared_memory()

79 }

81 // Map only header

81 - void *mapped = (netdata_ebpf_cgroup_shm_header_t *) ebpf_cgroup_map_shm_locally(shm_fd_ebpf_cgroup,

82 - sizeof(netdata_ebpf_cgroup_shm_header_t));

82 + void *mapped = (netdata_ebpf_cgroup_shm_header_t *)ebpf_cgroup_map_shm_locally(

83 + shm_fd_ebpf_cgroup, sizeof(netdata_ebpf_cgroup_shm_header_t));

84 if (unlikely(mapped == SEM_FAILED)) {

85 return;

86 }

87 netdata_ebpf_cgroup_shm_header_t *header = mapped;

88 - size_t length = header->body_length;

89 + size_t length = header->body_length;

91 nd_munmap(header, sizeof(netdata_ebpf_cgroup_shm_header_t));

@@ -191,7 +192,7 @@ static inline void ebpf_cgroup_set_target_data(ebpf_cgroup_target_t *out, netdat

192 *

193 * @return It returns a pointer for the structure associated with the input.

194 */

194 -static ebpf_cgroup_target_t * ebpf_cgroup_find_or_create(netdata_ebpf_cgroup_shm_body_t *ptr)

195 +static ebpf_cgroup_target_t *ebpf_cgroup_find_or_create(netdata_ebpf_cgroup_shm_body_t *ptr)

196 {

197 ebpf_cgroup_target_t *ect, *prev;

198 for (ect = ebpf_cgroup_pids, prev = ebpf_cgroup_pids; ect; prev = ect, ect = ect->next) {

@@ -232,7 +233,7 @@ static void ebpf_update_pid_link_list(ebpf_cgroup_target_t *ect, char *path)

233 return;

234

235 size_t lines = procfile_lines(ff), l;

235 - for (l = 0; l < lines ;l++) {

236 + for (l = 0; l < lines; l++) {

237 int pid = (int)str2l(procfile_lineword(ff, l, 0));

238 if (pid) {

239 struct pid_on_target2 *pt, *prev;

@@ -261,12 +262,12 @@ static void ebpf_update_pid_link_list(ebpf_cgroup_target_t *ect, char *path)

262 * Set variable remove. If this variable is not reset, the structure will be removed from link list.

263 */

264 void ebpf_reset_updated_var()

264 - {

265 - ebpf_cgroup_target_t *ect;

266 - for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

267 - ect->updated = 0;

268 - }

269 - }

265 +{

266 + ebpf_cgroup_target_t *ect;

267 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

268 + ect->updated = 0;

269 + }

270 +}

271

272 /**

273 * Parse cgroup shared memory

@@ -294,7 +295,7 @@ void ebpf_parse_cgroup_shm_data()

295 for (i = 0; i < end; i++) {

296 netdata_ebpf_cgroup_shm_body_t *ptr = &shm_ebpf_cgroup.body[i];

297 if (ptr->enabled) {

297 - ebpf_cgroup_target_t *ect = ebpf_cgroup_find_or_create(ptr);

298 + ebpf_cgroup_target_t *ect = ebpf_cgroup_find_or_create(ptr);

299 ebpf_update_pid_link_list(ect, ptr->path);

300 }

301 }

@@ -303,8 +304,11 @@ void ebpf_parse_cgroup_shm_data()

304 sem_post(shm_sem_ebpf_cgroup);

305 pthread_mutex_unlock(&mutex_cgroup_shm);

306 #ifdef NETDATA_DEV_MODE

306 - netdata_log_info("Updating cgroup %d (Previous: %d, Current: %d)",

307 - send_cgroup_chart, previous, shm_ebpf_cgroup.header->cgroup_root_count);

307 + netdata_log_info(

308 + "Updating cgroup %d (Previous: %d, Current: %d)",

309 + send_cgroup_chart,

310 + previous,

311 + shm_ebpf_cgroup.header->cgroup_root_count);

312 #endif

313

314 sem_post(shm_sem_ebpf_cgroup);

@@ -329,17 +333,18 @@ void ebpf_parse_cgroup_shm_data()

333 */

334 void ebpf_create_charts_on_systemd(ebpf_systemd_args_t *chart)

335 {

332 - ebpf_write_chart_cmd(chart->id,

333 - chart->suffix,

334 - "",

335 - chart->title,

336 - chart->units,

337 - chart->family,

338 - chart->charttype,

339 - chart->context,

340 - chart->order,

341 - chart->update_every,

342 - chart->module);

336 + ebpf_write_chart_cmd(

337 + chart->id,

338 + chart->suffix,

339 + "",

340 + chart->title,

341 + chart->units,

342 + chart->family,

343 + chart->charttype,

344 + chart->context,

345 + chart->order,

346 + chart->update_every,

347 + chart->module);

348 char service_name[512];

349 snprintfz(service_name, 511, "%s", (!strstr(chart->id, "systemd_")) ? chart->id : (chart->id + 8));

350 ebpf_create_chart_labels("service_name", service_name, RRDLABEL_SRC_AUTO);

@@ -382,7 +387,7 @@ void *ebpf_cgroup_integration(void *ptr __maybe_unused)

387

388 // We are using a small heartbeat time to wake up thread,

389 // but we should not update so frequently the shared memory data

385 - if (++counter >= NETDATA_EBPF_CGROUP_UPDATE) {

390 + if (++counter >= NETDATA_EBPF_CGROUP_UPDATE) {

391 counter = 0;

392 if (!shm_ebpf_cgroup.header)

393 ebpf_map_cgroup_shared_memory();

src/collectors/ebpf.plugin/ebpf_cgroup.h

+17 -17

@@ -27,24 +27,24 @@ struct pid_on_target2 {

28 enum ebpf_cgroup_flags {

29 NETDATA_EBPF_CGROUP_HAS_PROCESS_CHART = 1,

30 - NETDATA_EBPF_CGROUP_HAS_SWAP_CHART = 1<<2,

31 - NETDATA_EBPF_CGROUP_HAS_SOCKET_CHART = 1<<3,

32 - NETDATA_EBPF_CGROUP_HAS_FD_CHART = 1<<4,

33 - NETDATA_EBPF_CGROUP_HAS_VFS_CHART = 1<<5,

34 - NETDATA_EBPF_CGROUP_HAS_OOMKILL_CHART = 1<<6,

35 - NETDATA_EBPF_CGROUP_HAS_CACHESTAT_CHART = 1<<7,

36 - NETDATA_EBPF_CGROUP_HAS_DC_CHART = 1<<8,

37 - NETDATA_EBPF_CGROUP_HAS_SHM_CHART = 1<<9,

30 + NETDATA_EBPF_CGROUP_HAS_SWAP_CHART = 1 << 2,

31 + NETDATA_EBPF_CGROUP_HAS_SOCKET_CHART = 1 << 3,

32 + NETDATA_EBPF_CGROUP_HAS_FD_CHART = 1 << 4,

33 + NETDATA_EBPF_CGROUP_HAS_VFS_CHART = 1 << 5,

34 + NETDATA_EBPF_CGROUP_HAS_OOMKILL_CHART = 1 << 6,

35 + NETDATA_EBPF_CGROUP_HAS_CACHESTAT_CHART = 1 << 7,

36 + NETDATA_EBPF_CGROUP_HAS_DC_CHART = 1 << 8,

37 + NETDATA_EBPF_CGROUP_HAS_SHM_CHART = 1 << 9,

39 - NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART = 1<<16,

40 - NETDATA_EBPF_SERVICES_HAS_SWAP_CHART = 1<<17,

41 - NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART = 1<<18,

42 - NETDATA_EBPF_SERVICES_HAS_FD_CHART = 1<<19,

43 - NETDATA_EBPF_SERVICES_HAS_VFS_CHART = 1<<20,

44 - NETDATA_EBPF_SERVICES_HAS_OOMKILL_CHART = 1<<21,

45 - NETDATA_EBPF_SERVICES_HAS_CACHESTAT_CHART = 1<<22,

46 - NETDATA_EBPF_SERVICES_HAS_DC_CHART = 1<<23,

47 - NETDATA_EBPF_SERVICES_HAS_SHM_CHART = 1<<24

39 + NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART = 1 << 16,

40 + NETDATA_EBPF_SERVICES_HAS_SWAP_CHART = 1 << 17,

41 + NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART = 1 << 18,

42 + NETDATA_EBPF_SERVICES_HAS_FD_CHART = 1 << 19,

43 + NETDATA_EBPF_SERVICES_HAS_VFS_CHART = 1 << 20,

44 + NETDATA_EBPF_SERVICES_HAS_OOMKILL_CHART = 1 << 21,

45 + NETDATA_EBPF_SERVICES_HAS_CACHESTAT_CHART = 1 << 22,

46 + NETDATA_EBPF_SERVICES_HAS_DC_CHART = 1 << 23,

47 + NETDATA_EBPF_SERVICES_HAS_SHM_CHART = 1 << 24

48 };

50 typedef struct ebpf_cgroup_target {

src/collectors/ebpf.plugin/ebpf_dcstat.c

+446 -359

@@ -3,7 +3,7 @@

3 #include "ebpf.h"

4 #include "ebpf_dcstat.h"

6 -static char *dcstat_counter_dimension_name[NETDATA_DCSTAT_IDX_END] = { "ratio", "reference", "slow", "miss" };

6 +static char *dcstat_counter_dimension_name[NETDATA_DCSTAT_IDX_END] = {"ratio", "reference", "slow", "miss"};

7 static netdata_syscall_stat_t dcstat_counter_aggregated_data[NETDATA_DCSTAT_IDX_END];

8 static netdata_publish_syscall_t dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_END];

@@ -14,46 +14,55 @@ static netdata_idx_t *dcstat_values = NULL;

15 struct config dcstat_config = APPCONFIG_INITIALIZER;

17 -ebpf_local_maps_t dcstat_maps[] = {{.name = "dcstat_global", .internal_input = NETDATA_DIRECTORY_CACHE_END,

18 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

19 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

17 +ebpf_local_maps_t dcstat_maps[] = {

18 + {.name = "dcstat_global",

19 + .internal_input = NETDATA_DIRECTORY_CACHE_END,

20 + .user_input = 0,

21 + .type = NETDATA_EBPF_MAP_STATIC,

22 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

23 #ifdef LIBBPF_MAJOR_VERSION

21 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

24 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

25 #endif

23 - },

24 - {.name = "dcstat_pid", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

25 - .user_input = 0,

26 - .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

27 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

26 + },

27 + {.name = "dcstat_pid",

28 + .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

29 + .user_input = 0,

30 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

31 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

32 #ifdef LIBBPF_MAJOR_VERSION

29 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

33 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

34 #endif

31 - },

32 - {.name = "dcstat_ctrl", .internal_input = NETDATA_CONTROLLER_END,

33 - .user_input = 0,

34 - .type = NETDATA_EBPF_MAP_CONTROLLER,

35 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

35 + },

36 + {.name = "dcstat_ctrl",

37 + .internal_input = NETDATA_CONTROLLER_END,

38 + .user_input = 0,

39 + .type = NETDATA_EBPF_MAP_CONTROLLER,

40 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

41 #ifdef LIBBPF_MAJOR_VERSION

37 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

42 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

43 #endif

39 - },

40 - {.name = NULL, .internal_input = 0, .user_input = 0,

41 - .type = NETDATA_EBPF_MAP_CONTROLLER,

42 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

44 + },

45 + {.name = NULL,

46 + .internal_input = 0,

47 + .user_input = 0,

48 + .type = NETDATA_EBPF_MAP_CONTROLLER,

49 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

50 #ifdef LIBBPF_MAJOR_VERSION

44 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

51 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

52 #endif

46 - }};

53 + }};

48 -static ebpf_specify_name_t dc_optional_name[] = { {.program_name = "netdata_lookup_fast",

49 - .function_to_attach = "lookup_fast",

50 - .optional = NULL,

51 - .retprobe = CONFIG_BOOLEAN_NO},

52 - {.program_name = NULL}};

55 +static ebpf_specify_name_t dc_optional_name[] = {

56 + {.program_name = "netdata_lookup_fast",

57 + .function_to_attach = "lookup_fast",

58 + .optional = NULL,

59 + .retprobe = CONFIG_BOOLEAN_NO},

60 + {.program_name = NULL}};

54 -netdata_ebpf_targets_t dc_targets[] = { {.name = "lookup_fast", .mode = EBPF_LOAD_TRAMPOLINE},

55 - {.name = "d_lookup", .mode = EBPF_LOAD_TRAMPOLINE},

56 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

62 +netdata_ebpf_targets_t dc_targets[] = {

63 + {.name = "lookup_fast", .mode = EBPF_LOAD_TRAMPOLINE},

64 + {.name = "d_lookup", .mode = EBPF_LOAD_TRAMPOLINE},

65 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

67 struct netdata_static_thread ebpf_read_dcstat = {

68 .name = "EBPF_READ_DCSTAT",

@@ -63,8 +72,7 @@ struct netdata_static_thread ebpf_read_dcstat = {

72 .enabled = 1,

73 .thread = NULL,

74 .init_routine = NULL,

66 - .start_routine = NULL

67 -};

75 + .start_routine = NULL};

77 #ifdef LIBBPF_MAJOR_VERSION

78 /**

@@ -102,11 +110,10 @@ static inline void ebpf_dc_disable_trampoline(struct dc_bpf *obj)

110 */

111 static void ebpf_dc_set_trampoline_target(struct dc_bpf *obj)

112 {

105 - bpf_program__set_attach_target(obj->progs.netdata_lookup_fast_fentry, 0,

106 - dc_targets[NETDATA_DC_TARGET_LOOKUP_FAST].name);

113 + bpf_program__set_attach_target(

114 + obj->progs.netdata_lookup_fast_fentry, 0, dc_targets[NETDATA_DC_TARGET_LOOKUP_FAST].name);

115

108 - bpf_program__set_attach_target(obj->progs.netdata_d_lookup_fexit, 0,

109 - dc_targets[NETDATA_DC_TARGET_D_LOOKUP].name);

116 + bpf_program__set_attach_target(obj->progs.netdata_d_lookup_fexit, 0, dc_targets[NETDATA_DC_TARGET_D_LOOKUP].name);

117 }

118

119 /**

@@ -120,20 +127,18 @@ static void ebpf_dc_set_trampoline_target(struct dc_bpf *obj)

127 */

128 static int ebpf_dc_attach_probes(struct dc_bpf *obj)

129 {

123 - obj->links.netdata_d_lookup_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_d_lookup_kretprobe,

124 - true,

125 - dc_targets[NETDATA_DC_TARGET_D_LOOKUP].name);

130 + obj->links.netdata_d_lookup_kretprobe = bpf_program__attach_kprobe(

131 + obj->progs.netdata_d_lookup_kretprobe, true, dc_targets[NETDATA_DC_TARGET_D_LOOKUP].name);

132 long ret = libbpf_get_error(obj->links.netdata_d_lookup_kretprobe);

133 if (ret)

134 return -1;

135

136 char *lookup_name = (dc_optional_name[NETDATA_DC_TARGET_LOOKUP_FAST].optional) ?

131 - dc_optional_name[NETDATA_DC_TARGET_LOOKUP_FAST].optional :

132 - dc_targets[NETDATA_DC_TARGET_LOOKUP_FAST].name ;

137 + dc_optional_name[NETDATA_DC_TARGET_LOOKUP_FAST].optional :

138 + dc_targets[NETDATA_DC_TARGET_LOOKUP_FAST].name;

139

134 - obj->links.netdata_lookup_fast_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_lookup_fast_kprobe,

135 - false,

136 - lookup_name);

140 + obj->links.netdata_lookup_fast_kprobe =

141 + bpf_program__attach_kprobe(obj->progs.netdata_lookup_fast_kprobe, false, lookup_name);

142 ret = libbpf_get_error(obj->links.netdata_lookup_fast_kprobe);

143 if (ret)

144 return -1;

@@ -151,8 +156,8 @@ static int ebpf_dc_attach_probes(struct dc_bpf *obj)

156 */

157 static void ebpf_dc_adjust_map(struct dc_bpf *obj, ebpf_module_t *em)

158 {

154 - ebpf_update_map_size(obj->maps.dcstat_pid, &dcstat_maps[NETDATA_DCSTAT_PID_STATS],

155 - em, bpf_map__name(obj->maps.dcstat_pid));

159 + ebpf_update_map_size(

160 + obj->maps.dcstat_pid, &dcstat_maps[NETDATA_DCSTAT_PID_STATS], em, bpf_map__name(obj->maps.dcstat_pid));

161

162 ebpf_update_map_type(obj->maps.dcstat_global, &dcstat_maps[NETDATA_DCSTAT_GLOBAL_STATS]);

163 ebpf_update_map_type(obj->maps.dcstat_pid, &dcstat_maps[NETDATA_DCSTAT_PID_STATS]);

@@ -185,13 +190,15 @@ static void ebpf_dc_set_hash_tables(struct dc_bpf *obj)

190 */

191 netdata_ebpf_program_loaded_t ebpf_dc_update_load(ebpf_module_t *em)

192 {

188 - if (!strcmp(dc_optional_name[NETDATA_DC_TARGET_LOOKUP_FAST].optional,

189 - dc_optional_name[NETDATA_DC_TARGET_LOOKUP_FAST].function_to_attach))

193 + if (!strcmp(

194 + dc_optional_name[NETDATA_DC_TARGET_LOOKUP_FAST].optional,

195 + dc_optional_name[NETDATA_DC_TARGET_LOOKUP_FAST].function_to_attach))

196 return EBPF_LOAD_TRAMPOLINE;

197

198 if (em->targets[NETDATA_DC_TARGET_LOOKUP_FAST].mode != EBPF_LOAD_RETPROBE)

193 - netdata_log_info("When your kernel was compiled the symbol %s was modified, instead to use `trampoline`, the plugin will use `probes`.",

194 - dc_optional_name[NETDATA_DC_TARGET_LOOKUP_FAST].function_to_attach);

199 + netdata_log_info(

200 + "When your kernel was compiled the symbol %s was modified, instead to use `trampoline`, the plugin will use `probes`.",

201 + dc_optional_name[NETDATA_DC_TARGET_LOOKUP_FAST].function_to_attach);

202

203 return EBPF_LOAD_RETPROBE;

204 }

@@ -208,7 +215,7 @@ netdata_ebpf_program_loaded_t ebpf_dc_update_load(ebpf_module_t *em)

215 */

216 static inline int ebpf_dc_load_and_attach(struct dc_bpf *obj, ebpf_module_t *em)

217 {

211 - netdata_ebpf_program_loaded_t test = ebpf_dc_update_load(em);

218 + netdata_ebpf_program_loaded_t test = ebpf_dc_update_load(em);

219 if (test == EBPF_LOAD_TRAMPOLINE) {

220 ebpf_dc_disable_probes(obj);

221

@@ -252,10 +259,10 @@ static inline int ebpf_dc_load_and_attach(struct dc_bpf *obj, ebpf_module_t *em)

259 */

260 void dcstat_update_publish(netdata_publish_dcstat_t *out, uint64_t cache_access, uint64_t not_found)

261 {

255 - NETDATA_DOUBLE successful_access = (NETDATA_DOUBLE) (((long long)cache_access) - ((long long)not_found));

256 - NETDATA_DOUBLE ratio = (cache_access) ? successful_access/(NETDATA_DOUBLE)cache_access : 0;

262 + NETDATA_DOUBLE successful_access = (NETDATA_DOUBLE)(((long long)cache_access) - ((long long)not_found));

263 + NETDATA_DOUBLE ratio = (cache_access) ? successful_access / (NETDATA_DOUBLE)cache_access : 0;

264

258 - out->ratio = (long long )(ratio*100);

265 + out->ratio = (long long)(ratio * 100);

266 }

267

268 /*****************************************************************

@@ -275,49 +282,53 @@ static void ebpf_obsolete_specific_dc_charts(char *type, int update_every);

282 */

283 static void ebpf_obsolete_dc_services(ebpf_module_t *em, char *id)

284 {

278 - ebpf_write_chart_obsolete(id,

279 - NETDATA_DC_HIT_CHART,

280 - "",

281 - "Percentage of files inside directory cache",

282 - EBPF_COMMON_UNITS_PERCENTAGE,

283 - NETDATA_DIRECTORY_CACHE_SUBMENU,

284 - NETDATA_EBPF_CHART_TYPE_LINE,

285 - NETDATA_SYSTEMD_DC_HIT_RATIO_CONTEXT,

286 - 21200,

287 - em->update_every);

288 -

289 - ebpf_write_chart_obsolete(id,

290 - NETDATA_DC_REFERENCE_CHART,

291 - "",

292 - "Count file access",

293 - EBPF_COMMON_UNITS_FILES,

294 - NETDATA_DIRECTORY_CACHE_SUBMENU,

295 - NETDATA_EBPF_CHART_TYPE_LINE,

296 - NETDATA_SYSTEMD_DC_REFERENCE_CONTEXT,

297 - 21201,

298 - em->update_every);

299 -

300 - ebpf_write_chart_obsolete(id,

301 - NETDATA_DC_REQUEST_NOT_CACHE_CHART,

302 - "",

303 - "Files not present inside directory cache",

304 - EBPF_COMMON_UNITS_FILES,

305 - NETDATA_DIRECTORY_CACHE_SUBMENU,

306 - NETDATA_EBPF_CHART_TYPE_LINE,

307 - NETDATA_SYSTEMD_DC_NOT_CACHE_CONTEXT,

308 - 21202,

309 - em->update_every);

310 -

311 - ebpf_write_chart_obsolete(id,

312 - NETDATA_DC_REQUEST_NOT_FOUND_CHART,

313 - "",

314 - "Files not found",

315 - EBPF_COMMON_UNITS_FILES,

316 - NETDATA_DIRECTORY_CACHE_SUBMENU,

317 - NETDATA_EBPF_CHART_TYPE_LINE,

318 - NETDATA_SYSTEMD_DC_NOT_FOUND_CONTEXT,

319 - 21203,

320 - em->update_every);

285 + ebpf_write_chart_obsolete(

286 + id,

287 + NETDATA_DC_HIT_CHART,

288 + "",

289 + "Percentage of files inside directory cache",

290 + EBPF_COMMON_UNITS_PERCENTAGE,

291 + NETDATA_DIRECTORY_CACHE_SUBMENU,

292 + NETDATA_EBPF_CHART_TYPE_LINE,

293 + NETDATA_SYSTEMD_DC_HIT_RATIO_CONTEXT,

294 + 21200,

295 + em->update_every);

296 +

297 + ebpf_write_chart_obsolete(

298 + id,

299 + NETDATA_DC_REFERENCE_CHART,

300 + "",

301 + "Count file access",

302 + EBPF_COMMON_UNITS_FILES,

303 + NETDATA_DIRECTORY_CACHE_SUBMENU,

304 + NETDATA_EBPF_CHART_TYPE_LINE,

305 + NETDATA_SYSTEMD_DC_REFERENCE_CONTEXT,

306 + 21201,

307 + em->update_every);

308 +

309 + ebpf_write_chart_obsolete(

310 + id,

311 + NETDATA_DC_REQUEST_NOT_CACHE_CHART,

312 + "",

313 + "Files not present inside directory cache",

314 + EBPF_COMMON_UNITS_FILES,

315 + NETDATA_DIRECTORY_CACHE_SUBMENU,

316 + NETDATA_EBPF_CHART_TYPE_LINE,

317 + NETDATA_SYSTEMD_DC_NOT_CACHE_CONTEXT,

318 + 21202,

319 + em->update_every);

320 +

321 + ebpf_write_chart_obsolete(

322 + id,

323 + NETDATA_DC_REQUEST_NOT_FOUND_CHART,

324 + "",

325 + "Files not found",

326 + EBPF_COMMON_UNITS_FILES,

327 + NETDATA_DIRECTORY_CACHE_SUBMENU,

328 + NETDATA_EBPF_CHART_TYPE_LINE,

329 + NETDATA_SYSTEMD_DC_NOT_FOUND_CONTEXT,

330 + 21203,

331 + em->update_every);

332 }

333

334 /**

@@ -327,11 +338,12 @@ static void ebpf_obsolete_dc_services(ebpf_module_t *em, char *id)

338 *

339 * @param em a pointer to `struct ebpf_module`

340 */

330 -static inline void ebpf_obsolete_dc_cgroup_charts(ebpf_module_t *em) {

341 +static inline void ebpf_obsolete_dc_cgroup_charts(ebpf_module_t *em)

342 +{

343 pthread_mutex_lock(&mutex_cgroup_shm);

344

345 ebpf_cgroup_target_t *ect;

334 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

346 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

347 if (ect->systemd) {

348 ebpf_obsolete_dc_services(em, ect->name);

349

@@ -356,54 +368,58 @@ void ebpf_obsolete_dc_apps_charts(struct ebpf_module *em)

368 int update_every = em->update_every;

369 pthread_mutex_lock(&collect_data_mutex);

370 for (w = apps_groups_root_target; w; w = w->next) {

359 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_DCSTAT_IDX))))

371 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_DCSTAT_IDX))))

372 continue;

373

362 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

363 - w->clean_name,

364 - "_ebpf_dc_hit",

365 - "Percentage of files inside directory cache.",

366 - EBPF_COMMON_UNITS_PERCENTAGE,

367 - NETDATA_DIRECTORY_CACHE_SUBMENU,

368 - NETDATA_EBPF_CHART_TYPE_LINE,

369 - "app.ebpf_dc_hit",

370 - 20265,

371 - update_every);

372 -

373 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

374 - w->clean_name,

375 - "_ebpf_dc_reference",

376 - "Count file access.",

377 - EBPF_COMMON_UNITS_FILES,

378 - NETDATA_DIRECTORY_CACHE_SUBMENU,

379 - NETDATA_EBPF_CHART_TYPE_STACKED,

380 - "app.ebpf_dc_reference",

381 - 20266,

382 - update_every);

383 -

384 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

385 - w->clean_name,

386 - "_ebpf_not_cache",

387 - "Files not present inside directory cache.",

388 - EBPF_COMMON_UNITS_FILES,

389 - NETDATA_DIRECTORY_CACHE_SUBMENU,

390 - NETDATA_EBPF_CHART_TYPE_STACKED,

391 - "app.ebpf_dc_not_cache",

392 - 20267,

393 - update_every);

394 -

395 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

396 - w->clean_name,

397 - "_ebpf_not_found",

398 - "Files not found.",

399 - EBPF_COMMON_UNITS_FILES,

400 - NETDATA_DIRECTORY_CACHE_SUBMENU,

401 - NETDATA_EBPF_CHART_TYPE_STACKED,

402 - "app.ebpf_dc_not_found",

403 - 20268,

404 - update_every);

405 -

406 - w->charts_created &= ~(1<<EBPF_MODULE_DCSTAT_IDX);

374 + ebpf_write_chart_obsolete(

375 + NETDATA_APP_FAMILY,

376 + w->clean_name,

377 + "_ebpf_dc_hit",

378 + "Percentage of files inside directory cache.",

379 + EBPF_COMMON_UNITS_PERCENTAGE,

380 + NETDATA_DIRECTORY_CACHE_SUBMENU,

381 + NETDATA_EBPF_CHART_TYPE_LINE,

382 + "app.ebpf_dc_hit",

383 + 20265,

384 + update_every);

385 +

386 + ebpf_write_chart_obsolete(

387 + NETDATA_APP_FAMILY,

388 + w->clean_name,

389 + "_ebpf_dc_reference",

390 + "Count file access.",

391 + EBPF_COMMON_UNITS_FILES,

392 + NETDATA_DIRECTORY_CACHE_SUBMENU,

393 + NETDATA_EBPF_CHART_TYPE_STACKED,

394 + "app.ebpf_dc_reference",

395 + 20266,

396 + update_every);

397 +

398 + ebpf_write_chart_obsolete(

399 + NETDATA_APP_FAMILY,

400 + w->clean_name,

401 + "_ebpf_not_cache",

402 + "Files not present inside directory cache.",

403 + EBPF_COMMON_UNITS_FILES,

404 + NETDATA_DIRECTORY_CACHE_SUBMENU,

405 + NETDATA_EBPF_CHART_TYPE_STACKED,

406 + "app.ebpf_dc_not_cache",

407 + 20267,

408 + update_every);

409 +

410 + ebpf_write_chart_obsolete(

411 + NETDATA_APP_FAMILY,

412 + w->clean_name,

413 + "_ebpf_not_found",

414 + "Files not found.",

415 + EBPF_COMMON_UNITS_FILES,

416 + NETDATA_DIRECTORY_CACHE_SUBMENU,

417 + NETDATA_EBPF_CHART_TYPE_STACKED,

418 + "app.ebpf_dc_not_found",

419 + 20268,

420 + update_every);

421 +

422 + w->charts_created &= ~(1 << EBPF_MODULE_DCSTAT_IDX);

423 }

424 pthread_mutex_unlock(&collect_data_mutex);

425 }

@@ -417,27 +433,29 @@ void ebpf_obsolete_dc_apps_charts(struct ebpf_module *em)

433 */

434 static void ebpf_obsolete_dc_global(ebpf_module_t *em)

435 {

420 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

421 - NETDATA_DC_HIT_CHART,

422 - "",

423 - "Percentage of files inside directory cache",

424 - EBPF_COMMON_UNITS_PERCENTAGE,

425 - NETDATA_DIRECTORY_CACHE_SUBMENU,

426 - NETDATA_EBPF_CHART_TYPE_LINE,

427 - NETDATA_FS_DC_HIT_RATIO_CONTEXT,

428 - 21200,

429 - em->update_every);

430 -

431 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

432 - NETDATA_DC_REFERENCE_CHART,

433 - "",

434 - "Variables used to calculate hit ratio.",

435 - EBPF_COMMON_UNITS_FILES,

436 - NETDATA_DIRECTORY_CACHE_SUBMENU,

437 - NETDATA_EBPF_CHART_TYPE_LINE,

438 - NETDATA_FS_DC_REFERENCE_CONTEXT,

439 - 21201,

440 - em->update_every);

436 + ebpf_write_chart_obsolete(

437 + NETDATA_FILESYSTEM_FAMILY,

438 + NETDATA_DC_HIT_CHART,

439 + "",

440 + "Percentage of files inside directory cache",

441 + EBPF_COMMON_UNITS_PERCENTAGE,

442 + NETDATA_DIRECTORY_CACHE_SUBMENU,

443 + NETDATA_EBPF_CHART_TYPE_LINE,

444 + NETDATA_FS_DC_HIT_RATIO_CONTEXT,

445 + 21200,

446 + em->update_every);

447 +

448 + ebpf_write_chart_obsolete(

449 + NETDATA_FILESYSTEM_FAMILY,

450 + NETDATA_DC_REFERENCE_CHART,

451 + "",

452 + "Variables used to calculate hit ratio.",

453 + EBPF_COMMON_UNITS_FILES,

454 + NETDATA_DIRECTORY_CACHE_SUBMENU,

455 + NETDATA_EBPF_CHART_TYPE_LINE,

456 + NETDATA_FS_DC_REFERENCE_CONTEXT,

457 + 21201,

458 + em->update_every);

459 }

460

461 /**

@@ -451,10 +469,11 @@ static void ebpf_dcstat_exit(void *pptr)

469 {

470 pids_fd[NETDATA_EBPF_PIDS_DCSTAT_IDX] = -1;

471 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

454 - if(!em) return;

472 + if (!em)

473 + return;

474

475 pthread_mutex_lock(&lock);

457 - collect_pids &= ~(1<<EBPF_MODULE_DCSTAT_IDX);

476 + collect_pids &= ~(1 << EBPF_MODULE_DCSTAT_IDX);

477 pthread_mutex_unlock(&lock);

478

479 if (ebpf_read_dcstat.thread)

@@ -486,7 +505,7 @@ static void ebpf_dcstat_exit(void *pptr)

505 }

506 #endif

507

489 - if (em->objects){

508 + if (em->objects) {

509 ebpf_unload_legacy_code(em->objects, em->probe_links);

510 em->objects = NULL;

511 em->probe_links = NULL;

@@ -577,7 +596,7 @@ static void ebpf_read_dc_apps_table(int maps_per_core)

596 }

597 }

598

580 -end_dc_loop:

599 + end_dc_loop:

600 // We are cleaning to avoid passing data read from one process to other.

601 memset(cv, 0, length);

602 key = next_key;

@@ -616,7 +635,7 @@ void ebpf_dc_resume_apps_data()

635 struct ebpf_target *w;

636

637 for (w = apps_groups_root_target; w; w = w->next) {

619 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_DCSTAT_IDX))))

638 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_DCSTAT_IDX))))

639 continue;

640

641 ebpf_dcstat_sum_pids(&w->dcstat, w->root_pid);

@@ -695,67 +714,71 @@ void ebpf_dcstat_create_apps_charts(struct ebpf_module *em, void *ptr)

714 if (unlikely(!w->exposed))

715 continue;

716

698 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

699 - w->clean_name,

700 - "_ebpf_dc_hit",

701 - "Percentage of files inside directory cache.",

702 - EBPF_COMMON_UNITS_PERCENTAGE,

703 - NETDATA_DIRECTORY_CACHE_SUBMENU,

704 - NETDATA_EBPF_CHART_TYPE_LINE,

705 - "app.ebpf_dc_hit",

706 - 20265,

707 - update_every,

708 - NETDATA_EBPF_MODULE_NAME_DCSTAT);

717 + ebpf_write_chart_cmd(

718 + NETDATA_APP_FAMILY,

719 + w->clean_name,

720 + "_ebpf_dc_hit",

721 + "Percentage of files inside directory cache.",

722 + EBPF_COMMON_UNITS_PERCENTAGE,

723 + NETDATA_DIRECTORY_CACHE_SUBMENU,

724 + NETDATA_EBPF_CHART_TYPE_LINE,

725 + "app.ebpf_dc_hit",

726 + 20265,

727 + update_every,

728 + NETDATA_EBPF_MODULE_NAME_DCSTAT);

729 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

730 ebpf_commit_label();

731 fprintf(stdout, "DIMENSION ratio '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

732

713 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

714 - w->clean_name,

715 - "_ebpf_dc_reference",

716 - "Count file access.",

717 - EBPF_COMMON_UNITS_FILES,

718 - NETDATA_DIRECTORY_CACHE_SUBMENU,

719 - NETDATA_EBPF_CHART_TYPE_STACKED,

720 - "app.ebpf_dc_reference",

721 - 20266,

722 - update_every,

723 - NETDATA_EBPF_MODULE_NAME_DCSTAT);

733 + ebpf_write_chart_cmd(

734 + NETDATA_APP_FAMILY,

735 + w->clean_name,

736 + "_ebpf_dc_reference",

737 + "Count file access.",

738 + EBPF_COMMON_UNITS_FILES,

739 + NETDATA_DIRECTORY_CACHE_SUBMENU,

740 + NETDATA_EBPF_CHART_TYPE_STACKED,

741 + "app.ebpf_dc_reference",

742 + 20266,

743 + update_every,

744 + NETDATA_EBPF_MODULE_NAME_DCSTAT);

745 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

746 ebpf_commit_label();

747 fprintf(stdout, "DIMENSION files '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

748

728 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

729 - w->clean_name,

730 - "_ebpf_not_cache",

731 - "Files not present inside directory cache.",

732 - EBPF_COMMON_UNITS_FILES,

733 - NETDATA_DIRECTORY_CACHE_SUBMENU,

734 - NETDATA_EBPF_CHART_TYPE_STACKED,

735 - "app.ebpf_dc_not_cache",

736 - 20267,

737 - update_every,

738 - NETDATA_EBPF_MODULE_NAME_DCSTAT);

749 + ebpf_write_chart_cmd(

750 + NETDATA_APP_FAMILY,

751 + w->clean_name,

752 + "_ebpf_not_cache",

753 + "Files not present inside directory cache.",

754 + EBPF_COMMON_UNITS_FILES,

755 + NETDATA_DIRECTORY_CACHE_SUBMENU,

756 + NETDATA_EBPF_CHART_TYPE_STACKED,

757 + "app.ebpf_dc_not_cache",

758 + 20267,

759 + update_every,

760 + NETDATA_EBPF_MODULE_NAME_DCSTAT);

761 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

762 ebpf_commit_label();

763 fprintf(stdout, "DIMENSION files '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

764

743 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

744 - w->clean_name,

745 - "_ebpf_not_found",

746 - "Files not found.",

747 - EBPF_COMMON_UNITS_FILES,

748 - NETDATA_DIRECTORY_CACHE_SUBMENU,

749 - NETDATA_EBPF_CHART_TYPE_STACKED,

750 - "app.ebpf_dc_not_found",

751 - 20268,

752 - update_every,

753 - NETDATA_EBPF_MODULE_NAME_DCSTAT);

765 + ebpf_write_chart_cmd(

766 + NETDATA_APP_FAMILY,

767 + w->clean_name,

768 + "_ebpf_not_found",

769 + "Files not found.",

770 + EBPF_COMMON_UNITS_FILES,

771 + NETDATA_DIRECTORY_CACHE_SUBMENU,

772 + NETDATA_EBPF_CHART_TYPE_STACKED,

773 + "app.ebpf_dc_not_found",

774 + 20268,

775 + update_every,

776 + NETDATA_EBPF_MODULE_NAME_DCSTAT);

777 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

778 ebpf_commit_label();

779 fprintf(stdout, "DIMENSION files '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

780

758 - w->charts_created |= 1<<EBPF_MODULE_DCSTAT_IDX;

781 + w->charts_created |= 1 << EBPF_MODULE_DCSTAT_IDX;

782 }

783

784 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;

@@ -804,19 +827,21 @@ static void ebpf_update_dc_cgroup()

827 */

828 static void ebpf_dc_read_global_tables(netdata_idx_t *stats, int maps_per_core)

829 {

807 - ebpf_read_global_table_stats(dcstat_hash_values,

808 - dcstat_values,

809 - dcstat_maps[NETDATA_DCSTAT_GLOBAL_STATS].map_fd,

810 - maps_per_core,

811 - NETDATA_KEY_DC_REFERENCE,

812 - NETDATA_DIRECTORY_CACHE_END);

813 -

814 - ebpf_read_global_table_stats(stats,

815 - dcstat_values,

816 - dcstat_maps[NETDATA_DCSTAT_CTRL].map_fd,

817 - maps_per_core,

818 - NETDATA_CONTROLLER_PID_TABLE_ADD,

819 - NETDATA_CONTROLLER_END);

830 + ebpf_read_global_table_stats(

831 + dcstat_hash_values,

832 + dcstat_values,

833 + dcstat_maps[NETDATA_DCSTAT_GLOBAL_STATS].map_fd,

834 + maps_per_core,

835 + NETDATA_KEY_DC_REFERENCE,

836 + NETDATA_DIRECTORY_CACHE_END);

837 +

838 + ebpf_read_global_table_stats(

839 + stats,

840 + dcstat_values,

841 + dcstat_maps[NETDATA_DCSTAT_CTRL].map_fd,

842 + maps_per_core,

843 + NETDATA_CONTROLLER_PID_TABLE_ADD,

844 + NETDATA_CONTROLLER_END);

845 }

846

847 /**

@@ -831,10 +856,10 @@ void ebpf_dcache_send_apps_data(struct ebpf_target *root)

856

857 pthread_mutex_lock(&collect_data_mutex);

858 for (w = root; w; w = w->next) {

834 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_DCSTAT_IDX))))

859 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_DCSTAT_IDX))))

860 continue;

861

837 - value = (collected_number) w->dcstat.ratio;

862 + value = (collected_number)w->dcstat.ratio;

863 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_dc_hit");

864 write_chart_dimension("ratio", value);

865 ebpf_write_end_chart();

@@ -845,7 +870,7 @@ void ebpf_dcache_send_apps_data(struct ebpf_target *root)

870 w->dcstat.cache_access = (long long)w->dcstat.curr.cache_access - (long long)w->dcstat.prev.cache_access;

871

872 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_dc_reference");

848 - value = (collected_number) w->dcstat.cache_access;

873 + value = (collected_number)w->dcstat.cache_access;

874 write_chart_dimension("files", value);

875 ebpf_write_end_chart();

876 w->dcstat.prev.cache_access = w->dcstat.curr.cache_access;

@@ -853,8 +878,9 @@ void ebpf_dcache_send_apps_data(struct ebpf_target *root)

878 if (w->dcstat.curr.file_system < w->dcstat.prev.file_system) {

879 w->dcstat.prev.file_system = 0;

880 }

856 - value = (collected_number) (!w->dcstat.cache_access) ? 0 :

857 - (long long )w->dcstat.curr.file_system - (long long)w->dcstat.prev.file_system;

881 + value = (collected_number)(!w->dcstat.cache_access) ?

882 + 0 :

883 + (long long)w->dcstat.curr.file_system - (long long)w->dcstat.prev.file_system;

884 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_not_cache");

885 write_chart_dimension("files", value);

886 ebpf_write_end_chart();

@@ -863,8 +889,9 @@ void ebpf_dcache_send_apps_data(struct ebpf_target *root)

889 if (w->dcstat.curr.not_found < w->dcstat.prev.not_found) {

890 w->dcstat.prev.not_found = 0;

891 }

866 - value = (collected_number) (!w->dcstat.cache_access) ? 0 :

867 - (long long)w->dcstat.curr.not_found - (long long)w->dcstat.prev.not_found;

892 + value = (collected_number)(!w->dcstat.cache_access) ?

893 + 0 :

894 + (long long)w->dcstat.curr.not_found - (long long)w->dcstat.prev.not_found;

895 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_not_found");

896 write_chart_dimension("files", value);

897 ebpf_write_end_chart();

@@ -880,8 +907,8 @@ void ebpf_dcache_send_apps_data(struct ebpf_target *root)

907 */

908 static void dcstat_send_global(netdata_publish_dcstat_t *publish)

909 {

883 - dcstat_update_publish(publish, dcstat_hash_values[NETDATA_KEY_DC_REFERENCE],

884 - dcstat_hash_values[NETDATA_KEY_DC_MISS]);

910 + dcstat_update_publish(

911 + publish, dcstat_hash_values[NETDATA_KEY_DC_REFERENCE], dcstat_hash_values[NETDATA_KEY_DC_MISS]);

912

913 netdata_publish_syscall_t *ptr = dcstat_counter_publish_aggregated;

914 netdata_idx_t value = dcstat_hash_values[NETDATA_KEY_DC_REFERENCE];

@@ -890,7 +917,7 @@ static void dcstat_send_global(netdata_publish_dcstat_t *publish)

917 ptr[NETDATA_DCSTAT_IDX_REFERENCE].pcall = value;

918

919 value = dcstat_hash_values[NETDATA_KEY_DC_SLOW];

893 - ptr[NETDATA_DCSTAT_IDX_SLOW].ncall = value - ptr[NETDATA_DCSTAT_IDX_SLOW].pcall;

920 + ptr[NETDATA_DCSTAT_IDX_SLOW].ncall = value - ptr[NETDATA_DCSTAT_IDX_SLOW].pcall;

921 ptr[NETDATA_DCSTAT_IDX_SLOW].pcall = value;

922

923 value = dcstat_hash_values[NETDATA_KEY_DC_MISS];

@@ -902,12 +929,14 @@ static void dcstat_send_global(netdata_publish_dcstat_t *publish)

929 ptr[NETDATA_DCSTAT_IDX_MISS].ncall = 0;

930 }

931

905 - ebpf_one_dimension_write_charts(NETDATA_FILESYSTEM_FAMILY, NETDATA_DC_HIT_CHART,

906 - ptr[NETDATA_DCSTAT_IDX_RATIO].dimension, publish->ratio);

932 + ebpf_one_dimension_write_charts(

933 + NETDATA_FILESYSTEM_FAMILY, NETDATA_DC_HIT_CHART, ptr[NETDATA_DCSTAT_IDX_RATIO].dimension, publish->ratio);

934

935 write_count_chart(

909 - NETDATA_DC_REFERENCE_CHART, NETDATA_FILESYSTEM_FAMILY,

910 - &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE], 3);

936 + NETDATA_DC_REFERENCE_CHART,

937 + NETDATA_FILESYSTEM_FAMILY,

938 + &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE],

939 + 3);

940 }

941

942 /**

@@ -921,44 +950,71 @@ static void dcstat_send_global(netdata_publish_dcstat_t *publish)

950 static void ebpf_create_specific_dc_charts(char *type, int update_every)

951 {

952 char *label = (!strncmp(type, "cgroup_", 7)) ? &type[7] : type;

924 - ebpf_create_chart(type, NETDATA_DC_HIT_CHART, "Percentage of files inside directory cache",

925 - EBPF_COMMON_UNITS_PERCENTAGE, NETDATA_DIRECTORY_CACHE_SUBMENU,

926 - NETDATA_CGROUP_DC_HIT_RATIO_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

927 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5700,

928 - ebpf_create_global_dimension,

929 - dcstat_counter_publish_aggregated, 1, update_every, NETDATA_EBPF_MODULE_NAME_DCSTAT);

953 + ebpf_create_chart(

954 + type,

955 + NETDATA_DC_HIT_CHART,

956 + "Percentage of files inside directory cache",

957 + EBPF_COMMON_UNITS_PERCENTAGE,

958 + NETDATA_DIRECTORY_CACHE_SUBMENU,

959 + NETDATA_CGROUP_DC_HIT_RATIO_CONTEXT,

960 + NETDATA_EBPF_CHART_TYPE_LINE,

961 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5700,

962 + ebpf_create_global_dimension,

963 + dcstat_counter_publish_aggregated,

964 + 1,

965 + update_every,

966 + NETDATA_EBPF_MODULE_NAME_DCSTAT);

967 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

968 ebpf_commit_label();

969

933 - ebpf_create_chart(type, NETDATA_DC_REFERENCE_CHART, "Count file access",

934 - EBPF_COMMON_UNITS_FILES, NETDATA_DIRECTORY_CACHE_SUBMENU,

935 - NETDATA_CGROUP_DC_REFERENCE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

936 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5701,

937 - ebpf_create_global_dimension,

938 - &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE], 1,

939 - update_every, NETDATA_EBPF_MODULE_NAME_DCSTAT);

970 + ebpf_create_chart(

971 + type,

972 + NETDATA_DC_REFERENCE_CHART,

973 + "Count file access",

974 + EBPF_COMMON_UNITS_FILES,

975 + NETDATA_DIRECTORY_CACHE_SUBMENU,

976 + NETDATA_CGROUP_DC_REFERENCE_CONTEXT,

977 + NETDATA_EBPF_CHART_TYPE_LINE,

978 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5701,

979 + ebpf_create_global_dimension,

980 + &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE],

981 + 1,

982 + update_every,

983 + NETDATA_EBPF_MODULE_NAME_DCSTAT);

984 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

985 ebpf_commit_label();

986

943 - ebpf_create_chart(type, NETDATA_DC_REQUEST_NOT_CACHE_CHART,

944 - "Files not present inside directory cache",

945 - EBPF_COMMON_UNITS_FILES, NETDATA_DIRECTORY_CACHE_SUBMENU,

946 - NETDATA_CGROUP_DC_NOT_CACHE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

947 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5702,

948 - ebpf_create_global_dimension,

949 - &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_SLOW], 1,

950 - update_every, NETDATA_EBPF_MODULE_NAME_DCSTAT);

987 + ebpf_create_chart(

988 + type,

989 + NETDATA_DC_REQUEST_NOT_CACHE_CHART,

990 + "Files not present inside directory cache",

991 + EBPF_COMMON_UNITS_FILES,

992 + NETDATA_DIRECTORY_CACHE_SUBMENU,

993 + NETDATA_CGROUP_DC_NOT_CACHE_CONTEXT,

994 + NETDATA_EBPF_CHART_TYPE_LINE,

995 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5702,

996 + ebpf_create_global_dimension,

997 + &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_SLOW],

998 + 1,

999 + update_every,

1000 + NETDATA_EBPF_MODULE_NAME_DCSTAT);

1001 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1002 ebpf_commit_label();

1003

954 - ebpf_create_chart(type, NETDATA_DC_REQUEST_NOT_FOUND_CHART,

955 - "Files not found",

956 - EBPF_COMMON_UNITS_FILES, NETDATA_DIRECTORY_CACHE_SUBMENU,

957 - NETDATA_CGROUP_DC_NOT_FOUND_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

958 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5703,

959 - ebpf_create_global_dimension,

960 - &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_MISS], 1,

961 - update_every, NETDATA_EBPF_MODULE_NAME_DCSTAT);

1004 + ebpf_create_chart(

1005 + type,

1006 + NETDATA_DC_REQUEST_NOT_FOUND_CHART,

1007 + "Files not found",

1008 + EBPF_COMMON_UNITS_FILES,

1009 + NETDATA_DIRECTORY_CACHE_SUBMENU,

1010 + NETDATA_CGROUP_DC_NOT_FOUND_CONTEXT,

1011 + NETDATA_EBPF_CHART_TYPE_LINE,

1012 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5703,

1013 + ebpf_create_global_dimension,

1014 + &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_MISS],

1015 + 1,

1016 + update_every,

1017 + NETDATA_EBPF_MODULE_NAME_DCSTAT);

1018 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1019 ebpf_commit_label();

1020 }

@@ -973,33 +1029,53 @@ static void ebpf_create_specific_dc_charts(char *type, int update_every)

1029 */

1030 static void ebpf_obsolete_specific_dc_charts(char *type, int update_every)

1031 {

976 - ebpf_write_chart_obsolete(type, NETDATA_DC_HIT_CHART,

977 - "",

978 - "Percentage of files inside directory cache",

979 - EBPF_COMMON_UNITS_PERCENTAGE, NETDATA_DIRECTORY_CACHE_SUBMENU,

980 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_DC_HIT_RATIO_CONTEXT,

981 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5700, update_every);

982 -

983 - ebpf_write_chart_obsolete(type, NETDATA_DC_REFERENCE_CHART,

984 - "",

985 - "Count file access",

986 - EBPF_COMMON_UNITS_FILES, NETDATA_DIRECTORY_CACHE_SUBMENU,

987 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_DC_REFERENCE_CONTEXT,

988 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5701, update_every);

989 -

990 - ebpf_write_chart_obsolete(type, NETDATA_DC_REQUEST_NOT_CACHE_CHART,

991 - "",

992 - "Files not present inside directory cache",

993 - EBPF_COMMON_UNITS_FILES, NETDATA_DIRECTORY_CACHE_SUBMENU,

994 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_DC_NOT_CACHE_CONTEXT,

995 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5702, update_every);

996 -

997 - ebpf_write_chart_obsolete(type, NETDATA_DC_REQUEST_NOT_FOUND_CHART,

998 - "",

999 - "Files not found",

1000 - EBPF_COMMON_UNITS_FILES, NETDATA_DIRECTORY_CACHE_SUBMENU,

1001 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_DC_NOT_FOUND_CONTEXT,

1002 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5703, update_every);

1032 + ebpf_write_chart_obsolete(

1033 + type,

1034 + NETDATA_DC_HIT_CHART,

1035 + "",

1036 + "Percentage of files inside directory cache",

1037 + EBPF_COMMON_UNITS_PERCENTAGE,

1038 + NETDATA_DIRECTORY_CACHE_SUBMENU,

1039 + NETDATA_EBPF_CHART_TYPE_LINE,

1040 + NETDATA_CGROUP_DC_HIT_RATIO_CONTEXT,

1041 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5700,

1042 + update_every);

1043 +

1044 + ebpf_write_chart_obsolete(

1045 + type,

1046 + NETDATA_DC_REFERENCE_CHART,

1047 + "",

1048 + "Count file access",

1049 + EBPF_COMMON_UNITS_FILES,

1050 + NETDATA_DIRECTORY_CACHE_SUBMENU,

1051 + NETDATA_EBPF_CHART_TYPE_LINE,

1052 + NETDATA_CGROUP_DC_REFERENCE_CONTEXT,

1053 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5701,

1054 + update_every);

1055 +

1056 + ebpf_write_chart_obsolete(

1057 + type,

1058 + NETDATA_DC_REQUEST_NOT_CACHE_CHART,

1059 + "",

1060 + "Files not present inside directory cache",

1061 + EBPF_COMMON_UNITS_FILES,

1062 + NETDATA_DIRECTORY_CACHE_SUBMENU,

1063 + NETDATA_EBPF_CHART_TYPE_LINE,

1064 + NETDATA_CGROUP_DC_NOT_CACHE_CONTEXT,

1065 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5702,

1066 + update_every);

1067 +

1068 + ebpf_write_chart_obsolete(

1069 + type,

1070 + NETDATA_DC_REQUEST_NOT_FOUND_CHART,

1071 + "",

1072 + "Files not found",

1073 + EBPF_COMMON_UNITS_FILES,

1074 + NETDATA_DIRECTORY_CACHE_SUBMENU,

1075 + NETDATA_EBPF_CHART_TYPE_LINE,

1076 + NETDATA_CGROUP_DC_NOT_FOUND_CONTEXT,

1077 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5703,

1078 + update_every);

1079 }

1080

1081 /**

@@ -1032,15 +1108,15 @@ void ebpf_dc_sum_cgroup_pids(netdata_publish_dcstat_t *publish, struct pid_on_ta

1108 void ebpf_dc_calc_chart_values()

1109 {

1110 ebpf_cgroup_target_t *ect;

1035 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1111 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1112 ebpf_dc_sum_cgroup_pids(&ect->publish_dc, ect->pids);

1113 uint64_t cache = ect->publish_dc.curr.cache_access;

1114 uint64_t not_found = ect->publish_dc.curr.not_found;

1115

1116 dcstat_update_publish(&ect->publish_dc, cache, not_found);

1117

1042 - ect->publish_dc.cache_access = (long long)ect->publish_dc.curr.cache_access -

1043 - (long long)ect->publish_dc.prev.cache_access;

1118 + ect->publish_dc.cache_access =

1119 + (long long)ect->publish_dc.curr.cache_access - (long long)ect->publish_dc.prev.cache_access;

1120 ect->publish_dc.prev.cache_access = ect->publish_dc.curr.cache_access;

1121

1122 if (ect->publish_dc.curr.not_found < ect->publish_dc.prev.not_found) {

@@ -1069,8 +1145,7 @@ static void ebpf_create_systemd_dc_charts(int update_every)

1145 .module = NETDATA_EBPF_MODULE_NAME_DCSTAT,

1146 .update_every = 0,

1147 .suffix = NETDATA_DC_HIT_CHART,

1072 - .dimension = "percentage"

1073 - };

1148 + .dimension = "percentage"};

1149

1150 static ebpf_systemd_args_t data_dc_references = {

1151 .title = "Count file access",

@@ -1083,8 +1158,7 @@ static void ebpf_create_systemd_dc_charts(int update_every)

1158 .module = NETDATA_EBPF_MODULE_NAME_DCSTAT,

1159 .update_every = 0,

1160 .suffix = NETDATA_DC_REFERENCE_CHART,

1086 - .dimension = "files"

1087 - };

1161 + .dimension = "files"};

1162

1163 static ebpf_systemd_args_t data_dc_not_cache = {

1164 .title = "Files not present inside directory cache",

@@ -1097,8 +1171,7 @@ static void ebpf_create_systemd_dc_charts(int update_every)

1171 .module = NETDATA_EBPF_MODULE_NAME_DCSTAT,

1172 .update_every = 0,

1173 .suffix = NETDATA_DC_REQUEST_NOT_CACHE_CHART,

1100 - .dimension = "files"

1101 - };

1174 + .dimension = "files"};

1175

1176 static ebpf_systemd_args_t data_dc_not_found = {

1177 .title = "Files not found",

@@ -1111,12 +1184,11 @@ static void ebpf_create_systemd_dc_charts(int update_every)

1184 .module = NETDATA_EBPF_MODULE_NAME_DCSTAT,

1185 .update_every = 0,

1186 .suffix = NETDATA_DC_REQUEST_NOT_FOUND_CHART,

1114 - .dimension = "files"

1115 - };

1187 + .dimension = "files"};

1188

1189 if (!data_dc_not_cache.update_every)

1118 - data_dc_hit_ratio.update_every = data_dc_not_cache.update_every =

1119 - data_dc_not_found.update_every = data_dc_references.update_every = update_every;

1190 + data_dc_hit_ratio.update_every = data_dc_not_cache.update_every = data_dc_not_found.update_every =

1191 + data_dc_references.update_every = update_every;

1192

1193 ebpf_cgroup_target_t *w;

1194 for (w = ebpf_cgroup_pids; w; w = w->next) {

@@ -1146,32 +1218,34 @@ static void ebpf_send_systemd_dc_charts()

1218 ebpf_cgroup_target_t *ect;

1219 collected_number value;

1220 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1149 - if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_DC_CHART)) ) {

1221 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_DC_CHART))) {

1222 continue;

1223 }

1224

1225 ebpf_write_begin_chart(ect->name, NETDATA_DC_HIT_CHART, "");

1154 - write_chart_dimension("percentage", (long long) ect->publish_dc.ratio);

1226 + write_chart_dimension("percentage", (long long)ect->publish_dc.ratio);

1227 ebpf_write_end_chart();

1228

1229 ebpf_write_begin_chart(ect->name, NETDATA_DC_REFERENCE_CHART, "");

1158 - write_chart_dimension("files", (long long) ect->publish_dc.cache_access);

1230 + write_chart_dimension("files", (long long)ect->publish_dc.cache_access);

1231 ebpf_write_end_chart();

1232

1233 ebpf_write_begin_chart(ect->name, NETDATA_DC_REQUEST_NOT_CACHE_CHART, "");

1162 - value = (collected_number) (!ect->publish_dc.cache_access) ? 0 :

1163 - (long long )ect->publish_dc.curr.file_system - (long long)ect->publish_dc.prev.file_system;

1234 + value = (collected_number)(!ect->publish_dc.cache_access) ?

1235 + 0 :

1236 + (long long)ect->publish_dc.curr.file_system - (long long)ect->publish_dc.prev.file_system;

1237 ect->publish_dc.prev.file_system = ect->publish_dc.curr.file_system;

1165 - write_chart_dimension("files", (long long) value);

1238 + write_chart_dimension("files", (long long)value);

1239 ebpf_write_end_chart();

1240

1241 ebpf_write_begin_chart(ect->name, NETDATA_DC_REQUEST_NOT_FOUND_CHART, "");

1169 - value = (collected_number) (!ect->publish_dc.cache_access) ? 0 :

1170 - (long long)ect->publish_dc.curr.not_found - (long long)ect->publish_dc.prev.not_found;

1242 + value = (collected_number)(!ect->publish_dc.cache_access) ?

1243 + 0 :

1244 + (long long)ect->publish_dc.curr.not_found - (long long)ect->publish_dc.prev.not_found;

1245

1246 ect->publish_dc.prev.not_found = ect->publish_dc.curr.not_found;

1247

1174 - write_chart_dimension("files", (long long) value);

1248 + write_chart_dimension("files", (long long)value);

1249 ebpf_write_end_chart();

1250 }

1251 }

@@ -1186,29 +1260,29 @@ static void ebpf_send_specific_dc_data(char *type, netdata_publish_dcstat_t *pdc

1260 {

1261 collected_number value;

1262 ebpf_write_begin_chart(type, NETDATA_DC_HIT_CHART, "");

1189 - write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_RATIO].name,

1190 - (long long) pdc->ratio);

1263 + write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_RATIO].name, (long long)pdc->ratio);

1264 ebpf_write_end_chart();

1265

1266 ebpf_write_begin_chart(type, NETDATA_DC_REFERENCE_CHART, "");

1194 - write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE].name,

1195 - (long long) pdc->cache_access);

1267 + write_chart_dimension(

1268 + dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE].name, (long long)pdc->cache_access);

1269 ebpf_write_end_chart();

1270

1198 - value = (collected_number) (!pdc->cache_access) ? 0 :

1199 - (long long )pdc->curr.file_system - (long long)pdc->prev.file_system;

1271 + value = (collected_number)(!pdc->cache_access) ?

1272 + 0 :

1273 + (long long)pdc->curr.file_system - (long long)pdc->prev.file_system;

1274 pdc->prev.file_system = pdc->curr.file_system;

1275

1276 ebpf_write_begin_chart(type, NETDATA_DC_REQUEST_NOT_CACHE_CHART, "");

1203 - write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_SLOW].name, (long long) value);

1277 + write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_SLOW].name, (long long)value);

1278 ebpf_write_end_chart();

1279

1206 - value = (collected_number) (!pdc->cache_access) ? 0 :

1207 - (long long)pdc->curr.not_found - (long long)pdc->prev.not_found;

1280 + value =

1281 + (collected_number)(!pdc->cache_access) ? 0 : (long long)pdc->curr.not_found - (long long)pdc->prev.not_found;

1282 pdc->prev.not_found = pdc->curr.not_found;

1283

1284 ebpf_write_begin_chart(type, NETDATA_DC_REQUEST_NOT_FOUND_CHART, "");

1211 - write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_MISS].name, (long long) value);

1285 + write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_MISS].name, (long long)value);

1286 ebpf_write_end_chart();

1287 }

1288

@@ -1231,7 +1305,7 @@ void ebpf_dc_send_cgroup_data(int update_every)

1305 ebpf_send_systemd_dc_charts();

1306 }

1307

1234 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1308 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1309 if (ect->systemd)

1310 continue;

1311

@@ -1321,24 +1395,35 @@ static void dcstat_collector(ebpf_module_t *em)

1395 */

1396 static void ebpf_create_dc_global_charts(int update_every)

1397 {

1324 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY, NETDATA_DC_HIT_CHART,

1325 - "Percentage of files inside directory cache",

1326 - EBPF_COMMON_UNITS_PERCENTAGE, NETDATA_DIRECTORY_CACHE_SUBMENU,

1327 - NETDATA_FS_DC_HIT_RATIO_CONTEXT,

1328 - NETDATA_EBPF_CHART_TYPE_LINE,

1329 - 21200,

1330 - ebpf_create_global_dimension,

1331 - dcstat_counter_publish_aggregated, 1, update_every, NETDATA_EBPF_MODULE_NAME_DCSTAT);

1332 -

1333 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY, NETDATA_DC_REFERENCE_CHART,

1334 - "Variables used to calculate hit ratio.",

1335 - EBPF_COMMON_UNITS_FILES, NETDATA_DIRECTORY_CACHE_SUBMENU,

1336 - NETDATA_FS_DC_REFERENCE_CONTEXT,

1337 - NETDATA_EBPF_CHART_TYPE_LINE,

1338 - 21201,

1339 - ebpf_create_global_dimension,

1340 - &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE], 3,

1341 - update_every, NETDATA_EBPF_MODULE_NAME_DCSTAT);

1398 + ebpf_create_chart(

1399 + NETDATA_FILESYSTEM_FAMILY,

1400 + NETDATA_DC_HIT_CHART,

1401 + "Percentage of files inside directory cache",

1402 + EBPF_COMMON_UNITS_PERCENTAGE,

1403 + NETDATA_DIRECTORY_CACHE_SUBMENU,

1404 + NETDATA_FS_DC_HIT_RATIO_CONTEXT,

1405 + NETDATA_EBPF_CHART_TYPE_LINE,

1406 + 21200,

1407 + ebpf_create_global_dimension,

1408 + dcstat_counter_publish_aggregated,

1409 + 1,

1410 + update_every,

1411 + NETDATA_EBPF_MODULE_NAME_DCSTAT);

1412 +

1413 + ebpf_create_chart(

1414 + NETDATA_FILESYSTEM_FAMILY,

1415 + NETDATA_DC_REFERENCE_CHART,

1416 + "Variables used to calculate hit ratio.",

1417 + EBPF_COMMON_UNITS_FILES,

1418 + NETDATA_DIRECTORY_CACHE_SUBMENU,

1419 + NETDATA_FS_DC_REFERENCE_CONTEXT,

1420 + NETDATA_EBPF_CHART_TYPE_LINE,

1421 + 21201,

1422 + ebpf_create_global_dimension,

1423 + &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE],

1424 + 3,

1425 + update_every,

1426 + NETDATA_EBPF_MODULE_NAME_DCSTAT);

1427

1428 fflush(stdout);

1429 }

@@ -1431,13 +1516,15 @@ void *ebpf_dcstat_thread(void *ptr)

1516 ebpf_dcstat_allocate_global_vectors();

1517

1518 int algorithms[NETDATA_DCSTAT_IDX_END] = {

1434 - NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX,

1435 - NETDATA_EBPF_ABSOLUTE_IDX

1436 - };

1519 + NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX};

1520

1438 - ebpf_global_labels(dcstat_counter_aggregated_data, dcstat_counter_publish_aggregated,

1439 - dcstat_counter_dimension_name, dcstat_counter_dimension_name,

1440 - algorithms, NETDATA_DCSTAT_IDX_END);

1521 + ebpf_global_labels(

1522 + dcstat_counter_aggregated_data,

1523 + dcstat_counter_publish_aggregated,

1524 + dcstat_counter_dimension_name,

1525 + dcstat_counter_dimension_name,

1526 + algorithms,

1527 + NETDATA_DCSTAT_IDX_END);

1528

1529 pthread_mutex_lock(&lock);

1530 ebpf_create_dc_global_charts(em->update_every);

@@ -1446,8 +1533,8 @@ void *ebpf_dcstat_thread(void *ptr)

1533

1534 pthread_mutex_unlock(&lock);

1535

1449 - ebpf_read_dcstat.thread = nd_thread_create(ebpf_read_dcstat.name, NETDATA_THREAD_OPTION_DEFAULT,

1450 - ebpf_read_dcstat_thread, em);

1536 + ebpf_read_dcstat.thread =

1537 + nd_thread_create(ebpf_read_dcstat.name, NETDATA_THREAD_OPTION_DEFAULT, ebpf_read_dcstat_thread, em);

1538

1539 dcstat_collector(em);

1540

src/collectors/ebpf.plugin/ebpf_dcstat.h

+4 -10

@@ -7,7 +7,8 @@

8 // Module name & description

9 #define NETDATA_EBPF_MODULE_NAME_DCSTAT "dcstat"

10 -#define NETDATA_EBPF_DC_MODULE_DESC "Monitor file access using directory cache. This thread is integrated with apps and cgroup."

10 +#define NETDATA_EBPF_DC_MODULE_DESC \

11 + "Monitor file access using directory cache. This thread is integrated with apps and cgroup."

13 // charts

14 #define NETDATA_DC_HIT_CHART "dc_hit_ratio"

@@ -50,11 +51,7 @@ enum directory_cache_indexes {

51 NETDATA_DCSTAT_IDX_END

52 };

53 -enum directory_cache_tables {

54 - NETDATA_DCSTAT_GLOBAL_STATS,

55 - NETDATA_DCSTAT_PID_STATS,

56 - NETDATA_DCSTAT_CTRL

57 -};

54 +enum directory_cache_tables { NETDATA_DCSTAT_GLOBAL_STATS, NETDATA_DCSTAT_PID_STATS, NETDATA_DCSTAT_CTRL };

56 // variables

57 enum directory_cache_counters {

@@ -66,10 +63,7 @@ enum directory_cache_counters {

63 NETDATA_DIRECTORY_CACHE_END

64 };

69 -enum directory_cache_targets {

70 - NETDATA_DC_TARGET_LOOKUP_FAST,

71 - NETDATA_DC_TARGET_D_LOOKUP

72 -};

66 +enum directory_cache_targets { NETDATA_DC_TARGET_LOOKUP_FAST, NETDATA_DC_TARGET_D_LOOKUP };

68 typedef struct __attribute__((packed)) netdata_publish_dcstat_pid {

69 uint64_t cache_access;

src/collectors/ebpf.plugin/ebpf_disk.c

+79 -50

@@ -8,33 +8,40 @@

9 struct config disk_config = APPCONFIG_INITIALIZER;

11 -static ebpf_local_maps_t disk_maps[] = {{.name = "tbl_disk_iocall", .internal_input = NETDATA_DISK_HISTOGRAM_LENGTH,

12 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

13 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

11 +static ebpf_local_maps_t disk_maps[] = {

12 + {.name = "tbl_disk_iocall",

13 + .internal_input = NETDATA_DISK_HISTOGRAM_LENGTH,

14 + .user_input = 0,

15 + .type = NETDATA_EBPF_MAP_STATIC,

16 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

17 #ifdef LIBBPF_MAJOR_VERSION

15 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

18 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

19 #endif

17 - },

18 - {.name = "tmp_disk_tp_stat", .internal_input = 8192, .user_input = 8192,

19 - .type = NETDATA_EBPF_MAP_STATIC,

20 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

20 + },

21 + {.name = "tmp_disk_tp_stat",

22 + .internal_input = 8192,

23 + .user_input = 8192,

24 + .type = NETDATA_EBPF_MAP_STATIC,

25 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

26 #ifdef LIBBPF_MAJOR_VERSION

22 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

27 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

28 #endif

24 - },

25 - {.name = NULL, .internal_input = 0, .user_input = 0,

26 - .type = NETDATA_EBPF_MAP_CONTROLLER,

27 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

29 + },

30 + {.name = NULL,

31 + .internal_input = 0,

32 + .user_input = 0,

33 + .type = NETDATA_EBPF_MAP_CONTROLLER,

34 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

35 #ifdef LIBBPF_MAJOR_VERSION

29 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

36 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

37 #endif

31 - }};

38 + }};

39 static avl_tree_lock disk_tree;

40 netdata_ebpf_disks_t *disk_list = NULL;

35 -char *tracepoint_block_type = { "block"} ;

36 -char *tracepoint_block_issue = { "block_rq_issue" };

37 -char *tracepoint_block_rq_complete = { "block_rq_complete" };

42 +char *tracepoint_block_type = {"block"};

43 +char *tracepoint_block_issue = {"block_rq_issue"};

44 +char *tracepoint_block_rq_complete = {"block_rq_complete"};

46 static int was_block_issue_enabled = 0;

47 static int was_block_rq_complete_enabled = 0;

@@ -57,9 +64,9 @@ pthread_mutex_t plot_mutex;

64 * @param obj is the main structure for bpf objects.

65 */

66 static inline void ebpf_disk_set_hash_table(struct disk_bpf *obj)

60 - {

67 +{

68 disk_maps[NETDATA_DISK_IO].map_fd = bpf_map__fd(obj->maps.tbl_disk_iocall);

62 - }

69 +}

71 /**

72 * Load and attach

@@ -177,7 +184,7 @@ static inline int ebpf_parse_size(netdata_ebpf_disks_t *w, char *filename)

184 file_length = FILENAME_MAX;

185

186 content[file_length] = '\0';

180 - w->end = w->start + strtoul(content, NULL, 10) -1;

187 + w->end = w->start + strtoul(content, NULL, 10) - 1;

188 }

189 close(fd);

190

@@ -196,7 +203,7 @@ static void ebpf_read_disk_info(netdata_ebpf_disks_t *w, char *name)

203 {

204 static netdata_ebpf_disks_t *main_disk = NULL;

205 static uint32_t key = 0;

199 - char *path = { "/sys/block" };

206 + char *path = {"/sys/block"};

207 char disk[NETDATA_DISK_NAME_LEN + 1];

208 char filename[FILENAME_MAX + 1];

209 snprintfz(disk, NETDATA_DISK_NAME_LEN, "%s", name);

@@ -243,7 +250,8 @@ static void ebpf_read_disk_info(netdata_ebpf_disks_t *w, char *name)

250 *

251 * @return

252 */

246 -static inline uint32_t netdata_new_encode_dev(uint32_t major, uint32_t minor) {

253 +static inline uint32_t netdata_new_encode_dev(uint32_t major, uint32_t minor)

254 +{

255 return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);

256 }

257

@@ -288,7 +296,7 @@ static void update_disk_table(char *name, int major, int minor, time_t current_t

296

297 uint32_t dev = netdata_new_encode_dev(major, minor);

298 find.dev = dev;

291 - netdata_ebpf_disks_t *ret = (netdata_ebpf_disks_t *) avl_search_lock(&disk_tree, (avl_t *)&find);

299 + netdata_ebpf_disks_t *ret = (netdata_ebpf_disks_t *)avl_search_lock(&disk_tree, (avl_t *)&find);

300 if (ret) { // Disk is already present

301 ret->flags |= NETDATA_DISK_IS_HERE;

302 ret->last_update = current_time;

@@ -335,12 +343,13 @@ static void update_disk_table(char *name, int major, int minor, time_t current_t

343 ebpf_read_disk_info(w, name);

344

345 netdata_ebpf_disks_t *check;

338 - check = (netdata_ebpf_disks_t *) avl_insert_lock(&disk_tree, (avl_t *)w);

346 + check = (netdata_ebpf_disks_t *)avl_insert_lock(&disk_tree, (avl_t *)w);

347 if (check != w)

348 netdata_log_error("Internal error, cannot insert the AVL tree.");

349

350 #ifdef NETDATA_INTERNAL_CHECKS

343 - netdata_log_info("The Latency is monitoring the hard disk %s (Major = %d, Minor = %d, Device = %u)", name, major, minor,w->dev);

351 + netdata_log_info(

352 + "The Latency is monitoring the hard disk %s (Major = %d, Minor = %d, Device = %u)", name, major, minor, w->dev);

353 #endif

354

355 w->flags |= NETDATA_DISK_IS_HERE;

@@ -367,7 +376,7 @@ static int read_local_disks()

376

377 size_t lines = procfile_lines(ff), l;

378 time_t current_time = now_realtime_sec();

370 - for(l = 2; l < lines ;l++) {

379 + for (l = 2; l < lines; l++) {

380 size_t words = procfile_linewords(ff, l);

381 // This is header or end of file

382 if (unlikely(words < 4))

@@ -417,7 +426,7 @@ void ebpf_update_disks(ebpf_module_t *em)

426 */

427 static void ebpf_disk_disable_tracepoints()

428 {

420 - char *default_message = { "Cannot disable the tracepoint" };

429 + char *default_message = {"Cannot disable the tracepoint"};

430 if (!was_block_issue_enabled) {

431 if (ebpf_disable_tracing_values(tracepoint_block_type, tracepoint_block_issue))

432 netdata_log_error("%s %s/%s.", default_message, tracepoint_block_type, tracepoint_block_issue);

@@ -479,16 +488,17 @@ static void ebpf_obsolete_disk_global(ebpf_module_t *em)

488 netdata_ebpf_disks_t *ned = move->plot;

489 uint32_t flags = ned->flags;

490 if (flags & NETDATA_DISK_CHART_CREATED) {

482 - ebpf_write_chart_obsolete(ned->histogram.name,

483 - ned->family,

484 - "",

485 - "Disk latency",

486 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

487 - ned->family,

488 - NETDATA_EBPF_CHART_TYPE_STACKED,

489 - NETDATA_EBPF_DISK_LATENCY_CONTEXT,

490 - ned->histogram.order,

491 - em->update_every);

491 + ebpf_write_chart_obsolete(

492 + ned->histogram.name,

493 + ned->family,

494 + "",

495 + "Disk latency",

496 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

497 + ned->family,

498 + NETDATA_EBPF_CHART_TYPE_STACKED,

499 + NETDATA_EBPF_DISK_LATENCY_CONTEXT,

500 + ned->histogram.order,

501 + em->update_every);

502 }

503

504 move = move->next;

@@ -505,7 +515,8 @@ static void ebpf_obsolete_disk_global(ebpf_module_t *em)

515 static void ebpf_disk_exit(void *pptr)

516 {

517 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

508 - if(!em) return;

518 + if (!em)

519 + return;

520

521 if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) {

522 pthread_mutex_lock(&lock);

@@ -653,9 +664,17 @@ static void read_hard_disk_tables(int table, int maps_per_core)

664 */

665 static void ebpf_obsolete_hd_charts(netdata_ebpf_disks_t *w, int update_every)

666 {

656 - ebpf_write_chart_obsolete(w->histogram.name, w->family, "", "Disk latency", EBPF_COMMON_UNITS_CALLS_PER_SEC,

657 - w->family, NETDATA_EBPF_CHART_TYPE_STACKED, NETDATA_EBPF_DISK_LATENCY_CONTEXT,

658 - w->histogram.order, update_every);

667 + ebpf_write_chart_obsolete(

668 + w->histogram.name,

669 + w->family,

670 + "",

671 + "Disk latency",

672 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

673 + w->family,

674 + NETDATA_EBPF_CHART_TYPE_STACKED,

675 + NETDATA_EBPF_DISK_LATENCY_CONTEXT,

676 + w->histogram.order,

677 + update_every);

678

679 w->flags = NETDATA_DISK_NONE;

680 }

@@ -677,10 +696,20 @@ static void ebpf_create_hd_charts(netdata_ebpf_disks_t *w, int update_every)

696 w->histogram.title = NULL;

697 w->histogram.order = order;

698

680 - ebpf_create_chart(w->histogram.name, family, "Disk latency", EBPF_COMMON_UNITS_CALLS_PER_SEC,

681 - family, NETDATA_EBPF_DISK_LATENCY_CONTEXT, NETDATA_EBPF_CHART_TYPE_STACKED, order,

682 - ebpf_create_global_dimension, disk_publish_aggregated, NETDATA_EBPF_HIST_MAX_BINS,

683 - update_every, NETDATA_EBPF_MODULE_NAME_DISK);

699 + ebpf_create_chart(

700 + w->histogram.name,

701 + family,

702 + "Disk latency",

703 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

704 + family,

705 + NETDATA_EBPF_DISK_LATENCY_CONTEXT,

706 + NETDATA_EBPF_CHART_TYPE_STACKED,

707 + order,

708 + ebpf_create_global_dimension,

709 + disk_publish_aggregated,

710 + NETDATA_EBPF_HIST_MAX_BINS,

711 + update_every,

712 + NETDATA_EBPF_MODULE_NAME_DISK);

713 order++;

714

715 w->flags |= NETDATA_DISK_CHART_CREATED;

@@ -751,8 +780,8 @@ static void ebpf_latency_send_hd_data(int update_every)

780 }

781

782 if ((flags & NETDATA_DISK_CHART_CREATED)) {

754 - write_histogram_chart(ned->histogram.name, ned->family,

755 - ned->histogram.histogram, dimensions, NETDATA_EBPF_HIST_MAX_BINS);

783 + write_histogram_chart(

784 + ned->histogram.name, ned->family, ned->histogram.histogram, dimensions, NETDATA_EBPF_HIST_MAX_BINS);

785 }

786

787 ned->flags &= ~NETDATA_DISK_IS_HERE;

@@ -919,8 +948,8 @@ void *ebpf_disk_thread(void *ptr)

948 ebpf_fill_algorithms(algorithms, NETDATA_EBPF_HIST_MAX_BINS, NETDATA_EBPF_INCREMENTAL_IDX);

949 dimensions = ebpf_fill_histogram_dimension(NETDATA_EBPF_HIST_MAX_BINS);

950

922 - ebpf_global_labels(disk_aggregated_data, disk_publish_aggregated, dimensions, dimensions, algorithms,

923 - NETDATA_EBPF_HIST_MAX_BINS);

951 + ebpf_global_labels(

952 + disk_aggregated_data, disk_publish_aggregated, dimensions, dimensions, algorithms, NETDATA_EBPF_HIST_MAX_BINS);

953

954 pthread_mutex_lock(&lock);

955 ebpf_update_stats(&plugin_statistics, em);

src/collectors/ebpf.plugin/ebpf_disk.h

+2 -3

@@ -16,8 +16,8 @@

16 #define NETDATA_DISK_CONFIG_FILE "disk.conf"

18 // Decode function extracted from: https://elixir.bootlin.com/linux/v5.10.8/source/include/linux/kdev_t.h#L7

19 -#define MINORBITS 20

20 -#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))

19 +#define MINORBITS 20

20 +#define MKDEV(ma, mi) (((ma) << MINORBITS) | (mi))

22 enum netdata_latency_disks_flags {

23 NETDATA_DISK_NONE = 0,

@@ -75,4 +75,3 @@ extern struct config disk_config;

75 void *ebpf_disk_thread(void *ptr);

77 #endif /* NETDATA_EBPF_DISK_H */

78 -

src/collectors/ebpf.plugin/ebpf_fd.c

+383 -311

@@ -3,8 +3,8 @@

3 #include "ebpf.h"

4 #include "ebpf_fd.h"

6 -static char *fd_dimension_names[NETDATA_FD_SYSCALL_END] = { "open", "close" };

7 -static char *fd_id_names[NETDATA_FD_SYSCALL_END] = { "do_sys_open", "__close_fd" };

6 +static char *fd_dimension_names[NETDATA_FD_SYSCALL_END] = {"open", "close"};

7 +static char *fd_id_names[NETDATA_FD_SYSCALL_END] = {"do_sys_open", "__close_fd"};

9 #ifdef LIBBPF_MAJOR_VERSION

10 static char *close_targets[NETDATA_EBPF_MAX_FD_TARGETS] = {"close_fd", "__close_fd"};

@@ -14,37 +14,43 @@ static char *open_targets[NETDATA_EBPF_MAX_FD_TARGETS] = {"do_sys_openat2", "do_

14 static netdata_syscall_stat_t fd_aggregated_data[NETDATA_FD_SYSCALL_END];

15 static netdata_publish_syscall_t fd_publish_aggregated[NETDATA_FD_SYSCALL_END];

17 -static ebpf_local_maps_t fd_maps[] = {{.name = "tbl_fd_pid", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

18 - .user_input = 0,

19 - .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

20 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

17 +static ebpf_local_maps_t fd_maps[] = {

18 + {.name = "tbl_fd_pid",

19 + .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

20 + .user_input = 0,

21 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

22 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

23 #ifdef LIBBPF_MAJOR_VERSION

22 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

24 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

25 #endif

24 - },

25 - {.name = "tbl_fd_global", .internal_input = NETDATA_KEY_END_VECTOR,

26 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

27 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

26 + },

27 + {.name = "tbl_fd_global",

28 + .internal_input = NETDATA_KEY_END_VECTOR,

29 + .user_input = 0,

30 + .type = NETDATA_EBPF_MAP_STATIC,

31 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

32 #ifdef LIBBPF_MAJOR_VERSION

29 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

33 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

34 #endif

31 - },

32 - {.name = "fd_ctrl", .internal_input = NETDATA_CONTROLLER_END,

33 - .user_input = 0,

34 - .type = NETDATA_EBPF_MAP_CONTROLLER,

35 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

35 + },

36 + {.name = "fd_ctrl",

37 + .internal_input = NETDATA_CONTROLLER_END,

38 + .user_input = 0,

39 + .type = NETDATA_EBPF_MAP_CONTROLLER,

40 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

41 #ifdef LIBBPF_MAJOR_VERSION

37 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

42 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

43 #endif

39 - },

40 - {.name = NULL, .internal_input = 0, .user_input = 0,

41 - .type = NETDATA_EBPF_MAP_CONTROLLER,

42 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

44 + },

45 + {.name = NULL,

46 + .internal_input = 0,

47 + .user_input = 0,

48 + .type = NETDATA_EBPF_MAP_CONTROLLER,

49 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

50 #ifdef LIBBPF_MAJOR_VERSION

44 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

51 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

52 #endif

46 - }};

47 -

53 + }};

55 struct config fd_config = APPCONFIG_INITIALIZER;

@@ -53,9 +59,10 @@ static netdata_idx_t *fd_values = NULL;

60 netdata_fd_stat_t *fd_vector = NULL;

56 -netdata_ebpf_targets_t fd_targets[] = { {.name = "open", .mode = EBPF_LOAD_TRAMPOLINE},

57 - {.name = "close", .mode = EBPF_LOAD_TRAMPOLINE},

58 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

62 +netdata_ebpf_targets_t fd_targets[] = {

63 + {.name = "open", .mode = EBPF_LOAD_TRAMPOLINE},

64 + {.name = "close", .mode = EBPF_LOAD_TRAMPOLINE},

65 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

67 struct netdata_static_thread ebpf_read_fd = {

68 .name = "EBPF_READ_FD",

@@ -65,8 +72,7 @@ struct netdata_static_thread ebpf_read_fd = {

72 .enabled = 1,

73 .thread = NULL,

74 .init_routine = NULL,

68 - .start_routine = NULL

69 -};

75 + .start_routine = NULL};

77 #ifdef LIBBPF_MAJOR_VERSION

78 /**

@@ -179,41 +185,39 @@ static void ebpf_set_trampoline_target(struct fd_bpf *obj)

185 */

186 static int ebpf_fd_attach_probe(struct fd_bpf *obj)

187 {

182 - obj->links.netdata_sys_open_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_sys_open_kprobe, false,

183 - fd_targets[NETDATA_FD_SYSCALL_OPEN].name);

188 + obj->links.netdata_sys_open_kprobe =

189 + bpf_program__attach_kprobe(obj->progs.netdata_sys_open_kprobe, false, fd_targets[NETDATA_FD_SYSCALL_OPEN].name);

190 long ret = libbpf_get_error(obj->links.netdata_sys_open_kprobe);

191 if (ret)

192 return -1;

193

188 - obj->links.netdata_sys_open_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_sys_open_kretprobe, true,

189 - fd_targets[NETDATA_FD_SYSCALL_OPEN].name);

194 + obj->links.netdata_sys_open_kretprobe = bpf_program__attach_kprobe(

195 + obj->progs.netdata_sys_open_kretprobe, true, fd_targets[NETDATA_FD_SYSCALL_OPEN].name);

196 ret = libbpf_get_error(obj->links.netdata_sys_open_kretprobe);

197 if (ret)

198 return -1;

199

200 if (!strcmp(fd_targets[NETDATA_FD_SYSCALL_CLOSE].name, close_targets[NETDATA_FD_CLOSE_FD])) {

195 - obj->links.netdata_close_fd_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_close_fd_kretprobe, true,

196 - fd_targets[NETDATA_FD_SYSCALL_CLOSE].name);

201 + obj->links.netdata_close_fd_kretprobe = bpf_program__attach_kprobe(

202 + obj->progs.netdata_close_fd_kretprobe, true, fd_targets[NETDATA_FD_SYSCALL_CLOSE].name);

203 ret = libbpf_get_error(obj->links.netdata_close_fd_kretprobe);

204 if (ret)

205 return -1;

206

201 - obj->links.netdata_close_fd_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_close_fd_kprobe, false,

202 - fd_targets[NETDATA_FD_SYSCALL_CLOSE].name);

207 + obj->links.netdata_close_fd_kprobe = bpf_program__attach_kprobe(

208 + obj->progs.netdata_close_fd_kprobe, false, fd_targets[NETDATA_FD_SYSCALL_CLOSE].name);

209 ret = libbpf_get_error(obj->links.netdata_close_fd_kprobe);

210 if (ret)

211 return -1;

212 } else {

207 - obj->links.netdata___close_fd_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata___close_fd_kretprobe,

208 - true,

209 - fd_targets[NETDATA_FD_SYSCALL_CLOSE].name);

213 + obj->links.netdata___close_fd_kretprobe = bpf_program__attach_kprobe(

214 + obj->progs.netdata___close_fd_kretprobe, true, fd_targets[NETDATA_FD_SYSCALL_CLOSE].name);

215 ret = libbpf_get_error(obj->links.netdata___close_fd_kretprobe);

216 if (ret)

217 return -1;

218

214 - obj->links.netdata___close_fd_kprobe = bpf_program__attach_kprobe(obj->progs.netdata___close_fd_kprobe,

215 - false,

216 - fd_targets[NETDATA_FD_SYSCALL_CLOSE].name);

219 + obj->links.netdata___close_fd_kprobe = bpf_program__attach_kprobe(

220 + obj->progs.netdata___close_fd_kprobe, false, fd_targets[NETDATA_FD_SYSCALL_CLOSE].name);

221 ret = libbpf_get_error(obj->links.netdata___close_fd_kprobe);

222 if (ret)

223 return -1;

@@ -290,8 +294,7 @@ static void ebpf_fd_set_hash_tables(struct fd_bpf *obj)

294 */

295 static void ebpf_fd_adjust_map(struct fd_bpf *obj, ebpf_module_t *em)

296 {

293 - ebpf_update_map_size(obj->maps.tbl_fd_pid, &fd_maps[NETDATA_FD_PID_STATS],

294 - em, bpf_map__name(obj->maps.tbl_fd_pid));

297 + ebpf_update_map_size(obj->maps.tbl_fd_pid, &fd_maps[NETDATA_FD_PID_STATS], em, bpf_map__name(obj->maps.tbl_fd_pid));

298

299 ebpf_update_map_type(obj->maps.tbl_fd_global, &fd_maps[NETDATA_FD_GLOBAL_STATS]);

300 ebpf_update_map_type(obj->maps.tbl_fd_pid, &fd_maps[NETDATA_FD_PID_STATS]);

@@ -363,52 +366,56 @@ static void ebpf_obsolete_specific_fd_charts(char *type, ebpf_module_t *em);

366 */

367 static void ebpf_obsolete_fd_services(ebpf_module_t *em, char *id)

368 {

366 - ebpf_write_chart_obsolete(id,

367 - NETDATA_SYSCALL_APPS_FILE_OPEN,

368 - "",

369 - "Number of open files",

370 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

371 - NETDATA_APPS_FILE_GROUP,

372 - NETDATA_EBPF_CHART_TYPE_STACKED,

373 - NETDATA_CGROUP_FD_OPEN_CONTEXT,

374 - 20270,

375 - em->update_every);

369 + ebpf_write_chart_obsolete(

370 + id,

371 + NETDATA_SYSCALL_APPS_FILE_OPEN,

372 + "",

373 + "Number of open files",

374 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

375 + NETDATA_APPS_FILE_GROUP,

376 + NETDATA_EBPF_CHART_TYPE_STACKED,

377 + NETDATA_CGROUP_FD_OPEN_CONTEXT,

378 + 20270,

379 + em->update_every);

380

381 if (em->mode < MODE_ENTRY) {

378 - ebpf_write_chart_obsolete(id,

379 - NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR,

380 - "",

381 - "Fails to open files",

382 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

383 - NETDATA_APPS_FILE_GROUP,

384 - NETDATA_EBPF_CHART_TYPE_STACKED,

385 - NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT,

386 - 20271,

387 - em->update_every);

382 + ebpf_write_chart_obsolete(

383 + id,

384 + NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR,

385 + "",

386 + "Fails to open files",

387 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

388 + NETDATA_APPS_FILE_GROUP,

389 + NETDATA_EBPF_CHART_TYPE_STACKED,

390 + NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT,

391 + 20271,

392 + em->update_every);

393 }

394

390 - ebpf_write_chart_obsolete(id,

391 - NETDATA_SYSCALL_APPS_FILE_CLOSED,

392 - "",

393 - "Files closed",

394 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

395 - NETDATA_APPS_FILE_GROUP,

396 - NETDATA_EBPF_CHART_TYPE_STACKED,

397 - NETDATA_CGROUP_FD_CLOSE_CONTEXT,

398 - 20272,

399 - em->update_every);

395 + ebpf_write_chart_obsolete(

396 + id,

397 + NETDATA_SYSCALL_APPS_FILE_CLOSED,

398 + "",

399 + "Files closed",

400 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

401 + NETDATA_APPS_FILE_GROUP,

402 + NETDATA_EBPF_CHART_TYPE_STACKED,

403 + NETDATA_CGROUP_FD_CLOSE_CONTEXT,

404 + 20272,

405 + em->update_every);

406

407 if (em->mode < MODE_ENTRY) {

402 - ebpf_write_chart_obsolete(id,

403 - NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR,

404 - "",

405 - "Fails to close files",

406 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

407 - NETDATA_APPS_FILE_GROUP,

408 - NETDATA_EBPF_CHART_TYPE_STACKED,

409 - NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT,

410 - 20273,

411 - em->update_every);

408 + ebpf_write_chart_obsolete(

409 + id,

410 + NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR,

411 + "",

412 + "Fails to close files",

413 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

414 + NETDATA_APPS_FILE_GROUP,

415 + NETDATA_EBPF_CHART_TYPE_STACKED,

416 + NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT,

417 + 20273,

418 + em->update_every);

419 }

420 }

421

@@ -419,11 +426,12 @@ static void ebpf_obsolete_fd_services(ebpf_module_t *em, char *id)

426 *

427 * @param em a pointer to `struct ebpf_module`

428 */

422 -static inline void ebpf_obsolete_fd_cgroup_charts(ebpf_module_t *em) {

429 +static inline void ebpf_obsolete_fd_cgroup_charts(ebpf_module_t *em)

430 +{

431 pthread_mutex_lock(&mutex_cgroup_shm);

432

433 ebpf_cgroup_target_t *ect;

426 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

434 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

435 if (ect->systemd) {

436 ebpf_obsolete_fd_services(em, ect->name);

437

@@ -448,57 +456,61 @@ void ebpf_obsolete_fd_apps_charts(struct ebpf_module *em)

456 int update_every = em->update_every;

457 pthread_mutex_lock(&collect_data_mutex);

458 for (w = apps_groups_root_target; w; w = w->next) {

451 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_FD_IDX))))

459 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_FD_IDX))))

460 continue;

461

454 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

455 - w->clean_name,

456 - "_ebpf_file_open",

457 - "Number of open files",

458 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

459 - NETDATA_APPS_FILE_FDS,

460 - NETDATA_EBPF_CHART_TYPE_STACKED,

461 - "app.ebpf_file_open",

462 - 20220,

463 - update_every);

462 + ebpf_write_chart_obsolete(

463 + NETDATA_APP_FAMILY,

464 + w->clean_name,

465 + "_ebpf_file_open",

466 + "Number of open files",

467 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

468 + NETDATA_APPS_FILE_FDS,

469 + NETDATA_EBPF_CHART_TYPE_STACKED,

470 + "app.ebpf_file_open",

471 + 20220,

472 + update_every);

473

474 if (em->mode < MODE_ENTRY) {

466 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

467 - w->clean_name,

468 - "_ebpf_file_open_error",

469 - "Fails to open files.",

470 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

471 - NETDATA_APPS_FILE_FDS,

472 - NETDATA_EBPF_CHART_TYPE_STACKED,

473 - "app.ebpf_file_open_error",

474 - 20221,

475 - update_every);

475 + ebpf_write_chart_obsolete(

476 + NETDATA_APP_FAMILY,

477 + w->clean_name,

478 + "_ebpf_file_open_error",

479 + "Fails to open files.",

480 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

481 + NETDATA_APPS_FILE_FDS,

482 + NETDATA_EBPF_CHART_TYPE_STACKED,

483 + "app.ebpf_file_open_error",

484 + 20221,

485 + update_every);

486 }

487

478 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,

479 - w->clean_name,

480 - "_ebpf_file_closed",

481 - "Files closed.",

482 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

483 - NETDATA_APPS_FILE_FDS,

484 - NETDATA_EBPF_CHART_TYPE_STACKED,

485 - "app.ebpf_file_closed",

486 - 20222,

487 - update_every);

488 + ebpf_write_chart_obsolete(

489 + NETDATA_APPS_FAMILY,

490 + w->clean_name,

491 + "_ebpf_file_closed",

492 + "Files closed.",

493 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

494 + NETDATA_APPS_FILE_FDS,

495 + NETDATA_EBPF_CHART_TYPE_STACKED,

496 + "app.ebpf_file_closed",

497 + 20222,

498 + update_every);

499

500 if (em->mode < MODE_ENTRY) {

490 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,

491 - w->clean_name,

492 - "_ebpf_file_close_error",

493 - "Fails to close files.",

494 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

495 - NETDATA_APPS_FILE_FDS,

496 - NETDATA_EBPF_CHART_TYPE_STACKED,

497 - "app.ebpf_fd_close_error",

498 - 20223,

499 - update_every);

501 + ebpf_write_chart_obsolete(

502 + NETDATA_APPS_FAMILY,

503 + w->clean_name,

504 + "_ebpf_file_close_error",

505 + "Fails to close files.",

506 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

507 + NETDATA_APPS_FILE_FDS,

508 + NETDATA_EBPF_CHART_TYPE_STACKED,

509 + "app.ebpf_fd_close_error",

510 + 20223,

511 + update_every);

512 }

501 - w->charts_created &= ~(1<<EBPF_MODULE_FD_IDX);

513 + w->charts_created &= ~(1 << EBPF_MODULE_FD_IDX);

514 }

515 pthread_mutex_unlock(&collect_data_mutex);

516 }

@@ -512,28 +524,30 @@ void ebpf_obsolete_fd_apps_charts(struct ebpf_module *em)

524 */

525 static void ebpf_obsolete_fd_global(ebpf_module_t *em)

526 {

515 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

516 - NETDATA_FILE_OPEN_CLOSE_COUNT,

517 - "",

518 - "Open and close calls",

519 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

520 - NETDATA_FILE_GROUP,

521 - NETDATA_EBPF_CHART_TYPE_LINE,

522 - NETDATA_FS_FILEDESCRIPTOR_CONTEXT,

523 - NETDATA_CHART_PRIO_EBPF_FD_CHARTS,

524 - em->update_every);

527 + ebpf_write_chart_obsolete(

528 + NETDATA_FILESYSTEM_FAMILY,

529 + NETDATA_FILE_OPEN_CLOSE_COUNT,

530 + "",

531 + "Open and close calls",

532 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

533 + NETDATA_FILE_GROUP,

534 + NETDATA_EBPF_CHART_TYPE_LINE,

535 + NETDATA_FS_FILEDESCRIPTOR_CONTEXT,

536 + NETDATA_CHART_PRIO_EBPF_FD_CHARTS,

537 + em->update_every);

538

539 if (em->mode < MODE_ENTRY) {

527 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

528 - NETDATA_FILE_OPEN_ERR_COUNT,

529 - "",

530 - "Open fails",

531 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

532 - NETDATA_FILE_GROUP,

533 - NETDATA_EBPF_CHART_TYPE_LINE,

534 - NETDATA_FS_FILEDESCRIPTOR_ERROR_CONTEXT,

535 - NETDATA_CHART_PRIO_EBPF_FD_CHARTS + 1,

536 - em->update_every);

540 + ebpf_write_chart_obsolete(

541 + NETDATA_FILESYSTEM_FAMILY,

542 + NETDATA_FILE_OPEN_ERR_COUNT,

543 + "",

544 + "Open fails",

545 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

546 + NETDATA_FILE_GROUP,

547 + NETDATA_EBPF_CHART_TYPE_LINE,

548 + NETDATA_FS_FILEDESCRIPTOR_ERROR_CONTEXT,

549 + NETDATA_CHART_PRIO_EBPF_FD_CHARTS + 1,

550 + em->update_every);

551 }

552 }

553

@@ -548,10 +562,11 @@ static void ebpf_fd_exit(void *pptr)

562 {

563 pids_fd[NETDATA_EBPF_PIDS_FD_IDX] = -1;

564 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

551 - if(!em) return;

565 + if (!em)

566 + return;

567

568 pthread_mutex_lock(&lock);

554 - collect_pids &= ~(1<<EBPF_MODULE_FD_IDX);

569 + collect_pids &= ~(1 << EBPF_MODULE_FD_IDX);

570 pthread_mutex_unlock(&lock);

571

572 if (ebpf_read_fd.thread)

@@ -613,12 +628,12 @@ static void ebpf_fd_send_data(ebpf_module_t *em)

628 fd_publish_aggregated[NETDATA_FD_SYSCALL_CLOSE].ncall = fd_hash_values[NETDATA_KEY_CALLS_CLOSE_FD];

629 fd_publish_aggregated[NETDATA_FD_SYSCALL_CLOSE].nerr = fd_hash_values[NETDATA_KEY_ERROR_CLOSE_FD];

630

616 - write_count_chart(NETDATA_FILE_OPEN_CLOSE_COUNT, NETDATA_FILESYSTEM_FAMILY, fd_publish_aggregated,

617 - NETDATA_FD_SYSCALL_END);

631 + write_count_chart(

632 + NETDATA_FILE_OPEN_CLOSE_COUNT, NETDATA_FILESYSTEM_FAMILY, fd_publish_aggregated, NETDATA_FD_SYSCALL_END);

633

634 if (em->mode < MODE_ENTRY) {

620 - write_err_chart(NETDATA_FILE_OPEN_ERR_COUNT, NETDATA_FILESYSTEM_FAMILY,

621 - fd_publish_aggregated, NETDATA_FD_SYSCALL_END);

635 + write_err_chart(

636 + NETDATA_FILE_OPEN_ERR_COUNT, NETDATA_FILESYSTEM_FAMILY, fd_publish_aggregated, NETDATA_FD_SYSCALL_END);

637 }

638 }

639

@@ -632,19 +647,21 @@ static void ebpf_fd_send_data(ebpf_module_t *em)

647 */

648 static void ebpf_fd_read_global_tables(netdata_idx_t *stats, int maps_per_core)

649 {

635 - ebpf_read_global_table_stats(fd_hash_values,

636 - fd_values,

637 - fd_maps[NETDATA_FD_GLOBAL_STATS].map_fd,

638 - maps_per_core,

639 - NETDATA_KEY_CALLS_DO_SYS_OPEN,

640 - NETDATA_FD_COUNTER);

641 -

642 - ebpf_read_global_table_stats(stats,

643 - fd_values,

644 - fd_maps[NETDATA_FD_CONTROLLER].map_fd,

645 - maps_per_core,

646 - NETDATA_CONTROLLER_PID_TABLE_ADD,

647 - NETDATA_CONTROLLER_END);

650 + ebpf_read_global_table_stats(

651 + fd_hash_values,

652 + fd_values,

653 + fd_maps[NETDATA_FD_GLOBAL_STATS].map_fd,

654 + maps_per_core,

655 + NETDATA_KEY_CALLS_DO_SYS_OPEN,

656 + NETDATA_FD_COUNTER);

657 +

658 + ebpf_read_global_table_stats(

659 + stats,

660 + fd_values,

661 + fd_maps[NETDATA_FD_CONTROLLER].map_fd,

662 + maps_per_core,

663 + NETDATA_CONTROLLER_PID_TABLE_ADD,

664 + NETDATA_CONTROLLER_END);

665 }

666

667 /**

@@ -721,7 +738,7 @@ static void ebpf_read_fd_apps_table(int maps_per_core)

738 }

739 }

740

724 -end_fd_loop:

741 + end_fd_loop:

742 // We are cleaning to avoid passing data read from one process to other.

743 memset(fv, 0, length);

744 key = next_key;

@@ -762,7 +779,7 @@ void ebpf_fd_resume_apps_data()

779 struct ebpf_target *w;

780

781 for (w = apps_groups_root_target; w; w = w->next) {

765 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_FD_IDX))))

782 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_FD_IDX))))

783 continue;

784

785 ebpf_fd_sum_pids(&w->fd, w->root_pid);

@@ -830,7 +847,7 @@ void *ebpf_read_fd_thread(void *ptr)

847 */

848 static void ebpf_update_fd_cgroup()

849 {

833 - ebpf_cgroup_target_t *ect ;

850 + ebpf_cgroup_target_t *ect;

851

852 pthread_mutex_lock(&mutex_cgroup_shm);

853 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

@@ -859,7 +876,7 @@ void ebpf_fd_send_apps_data(ebpf_module_t *em, struct ebpf_target *root)

876 struct ebpf_target *w;

877 pthread_mutex_lock(&collect_data_mutex);

878 for (w = root; w; w = w->next) {

862 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_FD_IDX))))

879 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_FD_IDX))))

880 continue;

881

882 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_file_open");

@@ -926,48 +943,74 @@ static void ebpf_fd_sum_cgroup_pids(netdata_publish_fd_stat_t *fd, struct pid_on

943 static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em)

944 {

945 char *label = (!strncmp(type, "cgroup_", 7)) ? &type[7] : type;

929 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_OPEN, "Number of open files",

930 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_FILE_GROUP,

931 - NETDATA_CGROUP_FD_OPEN_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

932 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5400,

933 - ebpf_create_global_dimension,

934 - &fd_publish_aggregated[NETDATA_FD_SYSCALL_OPEN],

935 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_FD);

946 + ebpf_create_chart(

947 + type,

948 + NETDATA_SYSCALL_APPS_FILE_OPEN,

949 + "Number of open files",

950 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

951 + NETDATA_APPS_FILE_GROUP,

952 + NETDATA_CGROUP_FD_OPEN_CONTEXT,

953 + NETDATA_EBPF_CHART_TYPE_LINE,

954 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5400,

955 + ebpf_create_global_dimension,

956 + &fd_publish_aggregated[NETDATA_FD_SYSCALL_OPEN],

957 + 1,

958 + em->update_every,

959 + NETDATA_EBPF_MODULE_NAME_FD);

960 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

961 ebpf_commit_label();

962

963 if (em->mode < MODE_ENTRY) {

940 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "Fails to open files",

941 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_FILE_GROUP,

942 - NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

943 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5401,

944 - ebpf_create_global_dimension,

945 - &fd_publish_aggregated[NETDATA_FD_SYSCALL_OPEN],

946 - 1, em->update_every,

947 - NETDATA_EBPF_MODULE_NAME_FD);

964 + ebpf_create_chart(

965 + type,

966 + NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR,

967 + "Fails to open files",

968 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

969 + NETDATA_APPS_FILE_GROUP,

970 + NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT,

971 + NETDATA_EBPF_CHART_TYPE_LINE,

972 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5401,

973 + ebpf_create_global_dimension,

974 + &fd_publish_aggregated[NETDATA_FD_SYSCALL_OPEN],

975 + 1,

976 + em->update_every,

977 + NETDATA_EBPF_MODULE_NAME_FD);

978 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

979 ebpf_commit_label();

980 }

981

952 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_CLOSED, "Files closed",

953 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_FILE_GROUP,

954 - NETDATA_CGROUP_FD_CLOSE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

955 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5402,

956 - ebpf_create_global_dimension,

957 - &fd_publish_aggregated[NETDATA_FD_SYSCALL_CLOSE],

958 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_FD);

982 + ebpf_create_chart(

983 + type,

984 + NETDATA_SYSCALL_APPS_FILE_CLOSED,

985 + "Files closed",

986 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

987 + NETDATA_APPS_FILE_GROUP,

988 + NETDATA_CGROUP_FD_CLOSE_CONTEXT,

989 + NETDATA_EBPF_CHART_TYPE_LINE,

990 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5402,

991 + ebpf_create_global_dimension,

992 + &fd_publish_aggregated[NETDATA_FD_SYSCALL_CLOSE],

993 + 1,

994 + em->update_every,

995 + NETDATA_EBPF_MODULE_NAME_FD);

996 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

997 ebpf_commit_label();

998

999 if (em->mode < MODE_ENTRY) {

963 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "Fails to close files",

964 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_FILE_GROUP,

965 - NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

966 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5403,

967 - ebpf_create_global_dimension,

968 - &fd_publish_aggregated[NETDATA_FD_SYSCALL_CLOSE],

969 - 1, em->update_every,

970 - NETDATA_EBPF_MODULE_NAME_FD);

1000 + ebpf_create_chart(

1001 + type,

1002 + NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR,

1003 + "Fails to close files",

1004 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1005 + NETDATA_APPS_FILE_GROUP,

1006 + NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT,

1007 + NETDATA_EBPF_CHART_TYPE_LINE,

1008 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5403,

1009 + ebpf_create_global_dimension,

1010 + &fd_publish_aggregated[NETDATA_FD_SYSCALL_CLOSE],

1011 + 1,

1012 + em->update_every,

1013 + NETDATA_EBPF_MODULE_NAME_FD);

1014 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1015 ebpf_commit_label();

1016 }

@@ -983,28 +1026,56 @@ static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em)

1026 */

1027 static void ebpf_obsolete_specific_fd_charts(char *type, ebpf_module_t *em)

1028 {

986 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_OPEN, "", "Number of open files",

987 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_FILE_GROUP,

988 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_FD_OPEN_CONTEXT,

989 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5400, em->update_every);

1029 + ebpf_write_chart_obsolete(

1030 + type,

1031 + NETDATA_SYSCALL_APPS_FILE_OPEN,

1032 + "",

1033 + "Number of open files",

1034 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1035 + NETDATA_APPS_FILE_GROUP,

1036 + NETDATA_EBPF_CHART_TYPE_LINE,

1037 + NETDATA_CGROUP_FD_OPEN_CONTEXT,

1038 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5400,

1039 + em->update_every);

1040

1041 if (em->mode < MODE_ENTRY) {

992 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "", "Fails to open files",

993 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_FILE_GROUP,

994 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT,

995 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5401, em->update_every);

1042 + ebpf_write_chart_obsolete(

1043 + type,

1044 + NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR,

1045 + "",

1046 + "Fails to open files",

1047 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1048 + NETDATA_APPS_FILE_GROUP,

1049 + NETDATA_EBPF_CHART_TYPE_LINE,

1050 + NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT,

1051 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5401,

1052 + em->update_every);

1053 }

1054

998 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_CLOSED, "", "Files closed",

999 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_FILE_GROUP,

1000 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_FD_CLOSE_CONTEXT,

1001 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5402, em->update_every);

1055 + ebpf_write_chart_obsolete(

1056 + type,

1057 + NETDATA_SYSCALL_APPS_FILE_CLOSED,

1058 + "",

1059 + "Files closed",

1060 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1061 + NETDATA_APPS_FILE_GROUP,

1062 + NETDATA_EBPF_CHART_TYPE_LINE,

1063 + NETDATA_CGROUP_FD_CLOSE_CONTEXT,

1064 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5402,

1065 + em->update_every);

1066

1067 if (em->mode < MODE_ENTRY) {

1004 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "", "Fails to close files",

1005 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_FILE_GROUP,

1006 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT,

1007 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5403, em->update_every);

1068 + ebpf_write_chart_obsolete(

1069 + type,

1070 + NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR,

1071 + "",

1072 + "Fails to close files",

1073 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1074 + NETDATA_APPS_FILE_GROUP,

1075 + NETDATA_EBPF_CHART_TYPE_LINE,

1076 + NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT,

1077 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5403,

1078 + em->update_every);

1079 }

1080 }

1081

@@ -1059,8 +1130,7 @@ static void ebpf_create_systemd_fd_charts(ebpf_module_t *em)

1130 .module = NETDATA_EBPF_MODULE_NAME_FD,

1131 .update_every = 0,

1132 .suffix = NETDATA_SYSCALL_APPS_FILE_OPEN,

1062 - .dimension = "calls"

1063 - };

1133 + .dimension = "calls"};

1134

1135 static ebpf_systemd_args_t data_open_error = {

1136 .title = "Fails to open files",

@@ -1073,8 +1143,7 @@ static void ebpf_create_systemd_fd_charts(ebpf_module_t *em)

1143 .module = NETDATA_EBPF_MODULE_NAME_FD,

1144 .update_every = 0,

1145 .suffix = NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR,

1076 - .dimension = "calls"

1077 - };

1146 + .dimension = "calls"};

1147

1148 static ebpf_systemd_args_t data_close = {

1149 .title = "Files closed",

@@ -1087,8 +1156,7 @@ static void ebpf_create_systemd_fd_charts(ebpf_module_t *em)

1156 .module = NETDATA_EBPF_MODULE_NAME_FD,

1157 .update_every = 0,

1158 .suffix = NETDATA_SYSCALL_APPS_FILE_CLOSED,

1090 - .dimension = "calls"

1091 - };

1159 + .dimension = "calls"};

1160

1161 static ebpf_systemd_args_t data_close_error = {

1162 .title = "Fails to close files",

@@ -1101,12 +1169,11 @@ static void ebpf_create_systemd_fd_charts(ebpf_module_t *em)

1169 .module = NETDATA_EBPF_MODULE_NAME_FD,

1170 .update_every = 0,

1171 .suffix = NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR,

1104 - .dimension = "calls"

1105 - };

1172 + .dimension = "calls"};

1173

1174 if (!data_open.update_every)

1108 - data_open.update_every = data_open_error.update_every =

1109 - data_close.update_every = data_close_error.update_every = em->update_every;

1175 + data_open.update_every = data_open_error.update_every = data_close.update_every =

1176 + data_close_error.update_every = em->update_every;

1177

1178 ebpf_cgroup_target_t *w;

1179 netdata_run_mode_t mode = em->mode;

@@ -1136,8 +1203,8 @@ static void ebpf_create_systemd_fd_charts(ebpf_module_t *em)

1203 static void ebpf_send_systemd_fd_charts(ebpf_module_t *em)

1204 {

1205 ebpf_cgroup_target_t *ect;

1139 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1140 - if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_FD_CHART)) ) {

1206 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1207 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_FD_CHART))) {

1208 continue;

1209 }

1210

@@ -1172,7 +1239,7 @@ static void ebpf_fd_send_cgroup_data(ebpf_module_t *em)

1239 {

1240 pthread_mutex_lock(&mutex_cgroup_shm);

1241 ebpf_cgroup_target_t *ect;

1175 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1242 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1243 ebpf_fd_sum_cgroup_pids(&ect->publish_systemd_fd, ect->pids);

1244 }

1245

@@ -1184,7 +1251,7 @@ static void ebpf_fd_send_cgroup_data(ebpf_module_t *em)

1251 ebpf_send_systemd_fd_charts(em);

1252 }

1253

1187 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1254 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1255 if (ect->systemd)

1256 continue;

1257

@@ -1193,7 +1260,7 @@ static void ebpf_fd_send_cgroup_data(ebpf_module_t *em)

1260 ect->flags |= NETDATA_EBPF_CGROUP_HAS_FD_CHART;

1261 }

1262

1196 - if (ect->flags & NETDATA_EBPF_CGROUP_HAS_FD_CHART ) {

1263 + if (ect->flags & NETDATA_EBPF_CGROUP_HAS_FD_CHART) {

1264 if (ect->updated) {

1265 ebpf_send_specific_fd_data(ect->name, &ect->publish_systemd_fd, em);

1266 } else {

@@ -1279,71 +1346,75 @@ void ebpf_fd_create_apps_charts(struct ebpf_module *em, void *ptr)

1346 if (unlikely(!w->exposed))

1347 continue;

1348

1282 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1283 - w->clean_name,

1284 - "_ebpf_file_open",

1285 - "Number of open files",

1286 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1287 - NETDATA_APPS_FILE_FDS,

1288 - NETDATA_EBPF_CHART_TYPE_STACKED,

1289 - "app.ebpf_file_open",

1290 - 20220,

1291 - update_every,

1292 - NETDATA_EBPF_MODULE_NAME_FD);

1349 + ebpf_write_chart_cmd(

1350 + NETDATA_APP_FAMILY,

1351 + w->clean_name,

1352 + "_ebpf_file_open",

1353 + "Number of open files",

1354 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1355 + NETDATA_APPS_FILE_FDS,

1356 + NETDATA_EBPF_CHART_TYPE_STACKED,

1357 + "app.ebpf_file_open",

1358 + 20220,

1359 + update_every,

1360 + NETDATA_EBPF_MODULE_NAME_FD);

1361 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1362 ebpf_commit_label();

1363 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1364

1365 if (em->mode < MODE_ENTRY) {

1298 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1299 - w->clean_name,

1300 - "_ebpf_file_open_error",

1301 - "Fails to open files.",

1302 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1303 - NETDATA_APPS_FILE_FDS,

1304 - NETDATA_EBPF_CHART_TYPE_STACKED,

1305 - "app.ebpf_file_open_error",

1306 - 20221,

1307 - update_every,

1308 - NETDATA_EBPF_MODULE_NAME_FD);

1366 + ebpf_write_chart_cmd(

1367 + NETDATA_APP_FAMILY,

1368 + w->clean_name,

1369 + "_ebpf_file_open_error",

1370 + "Fails to open files.",

1371 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1372 + NETDATA_APPS_FILE_FDS,

1373 + NETDATA_EBPF_CHART_TYPE_STACKED,

1374 + "app.ebpf_file_open_error",

1375 + 20221,

1376 + update_every,

1377 + NETDATA_EBPF_MODULE_NAME_FD);

1378 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1379 ebpf_commit_label();

1380 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1381 }

1382

1314 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1315 - w->clean_name,

1316 - "_ebpf_file_closed",

1317 - "Files closed.",

1318 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1319 - NETDATA_APPS_FILE_FDS,

1320 - NETDATA_EBPF_CHART_TYPE_STACKED,

1321 - "app.ebpf_file_closed",

1322 - 20222,

1323 - update_every,

1324 - NETDATA_EBPF_MODULE_NAME_FD);

1383 + ebpf_write_chart_cmd(

1384 + NETDATA_APP_FAMILY,

1385 + w->clean_name,

1386 + "_ebpf_file_closed",

1387 + "Files closed.",

1388 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1389 + NETDATA_APPS_FILE_FDS,

1390 + NETDATA_EBPF_CHART_TYPE_STACKED,

1391 + "app.ebpf_file_closed",

1392 + 20222,

1393 + update_every,

1394 + NETDATA_EBPF_MODULE_NAME_FD);

1395 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1396 ebpf_commit_label();

1397 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1398

1399 if (em->mode < MODE_ENTRY) {

1330 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1331 - w->clean_name,

1332 - "_ebpf_file_close_error",

1333 - "Fails to close files.",

1334 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1335 - NETDATA_APPS_FILE_FDS,

1336 - NETDATA_EBPF_CHART_TYPE_STACKED,

1337 - "app.ebpf_file_close_error",

1338 - 20223,

1339 - update_every,

1340 - NETDATA_EBPF_MODULE_NAME_FD);

1400 + ebpf_write_chart_cmd(

1401 + NETDATA_APP_FAMILY,

1402 + w->clean_name,

1403 + "_ebpf_file_close_error",

1404 + "Fails to close files.",

1405 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1406 + NETDATA_APPS_FILE_FDS,

1407 + NETDATA_EBPF_CHART_TYPE_STACKED,

1408 + "app.ebpf_file_close_error",

1409 + 20223,

1410 + update_every,

1411 + NETDATA_EBPF_MODULE_NAME_FD);

1412 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1413 ebpf_commit_label();

1414 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1415 }

1416

1346 - w->charts_created |= 1<<EBPF_MODULE_FD_IDX;

1417 + w->charts_created |= 1 << EBPF_MODULE_FD_IDX;

1418 }

1419

1420 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;

@@ -1358,32 +1429,36 @@ void ebpf_fd_create_apps_charts(struct ebpf_module *em, void *ptr)

1429 */

1430 static void ebpf_create_fd_global_charts(ebpf_module_t *em)

1431 {

1361 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

1362 - NETDATA_FILE_OPEN_CLOSE_COUNT,

1363 - "Open and close calls",

1364 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1365 - NETDATA_FILE_GROUP,

1366 - NETDATA_FS_FILEDESCRIPTOR_CONTEXT,

1367 - NETDATA_EBPF_CHART_TYPE_LINE,

1368 - NETDATA_CHART_PRIO_EBPF_FD_CHARTS,

1369 - ebpf_create_global_dimension,

1370 - fd_publish_aggregated,

1371 - NETDATA_FD_SYSCALL_END,

1372 - em->update_every, NETDATA_EBPF_MODULE_NAME_FD);

1432 + ebpf_create_chart(

1433 + NETDATA_FILESYSTEM_FAMILY,

1434 + NETDATA_FILE_OPEN_CLOSE_COUNT,

1435 + "Open and close calls",

1436 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1437 + NETDATA_FILE_GROUP,

1438 + NETDATA_FS_FILEDESCRIPTOR_CONTEXT,

1439 + NETDATA_EBPF_CHART_TYPE_LINE,

1440 + NETDATA_CHART_PRIO_EBPF_FD_CHARTS,

1441 + ebpf_create_global_dimension,

1442 + fd_publish_aggregated,

1443 + NETDATA_FD_SYSCALL_END,

1444 + em->update_every,

1445 + NETDATA_EBPF_MODULE_NAME_FD);

1446

1447 if (em->mode < MODE_ENTRY) {

1375 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

1376 - NETDATA_FILE_OPEN_ERR_COUNT,

1377 - "Open fails",

1378 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1379 - NETDATA_FILE_GROUP,

1380 - NETDATA_FS_FILEDESCRIPTOR_ERROR_CONTEXT,

1381 - NETDATA_EBPF_CHART_TYPE_LINE,

1382 - NETDATA_CHART_PRIO_EBPF_FD_CHARTS + 1,

1383 - ebpf_create_global_dimension,

1384 - fd_publish_aggregated,

1385 - NETDATA_FD_SYSCALL_END,

1386 - em->update_every, NETDATA_EBPF_MODULE_NAME_FD);

1448 + ebpf_create_chart(

1449 + NETDATA_FILESYSTEM_FAMILY,

1450 + NETDATA_FILE_OPEN_ERR_COUNT,

1451 + "Open fails",

1452 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1453 + NETDATA_FILE_GROUP,

1454 + NETDATA_FS_FILEDESCRIPTOR_ERROR_CONTEXT,

1455 + NETDATA_EBPF_CHART_TYPE_LINE,

1456 + NETDATA_CHART_PRIO_EBPF_FD_CHARTS + 1,

1457 + ebpf_create_global_dimension,

1458 + fd_publish_aggregated,

1459 + NETDATA_FD_SYSCALL_END,

1460 + em->update_every,

1461 + NETDATA_EBPF_MODULE_NAME_FD);

1462 }

1463

1464 fflush(stdout);

@@ -1464,18 +1539,16 @@ void *ebpf_fd_thread(void *ptr)

1539 #ifdef LIBBPF_MAJOR_VERSION

1540 ebpf_adjust_thread_load(em, default_btf);

1541 #endif

1467 - if (ebpf_fd_load_bpf(em)) {

1542 + if (ebpf_fd_load_bpf(em)) {

1543 goto endfd;

1544 }

1545

1546 ebpf_fd_allocate_global_vectors();

1547

1473 - int algorithms[NETDATA_FD_SYSCALL_END] = {

1474 - NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX

1475 - };

1548 + int algorithms[NETDATA_FD_SYSCALL_END] = {NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX};

1549

1477 - ebpf_global_labels(fd_aggregated_data, fd_publish_aggregated, fd_dimension_names, fd_id_names,

1478 - algorithms, NETDATA_FD_SYSCALL_END);

1550 + ebpf_global_labels(

1551 + fd_aggregated_data, fd_publish_aggregated, fd_dimension_names, fd_id_names, algorithms, NETDATA_FD_SYSCALL_END);

1552

1553 pthread_mutex_lock(&lock);

1554 ebpf_create_fd_global_charts(em);

@@ -1484,8 +1557,7 @@ void *ebpf_fd_thread(void *ptr)

1557

1558 pthread_mutex_unlock(&lock);

1559

1487 - ebpf_read_fd.thread = nd_thread_create(ebpf_read_fd.name, NETDATA_THREAD_OPTION_DEFAULT,

1488 - ebpf_read_fd_thread, em);

1560 + ebpf_read_fd.thread = nd_thread_create(ebpf_read_fd.name, NETDATA_THREAD_OPTION_DEFAULT, ebpf_read_fd_thread, em);

1561

1562 fd_collector(em);

1563

src/collectors/ebpf.plugin/ebpf_fd.h

+4 -4

@@ -5,7 +5,8 @@

6 // Module name & File description

7 #define NETDATA_EBPF_MODULE_NAME_FD "filedescriptor"

8 -#define NETDATA_EBPF_FD_MODULE_DESC "Monitor when files are open and closed. This thread is integrated with apps and cgroup."

8 +#define NETDATA_EBPF_FD_MODULE_DESC \

9 + "Monitor when files are open and closed. This thread is integrated with apps and cgroup."

11 // Menu group

12 #define NETDATA_FILE_GROUP "file_access"

@@ -43,8 +44,8 @@

44 typedef struct __attribute__((packed)) netdata_publish_fd_stat {

45 uint64_t ct;

46 - uint32_t open_call; // Open syscalls (open and openat)

47 - uint32_t close_call; // Close syscall (close)

47 + uint32_t open_call; // Open syscalls (open and openat)

48 + uint32_t close_call; // Close syscall (close)

50 // Errors

51 uint32_t open_err;

@@ -94,4 +95,3 @@ extern struct config fd_config;

95 extern netdata_ebpf_targets_t fd_targets[];

97 #endif /* NETDATA_EBPF_FD_H */

97 -

src/collectors/ebpf.plugin/ebpf_filesystem.c

+400 -289

@@ -4,120 +4,157 @@

5 struct config fs_config = APPCONFIG_INITIALIZER;

7 -ebpf_local_maps_t ext4_maps[] = {{.name = "tbl_ext4", .internal_input = NETDATA_KEY_CALLS_SYNC,

8 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

9 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

7 +ebpf_local_maps_t ext4_maps[] = {

8 + {.name = "tbl_ext4",

9 + .internal_input = NETDATA_KEY_CALLS_SYNC,

10 + .user_input = 0,

11 + .type = NETDATA_EBPF_MAP_STATIC,

12 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

13 #ifdef LIBBPF_MAJOR_VERSION

11 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

14 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

15 #endif

13 - },

14 - {.name = "tmp_ext4", .internal_input = 4192, .user_input = 4192,

15 - .type = NETDATA_EBPF_MAP_CONTROLLER,

16 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

16 + },

17 + {.name = "tmp_ext4",

18 + .internal_input = 4192,

19 + .user_input = 4192,

20 + .type = NETDATA_EBPF_MAP_CONTROLLER,

21 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

22 #ifdef LIBBPF_MAJOR_VERSION

18 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

23 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

24 #endif

20 - },

21 - {.name = NULL, .internal_input = 0, .user_input = 0,

22 - .type = NETDATA_EBPF_MAP_CONTROLLER,

23 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

25 + },

26 + {.name = NULL,

27 + .internal_input = 0,

28 + .user_input = 0,

29 + .type = NETDATA_EBPF_MAP_CONTROLLER,

30 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

31 #ifdef LIBBPF_MAJOR_VERSION

25 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

32 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

33 #endif

27 - }};

34 + }};

29 -ebpf_local_maps_t xfs_maps[] = {{.name = "tbl_xfs", .internal_input = NETDATA_KEY_CALLS_SYNC,

30 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

31 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

36 +ebpf_local_maps_t xfs_maps[] = {

37 + {.name = "tbl_xfs",

38 + .internal_input = NETDATA_KEY_CALLS_SYNC,

39 + .user_input = 0,

40 + .type = NETDATA_EBPF_MAP_STATIC,

41 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

42 #ifdef LIBBPF_MAJOR_VERSION

33 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

43 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

44 #endif

35 - },

36 - {.name = "tmp_xfs", .internal_input = 4192, .user_input = 4192,

37 - .type = NETDATA_EBPF_MAP_CONTROLLER,

38 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

45 + },

46 + {.name = "tmp_xfs",

47 + .internal_input = 4192,

48 + .user_input = 4192,

49 + .type = NETDATA_EBPF_MAP_CONTROLLER,

50 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

51 #ifdef LIBBPF_MAJOR_VERSION

40 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

52 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

53 #endif

42 - },

43 - {.name = NULL, .internal_input = 0, .user_input = 0,

44 - .type = NETDATA_EBPF_MAP_CONTROLLER,

45 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

54 + },

55 + {.name = NULL,

56 + .internal_input = 0,

57 + .user_input = 0,

58 + .type = NETDATA_EBPF_MAP_CONTROLLER,

59 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

60 #ifdef LIBBPF_MAJOR_VERSION

47 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

61 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

62 #endif

49 - }};

63 + }};

51 -ebpf_local_maps_t nfs_maps[] = {{.name = "tbl_nfs", .internal_input = NETDATA_KEY_CALLS_SYNC,

52 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

53 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

65 +ebpf_local_maps_t nfs_maps[] = {

66 + {.name = "tbl_nfs",

67 + .internal_input = NETDATA_KEY_CALLS_SYNC,

68 + .user_input = 0,

69 + .type = NETDATA_EBPF_MAP_STATIC,

70 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

71 #ifdef LIBBPF_MAJOR_VERSION

55 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

72 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

73 #endif

57 - },

58 - {.name = "tmp_nfs", .internal_input = 4192, .user_input = 4192,

59 - .type = NETDATA_EBPF_MAP_CONTROLLER,

60 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

74 + },

75 + {.name = "tmp_nfs",

76 + .internal_input = 4192,

77 + .user_input = 4192,

78 + .type = NETDATA_EBPF_MAP_CONTROLLER,

79 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

80 #ifdef LIBBPF_MAJOR_VERSION

62 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

81 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

82 #endif

64 - },

65 - {.name = NULL, .internal_input = 0, .user_input = 0,

66 - .type = NETDATA_EBPF_MAP_CONTROLLER,

67 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

83 + },

84 + {.name = NULL,

85 + .internal_input = 0,

86 + .user_input = 0,

87 + .type = NETDATA_EBPF_MAP_CONTROLLER,

88 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

89 #ifdef LIBBPF_MAJOR_VERSION

69 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

90 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

91 #endif

71 - }};

92 + }};

73 -ebpf_local_maps_t zfs_maps[] = {{.name = "tbl_zfs", .internal_input = NETDATA_KEY_CALLS_SYNC,

74 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

75 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

94 +ebpf_local_maps_t zfs_maps[] = {

95 + {.name = "tbl_zfs",

96 + .internal_input = NETDATA_KEY_CALLS_SYNC,

97 + .user_input = 0,

98 + .type = NETDATA_EBPF_MAP_STATIC,

99 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

100 #ifdef LIBBPF_MAJOR_VERSION

77 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

101 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

102 #endif

79 - },

80 - {.name = "tmp_zfs", .internal_input = 4192, .user_input = 4192,

81 - .type = NETDATA_EBPF_MAP_CONTROLLER,

82 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

103 + },

104 + {.name = "tmp_zfs",

105 + .internal_input = 4192,

106 + .user_input = 4192,

107 + .type = NETDATA_EBPF_MAP_CONTROLLER,

108 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

109 #ifdef LIBBPF_MAJOR_VERSION

84 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

110 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

111 #endif

86 - },

87 - {.name = NULL, .internal_input = 0, .user_input = 0,

88 - .type = NETDATA_EBPF_MAP_CONTROLLER,

89 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

112 + },

113 + {.name = NULL,

114 + .internal_input = 0,

115 + .user_input = 0,

116 + .type = NETDATA_EBPF_MAP_CONTROLLER,

117 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

118 #ifdef LIBBPF_MAJOR_VERSION

91 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

119 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

120 #endif

93 - }};

121 + }};

122

95 -ebpf_local_maps_t btrfs_maps[] = {{.name = "tbl_btrfs", .internal_input = NETDATA_KEY_CALLS_SYNC,

96 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

97 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

123 +ebpf_local_maps_t btrfs_maps[] = {

124 + {.name = "tbl_btrfs",

125 + .internal_input = NETDATA_KEY_CALLS_SYNC,

126 + .user_input = 0,

127 + .type = NETDATA_EBPF_MAP_STATIC,

128 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

129 #ifdef LIBBPF_MAJOR_VERSION

99 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

130 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

131 #endif

101 - },

102 - {.name = "tbl_ext_addr", .internal_input = 1, .user_input = 1,

103 - .type = NETDATA_EBPF_MAP_CONTROLLER,

104 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

132 + },

133 + {.name = "tbl_ext_addr",

134 + .internal_input = 1,

135 + .user_input = 1,

136 + .type = NETDATA_EBPF_MAP_CONTROLLER,

137 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

138 #ifdef LIBBPF_MAJOR_VERSION

106 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

139 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

140 #endif

108 - },

109 - {.name = "tmp_btrfs", .internal_input = 4192, .user_input = 4192,

110 - .type = NETDATA_EBPF_MAP_CONTROLLER,

111 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

141 + },

142 + {.name = "tmp_btrfs",

143 + .internal_input = 4192,

144 + .user_input = 4192,

145 + .type = NETDATA_EBPF_MAP_CONTROLLER,

146 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

147 #ifdef LIBBPF_MAJOR_VERSION

113 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

148 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

149 #endif

115 - },

116 - {.name = NULL, .internal_input = 0, .user_input = 0,

117 - .type = NETDATA_EBPF_MAP_CONTROLLER,

118 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

150 + },

151 + {.name = NULL,

152 + .internal_input = 0,

153 + .user_input = 0,

154 + .type = NETDATA_EBPF_MAP_CONTROLLER,

155 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

156 #ifdef LIBBPF_MAJOR_VERSION

120 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

157 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

158 #endif

159 }};

160

@@ -138,7 +175,7 @@ static netdata_idx_t *filesystem_hash_values = NULL;

175 * @param obj FS object loaded.

176 */

177 static void ebpf_fs_disable_kprobe(struct filesystem_bpf *obj)

141 - {

178 +{

179 // kprobe

180 bpf_program__set_autoload(obj->progs.netdata_fs_file_read_probe, false);

181 bpf_program__set_autoload(obj->progs.netdata_fs_file_write_probe, false);

@@ -151,17 +188,17 @@ static void ebpf_fs_disable_kprobe(struct filesystem_bpf *obj)

188 bpf_program__set_autoload(obj->progs.netdata_fs_file_open_retprobe, false);

189 bpf_program__set_autoload(obj->progs.netdata_fs_2nd_file_open_retprobe, false);

190 bpf_program__set_autoload(obj->progs.netdata_fs_getattr_retprobe, false);

154 - }

191 +}

192

156 - /**

193 +/**

194 * Disable trampoline

195 *

196 * Disable trampolines to use kprobes.

197 *

198 * @param obj FS object loaded.

199 */

163 - static void ebpf_fs_disable_trampoline(struct filesystem_bpf *obj)

164 - {

200 +static void ebpf_fs_disable_trampoline(struct filesystem_bpf *obj)

201 +{

202 // entry

203 bpf_program__set_autoload(obj->progs.netdata_fs_file_read_entry, false);

204 bpf_program__set_autoload(obj->progs.netdata_fs_file_write_entry, false);

@@ -175,9 +212,9 @@ static void ebpf_fs_disable_kprobe(struct filesystem_bpf *obj)

212 bpf_program__set_autoload(obj->progs.netdata_fs_file_open_exit, false);

213 bpf_program__set_autoload(obj->progs.netdata_fs_getattr_exit, false);

214 bpf_program__set_autoload(obj->progs.netdata_fs_2nd_file_open_exit, false);

178 - }

215 +}

216

180 - /**

217 +/**

218 * Set targets

219 *

220 * Set targets for each objects.

@@ -185,37 +222,27 @@ static void ebpf_fs_disable_kprobe(struct filesystem_bpf *obj)

222 * @param obj FS object loaded.

223 * @param functions array with function names.

224 */

188 - static void ebpf_fs_set_target(struct filesystem_bpf *obj, const char **functions)

225 +static void ebpf_fs_set_target(struct filesystem_bpf *obj, const char **functions)

226 {

190 - // entry

191 - bpf_program__set_attach_target(obj->progs.netdata_fs_file_read_entry, 0,

192 - functions[NETDATA_KEY_BTF_READ]);

193 - bpf_program__set_attach_target(obj->progs.netdata_fs_file_write_entry, 0,

194 - functions[NETDATA_KEY_BTF_WRITE]);

195 - bpf_program__set_attach_target(obj->progs.netdata_fs_file_open_entry, 0,

196 - functions[NETDATA_KEY_BTF_OPEN]);

197 - bpf_program__set_attach_target(obj->progs.netdata_fs_getattr_entry, 0,

198 - functions[NETDATA_KEY_BTF_SYNC_ATTR]);

199 -

200 - // exit

201 - bpf_program__set_attach_target(obj->progs.netdata_fs_file_read_exit, 0,

202 - functions[NETDATA_KEY_BTF_READ]);

203 - bpf_program__set_attach_target(obj->progs.netdata_fs_file_write_exit, 0,

204 - functions[NETDATA_KEY_BTF_WRITE]);

205 - bpf_program__set_attach_target(obj->progs.netdata_fs_file_open_exit, 0,

206 - functions[NETDATA_KEY_BTF_OPEN]);

207 - bpf_program__set_attach_target(obj->progs.netdata_fs_getattr_exit, 0,

208 - functions[NETDATA_KEY_BTF_SYNC_ATTR]);

209 -

210 - if (functions[NETDATA_KEY_BTF_OPEN2]) {

211 - bpf_program__set_attach_target(obj->progs.netdata_fs_2nd_file_open_entry, 0,

212 - functions[NETDATA_KEY_BTF_OPEN2]);

213 - bpf_program__set_attach_target(obj->progs.netdata_fs_2nd_file_open_exit, 0,

214 - functions[NETDATA_KEY_BTF_OPEN2]);

215 - } else {

216 - bpf_program__set_autoload(obj->progs.netdata_fs_2nd_file_open_entry, false);

217 - bpf_program__set_autoload(obj->progs.netdata_fs_2nd_file_open_exit, false);

218 - }

227 + // entry

228 + bpf_program__set_attach_target(obj->progs.netdata_fs_file_read_entry, 0, functions[NETDATA_KEY_BTF_READ]);

229 + bpf_program__set_attach_target(obj->progs.netdata_fs_file_write_entry, 0, functions[NETDATA_KEY_BTF_WRITE]);

230 + bpf_program__set_attach_target(obj->progs.netdata_fs_file_open_entry, 0, functions[NETDATA_KEY_BTF_OPEN]);

231 + bpf_program__set_attach_target(obj->progs.netdata_fs_getattr_entry, 0, functions[NETDATA_KEY_BTF_SYNC_ATTR]);

232 +

233 + // exit

234 + bpf_program__set_attach_target(obj->progs.netdata_fs_file_read_exit, 0, functions[NETDATA_KEY_BTF_READ]);

235 + bpf_program__set_attach_target(obj->progs.netdata_fs_file_write_exit, 0, functions[NETDATA_KEY_BTF_WRITE]);

236 + bpf_program__set_attach_target(obj->progs.netdata_fs_file_open_exit, 0, functions[NETDATA_KEY_BTF_OPEN]);

237 + bpf_program__set_attach_target(obj->progs.netdata_fs_getattr_exit, 0, functions[NETDATA_KEY_BTF_SYNC_ATTR]);

238 +

239 + if (functions[NETDATA_KEY_BTF_OPEN2]) {

240 + bpf_program__set_attach_target(obj->progs.netdata_fs_2nd_file_open_entry, 0, functions[NETDATA_KEY_BTF_OPEN2]);

241 + bpf_program__set_attach_target(obj->progs.netdata_fs_2nd_file_open_exit, 0, functions[NETDATA_KEY_BTF_OPEN2]);

242 + } else {

243 + bpf_program__set_autoload(obj->progs.netdata_fs_2nd_file_open_entry, false);

244 + bpf_program__set_autoload(obj->progs.netdata_fs_2nd_file_open_exit, false);

245 + }

246 }

247

248 /**

@@ -228,61 +255,61 @@ static void ebpf_fs_disable_kprobe(struct filesystem_bpf *obj)

255 */

256 static int ebpf_fs_attach_kprobe(struct filesystem_bpf *obj, const char **functions)

257 {

231 - // kprobe

232 - obj->links.netdata_fs_file_read_probe = bpf_program__attach_kprobe(obj->progs.netdata_fs_file_read_probe,

233 - false, functions[NETDATA_KEY_BTF_READ]);

234 - if (libbpf_get_error(obj->links.netdata_fs_file_read_probe))

235 - return -1;

236 -

237 - obj->links.netdata_fs_file_write_probe = bpf_program__attach_kprobe(obj->progs.netdata_fs_file_write_probe,

238 - false, functions[NETDATA_KEY_BTF_WRITE]);

239 - if (libbpf_get_error(obj->links.netdata_fs_file_write_probe))

240 - return -1;

241 -

242 - obj->links.netdata_fs_file_open_probe = bpf_program__attach_kprobe(obj->progs.netdata_fs_file_open_probe,

243 - false, functions[NETDATA_KEY_BTF_OPEN]);

244 - if (libbpf_get_error(obj->links.netdata_fs_file_open_probe))

245 - return -1;

246 -

247 - obj->links.netdata_fs_getattr_probe = bpf_program__attach_kprobe(obj->progs.netdata_fs_getattr_probe,

248 - false, functions[NETDATA_KEY_BTF_SYNC_ATTR]);

249 - if (libbpf_get_error(obj->links.netdata_fs_getattr_probe))

250 - return -1;

251 -

252 - // kretprobe

253 - obj->links.netdata_fs_file_read_retprobe = bpf_program__attach_kprobe(obj->progs.netdata_fs_file_read_retprobe,

254 - false, functions[NETDATA_KEY_BTF_READ]);

255 - if (libbpf_get_error(obj->links.netdata_fs_file_read_retprobe))

256 - return -1;

257 -

258 - obj->links.netdata_fs_file_write_retprobe = bpf_program__attach_kprobe(obj->progs.netdata_fs_file_write_retprobe,

259 - false, functions[NETDATA_KEY_BTF_WRITE]);

260 - if (libbpf_get_error(obj->links.netdata_fs_file_write_retprobe))

261 - return -1;

262 -

263 - obj->links.netdata_fs_file_open_retprobe = bpf_program__attach_kprobe(obj->progs.netdata_fs_file_open_retprobe,

264 - false, functions[NETDATA_KEY_BTF_OPEN]);

265 - if (libbpf_get_error(obj->links.netdata_fs_file_open_retprobe))

266 - return -1;

267 -

268 - obj->links.netdata_fs_getattr_retprobe = bpf_program__attach_kprobe(obj->progs.netdata_fs_getattr_retprobe,

269 - false, functions[NETDATA_KEY_BTF_SYNC_ATTR]);

270 - if (libbpf_get_error(obj->links.netdata_fs_getattr_retprobe))

271 - return -1;

272 -

273 - if (functions[NETDATA_KEY_BTF_OPEN2]) {

274 - obj->links.netdata_fs_2nd_file_open_probe = bpf_program__attach_kprobe(obj->progs.netdata_fs_2nd_file_open_probe,

275 - false, functions[NETDATA_KEY_BTF_OPEN2]);

276 - if (libbpf_get_error(obj->links.netdata_fs_2nd_file_open_probe))

277 - return -1;

278 -

279 - obj->links.netdata_fs_2nd_file_open_retprobe = bpf_program__attach_kprobe(obj->progs.netdata_fs_2nd_file_open_retprobe,

280 - false, functions[NETDATA_KEY_BTF_OPEN2]);

281 - if (libbpf_get_error(obj->links.netdata_fs_2nd_file_open_retprobe))

282 - return -1;

283 - }

284 -

285 - return 0;

258 + // kprobe

259 + obj->links.netdata_fs_file_read_probe =

260 + bpf_program__attach_kprobe(obj->progs.netdata_fs_file_read_probe, false, functions[NETDATA_KEY_BTF_READ]);

261 + if (libbpf_get_error(obj->links.netdata_fs_file_read_probe))

262 + return -1;

263 +

264 + obj->links.netdata_fs_file_write_probe =

265 + bpf_program__attach_kprobe(obj->progs.netdata_fs_file_write_probe, false, functions[NETDATA_KEY_BTF_WRITE]);

266 + if (libbpf_get_error(obj->links.netdata_fs_file_write_probe))

267 + return -1;

268 +

269 + obj->links.netdata_fs_file_open_probe =

270 + bpf_program__attach_kprobe(obj->progs.netdata_fs_file_open_probe, false, functions[NETDATA_KEY_BTF_OPEN]);

271 + if (libbpf_get_error(obj->links.netdata_fs_file_open_probe))

272 + return -1;

273 +

274 + obj->links.netdata_fs_getattr_probe =

275 + bpf_program__attach_kprobe(obj->progs.netdata_fs_getattr_probe, false, functions[NETDATA_KEY_BTF_SYNC_ATTR]);

276 + if (libbpf_get_error(obj->links.netdata_fs_getattr_probe))

277 + return -1;

278 +

279 + // kretprobe

280 + obj->links.netdata_fs_file_read_retprobe =

281 + bpf_program__attach_kprobe(obj->progs.netdata_fs_file_read_retprobe, false, functions[NETDATA_KEY_BTF_READ]);

282 + if (libbpf_get_error(obj->links.netdata_fs_file_read_retprobe))

283 + return -1;

284 +

285 + obj->links.netdata_fs_file_write_retprobe =

286 + bpf_program__attach_kprobe(obj->progs.netdata_fs_file_write_retprobe, false, functions[NETDATA_KEY_BTF_WRITE]);

287 + if (libbpf_get_error(obj->links.netdata_fs_file_write_retprobe))

288 + return -1;

289 +

290 + obj->links.netdata_fs_file_open_retprobe =

291 + bpf_program__attach_kprobe(obj->progs.netdata_fs_file_open_retprobe, false, functions[NETDATA_KEY_BTF_OPEN]);

292 + if (libbpf_get_error(obj->links.netdata_fs_file_open_retprobe))

293 + return -1;

294 +

295 + obj->links.netdata_fs_getattr_retprobe =

296 + bpf_program__attach_kprobe(obj->progs.netdata_fs_getattr_retprobe, false, functions[NETDATA_KEY_BTF_SYNC_ATTR]);

297 + if (libbpf_get_error(obj->links.netdata_fs_getattr_retprobe))

298 + return -1;

299 +

300 + if (functions[NETDATA_KEY_BTF_OPEN2]) {

301 + obj->links.netdata_fs_2nd_file_open_probe = bpf_program__attach_kprobe(

302 + obj->progs.netdata_fs_2nd_file_open_probe, false, functions[NETDATA_KEY_BTF_OPEN2]);

303 + if (libbpf_get_error(obj->links.netdata_fs_2nd_file_open_probe))

304 + return -1;

305 +

306 + obj->links.netdata_fs_2nd_file_open_retprobe = bpf_program__attach_kprobe(

307 + obj->progs.netdata_fs_2nd_file_open_retprobe, false, functions[NETDATA_KEY_BTF_OPEN2]);

308 + if (libbpf_get_error(obj->links.netdata_fs_2nd_file_open_retprobe))

309 + return -1;

310 + }

311 +

312 + return 0;

313 }

314

315 /**

@@ -295,8 +322,8 @@ static int ebpf_fs_attach_kprobe(struct filesystem_bpf *obj, const char **functi

322 * @param functions array with function names.

323 * @param bf sttruct with btf file loaded.

324 */

298 -static inline int ebpf_fs_load_and_attach(ebpf_local_maps_t *map, struct filesystem_bpf *obj,

299 - const char **functions, struct btf *bf)

325 +static inline int

326 +ebpf_fs_load_and_attach(ebpf_local_maps_t *map, struct filesystem_bpf *obj, const char **functions, struct btf *bf)

327 {

328 if (bf) {

329 ebpf_fs_disable_kprobe(obj);

@@ -336,7 +363,8 @@ static inline int ebpf_fs_load_and_attach(ebpf_local_maps_t *map, struct filesys

363 *

364 * @param efp

365 */

339 -static void ebpf_obsolete_cleanup_struct(ebpf_filesystem_partitions_t *efp) {

366 +static void ebpf_obsolete_cleanup_struct(ebpf_filesystem_partitions_t *efp)

367 +{

368 freez(efp->hread.name);

369 efp->hread.name = NULL;

370 freez(efp->hread.title);

@@ -386,26 +414,53 @@ static void ebpf_obsolete_fs_charts(int update_every)

414 if ((flags & test) == test) {

415 flags &= ~test;

416

389 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY, efp->hread.name,

390 - "",

391 - efp->hread.title,

392 - EBPF_COMMON_UNITS_CALLS_PER_SEC, efp->family_name,

393 - NULL, NETDATA_EBPF_CHART_TYPE_STACKED, efp->hread.order, update_every);

394 -

395 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY, efp->hwrite.name,

396 - "",

397 - efp->hwrite.title,

398 - EBPF_COMMON_UNITS_CALLS_PER_SEC, efp->family_name,

399 - NULL, NETDATA_EBPF_CHART_TYPE_STACKED, efp->hwrite.order, update_every);

400 -

401 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY, efp->hopen.name, "", efp->hopen.title,

402 - EBPF_COMMON_UNITS_CALLS_PER_SEC, efp->family_name,

403 - NULL, NETDATA_EBPF_CHART_TYPE_STACKED, efp->hopen.order, update_every);

404 -

405 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY, efp->hadditional.name,"", efp->hadditional.title,

406 - EBPF_COMMON_UNITS_CALLS_PER_SEC, efp->family_name,

407 - NULL, NETDATA_EBPF_CHART_TYPE_STACKED, efp->hadditional.order,

408 - update_every);

417 + ebpf_write_chart_obsolete(

418 + NETDATA_FILESYSTEM_FAMILY,

419 + efp->hread.name,

420 + "",

421 + efp->hread.title,

422 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

423 + efp->family_name,

424 + NULL,

425 + NETDATA_EBPF_CHART_TYPE_STACKED,

426 + efp->hread.order,

427 + update_every);

428 +

429 + ebpf_write_chart_obsolete(

430 + NETDATA_FILESYSTEM_FAMILY,

431 + efp->hwrite.name,

432 + "",

433 + efp->hwrite.title,

434 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

435 + efp->family_name,

436 + NULL,

437 + NETDATA_EBPF_CHART_TYPE_STACKED,

438 + efp->hwrite.order,

439 + update_every);

440 +

441 + ebpf_write_chart_obsolete(

442 + NETDATA_FILESYSTEM_FAMILY,

443 + efp->hopen.name,

444 + "",

445 + efp->hopen.title,

446 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

447 + efp->family_name,

448 + NULL,

449 + NETDATA_EBPF_CHART_TYPE_STACKED,

450 + efp->hopen.order,

451 + update_every);

452 +

453 + ebpf_write_chart_obsolete(

454 + NETDATA_FILESYSTEM_FAMILY,

455 + efp->hadditional.name,

456 + "",

457 + efp->hadditional.title,

458 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

459 + efp->family_name,

460 + NULL,

461 + NETDATA_EBPF_CHART_TYPE_STACKED,

462 + efp->hadditional.order,

463 + update_every);

464

465 ebpf_obsolete_cleanup_struct(efp);

466 }

@@ -425,7 +480,7 @@ static void ebpf_create_fs_charts(int update_every)

480 static int order = NETDATA_CHART_PRIO_EBPF_FILESYSTEM_CHARTS;

481 char chart_name[64], title[256], family[64], ctx[64];

482 int i;

428 - uint32_t test = NETDATA_FILESYSTEM_FLAG_CHART_CREATED|NETDATA_FILESYSTEM_REMOVE_CHARTS;

483 + uint32_t test = NETDATA_FILESYSTEM_FLAG_CHART_CREATED | NETDATA_FILESYSTEM_REMOVE_CHARTS;

484 for (i = 0; localfs[i].filesystem; i++) {

485 ebpf_filesystem_partitions_t *efp = &localfs[i];

486 uint32_t flags = efp->flags;

@@ -440,13 +495,20 @@ static void ebpf_create_fs_charts(int update_every)

495 efp->hread.order = order;

496 efp->family_name = strdupz(family);

497

443 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY, efp->hread.name,

444 - efp->hread.title,

445 - EBPF_COMMON_UNITS_CALLS_PER_SEC, efp->family_name,

446 - "filesystem.read_latency", NETDATA_EBPF_CHART_TYPE_STACKED, order,

447 - ebpf_create_global_dimension,

448 - filesystem_publish_aggregated, NETDATA_EBPF_HIST_MAX_BINS,

449 - update_every, NETDATA_EBPF_MODULE_NAME_FILESYSTEM);

498 + ebpf_create_chart(

499 + NETDATA_FILESYSTEM_FAMILY,

500 + efp->hread.name,

501 + efp->hread.title,

502 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

503 + efp->family_name,

504 + "filesystem.read_latency",

505 + NETDATA_EBPF_CHART_TYPE_STACKED,

506 + order,

507 + ebpf_create_global_dimension,

508 + filesystem_publish_aggregated,

509 + NETDATA_EBPF_HIST_MAX_BINS,

510 + update_every,

511 + NETDATA_EBPF_MODULE_NAME_FILESYSTEM);

512 order++;

513

514 snprintfz(title, sizeof(title) - 1, "%s latency for each write request.", efp->filesystem);

@@ -456,13 +518,20 @@ static void ebpf_create_fs_charts(int update_every)

518 efp->hwrite.title = strdupz(title);

519 efp->hwrite.ctx = strdupz(ctx);

520 efp->hwrite.order = order;

459 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY, efp->hwrite.name,

460 - efp->hwrite.title,

461 - EBPF_COMMON_UNITS_CALLS_PER_SEC, efp->family_name,

462 - "filesystem.write_latency", NETDATA_EBPF_CHART_TYPE_STACKED, order,

463 - ebpf_create_global_dimension,

464 - filesystem_publish_aggregated, NETDATA_EBPF_HIST_MAX_BINS,

465 - update_every, NETDATA_EBPF_MODULE_NAME_FILESYSTEM);

521 + ebpf_create_chart(

522 + NETDATA_FILESYSTEM_FAMILY,

523 + efp->hwrite.name,

524 + efp->hwrite.title,

525 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

526 + efp->family_name,

527 + "filesystem.write_latency",

528 + NETDATA_EBPF_CHART_TYPE_STACKED,

529 + order,

530 + ebpf_create_global_dimension,

531 + filesystem_publish_aggregated,

532 + NETDATA_EBPF_HIST_MAX_BINS,

533 + update_every,

534 + NETDATA_EBPF_MODULE_NAME_FILESYSTEM);

535 order++;

536

537 snprintfz(title, sizeof(title) - 1, "%s latency for each open request.", efp->filesystem);

@@ -472,13 +541,20 @@ static void ebpf_create_fs_charts(int update_every)

541 efp->hopen.title = strdupz(title);

542 efp->hopen.ctx = strdupz(ctx);

543 efp->hopen.order = order;

475 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY, efp->hopen.name,

476 - efp->hopen.title,

477 - EBPF_COMMON_UNITS_CALLS_PER_SEC, efp->family_name,

478 - "filesystem.open_latency", NETDATA_EBPF_CHART_TYPE_STACKED, order,

479 - ebpf_create_global_dimension,

480 - filesystem_publish_aggregated, NETDATA_EBPF_HIST_MAX_BINS,

481 - update_every, NETDATA_EBPF_MODULE_NAME_FILESYSTEM);

544 + ebpf_create_chart(

545 + NETDATA_FILESYSTEM_FAMILY,

546 + efp->hopen.name,

547 + efp->hopen.title,

548 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

549 + efp->family_name,

550 + "filesystem.open_latency",

551 + NETDATA_EBPF_CHART_TYPE_STACKED,

552 + order,

553 + ebpf_create_global_dimension,

554 + filesystem_publish_aggregated,

555 + NETDATA_EBPF_HIST_MAX_BINS,

556 + update_every,

557 + NETDATA_EBPF_MODULE_NAME_FILESYSTEM);

558 order++;

559

560 char *type = (efp->flags & NETDATA_FILESYSTEM_ATTR_CHARTS) ? "attribute" : "sync";

@@ -489,11 +565,20 @@ static void ebpf_create_fs_charts(int update_every)

565 efp->hadditional.title = strdupz(title);

566 efp->hadditional.ctx = strdupz(ctx);

567 efp->hadditional.order = order;

492 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY, efp->hadditional.name, efp->hadditional.title,

493 - EBPF_COMMON_UNITS_CALLS_PER_SEC, efp->family_name,

494 - ctx, NETDATA_EBPF_CHART_TYPE_STACKED, order, ebpf_create_global_dimension,

495 - filesystem_publish_aggregated, NETDATA_EBPF_HIST_MAX_BINS,

496 - update_every, NETDATA_EBPF_MODULE_NAME_FILESYSTEM);

568 + ebpf_create_chart(

569 + NETDATA_FILESYSTEM_FAMILY,

570 + efp->hadditional.name,

571 + efp->hadditional.title,

572 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

573 + efp->family_name,

574 + ctx,

575 + NETDATA_EBPF_CHART_TYPE_STACKED,

576 + order,

577 + ebpf_create_global_dimension,

578 + filesystem_publish_aggregated,

579 + NETDATA_EBPF_HIST_MAX_BINS,

580 + update_every,

581 + NETDATA_EBPF_MODULE_NAME_FILESYSTEM);

582 order++;

583 efp->flags |= NETDATA_FILESYSTEM_FLAG_CHART_CREATED;

584 }

@@ -542,8 +627,7 @@ int ebpf_filesystem_initialize_ebpf_data(ebpf_module_t *em)

627 em->kernels = kernels;

628 pthread_mutex_unlock(&lock);

629 return -1;

545 - } else if (ebpf_fs_load_and_attach(em->maps, efp->fs_obj,

546 - efp->functions, NULL)) {

630 + } else if (ebpf_fs_load_and_attach(em->maps, efp->fs_obj, efp->functions, NULL)) {

631 em->info.thread_name = saved_name;

632 em->kernels = kernels;

633 pthread_mutex_unlock(&lock);

@@ -569,8 +653,8 @@ int ebpf_filesystem_initialize_ebpf_data(ebpf_module_t *em)

653 if (!dimensions) {

654 dimensions = ebpf_fill_histogram_dimension(NETDATA_EBPF_HIST_MAX_BINS);

655

572 - memset(filesystem_aggregated_data, 0 , NETDATA_EBPF_HIST_MAX_BINS * sizeof(netdata_syscall_stat_t));

573 - memset(filesystem_publish_aggregated, 0 , NETDATA_EBPF_HIST_MAX_BINS * sizeof(netdata_publish_syscall_t));

656 + memset(filesystem_aggregated_data, 0, NETDATA_EBPF_HIST_MAX_BINS * sizeof(netdata_syscall_stat_t));

657 + memset(filesystem_publish_aggregated, 0, NETDATA_EBPF_HIST_MAX_BINS * sizeof(netdata_publish_syscall_t));

658

659 filesystem_hash_values = callocz(ebpf_nprocs, sizeof(netdata_idx_t));

660 }

@@ -588,14 +672,15 @@ static int ebpf_read_local_partitions()

672 char filename[FILENAME_MAX + 1];

673 snprintfz(filename, FILENAME_MAX, "%s/proc/self/mountinfo", netdata_configured_host_prefix);

674 procfile *ff = procfile_open(filename, " \t", PROCFILE_FLAG_DEFAULT);

591 - if(unlikely(!ff)) {

675 + if (unlikely(!ff)) {

676 snprintfz(filename, FILENAME_MAX, "%s/proc/1/mountinfo", netdata_configured_host_prefix);

677 ff = procfile_open(filename, " \t", PROCFILE_FLAG_DEFAULT);

594 - if(unlikely(!ff)) return 0;

678 + if (unlikely(!ff))

679 + return 0;

680 }

681

682 ff = procfile_readall(ff);

598 - if(unlikely(!ff))

683 + if (unlikely(!ff))

684 return 0;

685

686 int count = 0;

@@ -604,7 +689,7 @@ static int ebpf_read_local_partitions()

689 localfs[i].flags |= NETDATA_FILESYSTEM_REMOVE_CHARTS;

690 }

691

607 - for(l = 0; l < lines ; l++) {

692 + for (l = 0; l < lines; l++) {

693 // In "normal" situation the expected value is at column 7

694 // When `shared` options is added to mount information, the filesystem is at column 8

695 // Finally when we have systemd starting netdata, it will be at column 9

@@ -614,8 +699,8 @@ static int ebpf_read_local_partitions()

699

700 for (i = 0; localfs[i].filesystem; i++) {

701 ebpf_filesystem_partitions_t *w = &localfs[i];

617 - if (w->enabled && (!strcmp(fs, w->filesystem) ||

618 - (w->optional_filesystem && !strcmp(fs, w->optional_filesystem)))) {

702 + if (w->enabled &&

703 + (!strcmp(fs, w->filesystem) || (w->optional_filesystem && !strcmp(fs, w->optional_filesystem)))) {

704 if (!(localfs[i].flags & NETDATA_FILESYSTEM_FLAG_CHART_CREATED))

705 localfs[i].flags |= NETDATA_FILESYSTEM_LOAD_EBPF_PROGRAM;

706

@@ -734,52 +819,56 @@ static void ebpf_obsolete_filesystem_global(ebpf_module_t *em)

819 if (!efp->objects)

820 continue;

821

737 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

738 - efp->hread.name,

739 - "",

740 - efp->hread.title,

741 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

742 - efp->family_name,

743 - NETDATA_EBPF_CHART_TYPE_STACKED,

744 - "filesystem.read_latency",

745 - efp->hread.order,

746 - em->update_every);

822 + ebpf_write_chart_obsolete(

823 + NETDATA_FILESYSTEM_FAMILY,

824 + efp->hread.name,

825 + "",

826 + efp->hread.title,

827 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

828 + efp->family_name,

829 + NETDATA_EBPF_CHART_TYPE_STACKED,

830 + "filesystem.read_latency",

831 + efp->hread.order,

832 + em->update_every);

833 ebpf_cleanup_fs_histograms(&efp->hread);

834

749 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

750 - efp->hwrite.name,

751 - "",

752 - efp->hwrite.title,

753 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

754 - efp->family_name,

755 - NETDATA_EBPF_CHART_TYPE_STACKED,

756 - "filesystem.write_latency",

757 - efp->hwrite.order,

758 - em->update_every);

835 + ebpf_write_chart_obsolete(

836 + NETDATA_FILESYSTEM_FAMILY,

837 + efp->hwrite.name,

838 + "",

839 + efp->hwrite.title,

840 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

841 + efp->family_name,

842 + NETDATA_EBPF_CHART_TYPE_STACKED,

843 + "filesystem.write_latency",

844 + efp->hwrite.order,

845 + em->update_every);

846 ebpf_cleanup_fs_histograms(&efp->hwrite);

847

761 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

762 - efp->hopen.name,

763 - "",

764 - efp->hopen.title,

765 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

766 - efp->family_name,

767 - NETDATA_EBPF_CHART_TYPE_STACKED,

768 - "filesystem.open_latency",

769 - efp->hopen.order,

770 - em->update_every);

848 + ebpf_write_chart_obsolete(

849 + NETDATA_FILESYSTEM_FAMILY,

850 + efp->hopen.name,

851 + "",

852 + efp->hopen.title,

853 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

854 + efp->family_name,

855 + NETDATA_EBPF_CHART_TYPE_STACKED,

856 + "filesystem.open_latency",

857 + efp->hopen.order,

858 + em->update_every);

859 ebpf_cleanup_fs_histograms(&efp->hopen);

860

773 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

774 - efp->hadditional.name,

775 - "",

776 - efp->hadditional.title,

777 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

778 - efp->family_name,

779 - NETDATA_EBPF_CHART_TYPE_STACKED,

780 - efp->hadditional.ctx,

781 - efp->hadditional.order,

782 - em->update_every);

861 + ebpf_write_chart_obsolete(

862 + NETDATA_FILESYSTEM_FAMILY,

863 + efp->hadditional.name,

864 + "",

865 + efp->hadditional.title,

866 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

867 + efp->family_name,

868 + NETDATA_EBPF_CHART_TYPE_STACKED,

869 + efp->hadditional.ctx,

870 + efp->hadditional.order,

871 + em->update_every);

872 ebpf_cleanup_fs_histograms(&efp->hadditional);

873

874 efp->flags = NETDATA_FILESYSTEM_FLAG_NO_PARTITION;

@@ -796,7 +885,8 @@ static void ebpf_obsolete_filesystem_global(ebpf_module_t *em)

885 static void ebpf_filesystem_exit(void *pptr)

886 {

887 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

799 - if(!em) return;

888 + if (!em)

889 + return;

890

891 if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) {

892 pthread_mutex_lock(&lock);

@@ -859,7 +949,7 @@ static inline netdata_ebpf_histogram_t *select_hist(ebpf_filesystem_partitions_t

949 } else if (id < NETDATA_KEY_CALLS_OPEN) {

950 *idx = id - NETDATA_KEY_CALLS_WRITE;

951 return &efp->hopen;

862 - } else if (id < NETDATA_KEY_CALLS_SYNC ){

952 + } else if (id < NETDATA_KEY_CALLS_SYNC) {

953 *idx = id - NETDATA_KEY_CALLS_OPEN;

954 return &efp->hadditional;

955 }

@@ -935,7 +1025,7 @@ static void read_filesystem_tables(int maps_per_core)

1025 */

1026 void ebpf_filesystem_read_hash(ebpf_module_t *em)

1027 {

938 - (void) ebpf_update_partitions(em);

1028 + (void)ebpf_update_partitions(em);

1029

1030 ebpf_obsolete_fs_charts(em->update_every);

1031

@@ -957,17 +1047,33 @@ static void ebpf_histogram_send_data()

1047 for (i = 0; localfs[i].filesystem; i++) {

1048 ebpf_filesystem_partitions_t *efp = &localfs[i];

1049 if ((efp->flags & test) == NETDATA_FILESYSTEM_FLAG_HAS_PARTITION) {

960 - write_histogram_chart(NETDATA_FILESYSTEM_FAMILY, efp->hread.name,

961 - efp->hread.histogram, dimensions, NETDATA_EBPF_HIST_MAX_BINS);

962 -

963 - write_histogram_chart(NETDATA_FILESYSTEM_FAMILY, efp->hwrite.name,

964 - efp->hwrite.histogram, dimensions, NETDATA_EBPF_HIST_MAX_BINS);

965 -

966 - write_histogram_chart(NETDATA_FILESYSTEM_FAMILY, efp->hopen.name,

967 - efp->hopen.histogram, dimensions, NETDATA_EBPF_HIST_MAX_BINS);

968 -

969 - write_histogram_chart(NETDATA_FILESYSTEM_FAMILY, efp->hadditional.name,

970 - efp->hadditional.histogram, dimensions, NETDATA_EBPF_HIST_MAX_BINS);

1050 + write_histogram_chart(

1051 + NETDATA_FILESYSTEM_FAMILY,

1052 + efp->hread.name,

1053 + efp->hread.histogram,

1054 + dimensions,

1055 + NETDATA_EBPF_HIST_MAX_BINS);

1056 +

1057 + write_histogram_chart(

1058 + NETDATA_FILESYSTEM_FAMILY,

1059 + efp->hwrite.name,

1060 + efp->hwrite.histogram,

1061 + dimensions,

1062 + NETDATA_EBPF_HIST_MAX_BINS);

1063 +

1064 + write_histogram_chart(

1065 + NETDATA_FILESYSTEM_FAMILY,

1066 + efp->hopen.name,

1067 + efp->hopen.histogram,

1068 + dimensions,

1069 + NETDATA_EBPF_HIST_MAX_BINS);

1070 +

1071 + write_histogram_chart(

1072 + NETDATA_FILESYSTEM_FAMILY,

1073 + efp->hadditional.name,

1074 + efp->hadditional.histogram,

1075 + dimensions,

1076 + NETDATA_EBPF_HIST_MAX_BINS);

1077 }

1078 }

1079 }

@@ -1029,8 +1135,8 @@ static void ebpf_update_filesystem()

1135 for (i = 0; localfs[i].filesystem; i++) {

1136 snprintfz(dist, NETDATA_FS_MAX_DIST_NAME, "%sdist", localfs[i].filesystem);

1137

1032 - localfs[i].enabled = appconfig_get_boolean(&fs_config, NETDATA_FILESYSTEM_CONFIG_NAME, dist,

1033 - CONFIG_BOOLEAN_YES);

1138 + localfs[i].enabled =

1139 + appconfig_get_boolean(&fs_config, NETDATA_FILESYSTEM_CONFIG_NAME, dist, CONFIG_BOOLEAN_YES);

1140 }

1141 }

1142

@@ -1082,8 +1188,13 @@ void *ebpf_filesystem_thread(void *ptr)

1188

1189 int algorithms[NETDATA_EBPF_HIST_MAX_BINS];

1190 ebpf_fill_algorithms(algorithms, NETDATA_EBPF_HIST_MAX_BINS, NETDATA_EBPF_INCREMENTAL_IDX);

1085 - ebpf_global_labels(filesystem_aggregated_data, filesystem_publish_aggregated, dimensions, dimensions,

1086 - algorithms, NETDATA_EBPF_HIST_MAX_BINS);

1191 + ebpf_global_labels(

1192 + filesystem_aggregated_data,

1193 + filesystem_publish_aggregated,

1194 + dimensions,

1195 + dimensions,

1196 + algorithms,

1197 + NETDATA_EBPF_HIST_MAX_BINS);

1198

1199 pthread_mutex_lock(&lock);

1200 ebpf_create_fs_charts(em->update_every);

src/collectors/ebpf.plugin/ebpf_filesystem.h

+1 -4

@@ -38,10 +38,7 @@ enum netdata_filesystem_flags {

38 NETDATA_FILESYSTEM_ATTR_CHARTS = 32

39 };

41 -enum netdata_filesystem_table {

42 - NETDATA_MAIN_FS_TABLE,

43 - NETDATA_ADDR_FS_TABLE

44 -};

41 +enum netdata_filesystem_table { NETDATA_MAIN_FS_TABLE, NETDATA_ADDR_FS_TABLE };

43 enum netdata_filesystem_localfs_idx {

44 NETDATA_FS_LOCALFS_EXT4,

src/collectors/ebpf.plugin/ebpf_functions.c

+197 -87

@@ -48,7 +48,8 @@ static int ebpf_function_start_thread(ebpf_module_t *em, int period)

48 * @param code the error code to show with the message.

49 * @param msg the error message

50 */

51 -static inline void ebpf_function_error(const char *transaction, int code, const char *msg) {

51 +static inline void ebpf_function_error(const char *transaction, int code, const char *msg)

52 +{

53 pluginsd_function_json_error_to_stdout(transaction, code, msg);

54 }

@@ -59,7 +60,8 @@ static inline void ebpf_function_error(const char *transaction, int code, const

60 *

61 * @param transaction the transaction id that Netdata sent for this function execution

62 */

62 -static inline void ebpf_function_help(const char *transaction, const char *message) {

63 +static inline void ebpf_function_help(const char *transaction, const char *message)

64 +{

65 pluginsd_function_result_begin_to_stdout(transaction, HTTP_RESP_OK, "text/plain", now_realtime_sec() + 3600);

66 fprintf(stdout, "%s", message);

67 pluginsd_function_result_end_to_stdout();

@@ -70,7 +72,6 @@ static inline void ebpf_function_help(const char *transaction, const char *messa

72 * EBPF SOCKET FUNCTION

73 *****************************************************************/

73 -

75 /**

76 * Fill Fake socket

77 *

@@ -90,7 +91,8 @@ static inline void ebpf_socket_fill_fake_socket(netdata_socket_plus_t *fake_valu

91 fake_values->data.protocol = AF_UNSPEC;

92 }

93 -static NETDATA_DOUBLE bytes_to_mb(uint64_t bytes) {

94 +static NETDATA_DOUBLE bytes_to_mb(uint64_t bytes)

95 +{

96 return (NETDATA_DOUBLE)bytes / (1024 * 1024);

97 }

@@ -183,7 +185,8 @@ static void ebpf_socket_clean_judy_array_unsafe()

185 netdata_ebpf_judy_pid_stats_t *pid_ptr = (netdata_ebpf_judy_pid_stats_t *)*pid_value;

186 rw_spinlock_write_lock(&pid_ptr->socket_stats.rw_spinlock);

187 if (pid_ptr->socket_stats.JudyLArray) {

186 - while ((socket_value = JudyLFirstThenNext(pid_ptr->socket_stats.JudyLArray, &local_socket, &first_socket))) {

188 + while (

189 + (socket_value = JudyLFirstThenNext(pid_ptr->socket_stats.JudyLArray, &local_socket, &first_socket))) {

190 netdata_socket_plus_t *socket_clean = *socket_value;

191 aral_freez(aral_socket_table, socket_clean);

192 }

@@ -217,7 +220,8 @@ static void ebpf_socket_fill_function_buffer_unsafe(BUFFER *buf)

220 Word_t local_timestamp = 0;

221 rw_spinlock_read_lock(&pid_ptr->socket_stats.rw_spinlock);

222 if (pid_ptr->socket_stats.JudyLArray) {

220 - while ((socket_value = JudyLFirstThenNext(pid_ptr->socket_stats.JudyLArray, &local_timestamp, &first_socket))) {

223 + while ((

224 + socket_value = JudyLFirstThenNext(pid_ptr->socket_stats.JudyLArray, &local_timestamp, &first_socket))) {

225 netdata_socket_plus_t *values = (netdata_socket_plus_t *)*socket_value;

226 ebpf_fill_function_buffer(buf, values, pid_ptr->cmdline);

227 }

@@ -227,7 +231,7 @@ static void ebpf_socket_fill_function_buffer_unsafe(BUFFER *buf)

231 }

232

233 if (!counter) {

230 - netdata_socket_plus_t fake_values = { };

234 + netdata_socket_plus_t fake_values = {};

235 ebpf_socket_fill_fake_socket(&fake_values);

236 ebpf_fill_function_buffer(buf, &fake_values, NULL);

237 }

@@ -249,8 +253,8 @@ void ebpf_socket_read_open_connections(BUFFER *buf, struct ebpf_module *em)

253 // thread was not initialized or Array was reset

254 rw_spinlock_read_lock(&ebpf_judy_pid.index.rw_spinlock);

255 if (!em->maps || (em->maps[NETDATA_SOCKET_OPEN_SOCKET].map_fd == ND_EBPF_MAP_FD_NOT_INITIALIZED) ||

252 - !ebpf_judy_pid.index.JudyLArray){

253 - netdata_socket_plus_t fake_values = { };

256 + !ebpf_judy_pid.index.JudyLArray) {

257 + netdata_socket_plus_t fake_values = {};

258

259 ebpf_socket_fill_fake_socket(&fake_values);

260

@@ -275,14 +279,15 @@ void ebpf_socket_read_open_connections(BUFFER *buf, struct ebpf_module *em)

279 * @param timeout The function timeout

280 * @param cancelled Variable used to store function status.

281 */

278 -static void ebpf_function_socket_manipulation(const char *transaction,

279 - char *function __maybe_unused,

280 - usec_t *stop_monotonic_ut __maybe_unused,

281 - bool *cancelled __maybe_unused,

282 - BUFFER *payload __maybe_unused,

283 - HTTP_ACCESS access __maybe_unused,

284 - const char *source __maybe_unused,

285 - void *data __maybe_unused)

282 +static void ebpf_function_socket_manipulation(

283 + const char *transaction,

284 + char *function __maybe_unused,

285 + usec_t *stop_monotonic_ut __maybe_unused,

286 + bool *cancelled __maybe_unused,

287 + BUFFER *payload __maybe_unused,

288 + HTTP_ACCESS access __maybe_unused,

289 + const char *source __maybe_unused,

290 + void *data __maybe_unused)

291 {

292 ebpf_module_t *em = &ebpf_modules[EBPF_MODULE_SOCKET_IDX];

293

@@ -328,8 +333,7 @@ static void ebpf_function_socket_manipulation(const char *transaction,

333 " interfaces\n"

334 " When the collector receives this command, it read all available interfaces on host.\n"

335 "\n"

331 - "Filters can be combined. Each filter can be given only one time. Default all ports\n"

332 - };

336 + "Filters can be combined. Each filter can be given only one time. Default all ports\n"};

337

338 for (int i = 1; i < PLUGINSD_MAX_WORDS; i++) {

339 const char *keyword = get_word(words, num_words, i);

@@ -428,19 +432,18 @@ static void ebpf_function_socket_manipulation(const char *transaction,

432 ebpf_socket_clean_judy_array_unsafe();

433 rw_spinlock_write_unlock(&ebpf_judy_pid.index.rw_spinlock);

434

431 - collect_pids |= 1<<EBPF_MODULE_SOCKET_IDX;

435 + collect_pids |= 1 << EBPF_MODULE_SOCKET_IDX;

436 pthread_mutex_lock(&ebpf_exit_cleanup);

437 if (ebpf_function_start_thread(em, period)) {

434 - ebpf_function_error(transaction,

435 - HTTP_RESP_INTERNAL_SERVER_ERROR,

436 - "Cannot start thread.");

438 + ebpf_function_error(transaction, HTTP_RESP_INTERNAL_SERVER_ERROR, "Cannot start thread.");

439 pthread_mutex_unlock(&ebpf_exit_cleanup);

440 return;

441 }

442 } else {

443 pthread_mutex_lock(&ebpf_exit_cleanup);

444 if (period < 0)

443 - em->lifetime = (em->enabled != NETDATA_THREAD_EBPF_FUNCTION_RUNNING) ? EBPF_NON_FUNCTION_LIFE_TIME : EBPF_DEFAULT_LIFETIME;

445 + em->lifetime = (em->enabled != NETDATA_THREAD_EBPF_FUNCTION_RUNNING) ? EBPF_NON_FUNCTION_LIFE_TIME :

446 + EBPF_DEFAULT_LIFETIME;

447 }

448 pthread_mutex_unlock(&ebpf_exit_cleanup);

449

@@ -452,7 +455,7 @@ static void ebpf_function_socket_manipulation(const char *transaction,

455 buffer_json_member_add_boolean(wb, "has_history", false);

456 buffer_json_member_add_string(wb, "help", EBPF_PLUGIN_SOCKET_FUNCTION_DESCRIPTION);

457

455 - if(info)

458 + if (info)

459 goto close_and_send;

460

461 // Collect data

@@ -466,33 +469,77 @@ static void ebpf_function_socket_manipulation(const char *transaction,

469

470 // IMPORTANT!

471 // THE ORDER SHOULD BE THE SAME WITH THE VALUES!

469 - buffer_rrdf_table_add_field(wb, fields_id++, "PID", "Process ID", RRDF_FIELD_TYPE_INTEGER,

470 - RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NUMBER, 0, NULL, NAN,

471 - RRDF_FIELD_SORT_ASCENDING, NULL, RRDF_FIELD_SUMMARY_COUNT,

472 + buffer_rrdf_table_add_field(

473 + wb,

474 + fields_id++,

475 + "PID",

476 + "Process ID",

477 + RRDF_FIELD_TYPE_INTEGER,

478 + RRDF_FIELD_VISUAL_VALUE,

479 + RRDF_FIELD_TRANSFORM_NUMBER,

480 + 0,

481 + NULL,

482 + NAN,

483 + RRDF_FIELD_SORT_ASCENDING,

484 + NULL,

485 + RRDF_FIELD_SUMMARY_COUNT,

486 RRDF_FIELD_FILTER_MULTISELECT,

487 RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_STICKY,

488 NULL);

489

476 - buffer_rrdf_table_add_field(wb, fields_id++, "Name", "Process Name", RRDF_FIELD_TYPE_STRING,

477 - RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE, 0, NULL, NAN,

478 - RRDF_FIELD_SORT_ASCENDING, NULL, RRDF_FIELD_SUMMARY_COUNT,

479 - RRDF_FIELD_FILTER_MULTISELECT,

480 - RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY | RRDF_FIELD_OPTS_FULL_WIDTH,

481 - NULL);

490 + buffer_rrdf_table_add_field(

491 + wb,

492 + fields_id++,

493 + "Name",

494 + "Process Name",

495 + RRDF_FIELD_TYPE_STRING,

496 + RRDF_FIELD_VISUAL_VALUE,

497 + RRDF_FIELD_TRANSFORM_NONE,

498 + 0,

499 + NULL,

500 + NAN,

501 + RRDF_FIELD_SORT_ASCENDING,

502 + NULL,

503 + RRDF_FIELD_SUMMARY_COUNT,

504 + RRDF_FIELD_FILTER_MULTISELECT,

505 + RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY | RRDF_FIELD_OPTS_FULL_WIDTH,

506 + NULL);

507

483 - buffer_rrdf_table_add_field(wb, fields_id++, "Origin", "Connection Origin", RRDF_FIELD_TYPE_STRING,

484 - RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE, 0, NULL, NAN,

485 - RRDF_FIELD_SORT_ASCENDING, NULL, RRDF_FIELD_SUMMARY_COUNT,

486 - RRDF_FIELD_FILTER_MULTISELECT,

487 - RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,

488 - NULL);

508 + buffer_rrdf_table_add_field(

509 + wb,

510 + fields_id++,

511 + "Origin",

512 + "Connection Origin",

513 + RRDF_FIELD_TYPE_STRING,

514 + RRDF_FIELD_VISUAL_VALUE,

515 + RRDF_FIELD_TRANSFORM_NONE,

516 + 0,

517 + NULL,

518 + NAN,

519 + RRDF_FIELD_SORT_ASCENDING,

520 + NULL,

521 + RRDF_FIELD_SUMMARY_COUNT,

522 + RRDF_FIELD_FILTER_MULTISELECT,

523 + RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,

524 + NULL);

525

490 - buffer_rrdf_table_add_field(wb, fields_id++, "Src", "Source IP Address", RRDF_FIELD_TYPE_STRING,

491 - RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE, 0, NULL, NAN,

492 - RRDF_FIELD_SORT_ASCENDING, NULL, RRDF_FIELD_SUMMARY_COUNT,

493 - RRDF_FIELD_FILTER_MULTISELECT,

494 - RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,

495 - NULL);

526 + buffer_rrdf_table_add_field(

527 + wb,

528 + fields_id++,

529 + "Src",

530 + "Source IP Address",

531 + RRDF_FIELD_TYPE_STRING,

532 + RRDF_FIELD_VISUAL_VALUE,

533 + RRDF_FIELD_TRANSFORM_NONE,

534 + 0,

535 + NULL,

536 + NAN,

537 + RRDF_FIELD_SORT_ASCENDING,

538 + NULL,

539 + RRDF_FIELD_SUMMARY_COUNT,

540 + RRDF_FIELD_FILTER_MULTISELECT,

541 + RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,

542 + NULL);

543

544 /*

545 buffer_rrdf_table_add_field(wb, fields_id++, "SrcPort", "Source Port", RRDF_FIELD_TYPE_INTEGER,

@@ -503,47 +550,113 @@ static void ebpf_function_socket_manipulation(const char *transaction,

550 NULL);

551 */

552

506 - buffer_rrdf_table_add_field(wb, fields_id++, "Dst", "Destination IP Address", RRDF_FIELD_TYPE_STRING,

507 - RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE, 0, NULL, NAN,

508 - RRDF_FIELD_SORT_ASCENDING, NULL, RRDF_FIELD_SUMMARY_COUNT,

509 - RRDF_FIELD_FILTER_MULTISELECT,

510 - RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,

511 - NULL);

553 + buffer_rrdf_table_add_field(

554 + wb,

555 + fields_id++,

556 + "Dst",

557 + "Destination IP Address",

558 + RRDF_FIELD_TYPE_STRING,

559 + RRDF_FIELD_VISUAL_VALUE,

560 + RRDF_FIELD_TRANSFORM_NONE,

561 + 0,

562 + NULL,

563 + NAN,

564 + RRDF_FIELD_SORT_ASCENDING,

565 + NULL,

566 + RRDF_FIELD_SUMMARY_COUNT,

567 + RRDF_FIELD_FILTER_MULTISELECT,

568 + RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,

569 + NULL);

570

513 - buffer_rrdf_table_add_field(wb, fields_id++, "DstPort", "Destination Port", RRDF_FIELD_TYPE_STRING,

514 - RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE, 0, NULL, NAN,

515 - RRDF_FIELD_SORT_ASCENDING, NULL, RRDF_FIELD_SUMMARY_COUNT,

516 - RRDF_FIELD_FILTER_MULTISELECT,

517 - RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,

518 - NULL);

571 + buffer_rrdf_table_add_field(

572 + wb,

573 + fields_id++,

574 + "DstPort",

575 + "Destination Port",

576 + RRDF_FIELD_TYPE_STRING,

577 + RRDF_FIELD_VISUAL_VALUE,

578 + RRDF_FIELD_TRANSFORM_NONE,

579 + 0,

580 + NULL,

581 + NAN,

582 + RRDF_FIELD_SORT_ASCENDING,

583 + NULL,

584 + RRDF_FIELD_SUMMARY_COUNT,

585 + RRDF_FIELD_FILTER_MULTISELECT,

586 + RRDF_FIELD_OPTS_VISIBLE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,

587 + NULL);

588

520 - buffer_rrdf_table_add_field(wb, fields_id++, "Protocol", "Transport Layer Protocol", RRDF_FIELD_TYPE_STRING,

521 - RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NONE, 0, NULL, NAN,

522 - RRDF_FIELD_SORT_ASCENDING, NULL, RRDF_FIELD_SUMMARY_COUNT,

523 - RRDF_FIELD_FILTER_MULTISELECT,

524 - RRDF_FIELD_OPTS_NONE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,

525 - NULL);

589 + buffer_rrdf_table_add_field(

590 + wb,

591 + fields_id++,

592 + "Protocol",

593 + "Transport Layer Protocol",

594 + RRDF_FIELD_TYPE_STRING,

595 + RRDF_FIELD_VISUAL_VALUE,

596 + RRDF_FIELD_TRANSFORM_NONE,

597 + 0,

598 + NULL,

599 + NAN,

600 + RRDF_FIELD_SORT_ASCENDING,

601 + NULL,

602 + RRDF_FIELD_SUMMARY_COUNT,

603 + RRDF_FIELD_FILTER_MULTISELECT,

604 + RRDF_FIELD_OPTS_NONE | RRDF_FIELD_OPTS_UNIQUE_KEY | RRDF_FIELD_OPTS_STICKY,

605 + NULL);

606

527 - buffer_rrdf_table_add_field(wb, fields_id++, "Rcvd", "Traffic Received", RRDF_FIELD_TYPE_INTEGER,

528 - RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NUMBER, 3, "MB", NAN,

529 - RRDF_FIELD_SORT_DESCENDING, NULL, RRDF_FIELD_SUMMARY_SUM,

530 - RRDF_FIELD_FILTER_NONE,

531 - RRDF_FIELD_OPTS_VISIBLE,

532 - NULL);

607 + buffer_rrdf_table_add_field(

608 + wb,

609 + fields_id++,

610 + "Rcvd",

611 + "Traffic Received",

612 + RRDF_FIELD_TYPE_INTEGER,

613 + RRDF_FIELD_VISUAL_VALUE,

614 + RRDF_FIELD_TRANSFORM_NUMBER,

615 + 3,

616 + "MB",

617 + NAN,

618 + RRDF_FIELD_SORT_DESCENDING,

619 + NULL,

620 + RRDF_FIELD_SUMMARY_SUM,

621 + RRDF_FIELD_FILTER_NONE,

622 + RRDF_FIELD_OPTS_VISIBLE,

623 + NULL);

624

534 - buffer_rrdf_table_add_field(wb, fields_id++, "Sent", "Traffic Sent", RRDF_FIELD_TYPE_INTEGER,

535 - RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NUMBER, 3, "MB", NAN,

536 - RRDF_FIELD_SORT_DESCENDING, NULL, RRDF_FIELD_SUMMARY_SUM,

537 - RRDF_FIELD_FILTER_NONE,

538 - RRDF_FIELD_OPTS_VISIBLE,

539 - NULL);

625 + buffer_rrdf_table_add_field(

626 + wb,

627 + fields_id++,

628 + "Sent",

629 + "Traffic Sent",

630 + RRDF_FIELD_TYPE_INTEGER,

631 + RRDF_FIELD_VISUAL_VALUE,

632 + RRDF_FIELD_TRANSFORM_NUMBER,

633 + 3,

634 + "MB",

635 + NAN,

636 + RRDF_FIELD_SORT_DESCENDING,

637 + NULL,

638 + RRDF_FIELD_SUMMARY_SUM,

639 + RRDF_FIELD_FILTER_NONE,

640 + RRDF_FIELD_OPTS_VISIBLE,

641 + NULL);

642

541 - buffer_rrdf_table_add_field(wb, fields_id, "Conns", "Connections", RRDF_FIELD_TYPE_INTEGER,

542 - RRDF_FIELD_VISUAL_VALUE, RRDF_FIELD_TRANSFORM_NUMBER, 0, "connections", NAN,

543 - RRDF_FIELD_SORT_DESCENDING, NULL, RRDF_FIELD_SUMMARY_SUM,

544 - RRDF_FIELD_FILTER_NONE,

545 - RRDF_FIELD_OPTS_VISIBLE,

546 - NULL);

643 + buffer_rrdf_table_add_field(

644 + wb,

645 + fields_id,

646 + "Conns",

647 + "Connections",

648 + RRDF_FIELD_TYPE_INTEGER,

649 + RRDF_FIELD_VISUAL_VALUE,

650 + RRDF_FIELD_TRANSFORM_NUMBER,

651 + 0,

652 + "connections",

653 + NAN,

654 + RRDF_FIELD_SORT_DESCENDING,

655 + NULL,

656 + RRDF_FIELD_SUMMARY_SUM,

657 + RRDF_FIELD_FILTER_NONE,

658 + RRDF_FIELD_OPTS_VISIBLE,

659 + NULL);

660 }

661 buffer_json_object_close(wb); // columns

662

@@ -692,10 +805,7 @@ void *ebpf_function_thread(void *ptr)

805 {

806 (void)ptr;

807

695 - struct functions_evloop_globals *wg = functions_evloop_init(1,

696 - "EBPF",

697 - &lock,

698 - &ebpf_plugin_exit);

808 + struct functions_evloop_globals *wg = functions_evloop_init(1, "EBPF", &lock, &ebpf_plugin_exit);

809

810 functions_evloop_add_function(

811 wg, EBPF_FUNCTION_SOCKET, ebpf_function_socket_manipulation, PLUGINS_FUNCTIONS_TIMEOUT_DEFAULT, NULL);

@@ -713,7 +823,7 @@ void *ebpf_function_thread(void *ptr)

823

824 heartbeat_t hb;

825 heartbeat_init(&hb, USEC_PER_SEC);

716 - while(!ebpf_plugin_stop()) {

826 + while (!ebpf_plugin_stop()) {

827 heartbeat_next(&hb);

828

829 if (ebpf_plugin_stop()) {

src/collectors/ebpf.plugin/ebpf_functions.h

+10 -5

@@ -4,11 +4,16 @@

4 #define NETDATA_EBPF_FUNCTIONS_H 1

6 // Common

7 -static inline void EBPF_PLUGIN_FUNCTIONS(const char *NAME, const char *DESC, int update_every) {

8 - fprintf(stdout, PLUGINSD_KEYWORD_FUNCTION " GLOBAL \"%s\" %d \"%s\" \"top\" "HTTP_ACCESS_FORMAT" %d\n",

9 - NAME, update_every, DESC,

10 - (HTTP_ACCESS_FORMAT_CAST)(HTTP_ACCESS_SIGNED_ID | HTTP_ACCESS_SAME_SPACE | HTTP_ACCESS_SENSITIVE_DATA),

11 - RRDFUNCTIONS_PRIORITY_DEFAULT);

7 +static inline void EBPF_PLUGIN_FUNCTIONS(const char *NAME, const char *DESC, int update_every)

8 +{

9 + fprintf(

10 + stdout,

11 + PLUGINSD_KEYWORD_FUNCTION " GLOBAL \"%s\" %d \"%s\" \"top\" " HTTP_ACCESS_FORMAT " %d\n",

12 + NAME,

13 + update_every,

14 + DESC,

15 + (HTTP_ACCESS_FORMAT_CAST)(HTTP_ACCESS_SIGNED_ID | HTTP_ACCESS_SAME_SPACE | HTTP_ACCESS_SENSITIVE_DATA),

16 + RRDFUNCTIONS_PRIORITY_DEFAULT);

17 }

19 // configuration file & description

src/collectors/ebpf.plugin/ebpf_hardirq.c

+68 -123

@@ -6,38 +6,34 @@

6 struct config hardirq_config = APPCONFIG_INITIALIZER;

8 static ebpf_local_maps_t hardirq_maps[] = {

9 - {

10 - .name = "tbl_hardirq",

11 - .internal_input = NETDATA_HARDIRQ_MAX_IRQS,

12 - .user_input = 0,

13 - .type = NETDATA_EBPF_MAP_STATIC,

14 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

9 + {.name = "tbl_hardirq",

10 + .internal_input = NETDATA_HARDIRQ_MAX_IRQS,

11 + .user_input = 0,

12 + .type = NETDATA_EBPF_MAP_STATIC,

13 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

14 #ifdef LIBBPF_MAJOR_VERSION

16 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

15 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

16 #endif

17 },

19 - {

20 - .name = "tbl_hardirq_static",

21 - .internal_input = HARDIRQ_EBPF_STATIC_END,

22 - .user_input = 0,

23 - .type = NETDATA_EBPF_MAP_STATIC,

24 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

18 + {.name = "tbl_hardirq_static",

19 + .internal_input = HARDIRQ_EBPF_STATIC_END,

20 + .user_input = 0,

21 + .type = NETDATA_EBPF_MAP_STATIC,

22 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

23 #ifdef LIBBPF_MAJOR_VERSION

26 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

24 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

25 #endif

26 },

27 /* end */

30 - {

31 - .name = NULL,

32 - .internal_input = 0,

33 - .user_input = 0,

34 - .type = NETDATA_EBPF_MAP_CONTROLLER,

35 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

28 + {.name = NULL,

29 + .internal_input = 0,

30 + .user_input = 0,

31 + .type = NETDATA_EBPF_MAP_CONTROLLER,

32 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

33 #ifdef LIBBPF_MAJOR_VERSION

37 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

34 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

35 #endif

39 - }

40 -};

36 + }};

38 #define HARDIRQ_TP_CLASS_IRQ "irq"

39 #define HARDIRQ_TP_CLASS_IRQ_VECTORS "irq_vectors"

@@ -67,65 +63,20 @@ static ebpf_tracepoint_t hardirq_tracepoints[] = {

63 {.enabled = false, .class = HARDIRQ_TP_CLASS_IRQ_VECTORS, .event = "x86_platform_ipi_entry"},

64 {.enabled = false, .class = HARDIRQ_TP_CLASS_IRQ_VECTORS, .event = "x86_platform_ipi_exit"},

65 /* end */

70 - {.enabled = false, .class = NULL, .event = NULL}

71 -};

66 + {.enabled = false, .class = NULL, .event = NULL}};

68 static hardirq_static_val_t hardirq_static_vals[] = {

74 - {

75 - .idx = HARDIRQ_EBPF_STATIC_APIC_THERMAL,

76 - .name = "apic_thermal",

77 - .latency = 0

78 - },

79 - {

80 - .idx = HARDIRQ_EBPF_STATIC_APIC_THRESHOLD,

81 - .name = "apic_threshold",

82 - .latency = 0

83 - },

84 - {

85 - .idx = HARDIRQ_EBPF_STATIC_APIC_ERROR,

86 - .name = "apic_error",

87 - .latency = 0

88 - },

89 - {

90 - .idx = HARDIRQ_EBPF_STATIC_APIC_DEFERRED_ERROR,

91 - .name = "apic_deferred_error",

92 - .latency = 0

93 - },

94 - {

95 - .idx = HARDIRQ_EBPF_STATIC_APIC_SPURIOUS,

96 - .name = "apic_spurious",

97 - .latency = 0

98 - },

99 - {

100 - .idx = HARDIRQ_EBPF_STATIC_FUNC_CALL,

101 - .name = "func_call",

102 - .latency = 0

103 - },

104 - {

105 - .idx = HARDIRQ_EBPF_STATIC_FUNC_CALL_SINGLE,

106 - .name = "func_call_single",

107 - .latency = 0

108 - },

109 - {

110 - .idx = HARDIRQ_EBPF_STATIC_RESCHEDULE,

111 - .name = "reschedule",

112 - .latency = 0

113 - },

114 - {

115 - .idx = HARDIRQ_EBPF_STATIC_LOCAL_TIMER,

116 - .name = "local_timer",

117 - .latency = 0

118 - },

119 - {

120 - .idx = HARDIRQ_EBPF_STATIC_IRQ_WORK,

121 - .name = "irq_work",

122 - .latency = 0

123 - },

124 - {

125 - .idx = HARDIRQ_EBPF_STATIC_X86_PLATFORM_IPI,

126 - .name = "x86_platform_ipi",

127 - .latency = 0

128 - },

69 + {.idx = HARDIRQ_EBPF_STATIC_APIC_THERMAL, .name = "apic_thermal", .latency = 0},

70 + {.idx = HARDIRQ_EBPF_STATIC_APIC_THRESHOLD, .name = "apic_threshold", .latency = 0},

71 + {.idx = HARDIRQ_EBPF_STATIC_APIC_ERROR, .name = "apic_error", .latency = 0},

72 + {.idx = HARDIRQ_EBPF_STATIC_APIC_DEFERRED_ERROR, .name = "apic_deferred_error", .latency = 0},

73 + {.idx = HARDIRQ_EBPF_STATIC_APIC_SPURIOUS, .name = "apic_spurious", .latency = 0},

74 + {.idx = HARDIRQ_EBPF_STATIC_FUNC_CALL, .name = "func_call", .latency = 0},

75 + {.idx = HARDIRQ_EBPF_STATIC_FUNC_CALL_SINGLE, .name = "func_call_single", .latency = 0},

76 + {.idx = HARDIRQ_EBPF_STATIC_RESCHEDULE, .name = "reschedule", .latency = 0},

77 + {.idx = HARDIRQ_EBPF_STATIC_LOCAL_TIMER, .name = "local_timer", .latency = 0},

78 + {.idx = HARDIRQ_EBPF_STATIC_IRQ_WORK, .name = "irq_work", .latency = 0},

79 + {.idx = HARDIRQ_EBPF_STATIC_X86_PLATFORM_IPI, .name = "x86_platform_ipi", .latency = 0},

80 };

82 // store for "published" data from the reader thread, which the collector

@@ -220,17 +171,17 @@ void ebpf_hardirq_release(hardirq_val_t *stat)

171 */

172 static void ebpf_obsolete_hardirq_global(ebpf_module_t *em)

173 {

223 - ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,

224 - "hardirq_latency",

225 - "",

226 - "Hardware IRQ latency",

227 - EBPF_COMMON_UNITS_MILLISECONDS,

228 - "interrupts",

229 - NETDATA_EBPF_CHART_TYPE_STACKED,

230 - NETDATA_EBPF_SYSTEM_HARDIRQ_LATENCY_CTX,

231 - NETDATA_CHART_PRIO_HARDIRQ_LATENCY,

232 - em->update_every

233 - );

174 + ebpf_write_chart_obsolete(

175 + NETDATA_EBPF_SYSTEM_GROUP,

176 + "hardirq_latency",

177 + "",

178 + "Hardware IRQ latency",

179 + EBPF_COMMON_UNITS_MILLISECONDS,

180 + "interrupts",

181 + NETDATA_EBPF_CHART_TYPE_STACKED,

182 + NETDATA_EBPF_SYSTEM_HARDIRQ_LATENCY_CTX,

183 + NETDATA_CHART_PRIO_HARDIRQ_LATENCY,

184 + em->update_every);

185 }

186

187 /**

@@ -243,7 +194,8 @@ static void ebpf_obsolete_hardirq_global(ebpf_module_t *em)

194 static void hardirq_exit(void *pptr)

195 {

196 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

246 - if(!em) return;

197 + if (!em)

198 + return;

199

200 if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) {

201 pthread_mutex_lock(&lock);

@@ -291,11 +243,9 @@ static int hardirq_val_cmp(void *a, void *b)

243

244 if (ptr1->irq > ptr2->irq) {

245 return 1;

294 - }

295 - else if (ptr1->irq < ptr2->irq) {

246 + } else if (ptr1->irq < ptr2->irq) {

247 return -1;

297 - }

298 - else {

248 + } else {

249 return 0;

250 }

251 }

@@ -314,37 +264,38 @@ static int hardirq_parse_interrupts(char *irq_name, int irq)

264 {

265 static procfile *ff = NULL;

266 static int cpus = -1;

317 - if(unlikely(!ff)) {

267 + if (unlikely(!ff)) {

268 char filename[FILENAME_MAX + 1];

269 snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/interrupts");

270 ff = procfile_open(filename, " \t:", PROCFILE_FLAG_DEFAULT);

271 }

322 - if(unlikely(!ff))

272 + if (unlikely(!ff))

273 return -1;

274

275 ff = procfile_readall(ff);

326 - if(unlikely(!ff))

276 + if (unlikely(!ff))

277 return -1; // we return 0, so that we will retry to open it next time

278

279 size_t words = procfile_linewords(ff, 0);

330 - if(unlikely(cpus == -1)) {

280 + if (unlikely(cpus == -1)) {

281 uint32_t w;

282 cpus = 0;

333 - for(w = 0; w < words ; w++) {

334 - if(likely(strncmp(procfile_lineword(ff, 0, w), "CPU", 3) == 0))

283 + for (w = 0; w < words; w++) {

284 + if (likely(strncmp(procfile_lineword(ff, 0, w), "CPU", 3) == 0))

285 cpus++;

286 }

337 - }

287 + }

288

289 size_t lines = procfile_lines(ff), l;

340 - if(unlikely(!lines)) {

290 + if (unlikely(!lines)) {

291 collector_error("Cannot read /proc/interrupts, zero lines reported.");

292 return -1;

293 }

294

345 - for(l = 1; l < lines ;l++) {

295 + for (l = 1; l < lines; l++) {

296 words = procfile_linewords(ff, l);

347 - if(unlikely(!words)) continue;

297 + if (unlikely(!words))

298 + continue;

299 const char *id = procfile_lineword(ff, l, 0);

300 if (!isdigit(id[0]))

301 continue;

@@ -353,7 +304,7 @@ static int hardirq_parse_interrupts(char *irq_name, int irq)

304 if (cmp != irq)

305 continue;

306

356 - if(unlikely((uint32_t)(cpus + 2) < words)) {

307 + if (unlikely((uint32_t)(cpus + 2) < words)) {

308 const char *name = procfile_lineword(ff, l, words - 1);

309 // On some motherboards IRQ can have the same name, so we append IRQ id to differentiate.

310 snprintfz(irq_name, NETDATA_HARDIRQ_NAME_LEN - 1, "%d_%s", irq, name);

@@ -425,7 +376,7 @@ static int hardirq_read_latency_map(int mapfd)

376 uint64_t total_latency = 0;

377 int i;

378 for (i = 0; i < ebpf_nprocs; i++) {

428 - total_latency += hardirq_ebpf_vals[i].latency/1000;

379 + total_latency += hardirq_ebpf_vals[i].latency / 1000;

380 }

381

382 // can now safely publish latency for existing IRQs.

@@ -468,7 +419,7 @@ static void hardirq_read_latency_static_map(int mapfd)

419 int cpu_i;

420 int end = (running_on_kernel < NETDATA_KERNEL_V4_15) ? 1 : ebpf_nprocs;

421 for (cpu_i = 0; cpu_i < end; cpu_i++) {

471 - total_latency += hardirq_ebpf_static_vals[cpu_i].latency/1000;

422 + total_latency += hardirq_ebpf_static_vals[cpu_i].latency / 1000;

423 }

424

425 hardirq_static_vals[i].latency = total_latency;

@@ -501,9 +452,11 @@ static void hardirq_create_charts(int update_every)

452 NETDATA_EBPF_SYSTEM_HARDIRQ_LATENCY_CTX,

453 NETDATA_EBPF_CHART_TYPE_STACKED,

454 NETDATA_CHART_PRIO_HARDIRQ_LATENCY,

504 - NULL, NULL, 0, update_every,

505 - NETDATA_EBPF_MODULE_NAME_HARDIRQ

506 - );

455 + NULL,

456 + NULL,

457 + 0,

458 + update_every,

459 + NETDATA_EBPF_MODULE_NAME_HARDIRQ);

460

461 fflush(stdout);

462 }

@@ -513,9 +466,7 @@ static void hardirq_create_static_dims()

466 uint32_t i;

467 for (i = 0; i < HARDIRQ_EBPF_STATIC_END; i++) {

468 ebpf_write_global_dimension(

516 - hardirq_static_vals[i].name, hardirq_static_vals[i].name,

517 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]

518 - );

469 + hardirq_static_vals[i].name, hardirq_static_vals[i].name, ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

470 }

471 }

472

@@ -528,10 +479,7 @@ static int hardirq_write_dims(void *entry, void *data)

479

480 // IRQs get dynamically added in, so add the dimension if we haven't yet.

481 if (!v->dim_exists) {

531 - ebpf_write_global_dimension(

532 - v->name, v->name,

533 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]

534 - );

482 + ebpf_write_global_dimension(v->name, v->name, ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

483 v->dim_exists = true;

484 }

485

@@ -544,10 +492,7 @@ static inline void hardirq_write_static_dims()

492 {

493 uint32_t i;

494 for (i = 0; i < HARDIRQ_EBPF_STATIC_END; i++) {

547 - write_chart_dimension(

548 - hardirq_static_vals[i].name,

549 - hardirq_static_vals[i].latency

550 - );

495 + write_chart_dimension(hardirq_static_vals[i].name, hardirq_static_vals[i].latency);

496 }

497 }

498

src/collectors/ebpf.plugin/ebpf_hardirq.h

+1 -5

@@ -37,17 +37,13 @@ enum hardirq_ebpf_static {

37 HARDIRQ_EBPF_STATIC_END

38 };

40 -enum hardirq_maps {

41 - HARDIRQ_MAP_LATENCY,

42 - HARDIRQ_MAP_LATENCY_STATIC

43 -};

40 +enum hardirq_maps { HARDIRQ_MAP_LATENCY, HARDIRQ_MAP_LATENCY_STATIC };

42 typedef struct hardirq_ebpf_static_val {

43 uint64_t latency;

44 uint64_t ts;

45 } hardirq_ebpf_static_val_t;

50 -

47 /*****************************************************************

48 * below this is eBPF plugin-specific code.

49 *****************************************************************/

src/collectors/ebpf.plugin/ebpf_mdflush.c

+40 -50

@@ -7,29 +7,25 @@ struct config mdflush_config = APPCONFIG_INITIALIZER;

8 #define MDFLUSH_MAP_COUNT 0

9 static ebpf_local_maps_t mdflush_maps[] = {

10 - {

11 - .name = "tbl_mdflush",

12 - .internal_input = 1024,

13 - .user_input = 0,

14 - .type = NETDATA_EBPF_MAP_STATIC,

15 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

10 + {.name = "tbl_mdflush",

11 + .internal_input = 1024,

12 + .user_input = 0,

13 + .type = NETDATA_EBPF_MAP_STATIC,

14 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

15 #ifdef LIBBPF_MAJOR_VERSION

17 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

16 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

17 #endif

18 },

19 /* end */

21 - {

22 - .name = NULL,

23 - .internal_input = 0,

24 - .user_input = 0,

25 - .type = NETDATA_EBPF_MAP_CONTROLLER,

26 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED

27 - }

28 -};

29 -

30 -netdata_ebpf_targets_t mdflush_targets[] = { {.name = "md_flush_request", .mode = EBPF_LOAD_TRAMPOLINE},

31 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

20 + {.name = NULL,

21 + .internal_input = 0,

22 + .user_input = 0,

23 + .type = NETDATA_EBPF_MAP_CONTROLLER,

24 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED}};

26 +netdata_ebpf_targets_t mdflush_targets[] = {

27 + {.name = "md_flush_request", .mode = EBPF_LOAD_TRAMPOLINE},

28 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

30 // store for "published" data from the reader thread, which the collector

31 // thread will write to netdata agent.

@@ -72,8 +68,8 @@ static inline void ebpf_disable_trampoline(struct mdflush_bpf *obj)

68 */

69 static void ebpf_set_trampoline_target(struct mdflush_bpf *obj)

70 {

75 - bpf_program__set_attach_target(obj->progs.netdata_md_flush_request_fentry, 0,

76 - mdflush_targets[NETDATA_MD_FLUSH_REQUEST].name);

71 + bpf_program__set_attach_target(

72 + obj->progs.netdata_md_flush_request_fentry, 0, mdflush_targets[NETDATA_MD_FLUSH_REQUEST].name);

73 }

75 /**

@@ -85,9 +81,8 @@ static void ebpf_set_trampoline_target(struct mdflush_bpf *obj)

81 */

82 static inline int ebpf_load_probes(struct mdflush_bpf *obj)

83 {

88 - obj->links.netdata_md_flush_request_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_md_flush_request_kprobe,

89 - false,

90 - mdflush_targets[NETDATA_MD_FLUSH_REQUEST].name);

84 + obj->links.netdata_md_flush_request_kprobe = bpf_program__attach_kprobe(

85 + obj->progs.netdata_md_flush_request_kprobe, false, mdflush_targets[NETDATA_MD_FLUSH_REQUEST].name);

86 return libbpf_get_error(obj->links.netdata_md_flush_request_kprobe);

87 }

@@ -134,16 +129,17 @@ static inline int ebpf_mdflush_load_and_attach(struct mdflush_bpf *obj, ebpf_mod

129 */

130 static void ebpf_obsolete_mdflush_global(ebpf_module_t *em)

131 {

137 - ebpf_write_chart_obsolete("mdstat",

138 - "mdstat_flush",

139 - "",

140 - "MD flushes",

141 - "flushes",

142 - "flush (eBPF)",

143 - NETDATA_EBPF_CHART_TYPE_STACKED,

144 - "mdstat.mdstat_flush",

145 - NETDATA_CHART_PRIO_MDSTAT_FLUSH,

146 - em->update_every);

132 + ebpf_write_chart_obsolete(

133 + "mdstat",

134 + "mdstat_flush",

135 + "",

136 + "MD flushes",

137 + "flushes",

138 + "flush (eBPF)",

139 + NETDATA_EBPF_CHART_TYPE_STACKED,

140 + "mdstat.mdstat_flush",

141 + NETDATA_CHART_PRIO_MDSTAT_FLUSH,

142 + em->update_every);

143 }

144

145 /**

@@ -156,7 +152,8 @@ static void ebpf_obsolete_mdflush_global(ebpf_module_t *em)

152 static void mdflush_exit(void *pptr)

153 {

154 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

159 - if(!em) return;

155 + if (!em)

156 + return;

157

158 if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) {

159 pthread_mutex_lock(&lock);

@@ -196,11 +193,9 @@ static int mdflush_val_cmp(void *a, void *b)

193

194 if (ptr1->unit > ptr2->unit) {

195 return 1;

199 - }

200 - else if (ptr1->unit < ptr2->unit) {

196 + } else if (ptr1->unit < ptr2->unit) {

197 return -1;

202 - }

203 - else {

198 + } else {

199 return 0;

200 }

201 }

@@ -244,10 +239,7 @@ static void mdflush_read_count_map(int maps_per_core)

239 // there is no congestion.

240 bool v_is_new = false;

241 search_v.unit = key;

247 - v = (netdata_mdflush_t *)avl_search_lock(

248 - &mdflush_pub,

249 - (avl_t *)&search_v

250 - );

242 + v = (netdata_mdflush_t *)avl_search_lock(&mdflush_pub, (avl_t *)&search_v);

243 if (unlikely(v == NULL)) {

244 // flush count can only be added reliably at a later time.

245 // when they're added, only then will we AVL insert.

@@ -291,9 +283,11 @@ static void mdflush_create_charts(int update_every)

283 "mdstat.mdstat_flush",

284 NETDATA_EBPF_CHART_TYPE_STACKED,

285 NETDATA_CHART_PRIO_MDSTAT_FLUSH,

294 - NULL, NULL, 0, update_every,

295 - NETDATA_EBPF_MODULE_NAME_MDFLUSH

296 - );

286 + NULL,

287 + NULL,

288 + 0,

289 + update_every,

290 + NETDATA_EBPF_MODULE_NAME_MDFLUSH);

291

292 fflush(stdout);

293 }

@@ -307,10 +301,7 @@ static int mdflush_write_dims(void *entry, void *data)

301

302 // records get dynamically added in, so add the dim if we haven't yet.

303 if (!v->dim_exists) {

310 - ebpf_write_global_dimension(

311 - v->disk_name, v->disk_name,

312 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]

313 - );

304 + ebpf_write_global_dimension(v->disk_name, v->disk_name, ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

305 v->dim_exists = true;

306 }

307

@@ -412,7 +403,6 @@ static int ebpf_mdflush_load_bpf(ebpf_module_t *em)

403 return ret;

404 }

405

415 -

406 /**

407 * mdflush thread.

408 *

src/collectors/ebpf.plugin/ebpf_mount.c

+112 -91

@@ -3,22 +3,27 @@

3 #include "ebpf.h"

4 #include "ebpf_mount.h"

6 -static ebpf_local_maps_t mount_maps[] = {{.name = "tbl_mount", .internal_input = NETDATA_MOUNT_END,

7 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

8 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

6 +static ebpf_local_maps_t mount_maps[] = {

7 + {.name = "tbl_mount",

8 + .internal_input = NETDATA_MOUNT_END,

9 + .user_input = 0,

10 + .type = NETDATA_EBPF_MAP_STATIC,

11 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

12 #ifdef LIBBPF_MAJOR_VERSION

10 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

13 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

14 #endif

12 - },

13 - {.name = NULL, .internal_input = 0, .user_input = 0,

14 - .type = NETDATA_EBPF_MAP_CONTROLLER,

15 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

15 + },

16 + {.name = NULL,

17 + .internal_input = 0,

18 + .user_input = 0,

19 + .type = NETDATA_EBPF_MAP_CONTROLLER,

20 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

21 #ifdef LIBBPF_MAJOR_VERSION

17 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

22 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

23 #endif

19 - }};

24 + }};

21 -static char *mount_dimension_name[NETDATA_EBPF_MOUNT_SYSCALL] = { "mount", "umount" };

26 +static char *mount_dimension_name[NETDATA_EBPF_MOUNT_SYSCALL] = {"mount", "umount"};

27 static netdata_syscall_stat_t mount_aggregated_data[NETDATA_EBPF_MOUNT_SYSCALL];

28 static netdata_publish_syscall_t mount_publish_aggregated[NETDATA_EBPF_MOUNT_SYSCALL];

@@ -26,9 +31,10 @@ struct config mount_config = APPCONFIG_INITIALIZER;

32 static netdata_idx_t mount_hash_values[NETDATA_MOUNT_END];

29 -netdata_ebpf_targets_t mount_targets[] = { {.name = "mount", .mode = EBPF_LOAD_TRAMPOLINE},

30 - {.name = "umount", .mode = EBPF_LOAD_TRAMPOLINE},

31 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

34 +netdata_ebpf_targets_t mount_targets[] = {

35 + {.name = "mount", .mode = EBPF_LOAD_TRAMPOLINE},

36 + {.name = "umount", .mode = EBPF_LOAD_TRAMPOLINE},

37 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

39 #ifdef LIBBPF_MAJOR_VERSION

40 /*****************************************************************

@@ -91,23 +97,19 @@ static inline void ebpf_mount_disable_trampoline(struct mount_bpf *obj)

97 static inline void netdata_set_trampoline_target(struct mount_bpf *obj)

98 {

99 char syscall[NETDATA_EBPF_MAX_SYSCALL_LENGTH + 1];

94 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

95 - mount_targets[NETDATA_MOUNT_SYSCALL].name, running_on_kernel);

100 + ebpf_select_host_prefix(

101 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, mount_targets[NETDATA_MOUNT_SYSCALL].name, running_on_kernel);

102

97 - bpf_program__set_attach_target(obj->progs.netdata_mount_fentry, 0,

98 - syscall);

103 + bpf_program__set_attach_target(obj->progs.netdata_mount_fentry, 0, syscall);

104

100 - bpf_program__set_attach_target(obj->progs.netdata_mount_fexit, 0,

101 - syscall);

105 + bpf_program__set_attach_target(obj->progs.netdata_mount_fexit, 0, syscall);

106

103 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

104 - mount_targets[NETDATA_UMOUNT_SYSCALL].name, running_on_kernel);

107 + ebpf_select_host_prefix(

108 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, mount_targets[NETDATA_UMOUNT_SYSCALL].name, running_on_kernel);

109

106 - bpf_program__set_attach_target(obj->progs.netdata_umount_fentry, 0,

107 - syscall);

110 + bpf_program__set_attach_target(obj->progs.netdata_umount_fentry, 0, syscall);

111

109 - bpf_program__set_attach_target(obj->progs.netdata_umount_fexit, 0,

110 - syscall);

112 + bpf_program__set_attach_target(obj->progs.netdata_umount_fexit, 0, syscall);

113 }

114

115 /**

@@ -123,32 +125,28 @@ static int ebpf_mount_attach_probe(struct mount_bpf *obj)

125 {

126 char syscall[NETDATA_EBPF_MAX_SYSCALL_LENGTH + 1];

127

126 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

127 - mount_targets[NETDATA_MOUNT_SYSCALL].name, running_on_kernel);

128 + ebpf_select_host_prefix(

129 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, mount_targets[NETDATA_MOUNT_SYSCALL].name, running_on_kernel);

130

129 - obj->links.netdata_mount_probe = bpf_program__attach_kprobe(obj->progs.netdata_mount_probe,

130 - false, syscall);

131 + obj->links.netdata_mount_probe = bpf_program__attach_kprobe(obj->progs.netdata_mount_probe, false, syscall);

132 int ret = (int)libbpf_get_error(obj->links.netdata_mount_probe);

133 if (ret)

134 return -1;

135

135 - obj->links.netdata_mount_retprobe = bpf_program__attach_kprobe(obj->progs.netdata_mount_retprobe,

136 - true, syscall);

136 + obj->links.netdata_mount_retprobe = bpf_program__attach_kprobe(obj->progs.netdata_mount_retprobe, true, syscall);

137 ret = (int)libbpf_get_error(obj->links.netdata_mount_retprobe);

138 if (ret)

139 return -1;

140

141 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

142 - mount_targets[NETDATA_UMOUNT_SYSCALL].name, running_on_kernel);

141 + ebpf_select_host_prefix(

142 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, mount_targets[NETDATA_UMOUNT_SYSCALL].name, running_on_kernel);

143

144 - obj->links.netdata_umount_probe = bpf_program__attach_kprobe(obj->progs.netdata_umount_probe,

145 - false, syscall);

144 + obj->links.netdata_umount_probe = bpf_program__attach_kprobe(obj->progs.netdata_umount_probe, false, syscall);

145 ret = (int)libbpf_get_error(obj->links.netdata_umount_probe);

146 if (ret)

147 return -1;

148

150 - obj->links.netdata_umount_retprobe = bpf_program__attach_kprobe(obj->progs.netdata_umount_retprobe,

151 - true, syscall);

149 + obj->links.netdata_umount_retprobe = bpf_program__attach_kprobe(obj->progs.netdata_umount_retprobe, true, syscall);

150 ret = (int)libbpf_get_error(obj->links.netdata_umount_retprobe);

151 if (ret)

152 return -1;

@@ -184,13 +182,12 @@ static inline int ebpf_mount_load_and_attach(struct mount_bpf *obj, ebpf_module_

182 netdata_ebpf_program_loaded_t test = mt[NETDATA_MOUNT_SYSCALL].mode;

183

184 // We are testing only one, because all will have the same behavior

187 - if (test == EBPF_LOAD_TRAMPOLINE ) {

185 + if (test == EBPF_LOAD_TRAMPOLINE) {

186 ebpf_mount_disable_probe(obj);

187 ebpf_mount_disable_tracepoint(obj);

188

189 netdata_set_trampoline_target(obj);

192 - } else if (test == EBPF_LOAD_PROBE ||

193 - test == EBPF_LOAD_RETPROBE ) {

190 + } else if (test == EBPF_LOAD_PROBE || test == EBPF_LOAD_RETPROBE) {

191 ebpf_mount_disable_tracepoint(obj);

192 ebpf_mount_disable_trampoline(obj);

193 } else {

@@ -202,7 +199,7 @@ static inline int ebpf_mount_load_and_attach(struct mount_bpf *obj, ebpf_module_

199

200 int ret = mount_bpf__load(obj);

201 if (!ret) {

205 - if (test != EBPF_LOAD_PROBE && test != EBPF_LOAD_RETPROBE )

202 + if (test != EBPF_LOAD_PROBE && test != EBPF_LOAD_RETPROBE)

203 ret = mount_bpf__attach(obj);

204 else

205 ret = ebpf_mount_attach_probe(obj);

@@ -229,27 +226,29 @@ static inline int ebpf_mount_load_and_attach(struct mount_bpf *obj, ebpf_module_

226 */

227 static void ebpf_obsolete_mount_global(ebpf_module_t *em)

228 {

232 - ebpf_write_chart_obsolete(NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,

233 - NETDATA_EBPF_MOUNT_CALLS,

234 - "",

235 - "Calls to mount and umount syscalls",

236 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

237 - NETDATA_EBPF_MOUNT_FAMILY,

238 - NETDATA_EBPF_CHART_TYPE_LINE,

239 - "mount_points.call",

240 - NETDATA_CHART_PRIO_EBPF_MOUNT_CHARTS,

241 - em->update_every);

242 -

243 - ebpf_write_chart_obsolete(NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,

244 - NETDATA_EBPF_MOUNT_ERRORS,

245 - "",

246 - "Errors to mount and umount file systems",

247 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

248 - NETDATA_EBPF_MOUNT_FAMILY,

249 - NETDATA_EBPF_CHART_TYPE_LINE,

250 - "mount_points.error",

251 - NETDATA_CHART_PRIO_EBPF_MOUNT_CHARTS + 1,

252 - em->update_every);

229 + ebpf_write_chart_obsolete(

230 + NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,

231 + NETDATA_EBPF_MOUNT_CALLS,

232 + "",

233 + "Calls to mount and umount syscalls",

234 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

235 + NETDATA_EBPF_MOUNT_FAMILY,

236 + NETDATA_EBPF_CHART_TYPE_LINE,

237 + "mount_points.call",

238 + NETDATA_CHART_PRIO_EBPF_MOUNT_CHARTS,

239 + em->update_every);

240 +

241 + ebpf_write_chart_obsolete(

242 + NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,

243 + NETDATA_EBPF_MOUNT_ERRORS,

244 + "",

245 + "Errors to mount and umount file systems",

246 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

247 + NETDATA_EBPF_MOUNT_FAMILY,

248 + NETDATA_EBPF_CHART_TYPE_LINE,

249 + "mount_points.error",

250 + NETDATA_CHART_PRIO_EBPF_MOUNT_CHARTS + 1,

251 + em->update_every);

252 }

253

254 /**

@@ -262,7 +261,8 @@ static void ebpf_obsolete_mount_global(ebpf_module_t *em)

261 static void ebpf_mount_exit(void *pptr)

262 {

263 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

265 - if(!em) return;

264 + if (!em)

265 + return;

266

267 if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) {

268 pthread_mutex_lock(&lock);

@@ -347,11 +347,17 @@ static void ebpf_mount_send_data()

347 mount_publish_aggregated[i].nerr = mount_hash_values[j];

348 }

349

350 - write_count_chart(NETDATA_EBPF_MOUNT_CALLS, NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,

351 - mount_publish_aggregated, NETDATA_EBPF_MOUNT_SYSCALL);

352 -

353 - write_err_chart(NETDATA_EBPF_MOUNT_ERRORS, NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,

354 - mount_publish_aggregated, NETDATA_EBPF_MOUNT_SYSCALL);

350 + write_count_chart(

351 + NETDATA_EBPF_MOUNT_CALLS,

352 + NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,

353 + mount_publish_aggregated,

354 + NETDATA_EBPF_MOUNT_SYSCALL);

355 +

356 + write_err_chart(

357 + NETDATA_EBPF_MOUNT_ERRORS,

358 + NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,

359 + mount_publish_aggregated,

360 + NETDATA_EBPF_MOUNT_SYSCALL);

361 }

362

363 /**

@@ -407,25 +413,35 @@ static void mount_collector(ebpf_module_t *em)

413 */

414 static void ebpf_create_mount_charts(int update_every)

415 {

410 - ebpf_create_chart(NETDATA_EBPF_MOUNT_GLOBAL_FAMILY, NETDATA_EBPF_MOUNT_CALLS,

411 - "Calls to mount and umount syscalls",

412 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_EBPF_MOUNT_FAMILY,

413 - "mount_points.call",

414 - NETDATA_EBPF_CHART_TYPE_LINE,

415 - NETDATA_CHART_PRIO_EBPF_MOUNT_CHARTS,

416 - ebpf_create_global_dimension,

417 - mount_publish_aggregated, NETDATA_EBPF_MOUNT_SYSCALL,

418 - update_every, NETDATA_EBPF_MODULE_NAME_MOUNT);

419 -

420 - ebpf_create_chart(NETDATA_EBPF_MOUNT_GLOBAL_FAMILY, NETDATA_EBPF_MOUNT_ERRORS,

421 - "Errors to mount and umount file systems",

422 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_EBPF_MOUNT_FAMILY,

423 - "mount_points.error",

424 - NETDATA_EBPF_CHART_TYPE_LINE,

425 - NETDATA_CHART_PRIO_EBPF_MOUNT_CHARTS + 1,

426 - ebpf_create_global_dimension,

427 - mount_publish_aggregated, NETDATA_EBPF_MOUNT_SYSCALL,

428 - update_every, NETDATA_EBPF_MODULE_NAME_MOUNT);

416 + ebpf_create_chart(

417 + NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,

418 + NETDATA_EBPF_MOUNT_CALLS,

419 + "Calls to mount and umount syscalls",

420 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

421 + NETDATA_EBPF_MOUNT_FAMILY,

422 + "mount_points.call",

423 + NETDATA_EBPF_CHART_TYPE_LINE,

424 + NETDATA_CHART_PRIO_EBPF_MOUNT_CHARTS,

425 + ebpf_create_global_dimension,

426 + mount_publish_aggregated,

427 + NETDATA_EBPF_MOUNT_SYSCALL,

428 + update_every,

429 + NETDATA_EBPF_MODULE_NAME_MOUNT);

430 +

431 + ebpf_create_chart(

432 + NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,

433 + NETDATA_EBPF_MOUNT_ERRORS,

434 + "Errors to mount and umount file systems",

435 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

436 + NETDATA_EBPF_MOUNT_FAMILY,

437 + "mount_points.error",

438 + NETDATA_EBPF_CHART_TYPE_LINE,

439 + NETDATA_CHART_PRIO_EBPF_MOUNT_CHARTS + 1,

440 + ebpf_create_global_dimension,

441 + mount_publish_aggregated,

442 + NETDATA_EBPF_MOUNT_SYSCALL,

443 + update_every,

444 + NETDATA_EBPF_MODULE_NAME_MOUNT);

445

446 fflush(stdout);

447 }

@@ -495,10 +511,15 @@ void *ebpf_mount_thread(void *ptr)

511 goto endmount;

512 }

513

498 - int algorithms[NETDATA_EBPF_MOUNT_SYSCALL] = { NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX };

514 + int algorithms[NETDATA_EBPF_MOUNT_SYSCALL] = {NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX};

515

500 - ebpf_global_labels(mount_aggregated_data, mount_publish_aggregated, mount_dimension_name, mount_dimension_name,

501 - algorithms, NETDATA_EBPF_MOUNT_SYSCALL);

516 + ebpf_global_labels(

517 + mount_aggregated_data,

518 + mount_publish_aggregated,

519 + mount_dimension_name,

520 + mount_dimension_name,

521 + algorithms,

522 + NETDATA_EBPF_MOUNT_SYSCALL);

523

524 pthread_mutex_lock(&lock);

525 ebpf_create_mount_charts(em->update_every);

src/collectors/ebpf.plugin/ebpf_mount.h

+1 -3

@@ -25,9 +25,7 @@ enum mount_counters {

25 NETDATA_MOUNT_END

26 };

28 -enum mount_tables {

29 - NETDATA_KEY_MOUNT_TABLE

30 -};

28 +enum mount_tables { NETDATA_KEY_MOUNT_TABLE };

30 enum netdata_mount_syscalls {

31 NETDATA_MOUNT_SYSCALL,

src/collectors/ebpf.plugin/ebpf_oomkill.c

+99 -84

@@ -7,38 +7,33 @@ struct config oomkill_config = APPCONFIG_INITIALIZER;

8 #define OOMKILL_MAP_KILLCNT 0

9 static ebpf_local_maps_t oomkill_maps[] = {

10 - {

11 - .name = "tbl_oomkill",

12 - .internal_input = NETDATA_OOMKILL_MAX_ENTRIES,

13 - .user_input = 0,

14 - .type = NETDATA_EBPF_MAP_STATIC,

15 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

10 + {.name = "tbl_oomkill",

11 + .internal_input = NETDATA_OOMKILL_MAX_ENTRIES,

12 + .user_input = 0,

13 + .type = NETDATA_EBPF_MAP_STATIC,

14 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

15 #ifdef LIBBPF_MAJOR_VERSION

17 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

16 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

17 #endif

18 },

19 /* end */

21 - {

22 - .name = NULL,

23 - .internal_input = 0,

24 - .user_input = 0,

25 - .type = NETDATA_EBPF_MAP_CONTROLLER,

26 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

20 + {.name = NULL,

21 + .internal_input = 0,

22 + .user_input = 0,

23 + .type = NETDATA_EBPF_MAP_CONTROLLER,

24 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

25 #ifdef LIBBPF_MAJOR_VERSION

28 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

26 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

27 #endif

30 - }

31 -};

28 + }};

30 static ebpf_tracepoint_t oomkill_tracepoints[] = {

31 {.enabled = false, .class = "oom", .event = "mark_victim"},

32 /* end */

36 - {.enabled = false, .class = NULL, .event = NULL}

37 -};

33 + {.enabled = false, .class = NULL, .event = NULL}};

39 -static netdata_publish_syscall_t oomkill_publish_aggregated = {.name = "kills", .dimension = "kills",

40 - .algorithm = "absolute",

41 - .next = NULL};

35 +static netdata_publish_syscall_t oomkill_publish_aggregated =

36 + {.name = "kills", .dimension = "kills", .algorithm = "absolute", .next = NULL};

38 static void ebpf_obsolete_specific_oomkill_charts(char *type, int update_every);

@@ -51,16 +46,17 @@ static void ebpf_obsolete_specific_oomkill_charts(char *type, int update_every);

46 */

47 static void ebpf_obsolete_oomkill_services(ebpf_module_t *em, char *id)

48 {

54 - ebpf_write_chart_obsolete(id,

55 - NETDATA_OOMKILL_CHART,

56 - "",

57 - "Systemd service OOM kills.",

58 - EBPF_OOMKILL_UNIT_KILLS,

59 - NETDATA_EBPF_MEMORY_GROUP,

60 - NETDATA_EBPF_CHART_TYPE_STACKED,

61 - NETDATA_CGROUP_OOMKILLS_CONTEXT,

62 - 20191,

63 - em->update_every);

49 + ebpf_write_chart_obsolete(

50 + id,

51 + NETDATA_OOMKILL_CHART,

52 + "",

53 + "Systemd service OOM kills.",

54 + EBPF_OOMKILL_UNIT_KILLS,

55 + NETDATA_EBPF_MEMORY_GROUP,

56 + NETDATA_EBPF_CHART_TYPE_STACKED,

57 + NETDATA_CGROUP_OOMKILLS_CONTEXT,

58 + 20191,

59 + em->update_every);

60 }

62 /**

@@ -75,7 +71,7 @@ static inline void ebpf_obsolete_oomkill_cgroup_charts(ebpf_module_t *em)

71 pthread_mutex_lock(&mutex_cgroup_shm);

73 ebpf_cgroup_target_t *ect;

78 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

74 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

75 if (ect->systemd) {

76 ebpf_obsolete_oomkill_services(em, ect->name);

@@ -100,21 +96,22 @@ static void ebpf_obsolete_oomkill_apps(ebpf_module_t *em)

96 int update_every = em->update_every;

97 pthread_mutex_lock(&collect_data_mutex);

98 for (w = apps_groups_root_target; w; w = w->next) {

103 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_OOMKILL_IDX))))

99 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_OOMKILL_IDX))))

100 continue;

101

106 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

107 - w->clean_name,

108 - NETDATA_OOMKILL_CHART,

109 - "Processes OOM kills.",

110 - EBPF_OOMKILL_UNIT_KILLS,

111 - NETDATA_EBPF_MEMORY_GROUP,

112 - NETDATA_EBPF_CHART_TYPE_STACKED,

113 - "ebpf.app_oomkill",

114 - 20072,

115 - update_every);

116 -

117 - w->charts_created &= ~(1<<EBPF_MODULE_OOMKILL_IDX);

102 + ebpf_write_chart_obsolete(

103 + NETDATA_APP_FAMILY,

104 + w->clean_name,

105 + NETDATA_OOMKILL_CHART,

106 + "Processes OOM kills.",

107 + EBPF_OOMKILL_UNIT_KILLS,

108 + NETDATA_EBPF_MEMORY_GROUP,

109 + NETDATA_EBPF_CHART_TYPE_STACKED,

110 + "ebpf.app_oomkill",

111 + 20072,

112 + update_every);

113 +

114 + w->charts_created &= ~(1 << EBPF_MODULE_OOMKILL_IDX);

115 }

116 pthread_mutex_unlock(&collect_data_mutex);

117 }

@@ -127,10 +124,11 @@ static void ebpf_obsolete_oomkill_apps(ebpf_module_t *em)

124 static void oomkill_cleanup(void *pptr)

125 {

126 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

130 - if(!em) return;

127 + if (!em)

128 + return;

129

130 pthread_mutex_lock(&lock);

133 - collect_pids &= ~(1<<EBPF_MODULE_OOMKILL_IDX);

131 + collect_pids &= ~(1 << EBPF_MODULE_OOMKILL_IDX);

132 pthread_mutex_unlock(&lock);

133

134 if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) {

@@ -187,7 +185,7 @@ static void oomkill_write_data(int32_t *keys, uint32_t total)

185 pids = pids->next;

186 }

187 }

190 -write_dim:

188 + write_dim:

189 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, NETDATA_OOMKILL_CHART);

190 write_chart_dimension(oomkill_publish_aggregated.dimension, was_oomkilled);

191 ebpf_write_end_chart();

@@ -218,12 +216,20 @@ write_dim:

216 */

217 static void ebpf_create_specific_oomkill_charts(char *type, int update_every)

218 {

221 - ebpf_create_chart(type, NETDATA_OOMKILL_CHART, "Cgroup OOM kills.",

222 - EBPF_OOMKILL_UNIT_KILLS, NETDATA_EBPF_MEMORY_GROUP,

223 - NETDATA_CGROUP_OOMKILLS_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

224 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5600,

225 - ebpf_create_global_dimension,

226 - &oomkill_publish_aggregated, 1, update_every, NETDATA_EBPF_MODULE_NAME_OOMKILL);

219 + ebpf_create_chart(

220 + type,

221 + NETDATA_OOMKILL_CHART,

222 + "Cgroup OOM kills.",

223 + EBPF_OOMKILL_UNIT_KILLS,

224 + NETDATA_EBPF_MEMORY_GROUP,

225 + NETDATA_CGROUP_OOMKILLS_CONTEXT,

226 + NETDATA_EBPF_CHART_TYPE_LINE,

227 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5600,

228 + ebpf_create_global_dimension,

229 + &oomkill_publish_aggregated,

230 + 1,

231 + update_every,

232 + NETDATA_EBPF_MODULE_NAME_OOMKILL);

233 }

234

235 /**

@@ -246,14 +252,13 @@ static void ebpf_create_systemd_oomkill_charts(int update_every)

252 .module = NETDATA_EBPF_MODULE_NAME_OOMKILL,

253 .update_every = 0,

254 .suffix = NETDATA_OOMKILL_CHART,

249 - .dimension = "kills"

250 - };

255 + .dimension = "kills"};

256

257 if (!data_oom.update_every)

258 data_oom.update_every = update_every;

259

260 ebpf_cgroup_target_t *w;

256 - for (w = ebpf_cgroup_pids; w ; w = w->next) {

261 + for (w = ebpf_cgroup_pids; w; w = w->next) {

262 if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_OOMKILL_CHART))

263 continue;

264

@@ -272,12 +277,12 @@ static void ebpf_create_systemd_oomkill_charts(int update_every)

277 static void ebpf_send_systemd_oomkill_charts()

278 {

279 ebpf_cgroup_target_t *ect;

275 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

276 - if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_OOMKILL_CHART)) ) {

280 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

281 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_OOMKILL_CHART))) {

282 continue;

283 }

279 - ebpf_write_begin_chart(ect->name, NETDATA_OOMKILL_CHART, "");

280 - write_chart_dimension(oomkill_publish_aggregated.dimension, (long long) ect->oomkill);

284 + ebpf_write_begin_chart(ect->name, NETDATA_OOMKILL_CHART, "");

285 + write_chart_dimension(oomkill_publish_aggregated.dimension, (long long)ect->oomkill);

286 ect->oomkill = 0;

287 ebpf_write_end_chart();

288 }

@@ -308,10 +313,17 @@ static void ebpf_send_specific_oomkill_data(char *type, int value)

313 */

314 static void ebpf_obsolete_specific_oomkill_charts(char *type, int update_every)

315 {

311 - ebpf_write_chart_obsolete(type, NETDATA_OOMKILL_CHART, "", "Cgroup OOM kills.",

312 - EBPF_OOMKILL_UNIT_KILLS, NETDATA_EBPF_MEMORY_GROUP,

313 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_OOMKILLS_CONTEXT,

314 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5600, update_every);

316 + ebpf_write_chart_obsolete(

317 + type,

318 + NETDATA_OOMKILL_CHART,

319 + "",

320 + "Cgroup OOM kills.",

321 + EBPF_OOMKILL_UNIT_KILLS,

322 + NETDATA_EBPF_MEMORY_GROUP,

323 + NETDATA_EBPF_CHART_TYPE_LINE,

324 + NETDATA_CGROUP_OOMKILLS_CONTEXT,

325 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5600,

326 + update_every);

327 }

328

329 /**

@@ -331,7 +343,7 @@ void ebpf_oomkill_send_cgroup_data(int update_every)

343 ebpf_send_systemd_oomkill_charts();

344 }

345

334 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

346 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

347 if (ect->systemd)

348 continue;

349

@@ -371,7 +383,7 @@ static uint32_t oomkill_read_data(int32_t *keys)

383 uint32_t curr_key = 0;

384 uint32_t key = 0;

385 int mapfd = oomkill_maps[OOMKILL_MAP_KILLCNT].map_fd;

374 - uint32_t limit = NETDATA_OOMKILL_MAX_ENTRIES -1;

386 + uint32_t limit = NETDATA_OOMKILL_MAX_ENTRIES - 1;

387 while (bpf_map_get_next_key(mapfd, &curr_key, &key) == 0) {

388 curr_key = key;

389

@@ -474,8 +486,8 @@ static void oomkill_collector(ebpf_module_t *em)

486

487 uint32_t count = oomkill_read_data(keys);

488

477 - stats[NETDATA_CONTROLLER_PID_TABLE_ADD] += (uint64_t) count;

478 - stats[NETDATA_CONTROLLER_PID_TABLE_DEL] += (uint64_t) count;

489 + stats[NETDATA_CONTROLLER_PID_TABLE_ADD] += (uint64_t)count;

490 + stats[NETDATA_CONTROLLER_PID_TABLE_DEL] += (uint64_t)count;

491

492 if (cgroups && shm_ebpf_cgroup.header)

493 ebpf_update_oomkill_cgroup(keys, count);

@@ -511,24 +523,27 @@ void ebpf_oomkill_create_apps_charts(struct ebpf_module *em, void *ptr)

523 if (unlikely(!w->exposed))

524 continue;

525

514 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

515 - w->clean_name,

516 - NETDATA_OOMKILL_CHART,

517 - "Processes OOM kills.",

518 - EBPF_OOMKILL_UNIT_KILLS,

519 - NETDATA_EBPF_MEMORY_GROUP,

520 - NETDATA_EBPF_CHART_TYPE_STACKED,

521 - "app.ebpf_oomkill",

522 - 20072,

523 - update_every,

524 - NETDATA_EBPF_MODULE_NAME_OOMKILL);

526 + ebpf_write_chart_cmd(

527 + NETDATA_APP_FAMILY,

528 + w->clean_name,

529 + NETDATA_OOMKILL_CHART,

530 + "Processes OOM kills.",

531 + EBPF_OOMKILL_UNIT_KILLS,

532 + NETDATA_EBPF_MEMORY_GROUP,

533 + NETDATA_EBPF_CHART_TYPE_STACKED,

534 + "app.ebpf_oomkill",

535 + 20072,

536 + update_every,

537 + NETDATA_EBPF_MODULE_NAME_OOMKILL);

538 ebpf_create_chart_labels("app_group", w->clean_name, RRDLABEL_SRC_AUTO);

539 ebpf_commit_label();

527 - fprintf(stdout, "DIMENSION '%s' '' %s 1 1\n",

528 - oomkill_publish_aggregated.dimension,

529 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

540 + fprintf(

541 + stdout,

542 + "DIMENSION '%s' '' %s 1 1\n",

543 + oomkill_publish_aggregated.dimension,

544 + ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);

545

531 - w->charts_created |= 1<<EBPF_MODULE_OOMKILL_IDX;

546 + w->charts_created |= 1 << EBPF_MODULE_OOMKILL_IDX;

547 }

548

549 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;

src/collectors/ebpf.plugin/ebpf_process.c

+531 -408

@@ -9,45 +9,52 @@

9 *

10 *****************************************************************/

12 -static char *process_dimension_names[NETDATA_KEY_PUBLISH_PROCESS_END] = { "process", "task", "process", "thread" };

13 -static char *process_id_names[NETDATA_KEY_PUBLISH_PROCESS_END] = { "do_exit", "release_task", "_do_fork", "sys_clone" };

14 -static char *status[] = { "process", "zombie" };

15 -

16 -static ebpf_local_maps_t process_maps[] = {{.name = "tbl_pid_stats", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

17 - .user_input = 0,

18 - .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

19 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

12 +static char *process_dimension_names[NETDATA_KEY_PUBLISH_PROCESS_END] = {"process", "task", "process", "thread"};

13 +static char *process_id_names[NETDATA_KEY_PUBLISH_PROCESS_END] = {"do_exit", "release_task", "_do_fork", "sys_clone"};

14 +static char *status[] = {"process", "zombie"};

15 +

16 +static ebpf_local_maps_t process_maps[] = {

17 + {.name = "tbl_pid_stats",

18 + .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

19 + .user_input = 0,

20 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

21 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

22 #ifdef LIBBPF_MAJOR_VERSION

21 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

23 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

24 #endif

23 - },

24 - {.name = "tbl_total_stats", .internal_input = NETDATA_KEY_END_VECTOR,

25 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

26 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

25 + },

26 + {.name = "tbl_total_stats",

27 + .internal_input = NETDATA_KEY_END_VECTOR,

28 + .user_input = 0,

29 + .type = NETDATA_EBPF_MAP_STATIC,

30 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

31 #ifdef LIBBPF_MAJOR_VERSION

28 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

32 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

33 #endif

30 - },

31 - {.name = "process_ctrl", .internal_input = NETDATA_CONTROLLER_END,

32 - .user_input = 0,

33 - .type = NETDATA_EBPF_MAP_CONTROLLER,

34 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

34 + },

35 + {.name = "process_ctrl",

36 + .internal_input = NETDATA_CONTROLLER_END,

37 + .user_input = 0,

38 + .type = NETDATA_EBPF_MAP_CONTROLLER,

39 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

40 #ifdef LIBBPF_MAJOR_VERSION

36 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

41 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

42 #endif

38 - },

39 - {.name = NULL, .internal_input = 0, .user_input = 0,

40 - .type = NETDATA_EBPF_MAP_CONTROLLER,

41 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

43 + },

44 + {.name = NULL,

45 + .internal_input = 0,

46 + .user_input = 0,

47 + .type = NETDATA_EBPF_MAP_CONTROLLER,

48 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

49 #ifdef LIBBPF_MAJOR_VERSION

43 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

50 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

51 #endif

45 - }};

52 + }};

47 -char *tracepoint_sched_type = { "sched" } ;

48 -char *tracepoint_sched_process_exit = { "sched_process_exit" };

49 -char *tracepoint_sched_process_exec = { "sched_process_exec" };

50 -char *tracepoint_sched_process_fork = { "sched_process_fork" };

54 +char *tracepoint_sched_type = {"sched"};

55 +char *tracepoint_sched_process_exit = {"sched_process_exit"};

56 +char *tracepoint_sched_process_exec = {"sched_process_exec"};

57 +char *tracepoint_sched_process_fork = {"sched_process_fork"};

58 static int was_sched_process_exit_enabled = 0;

59 static int was_sched_process_exec_enabled = 0;

60 static int was_sched_process_fork_enabled = 0;

@@ -72,8 +79,10 @@ struct config process_config = APPCONFIG_INITIALIZER;

79 * @param pvc the second output structure with correlated dimensions

80 * @param input the structure with the input data.

81 */

75 -static void ebpf_update_global_publish(netdata_publish_syscall_t *publish, netdata_publish_vfs_common_t *pvc,

76 - netdata_syscall_stat_t *input)

82 +static void ebpf_update_global_publish(

83 + netdata_publish_syscall_t *publish,

84 + netdata_publish_vfs_common_t *pvc,

85 + netdata_syscall_stat_t *input)

86 {

87 netdata_publish_syscall_t *move = publish;

88 int selector = NETDATA_KEY_PUBLISH_PROCESS_EXIT;

@@ -91,8 +100,8 @@ static void ebpf_update_global_publish(netdata_publish_syscall_t *publish, netda

100 selector++;

101 }

102

94 - pvc->running = (long)publish[NETDATA_KEY_PUBLISH_PROCESS_FORK].ncall -

95 - (long)publish[NETDATA_KEY_PUBLISH_PROCESS_CLONE].ncall;

103 + pvc->running =

104 + (long)publish[NETDATA_KEY_PUBLISH_PROCESS_FORK].ncall - (long)publish[NETDATA_KEY_PUBLISH_PROCESS_CLONE].ncall;

105 publish[NETDATA_KEY_PUBLISH_PROCESS_RELEASE_TASK].ncall = -publish[NETDATA_KEY_PUBLISH_PROCESS_RELEASE_TASK].ncall;

106 pvc->zombie = (long)publish[NETDATA_KEY_PUBLISH_PROCESS_EXIT].ncall +

107 (long)publish[NETDATA_KEY_PUBLISH_PROCESS_RELEASE_TASK].ncall;

@@ -124,15 +133,24 @@ static void ebpf_process_send_data(ebpf_module_t *em)

133 netdata_publish_vfs_common_t pvc;

134 ebpf_update_global_publish(process_publish_aggregated, &pvc, process_aggregated_data);

135

127 - write_count_chart(NETDATA_EXIT_SYSCALL, NETDATA_EBPF_SYSTEM_GROUP,

128 - &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT], 2);

129 - write_count_chart(NETDATA_PROCESS_SYSCALL, NETDATA_EBPF_SYSTEM_GROUP,

130 - &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK], 2);

136 + write_count_chart(

137 + NETDATA_EXIT_SYSCALL,

138 + NETDATA_EBPF_SYSTEM_GROUP,

139 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT],

140 + 2);

141 + write_count_chart(

142 + NETDATA_PROCESS_SYSCALL,

143 + NETDATA_EBPF_SYSTEM_GROUP,

144 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK],

145 + 2);

146

147 write_status_chart(NETDATA_EBPF_SYSTEM_GROUP, &pvc);

148 if (em->mode < MODE_ENTRY) {

134 - write_err_chart(NETDATA_PROCESS_ERROR_NAME, NETDATA_EBPF_SYSTEM_GROUP,

135 - &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK], 2);

149 + write_err_chart(

150 + NETDATA_PROCESS_ERROR_NAME,

151 + NETDATA_EBPF_SYSTEM_GROUP,

152 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK],

153 + 2);

154 }

155 }

156

@@ -146,7 +164,7 @@ void ebpf_process_send_apps_data(struct ebpf_target *root, ebpf_module_t *em)

164 struct ebpf_target *w;

165

166 for (w = root; w; w = w->next) {

149 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_PROCESS_IDX))))

167 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_PROCESS_IDX))))

168 continue;

169

170 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_process_start");

@@ -187,19 +205,21 @@ void ebpf_process_send_apps_data(struct ebpf_target *root, ebpf_module_t *em)

205 static void ebpf_read_process_hash_global_tables(netdata_idx_t *stats, int maps_per_core)

206 {

207 netdata_idx_t res[NETDATA_KEY_END_VECTOR];

190 - ebpf_read_global_table_stats(res,

191 - process_hash_values,

192 - process_maps[NETDATA_PROCESS_GLOBAL_TABLE].map_fd,

193 - maps_per_core,

194 - 0,

195 - NETDATA_KEY_END_VECTOR);

196 -

197 - ebpf_read_global_table_stats(stats,

198 - process_hash_values,

199 - process_maps[NETDATA_PROCESS_CTRL_TABLE].map_fd,

200 - maps_per_core,

201 - NETDATA_CONTROLLER_PID_TABLE_ADD,

202 - NETDATA_CONTROLLER_END);

208 + ebpf_read_global_table_stats(

209 + res,

210 + process_hash_values,

211 + process_maps[NETDATA_PROCESS_GLOBAL_TABLE].map_fd,

212 + maps_per_core,

213 + 0,

214 + NETDATA_KEY_END_VECTOR);

215 +

216 + ebpf_read_global_table_stats(

217 + stats,

218 + process_hash_values,

219 + process_maps[NETDATA_PROCESS_CTRL_TABLE].map_fd,

220 + maps_per_core,

221 + NETDATA_CONTROLLER_PID_TABLE_ADD,

222 + NETDATA_CONTROLLER_END);

223

224 process_aggregated_data[NETDATA_KEY_PUBLISH_PROCESS_EXIT].call = res[NETDATA_KEY_CALLS_DO_EXIT];

225 process_aggregated_data[NETDATA_KEY_PUBLISH_PROCESS_RELEASE_TASK].call = res[NETDATA_KEY_CALLS_RELEASE_TASK];

@@ -219,7 +239,7 @@ static void ebpf_read_process_hash_global_tables(netdata_idx_t *stats, int maps_

239 */

240 static void ebpf_update_process_cgroup()

241 {

222 - ebpf_cgroup_target_t *ect ;

242 + ebpf_cgroup_target_t *ect;

243 pthread_mutex_lock(&mutex_cgroup_shm);

244 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

245 struct pid_on_target2 *pids;

@@ -253,16 +273,17 @@ static void ebpf_update_process_cgroup()

273 * @param order the order number of the specified chart

274 * @param update_every value to overwrite the update frequency set by the server.

275 */

256 -static void ebpf_process_status_chart(char *family, char *name, char *axis,

257 - char *web, char *algorithm, int order, int update_every)

276 +static void

277 +ebpf_process_status_chart(char *family, char *name, char *axis, char *web, char *algorithm, int order, int update_every)

278 {

259 - printf("CHART %s.%s '' 'Process not closed' '%s' '%s' 'system.process_status' line %d %d '' 'ebpf.plugin' 'process'\n",

260 - family,

261 - name,

262 - axis,

263 - web,

264 - order,

265 - update_every);

279 + printf(

280 + "CHART %s.%s '' 'Process not closed' '%s' '%s' 'system.process_status' line %d %d '' 'ebpf.plugin' 'process'\n",

281 + family,

282 + name,

283 + axis,

284 + web,

285 + order,

286 + update_every);

287

288 printf("DIMENSION %s '' %s 1 1\n", status[0], algorithm);

289 printf("DIMENSION %s '' %s 1 1\n", status[1], algorithm);

@@ -277,49 +298,60 @@ static void ebpf_process_status_chart(char *family, char *name, char *axis,

298 */

299 static void ebpf_create_global_charts(ebpf_module_t *em)

300 {

280 - ebpf_create_chart(NETDATA_EBPF_SYSTEM_GROUP,

281 - NETDATA_PROCESS_SYSCALL,

282 - "Start process",

283 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

284 - NETDATA_PROCESS_GROUP,

285 - "system.process_thread",

286 - NETDATA_EBPF_CHART_TYPE_LINE,

287 - 21002,

288 - ebpf_create_global_dimension,

289 - &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK],

290 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);

291 -

292 - ebpf_create_chart(NETDATA_EBPF_SYSTEM_GROUP,

293 - NETDATA_EXIT_SYSCALL,

294 - "Exit process",

295 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

296 - NETDATA_PROCESS_GROUP,

297 - "system.exit",

298 - NETDATA_EBPF_CHART_TYPE_LINE,

299 - 21003,

300 - ebpf_create_global_dimension,

301 - &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT],

302 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);

303 -

304 - ebpf_process_status_chart(NETDATA_EBPF_SYSTEM_GROUP,

305 - NETDATA_PROCESS_STATUS_NAME,

306 - EBPF_COMMON_UNITS_CALLS,

307 - NETDATA_PROCESS_GROUP,

308 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],

309 - 21004, em->update_every);

301 + ebpf_create_chart(

302 + NETDATA_EBPF_SYSTEM_GROUP,

303 + NETDATA_PROCESS_SYSCALL,

304 + "Start process",

305 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

306 + NETDATA_PROCESS_GROUP,

307 + "system.process_thread",

308 + NETDATA_EBPF_CHART_TYPE_LINE,

309 + 21002,

310 + ebpf_create_global_dimension,

311 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK],

312 + 2,

313 + em->update_every,

314 + NETDATA_EBPF_MODULE_NAME_PROCESS);

315 +

316 + ebpf_create_chart(

317 + NETDATA_EBPF_SYSTEM_GROUP,

318 + NETDATA_EXIT_SYSCALL,

319 + "Exit process",

320 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

321 + NETDATA_PROCESS_GROUP,

322 + "system.exit",

323 + NETDATA_EBPF_CHART_TYPE_LINE,

324 + 21003,

325 + ebpf_create_global_dimension,

326 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT],

327 + 2,

328 + em->update_every,

329 + NETDATA_EBPF_MODULE_NAME_PROCESS);

330 +

331 + ebpf_process_status_chart(

332 + NETDATA_EBPF_SYSTEM_GROUP,

333 + NETDATA_PROCESS_STATUS_NAME,

334 + EBPF_COMMON_UNITS_CALLS,

335 + NETDATA_PROCESS_GROUP,

336 + ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],

337 + 21004,

338 + em->update_every);

339

340 if (em->mode < MODE_ENTRY) {

312 - ebpf_create_chart(NETDATA_EBPF_SYSTEM_GROUP,

313 - NETDATA_PROCESS_ERROR_NAME,

314 - "Fails to create process",

315 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

316 - NETDATA_PROCESS_GROUP,

317 - "system.task_error",

318 - NETDATA_EBPF_CHART_TYPE_LINE,

319 - 21005,

320 - ebpf_create_global_dimension,

321 - &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK],

322 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);

341 + ebpf_create_chart(

342 + NETDATA_EBPF_SYSTEM_GROUP,

343 + NETDATA_PROCESS_ERROR_NAME,

344 + "Fails to create process",

345 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

346 + NETDATA_PROCESS_GROUP,

347 + "system.task_error",

348 + NETDATA_EBPF_CHART_TYPE_LINE,

349 + 21005,

350 + ebpf_create_global_dimension,

351 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK],

352 + 2,

353 + em->update_every,

354 + NETDATA_EBPF_MODULE_NAME_PROCESS);

355 }

356

357 fflush(stdout);

@@ -342,83 +374,88 @@ void ebpf_process_create_apps_charts(struct ebpf_module *em, void *ptr)

374 if (unlikely(!w->exposed))

375 continue;

376

345 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

346 - w->clean_name,

347 - "_ebpf_process_start",

348 - "Process started.",

349 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

350 - NETDATA_PROCESS_GROUP,

351 - NETDATA_EBPF_CHART_TYPE_STACKED,

352 - "app.ebpf_process_start",

353 - 20161,

354 - update_every,

355 - NETDATA_EBPF_MODULE_NAME_PROCESS);

377 + ebpf_write_chart_cmd(

378 + NETDATA_APP_FAMILY,

379 + w->clean_name,

380 + "_ebpf_process_start",

381 + "Process started.",

382 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

383 + NETDATA_PROCESS_GROUP,

384 + NETDATA_EBPF_CHART_TYPE_STACKED,

385 + "app.ebpf_process_start",

386 + 20161,

387 + update_every,

388 + NETDATA_EBPF_MODULE_NAME_PROCESS);

389 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

390 ebpf_commit_label();

391 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

392

360 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

361 - w->clean_name,

362 - "_ebpf_thread_start",

363 - "Threads started.",

364 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

365 - NETDATA_PROCESS_GROUP,

366 - NETDATA_EBPF_CHART_TYPE_STACKED,

367 - "app.ebpf_thread_start",

368 - 20162,

369 - update_every,

370 - NETDATA_EBPF_MODULE_NAME_PROCESS);

393 + ebpf_write_chart_cmd(

394 + NETDATA_APP_FAMILY,

395 + w->clean_name,

396 + "_ebpf_thread_start",

397 + "Threads started.",

398 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

399 + NETDATA_PROCESS_GROUP,

400 + NETDATA_EBPF_CHART_TYPE_STACKED,

401 + "app.ebpf_thread_start",

402 + 20162,

403 + update_every,

404 + NETDATA_EBPF_MODULE_NAME_PROCESS);

405 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

406 ebpf_commit_label();

407 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

408

375 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

376 - w->clean_name,

377 - "_ebpf_task_exit",

378 - "Tasks starts exit process.",

379 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

380 - NETDATA_PROCESS_GROUP,

381 - NETDATA_EBPF_CHART_TYPE_STACKED,

382 - "app.ebpf_task_exit",

383 - 20163,

384 - update_every,

385 - NETDATA_EBPF_MODULE_NAME_PROCESS);

409 + ebpf_write_chart_cmd(

410 + NETDATA_APP_FAMILY,

411 + w->clean_name,

412 + "_ebpf_task_exit",

413 + "Tasks starts exit process.",

414 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

415 + NETDATA_PROCESS_GROUP,

416 + NETDATA_EBPF_CHART_TYPE_STACKED,

417 + "app.ebpf_task_exit",

418 + 20163,

419 + update_every,

420 + NETDATA_EBPF_MODULE_NAME_PROCESS);

421 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

422 ebpf_commit_label();

423 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

424

390 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

391 - w->clean_name,

392 - "_ebpf_task_released",

393 - "Tasks released.",

394 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

395 - NETDATA_PROCESS_GROUP,

396 - NETDATA_EBPF_CHART_TYPE_STACKED,

397 - "app.ebpf_task_released",

398 - 20164,

399 - update_every,

400 - NETDATA_EBPF_MODULE_NAME_PROCESS);

425 + ebpf_write_chart_cmd(

426 + NETDATA_APP_FAMILY,

427 + w->clean_name,

428 + "_ebpf_task_released",

429 + "Tasks released.",

430 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

431 + NETDATA_PROCESS_GROUP,

432 + NETDATA_EBPF_CHART_TYPE_STACKED,

433 + "app.ebpf_task_released",

434 + 20164,

435 + update_every,

436 + NETDATA_EBPF_MODULE_NAME_PROCESS);

437 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

438 ebpf_commit_label();

439 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

440

441 if (em->mode < MODE_ENTRY) {

406 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

407 - w->clean_name,

408 - "_ebpf_task_error",

409 - "Errors to create process or threads.",

410 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

411 - NETDATA_PROCESS_GROUP,

412 - NETDATA_EBPF_CHART_TYPE_STACKED,

413 - "app.ebpf_task_error",

414 - 20165,

415 - update_every,

416 - NETDATA_EBPF_MODULE_NAME_PROCESS);

442 + ebpf_write_chart_cmd(

443 + NETDATA_APP_FAMILY,

444 + w->clean_name,

445 + "_ebpf_task_error",

446 + "Errors to create process or threads.",

447 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

448 + NETDATA_PROCESS_GROUP,

449 + NETDATA_EBPF_CHART_TYPE_STACKED,

450 + "app.ebpf_task_error",

451 + 20165,

452 + update_every,

453 + NETDATA_EBPF_MODULE_NAME_PROCESS);

454 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

455 ebpf_commit_label();

456 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

457 }

421 - w->charts_created |= 1<<EBPF_MODULE_PROCESS_IDX;

458 + w->charts_created |= 1 << EBPF_MODULE_PROCESS_IDX;

459 }

460

461 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;

@@ -441,61 +478,66 @@ static void ebpf_obsolete_specific_process_charts(char *type, ebpf_module_t *em)

478 */

479 static void ebpf_obsolete_process_services(ebpf_module_t *em, char *id)

480 {

444 - ebpf_write_chart_obsolete(id,

445 - NETDATA_SYSCALL_APPS_TASK_PROCESS,

446 - "",

447 - "Process started",

448 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

449 - NETDATA_APPS_PROCESS_GROUP,

450 - NETDATA_EBPF_CHART_TYPE_STACKED,

451 - NETDATA_SYSTEMD_PROCESS_CREATE_CONTEXT,

452 - 20065,

453 - em->update_every);

454 -

455 - ebpf_write_chart_obsolete(id,

456 - NETDATA_SYSCALL_APPS_TASK_THREAD,

457 - "",

458 - "Threads started",

459 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

460 - NETDATA_APPS_PROCESS_GROUP,

461 - NETDATA_EBPF_CHART_TYPE_STACKED,

462 - NETDATA_SYSTEMD_THREAD_CREATE_CONTEXT,

463 - 20066,

464 - em->update_every);

465 -

466 - ebpf_write_chart_obsolete(id,

467 - NETDATA_SYSCALL_APPS_TASK_CLOSE,

468 - "",

469 - "Tasks starts exit process.",

470 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

471 - NETDATA_APPS_PROCESS_GROUP,

472 - NETDATA_EBPF_CHART_TYPE_STACKED,

473 - NETDATA_SYSTEMD_PROCESS_EXIT_CONTEXT,

474 - 20067,

475 - em->update_every);

476 -

477 - ebpf_write_chart_obsolete(id,

478 - NETDATA_SYSCALL_APPS_TASK_EXIT,

479 - "",

480 - "Tasks closed",

481 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

482 - NETDATA_APPS_PROCESS_GROUP,

483 - NETDATA_EBPF_CHART_TYPE_STACKED,

484 - NETDATA_SYSTEMD_PROCESS_CLOSE_CONTEXT,

485 - 20068,

486 - em->update_every);

481 + ebpf_write_chart_obsolete(

482 + id,

483 + NETDATA_SYSCALL_APPS_TASK_PROCESS,

484 + "",

485 + "Process started",

486 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

487 + NETDATA_APPS_PROCESS_GROUP,

488 + NETDATA_EBPF_CHART_TYPE_STACKED,

489 + NETDATA_SYSTEMD_PROCESS_CREATE_CONTEXT,

490 + 20065,

491 + em->update_every);

492 +

493 + ebpf_write_chart_obsolete(

494 + id,

495 + NETDATA_SYSCALL_APPS_TASK_THREAD,

496 + "",

497 + "Threads started",

498 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

499 + NETDATA_APPS_PROCESS_GROUP,

500 + NETDATA_EBPF_CHART_TYPE_STACKED,

501 + NETDATA_SYSTEMD_THREAD_CREATE_CONTEXT,

502 + 20066,

503 + em->update_every);

504 +

505 + ebpf_write_chart_obsolete(

506 + id,

507 + NETDATA_SYSCALL_APPS_TASK_CLOSE,

508 + "",

509 + "Tasks starts exit process.",

510 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

511 + NETDATA_APPS_PROCESS_GROUP,

512 + NETDATA_EBPF_CHART_TYPE_STACKED,

513 + NETDATA_SYSTEMD_PROCESS_EXIT_CONTEXT,

514 + 20067,

515 + em->update_every);

516 +

517 + ebpf_write_chart_obsolete(

518 + id,

519 + NETDATA_SYSCALL_APPS_TASK_EXIT,

520 + "",

521 + "Tasks closed",

522 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

523 + NETDATA_APPS_PROCESS_GROUP,

524 + NETDATA_EBPF_CHART_TYPE_STACKED,

525 + NETDATA_SYSTEMD_PROCESS_CLOSE_CONTEXT,

526 + 20068,

527 + em->update_every);

528

529 if (em->mode < MODE_ENTRY) {

489 - ebpf_write_chart_obsolete(id,

490 - NETDATA_SYSCALL_APPS_TASK_ERROR,

491 - "",

492 - "Errors to create process or threads.",

493 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

494 - NETDATA_APPS_PROCESS_GROUP,

495 - NETDATA_EBPF_CHART_TYPE_STACKED,

496 - NETDATA_SYSTEMD_PROCESS_ERROR_CONTEXT,

497 - 20069,

498 - em->update_every);

530 + ebpf_write_chart_obsolete(

531 + id,

532 + NETDATA_SYSCALL_APPS_TASK_ERROR,

533 + "",

534 + "Errors to create process or threads.",

535 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

536 + NETDATA_APPS_PROCESS_GROUP,

537 + NETDATA_EBPF_CHART_TYPE_STACKED,

538 + NETDATA_SYSTEMD_PROCESS_ERROR_CONTEXT,

539 + 20069,

540 + em->update_every);

541 }

542 }

543

@@ -506,11 +548,12 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em, char *id)

548 *

549 * @param em a pointer to `struct ebpf_module`

550 */

509 -static inline void ebpf_obsolete_process_cgroup_charts(ebpf_module_t *em) {

551 +static inline void ebpf_obsolete_process_cgroup_charts(ebpf_module_t *em)

552 +{

553 pthread_mutex_lock(&mutex_cgroup_shm);

554

555 ebpf_cgroup_target_t *ect;

513 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

556 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

557 if (ect->systemd) {

558 ebpf_obsolete_process_services(em, ect->name);

559

@@ -534,67 +577,72 @@ void ebpf_obsolete_process_apps_charts(struct ebpf_module *em)

577 struct ebpf_target *w;

578 int update_every = em->update_every;

579 for (w = apps_groups_root_target; w; w = w->next) {

537 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_PROCESS_IDX))))

580 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_PROCESS_IDX))))

581 continue;

582

540 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

541 - w->clean_name,

542 - "_ebpf_process_start",

543 - "Process started.",

544 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

545 - NETDATA_PROCESS_GROUP,

546 - NETDATA_EBPF_CHART_TYPE_STACKED,

547 - "app.ebpf_process_start",

548 - 20161,

549 - update_every);

550 -

551 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

552 - w->clean_name,

553 - "_ebpf_thread_start",

554 - "Threads started.",

555 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

556 - NETDATA_PROCESS_GROUP,

557 - NETDATA_EBPF_CHART_TYPE_STACKED,

558 - "app.ebpf_thread_start",

559 - 20162,

560 - update_every);

561 -

562 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

563 - w->clean_name,

564 - "_ebpf_task_exit",

565 - "Tasks starts exit process.",

566 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

567 - NETDATA_PROCESS_GROUP,

568 - NETDATA_EBPF_CHART_TYPE_STACKED,

569 - "app.ebpf_task_exit",

570 - 20163,

571 - update_every);

572 -

573 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

574 - w->clean_name,

575 - "_ebpf_task_released",

576 - "Tasks released.",

577 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

578 - NETDATA_PROCESS_GROUP,

579 - NETDATA_EBPF_CHART_TYPE_STACKED,

580 - "app.ebpf_task_released",

581 - 20164,

582 - update_every);

583 + ebpf_write_chart_obsolete(

584 + NETDATA_APP_FAMILY,

585 + w->clean_name,

586 + "_ebpf_process_start",

587 + "Process started.",

588 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

589 + NETDATA_PROCESS_GROUP,

590 + NETDATA_EBPF_CHART_TYPE_STACKED,

591 + "app.ebpf_process_start",

592 + 20161,

593 + update_every);

594 +

595 + ebpf_write_chart_obsolete(

596 + NETDATA_APP_FAMILY,

597 + w->clean_name,

598 + "_ebpf_thread_start",

599 + "Threads started.",

600 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

601 + NETDATA_PROCESS_GROUP,

602 + NETDATA_EBPF_CHART_TYPE_STACKED,

603 + "app.ebpf_thread_start",

604 + 20162,

605 + update_every);

606 +

607 + ebpf_write_chart_obsolete(

608 + NETDATA_APP_FAMILY,

609 + w->clean_name,

610 + "_ebpf_task_exit",

611 + "Tasks starts exit process.",

612 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

613 + NETDATA_PROCESS_GROUP,

614 + NETDATA_EBPF_CHART_TYPE_STACKED,

615 + "app.ebpf_task_exit",

616 + 20163,

617 + update_every);

618 +

619 + ebpf_write_chart_obsolete(

620 + NETDATA_APP_FAMILY,

621 + w->clean_name,

622 + "_ebpf_task_released",

623 + "Tasks released.",

624 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

625 + NETDATA_PROCESS_GROUP,

626 + NETDATA_EBPF_CHART_TYPE_STACKED,

627 + "app.ebpf_task_released",

628 + 20164,

629 + update_every);

630

631 if (em->mode < MODE_ENTRY) {

585 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

586 - w->clean_name,

587 - "_ebpf_task_error",

588 - "Errors to create process or threads.",

589 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

590 - NETDATA_PROCESS_GROUP,

591 - NETDATA_EBPF_CHART_TYPE_STACKED,

592 - "app.ebpf_task_error",

593 - 20165,

594 - update_every);

632 + ebpf_write_chart_obsolete(

633 + NETDATA_APP_FAMILY,

634 + w->clean_name,

635 + "_ebpf_task_error",

636 + "Errors to create process or threads.",

637 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

638 + NETDATA_PROCESS_GROUP,

639 + NETDATA_EBPF_CHART_TYPE_STACKED,

640 + "app.ebpf_task_error",

641 + 20165,

642 + update_every);

643 }

644

597 - w->charts_created &= ~(1<<EBPF_MODULE_PROCESS_IDX);

645 + w->charts_created &= ~(1 << EBPF_MODULE_PROCESS_IDX);

646 }

647 }

648

@@ -607,50 +655,54 @@ void ebpf_obsolete_process_apps_charts(struct ebpf_module *em)

655 */

656 static void ebpf_obsolete_process_global(ebpf_module_t *em)

657 {

610 - ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,

611 - NETDATA_PROCESS_SYSCALL,

612 - "",

613 - "Start process",

614 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

615 - NETDATA_PROCESS_GROUP,

616 - NETDATA_EBPF_CHART_TYPE_LINE,

617 - "system.process_thread",

618 - 21002,

619 - em->update_every);

620 -

621 - ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,

622 - NETDATA_EXIT_SYSCALL,

623 - "",

624 - "Exit process",

625 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

626 - NETDATA_PROCESS_GROUP,

627 - NETDATA_EBPF_CHART_TYPE_LINE,

628 - "system.exit",

629 - 21003,

630 - em->update_every);

631 -

632 - ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,

633 - NETDATA_PROCESS_STATUS_NAME,

634 - "",

635 - "Process not closed",

636 - EBPF_COMMON_UNITS_CALLS,

637 - NETDATA_PROCESS_GROUP,

638 - NETDATA_EBPF_CHART_TYPE_LINE,

639 - "system.process_status",

640 - 21004,

641 - em->update_every);

658 + ebpf_write_chart_obsolete(

659 + NETDATA_EBPF_SYSTEM_GROUP,

660 + NETDATA_PROCESS_SYSCALL,

661 + "",

662 + "Start process",

663 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

664 + NETDATA_PROCESS_GROUP,

665 + NETDATA_EBPF_CHART_TYPE_LINE,

666 + "system.process_thread",

667 + 21002,

668 + em->update_every);

669 +

670 + ebpf_write_chart_obsolete(

671 + NETDATA_EBPF_SYSTEM_GROUP,

672 + NETDATA_EXIT_SYSCALL,

673 + "",

674 + "Exit process",

675 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

676 + NETDATA_PROCESS_GROUP,

677 + NETDATA_EBPF_CHART_TYPE_LINE,

678 + "system.exit",

679 + 21003,

680 + em->update_every);

681 +

682 + ebpf_write_chart_obsolete(

683 + NETDATA_EBPF_SYSTEM_GROUP,

684 + NETDATA_PROCESS_STATUS_NAME,

685 + "",

686 + "Process not closed",

687 + EBPF_COMMON_UNITS_CALLS,

688 + NETDATA_PROCESS_GROUP,

689 + NETDATA_EBPF_CHART_TYPE_LINE,

690 + "system.process_status",

691 + 21004,

692 + em->update_every);

693

694 if (em->mode < MODE_ENTRY) {

644 - ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,

645 - NETDATA_PROCESS_ERROR_NAME,

646 - "",

647 - "Fails to create process",

648 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

649 - NETDATA_PROCESS_GROUP,

650 - NETDATA_EBPF_CHART_TYPE_LINE,

651 - "system.task_error",

652 - 21005,

653 - em->update_every);

695 + ebpf_write_chart_obsolete(

696 + NETDATA_EBPF_SYSTEM_GROUP,

697 + NETDATA_PROCESS_ERROR_NAME,

698 + "",

699 + "Fails to create process",

700 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

701 + NETDATA_PROCESS_GROUP,

702 + NETDATA_EBPF_CHART_TYPE_LINE,

703 + "system.task_error",

704 + 21005,

705 + em->update_every);

706 }

707 }

708

@@ -661,7 +713,7 @@ static void ebpf_obsolete_process_global(ebpf_module_t *em)

713 */

714 static void ebpf_process_disable_tracepoints()

715 {

664 - char *default_message = { "Cannot disable the tracepoint" };

716 + char *default_message = {"Cannot disable the tracepoint"};

717 if (!was_sched_process_exit_enabled) {

718 if (ebpf_disable_tracing_values(tracepoint_sched_type, tracepoint_sched_process_exit))

719 netdata_log_error("%s %s/%s.", default_message, tracepoint_sched_type, tracepoint_sched_process_exit);

@@ -689,10 +741,11 @@ static void ebpf_process_exit(void *pptr)

741 {

742 pids_fd[NETDATA_EBPF_PIDS_PROCESS_IDX] = -1;

743 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

692 - if(!em) return;

744 + if (!em)

745 + return;

746

747 pthread_mutex_lock(&lock);

695 - collect_pids &= ~(1<<EBPF_MODULE_PROCESS_IDX);

748 + collect_pids &= ~(1 << EBPF_MODULE_PROCESS_IDX);

749 pthread_mutex_unlock(&lock);

750

751 if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) {

@@ -738,7 +791,6 @@ static void ebpf_process_exit(void *pptr)

791 *

792 *****************************************************************/

793

741 -

794 /**

795 * Sum PIDs

796 *

@@ -767,8 +819,10 @@ static void ebpf_process_sum_cgroup_pids(ebpf_publish_process_t *ps, struct pid_

819

820 ps->exit_call = (accumulator.exit_call >= ps->exit_call) ? accumulator.exit_call : ps->exit_call;

821 ps->release_call = (accumulator.release_call >= ps->release_call) ? accumulator.release_call : ps->release_call;

770 - ps->create_process = (accumulator.create_process >= ps->create_process) ? accumulator.create_process : ps->create_process;

771 - ps->create_thread = (accumulator.create_thread >= ps->create_thread) ? accumulator.create_thread : ps->create_thread;

822 + ps->create_process =

823 + (accumulator.create_process >= ps->create_process) ? accumulator.create_process : ps->create_process;

824 + ps->create_thread =

825 + (accumulator.create_thread >= ps->create_thread) ? accumulator.create_thread : ps->create_thread;

826

827 ps->task_err = (accumulator.task_err >= ps->task_err) ? accumulator.task_err : ps->task_err;

828 }

@@ -785,29 +839,29 @@ static void ebpf_process_sum_cgroup_pids(ebpf_publish_process_t *ps, struct pid_

839 static void ebpf_send_specific_process_data(char *type, ebpf_publish_process_t *values, ebpf_module_t *em)

840 {

841 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_PROCESS, "");

788 - write_chart_dimension(process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK].name,

789 - (long long) values->create_process);

842 + write_chart_dimension(

843 + process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK].name, (long long)values->create_process);

844 ebpf_write_end_chart();

845

846 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_THREAD, "");

793 - write_chart_dimension(process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_CLONE].name,

794 - (long long) values->create_thread);

847 + write_chart_dimension(

848 + process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_CLONE].name, (long long)values->create_thread);

849 ebpf_write_end_chart();

850

851 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_EXIT, "");

798 - write_chart_dimension(process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT].name,

799 - (long long) values->release_call);

852 + write_chart_dimension(

853 + process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT].name, (long long)values->release_call);

854 ebpf_write_end_chart();

855

856 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_CLOSE, "");

803 - write_chart_dimension(process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_RELEASE_TASK].name,

804 - (long long) values->release_call);

857 + write_chart_dimension(

858 + process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_RELEASE_TASK].name, (long long)values->release_call);

859 ebpf_write_end_chart();

860

861 if (em->mode < MODE_ENTRY) {

862 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_ERROR, "");

809 - write_chart_dimension(process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT].name,

810 - (long long) values->task_err);

863 + write_chart_dimension(

864 + process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT].name, (long long)values->task_err);

865 ebpf_write_end_chart();

866 }

867 }

@@ -823,53 +877,89 @@ static void ebpf_send_specific_process_data(char *type, ebpf_publish_process_t *

877 static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em)

878 {

879 char *label = (!strncmp(type, "cgroup_", 7)) ? &type[7] : type;

826 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_PROCESS, "Process started",

827 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_PROCESS_GROUP,

828 - NETDATA_CGROUP_PROCESS_CREATE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

829 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5000,

830 - ebpf_create_global_dimension, &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK],

831 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);

880 + ebpf_create_chart(

881 + type,

882 + NETDATA_SYSCALL_APPS_TASK_PROCESS,

883 + "Process started",

884 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

885 + NETDATA_PROCESS_GROUP,

886 + NETDATA_CGROUP_PROCESS_CREATE_CONTEXT,

887 + NETDATA_EBPF_CHART_TYPE_LINE,

888 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5000,

889 + ebpf_create_global_dimension,

890 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK],

891 + 1,

892 + em->update_every,

893 + NETDATA_EBPF_MODULE_NAME_PROCESS);

894 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

895 ebpf_commit_label();

896

835 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_THREAD, "Threads started",

836 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_PROCESS_GROUP,

837 - NETDATA_CGROUP_THREAD_CREATE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

838 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5001,

839 - ebpf_create_global_dimension,

840 - &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_CLONE],

841 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);

897 + ebpf_create_chart(

898 + type,

899 + NETDATA_SYSCALL_APPS_TASK_THREAD,

900 + "Threads started",

901 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

902 + NETDATA_PROCESS_GROUP,

903 + NETDATA_CGROUP_THREAD_CREATE_CONTEXT,

904 + NETDATA_EBPF_CHART_TYPE_LINE,

905 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5001,

906 + ebpf_create_global_dimension,

907 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_CLONE],

908 + 1,

909 + em->update_every,

910 + NETDATA_EBPF_MODULE_NAME_PROCESS);

911 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

912 ebpf_commit_label();

913

845 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_EXIT, "Tasks starts exit process.",

846 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_PROCESS_GROUP,

847 - NETDATA_CGROUP_PROCESS_EXIT_CONTEXT,

848 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5002,

849 - ebpf_create_global_dimension,

850 - &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT],

851 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);

914 + ebpf_create_chart(

915 + type,

916 + NETDATA_SYSCALL_APPS_TASK_EXIT,

917 + "Tasks starts exit process.",

918 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

919 + NETDATA_PROCESS_GROUP,

920 + NETDATA_CGROUP_PROCESS_EXIT_CONTEXT,

921 + NETDATA_EBPF_CHART_TYPE_LINE,

922 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5002,

923 + ebpf_create_global_dimension,

924 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT],

925 + 1,

926 + em->update_every,

927 + NETDATA_EBPF_MODULE_NAME_PROCESS);

928 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

929 ebpf_commit_label();

930

855 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_CLOSE, "Tasks closed",

856 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_PROCESS_GROUP,

857 - NETDATA_CGROUP_PROCESS_CLOSE_CONTEXT,

858 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5003,

859 - ebpf_create_global_dimension,

860 - &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_RELEASE_TASK],

861 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);

931 + ebpf_create_chart(

932 + type,

933 + NETDATA_SYSCALL_APPS_TASK_CLOSE,

934 + "Tasks closed",

935 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

936 + NETDATA_PROCESS_GROUP,

937 + NETDATA_CGROUP_PROCESS_CLOSE_CONTEXT,

938 + NETDATA_EBPF_CHART_TYPE_LINE,

939 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5003,

940 + ebpf_create_global_dimension,

941 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_RELEASE_TASK],

942 + 1,

943 + em->update_every,

944 + NETDATA_EBPF_MODULE_NAME_PROCESS);

945 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

946 ebpf_commit_label();

947

948 if (em->mode < MODE_ENTRY) {

866 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_TASK_ERROR, "Errors to create process or threads.",

867 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_PROCESS_GROUP,

868 - NETDATA_CGROUP_PROCESS_ERROR_CONTEXT,

869 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5004,

870 - ebpf_create_global_dimension,

871 - &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT],

872 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);

949 + ebpf_create_chart(

950 + type,

951 + NETDATA_SYSCALL_APPS_TASK_ERROR,

952 + "Errors to create process or threads.",

953 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

954 + NETDATA_PROCESS_GROUP,

955 + NETDATA_CGROUP_PROCESS_ERROR_CONTEXT,

956 + NETDATA_EBPF_CHART_TYPE_LINE,

957 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5004,

958 + ebpf_create_global_dimension,

959 + &process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT],

960 + 1,

961 + em->update_every,

962 + NETDATA_EBPF_MODULE_NAME_PROCESS);

963 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

964 ebpf_commit_label();

965 }

@@ -885,31 +975,66 @@ static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em)

975 */

976 static void ebpf_obsolete_specific_process_charts(char *type, ebpf_module_t *em)

977 {

888 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_PROCESS, "", "Process started",

889 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_PROCESS_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,

890 - NETDATA_CGROUP_PROCESS_CREATE_CONTEXT, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5000,

891 - em->update_every);

892 -

893 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_THREAD, "", "Threads started",

894 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_PROCESS_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,

895 - NETDATA_CGROUP_THREAD_CREATE_CONTEXT, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5001,

896 - em->update_every);

897 -

898 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_EXIT, "","Tasks starts exit process.",

899 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_PROCESS_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,

900 - NETDATA_CGROUP_PROCESS_EXIT_CONTEXT, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5002,

901 - em->update_every);

902 -

903 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_CLOSE, "","Tasks closed",

904 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_PROCESS_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,

905 - NETDATA_CGROUP_PROCESS_CLOSE_CONTEXT, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5003,

906 - em->update_every);

978 + ebpf_write_chart_obsolete(

979 + type,

980 + NETDATA_SYSCALL_APPS_TASK_PROCESS,

981 + "",

982 + "Process started",

983 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

984 + NETDATA_PROCESS_GROUP,

985 + NETDATA_EBPF_CHART_TYPE_LINE,

986 + NETDATA_CGROUP_PROCESS_CREATE_CONTEXT,

987 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5000,

988 + em->update_every);

989 +

990 + ebpf_write_chart_obsolete(

991 + type,

992 + NETDATA_SYSCALL_APPS_TASK_THREAD,

993 + "",

994 + "Threads started",

995 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

996 + NETDATA_PROCESS_GROUP,

997 + NETDATA_EBPF_CHART_TYPE_LINE,

998 + NETDATA_CGROUP_THREAD_CREATE_CONTEXT,

999 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5001,

1000 + em->update_every);

1001 +

1002 + ebpf_write_chart_obsolete(

1003 + type,

1004 + NETDATA_SYSCALL_APPS_TASK_EXIT,

1005 + "",

1006 + "Tasks starts exit process.",

1007 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1008 + NETDATA_PROCESS_GROUP,

1009 + NETDATA_EBPF_CHART_TYPE_LINE,

1010 + NETDATA_CGROUP_PROCESS_EXIT_CONTEXT,

1011 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5002,

1012 + em->update_every);

1013 +

1014 + ebpf_write_chart_obsolete(

1015 + type,

1016 + NETDATA_SYSCALL_APPS_TASK_CLOSE,

1017 + "",

1018 + "Tasks closed",

1019 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1020 + NETDATA_PROCESS_GROUP,

1021 + NETDATA_EBPF_CHART_TYPE_LINE,

1022 + NETDATA_CGROUP_PROCESS_CLOSE_CONTEXT,

1023 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5003,

1024 + em->update_every);

1025

1026 if (em->mode < MODE_ENTRY) {

909 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_ERROR, "","Errors to create process or threads.",

910 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_PROCESS_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,

911 - NETDATA_CGROUP_PROCESS_ERROR_CONTEXT, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5004,

912 - em->update_every);

1027 + ebpf_write_chart_obsolete(

1028 + type,

1029 + NETDATA_SYSCALL_APPS_TASK_ERROR,

1030 + "",

1031 + "Errors to create process or threads.",

1032 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1033 + NETDATA_PROCESS_GROUP,

1034 + NETDATA_EBPF_CHART_TYPE_LINE,

1035 + NETDATA_CGROUP_PROCESS_ERROR_CONTEXT,

1036 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5004,

1037 + em->update_every);

1038 }

1039 }

1040

@@ -933,8 +1058,7 @@ static void ebpf_create_systemd_process_charts(ebpf_module_t *em)

1058 .module = NETDATA_EBPF_MODULE_NAME_PROCESS,

1059 .update_every = 0,

1060 .suffix = NETDATA_SYSCALL_APPS_TASK_PROCESS,

936 - .dimension = "calls"

937 - };

1061 + .dimension = "calls"};

1062

1063 static ebpf_systemd_args_t data_thread = {

1064 .title = "Threads started",

@@ -947,8 +1071,7 @@ static void ebpf_create_systemd_process_charts(ebpf_module_t *em)

1071 .module = NETDATA_EBPF_MODULE_NAME_PROCESS,

1072 .update_every = 0,

1073 .suffix = NETDATA_SYSCALL_APPS_TASK_THREAD,

950 - .dimension = "calls"

951 - };

1074 + .dimension = "calls"};

1075

1076 static ebpf_systemd_args_t task_exit = {

1077 .title = "Tasks starts exit process.",

@@ -961,8 +1084,7 @@ static void ebpf_create_systemd_process_charts(ebpf_module_t *em)

1084 .module = NETDATA_EBPF_MODULE_NAME_PROCESS,

1085 .update_every = 0,

1086 .suffix = NETDATA_SYSCALL_APPS_TASK_CLOSE,

964 - .dimension = "calls"

965 - };

1087 + .dimension = "calls"};

1088

1089 static ebpf_systemd_args_t task_closed = {

1090 .title = "Tasks closed",

@@ -975,8 +1097,7 @@ static void ebpf_create_systemd_process_charts(ebpf_module_t *em)

1097 .module = NETDATA_EBPF_MODULE_NAME_PROCESS,

1098 .update_every = 0,

1099 .suffix = NETDATA_SYSCALL_APPS_TASK_EXIT,

978 - .dimension = "calls"

979 - };

1100 + .dimension = "calls"};

1101

1102 static ebpf_systemd_args_t task_error = {

1103 .title = "Errors to create process or threads.",

@@ -989,14 +1110,13 @@ static void ebpf_create_systemd_process_charts(ebpf_module_t *em)

1110 .module = NETDATA_EBPF_MODULE_NAME_PROCESS,

1111 .update_every = 0,

1112 .suffix = NETDATA_SYSCALL_APPS_TASK_ERROR,

992 - .dimension = "calls"

993 - };

1113 + .dimension = "calls"};

1114

1115 ebpf_cgroup_target_t *w;

1116 netdata_run_mode_t mode = em->mode;

1117 if (!task_exit.update_every)

998 - data_process.update_every = data_thread.update_every = task_exit.update_every =

999 - task_closed.update_every = task_error.update_every = em->update_every;

1118 + data_process.update_every = data_thread.update_every = task_exit.update_every = task_closed.update_every =

1119 + task_error.update_every = em->update_every;

1120

1121 for (w = ebpf_cgroup_pids; w; w = w->next) {

1122 if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART))

@@ -1027,8 +1147,8 @@ static void ebpf_create_systemd_process_charts(ebpf_module_t *em)

1147 static void ebpf_send_systemd_process_charts(ebpf_module_t *em)

1148 {

1149 ebpf_cgroup_target_t *ect;

1030 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1031 - if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART)) ) {

1150 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1151 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_PROCESS_CHART))) {

1152 continue;

1153 }

1154

@@ -1065,7 +1185,7 @@ static void ebpf_process_send_cgroup_data(ebpf_module_t *em)

1185 {

1186 pthread_mutex_lock(&mutex_cgroup_shm);

1187 ebpf_cgroup_target_t *ect;

1068 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1188 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1189 ebpf_process_sum_cgroup_pids(&ect->publish_systemd_ps, ect->pids);

1190 }

1191

@@ -1077,7 +1197,7 @@ static void ebpf_process_send_cgroup_data(ebpf_module_t *em)

1197 ebpf_send_systemd_process_charts(em);

1198 }

1199

1080 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1200 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1201 if (ect->systemd)

1202 continue;

1203

@@ -1107,7 +1227,7 @@ static void ebpf_process_send_cgroup_data(ebpf_module_t *em)

1227 void ebpf_process_update_cgroup_algorithm()

1228 {

1229 int i;

1110 - for (i = 0; i < NETDATA_KEY_PUBLISH_PROCESS_END; i++) {

1230 + for (i = 0; i < NETDATA_KEY_PUBLISH_PROCESS_END; i++) {

1231 netdata_publish_syscall_t *ptr = &process_publish_aggregated[i];

1232 ptr->algorithm = ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX];

1233 }

@@ -1211,7 +1331,7 @@ static void ebpf_process_allocate_global_vectors(size_t length)

1331

1332 static void change_syscalls()

1333 {

1214 - static char *lfork = { "do_fork" };

1334 + static char *lfork = {"do_fork"};

1335 process_id_names[NETDATA_KEY_PUBLISH_PROCESS_FORK] = lfork;

1336 }

1337

@@ -1305,12 +1425,15 @@ void *ebpf_process_thread(void *ptr)

1425 }

1426

1427 int algorithms[NETDATA_KEY_PUBLISH_PROCESS_END] = {

1308 - NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX

1309 - };

1428 + NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX};

1429

1430 ebpf_global_labels(

1312 - process_aggregated_data, process_publish_aggregated, process_dimension_names, process_id_names,

1313 - algorithms, NETDATA_KEY_PUBLISH_PROCESS_END);

1431 + process_aggregated_data,

1432 + process_publish_aggregated,

1433 + process_dimension_names,

1434 + process_id_names,

1435 + algorithms,

1436 + NETDATA_KEY_PUBLISH_PROCESS_END);

1437

1438 ebpf_create_global_charts(em);

1439

src/collectors/ebpf.plugin/ebpf_process.h

+6 -9

@@ -5,7 +5,8 @@

6 // Module name & description

7 #define NETDATA_EBPF_MODULE_NAME_PROCESS "process"

8 -#define NETDATA_EBPF_MODULE_PROCESS_DESC "Monitor information about process life. This thread is integrated with apps and cgroup."

8 +#define NETDATA_EBPF_MODULE_PROCESS_DESC \

9 + "Monitor information about process life. This thread is integrated with apps and cgroup."

11 // Groups used on Dashboard

12 #define NETDATA_PROCESS_GROUP "processes"

@@ -56,14 +57,14 @@ enum netdata_ebpf_stats_order {

57 NETDATA_EBPF_ORDER_FUNCTION_PER_THREAD,

58 };

59 -enum netdata_ebpf_load_mode_stats{

60 +enum netdata_ebpf_load_mode_stats {

61 NETDATA_EBPF_LOAD_STAT_LEGACY,

62 NETDATA_EBPF_LOAD_STAT_CORE,

64 NETDATA_EBPF_LOAD_STAT_END

65 };

66 -enum netdata_ebpf_thread_per_core{

67 +enum netdata_ebpf_thread_per_core {

68 NETDATA_EBPF_THREAD_PER_CORE,

69 NETDATA_EBPF_THREAD_UNIQUE,

@@ -89,7 +90,7 @@ typedef enum ebpf_process_index {

90 // Do not change the enum order because we use

91 // different algorithms to make charts with incremental

92 // values (the three initial positions) and absolute values

92 -// (the remaining charts).

93 +// (the remaining charts).

94 typedef enum netdata_publish_process {

95 NETDATA_KEY_PUBLISH_PROCESS_EXIT,

96 NETDATA_KEY_PUBLISH_PROCESS_RELEASE_TASK,

@@ -99,11 +100,7 @@ typedef enum netdata_publish_process {

100 NETDATA_KEY_PUBLISH_PROCESS_END

101 } netdata_publish_process_t;

102

102 -enum ebpf_process_tables {

103 - NETDATA_PROCESS_PID_TABLE,

104 - NETDATA_PROCESS_GLOBAL_TABLE,

105 - NETDATA_PROCESS_CTRL_TABLE

106 -};

103 +enum ebpf_process_tables { NETDATA_PROCESS_PID_TABLE, NETDATA_PROCESS_GLOBAL_TABLE, NETDATA_PROCESS_CTRL_TABLE };

104

105 extern struct config process_config;

106

src/collectors/ebpf.plugin/ebpf_shm.c

+372 -349

@@ -3,7 +3,7 @@

3 #include "ebpf.h"

4 #include "ebpf_shm.h"

6 -static char *shm_dimension_name[NETDATA_SHM_END] = { "get", "at", "dt", "ctl" };

6 +static char *shm_dimension_name[NETDATA_SHM_END] = {"get", "at", "dt", "ctl"};

7 static netdata_syscall_stat_t shm_aggregated_data[NETDATA_SHM_END];

8 static netdata_publish_syscall_t shm_publish_aggregated[NETDATA_SHM_END];

@@ -14,37 +14,42 @@ static netdata_idx_t *shm_values = NULL;

15 struct config shm_config = APPCONFIG_INITIALIZER;

17 -static ebpf_local_maps_t shm_maps[] = {{.name = "tbl_pid_shm", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

18 - .user_input = 0,

19 - .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

20 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

17 +static ebpf_local_maps_t shm_maps[] = {

18 + {.name = "tbl_pid_shm",

19 + .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

20 + .user_input = 0,

21 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

22 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

23 #ifdef LIBBPF_MAJOR_VERSION

22 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

24 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

25 #endif

24 - },

25 - {.name = "shm_ctrl", .internal_input = NETDATA_CONTROLLER_END,

26 - .user_input = 0,

27 - .type = NETDATA_EBPF_MAP_CONTROLLER,

28 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

26 + },

27 + {.name = "shm_ctrl",

28 + .internal_input = NETDATA_CONTROLLER_END,

29 + .user_input = 0,

30 + .type = NETDATA_EBPF_MAP_CONTROLLER,

31 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

32 #ifdef LIBBPF_MAJOR_VERSION

30 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

33 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

34 #endif

32 - },

33 - {.name = "tbl_shm", .internal_input = NETDATA_SHM_END,

34 - .user_input = 0,

35 - .type = NETDATA_EBPF_MAP_STATIC,

36 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

35 + },

36 + {.name = "tbl_shm",

37 + .internal_input = NETDATA_SHM_END,

38 + .user_input = 0,

39 + .type = NETDATA_EBPF_MAP_STATIC,

40 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

41 #ifdef LIBBPF_MAJOR_VERSION

38 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

42 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

43 #endif

40 - },

41 - {.name = NULL, .internal_input = 0, .user_input = 0}};

44 + },

45 + {.name = NULL, .internal_input = 0, .user_input = 0}};

43 -netdata_ebpf_targets_t shm_targets[] = { {.name = "shmget", .mode = EBPF_LOAD_TRAMPOLINE},

44 - {.name = "shmat", .mode = EBPF_LOAD_TRAMPOLINE},

45 - {.name = "shmdt", .mode = EBPF_LOAD_TRAMPOLINE},

46 - {.name = "shmctl", .mode = EBPF_LOAD_TRAMPOLINE},

47 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

47 +netdata_ebpf_targets_t shm_targets[] = {

48 + {.name = "shmget", .mode = EBPF_LOAD_TRAMPOLINE},

49 + {.name = "shmat", .mode = EBPF_LOAD_TRAMPOLINE},

50 + {.name = "shmdt", .mode = EBPF_LOAD_TRAMPOLINE},

51 + {.name = "shmctl", .mode = EBPF_LOAD_TRAMPOLINE},

52 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

54 #ifdef NETDATA_DEV_MODE

55 int shm_disable_priority;

@@ -58,8 +63,7 @@ struct netdata_static_thread ebpf_read_shm = {

63 .enabled = 1,

64 .thread = NULL,

65 .init_routine = NULL,

61 - .start_routine = NULL

62 -};

66 + .start_routine = NULL};

68 #ifdef LIBBPF_MAJOR_VERSION

69 /*****************************************************************

@@ -123,26 +127,22 @@ static void ebpf_disable_trampoline(struct shm_bpf *obj)

127 static void ebpf_set_trampoline_target(struct shm_bpf *obj)

128 {

129 char syscall[NETDATA_EBPF_MAX_SYSCALL_LENGTH + 1];

126 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

127 - shm_targets[NETDATA_KEY_SHMGET_CALL].name, running_on_kernel);

128 -

129 - bpf_program__set_attach_target(obj->progs.netdata_shmget_fentry, 0,

130 - syscall);

131 -

132 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

133 - shm_targets[NETDATA_KEY_SHMAT_CALL].name, running_on_kernel);

134 - bpf_program__set_attach_target(obj->progs.netdata_shmat_fentry, 0,

135 - syscall);

136 -

137 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

138 - shm_targets[NETDATA_KEY_SHMDT_CALL].name, running_on_kernel);

139 - bpf_program__set_attach_target(obj->progs.netdata_shmdt_fentry, 0,

140 - syscall);

141 -

142 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

143 - shm_targets[NETDATA_KEY_SHMCTL_CALL].name, running_on_kernel);

144 - bpf_program__set_attach_target(obj->progs.netdata_shmctl_fentry, 0,

145 - syscall);

130 + ebpf_select_host_prefix(

131 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, shm_targets[NETDATA_KEY_SHMGET_CALL].name, running_on_kernel);

132 +

133 + bpf_program__set_attach_target(obj->progs.netdata_shmget_fentry, 0, syscall);

134 +

135 + ebpf_select_host_prefix(

136 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, shm_targets[NETDATA_KEY_SHMAT_CALL].name, running_on_kernel);

137 + bpf_program__set_attach_target(obj->progs.netdata_shmat_fentry, 0, syscall);

138 +

139 + ebpf_select_host_prefix(

140 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, shm_targets[NETDATA_KEY_SHMDT_CALL].name, running_on_kernel);

141 + bpf_program__set_attach_target(obj->progs.netdata_shmdt_fentry, 0, syscall);

142 +

143 + ebpf_select_host_prefix(

144 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, shm_targets[NETDATA_KEY_SHMCTL_CALL].name, running_on_kernel);

145 + bpf_program__set_attach_target(obj->progs.netdata_shmctl_fentry, 0, syscall);

146 }

147

148 /**

@@ -157,35 +157,31 @@ static void ebpf_set_trampoline_target(struct shm_bpf *obj)

157 static int ebpf_shm_attach_probe(struct shm_bpf *obj)

158 {

159 char syscall[NETDATA_EBPF_MAX_SYSCALL_LENGTH + 1];

160 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

161 - shm_targets[NETDATA_KEY_SHMGET_CALL].name, running_on_kernel);

160 + ebpf_select_host_prefix(

161 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, shm_targets[NETDATA_KEY_SHMGET_CALL].name, running_on_kernel);

162

163 - obj->links.netdata_shmget_probe = bpf_program__attach_kprobe(obj->progs.netdata_shmget_probe,

164 - false, syscall);

163 + obj->links.netdata_shmget_probe = bpf_program__attach_kprobe(obj->progs.netdata_shmget_probe, false, syscall);

164 long ret = libbpf_get_error(obj->links.netdata_shmget_probe);

165 if (ret)

166 return -1;

167

169 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

170 - shm_targets[NETDATA_KEY_SHMAT_CALL].name, running_on_kernel);

171 - obj->links.netdata_shmat_probe = bpf_program__attach_kprobe(obj->progs.netdata_shmat_probe,

172 - false, syscall);

168 + ebpf_select_host_prefix(

169 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, shm_targets[NETDATA_KEY_SHMAT_CALL].name, running_on_kernel);

170 + obj->links.netdata_shmat_probe = bpf_program__attach_kprobe(obj->progs.netdata_shmat_probe, false, syscall);

171 ret = libbpf_get_error(obj->links.netdata_shmat_probe);

172 if (ret)

173 return -1;

174

177 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

178 - shm_targets[NETDATA_KEY_SHMDT_CALL].name, running_on_kernel);

179 - obj->links.netdata_shmdt_probe = bpf_program__attach_kprobe(obj->progs.netdata_shmdt_probe,

180 - false, syscall);

175 + ebpf_select_host_prefix(

176 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, shm_targets[NETDATA_KEY_SHMDT_CALL].name, running_on_kernel);

177 + obj->links.netdata_shmdt_probe = bpf_program__attach_kprobe(obj->progs.netdata_shmdt_probe, false, syscall);

178 ret = libbpf_get_error(obj->links.netdata_shmdt_probe);

179 if (ret)

180 return -1;

181

185 - ebpf_select_host_prefix(syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH,

186 - shm_targets[NETDATA_KEY_SHMCTL_CALL].name, running_on_kernel);

187 - obj->links.netdata_shmctl_probe = bpf_program__attach_kprobe(obj->progs.netdata_shmctl_probe,

188 - false, syscall);

182 + ebpf_select_host_prefix(

183 + syscall, NETDATA_EBPF_MAX_SYSCALL_LENGTH, shm_targets[NETDATA_KEY_SHMCTL_CALL].name, running_on_kernel);

184 + obj->links.netdata_shmctl_probe = bpf_program__attach_kprobe(obj->progs.netdata_shmctl_probe, false, syscall);

185 ret = libbpf_get_error(obj->links.netdata_shmctl_probe);

186 if (ret)

187 return -1;

@@ -215,8 +211,8 @@ static void ebpf_shm_set_hash_tables(struct shm_bpf *obj)

211 */

212 static void ebpf_shm_adjust_map(struct shm_bpf *obj, ebpf_module_t *em)

213 {

218 - ebpf_update_map_size(obj->maps.tbl_pid_shm, &shm_maps[NETDATA_PID_SHM_TABLE],

219 - em, bpf_map__name(obj->maps.tbl_pid_shm));

214 + ebpf_update_map_size(

215 + obj->maps.tbl_pid_shm, &shm_maps[NETDATA_PID_SHM_TABLE], em, bpf_map__name(obj->maps.tbl_pid_shm));

216

217 ebpf_update_map_type(obj->maps.tbl_shm, &shm_maps[NETDATA_SHM_GLOBAL_TABLE]);

218 ebpf_update_map_type(obj->maps.tbl_pid_shm, &shm_maps[NETDATA_PID_SHM_TABLE]);

@@ -239,15 +235,15 @@ static inline int ebpf_shm_load_and_attach(struct shm_bpf *obj, ebpf_module_t *e

235 netdata_ebpf_program_loaded_t test = shmt[NETDATA_KEY_SHMGET_CALL].mode;

236

237 // We are testing only one, because all will have the same behavior

242 - if (test == EBPF_LOAD_TRAMPOLINE ) {

238 + if (test == EBPF_LOAD_TRAMPOLINE) {

239 ebpf_shm_disable_tracepoint(obj);

240 ebpf_disable_probe(obj);

241

242 ebpf_set_trampoline_target(obj);

247 - } else if (test == EBPF_LOAD_PROBE || test == EBPF_LOAD_RETPROBE ) {

243 + } else if (test == EBPF_LOAD_PROBE || test == EBPF_LOAD_RETPROBE) {

244 ebpf_shm_disable_tracepoint(obj);

245 ebpf_disable_trampoline(obj);

250 - } else {

246 + } else {

247 ebpf_disable_probe(obj);

248 ebpf_disable_trampoline(obj);

249 }

@@ -283,49 +279,53 @@ static void ebpf_obsolete_specific_shm_charts(char *type, int update_every);

279 */

280 static void ebpf_obsolete_shm_services(ebpf_module_t *em, char *id)

281 {

286 - ebpf_write_chart_obsolete(id,

287 - NETDATA_SHMGET_CHART,

288 - "",

289 - "Calls to syscall shmget(2).",

290 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

291 - NETDATA_APPS_IPC_SHM_GROUP,

292 - NETDATA_EBPF_CHART_TYPE_STACKED,

293 - NETDATA_SYSTEMD_SHM_GET_CONTEXT,

294 - 20191,

295 - em->update_every);

296 -

297 - ebpf_write_chart_obsolete(id,

298 - NETDATA_SHMAT_CHART,

299 - "",

300 - "Calls to syscall shmat(2).",

301 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

302 - NETDATA_APPS_IPC_SHM_GROUP,

303 - NETDATA_EBPF_CHART_TYPE_STACKED,

304 - NETDATA_SYSTEMD_SHM_AT_CONTEXT,

305 - 20192,

306 - em->update_every);

307 -

308 - ebpf_write_chart_obsolete(id,

309 - NETDATA_SHMDT_CHART,

310 - "",

311 - "Calls to syscall shmdt(2).",

312 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

313 - NETDATA_APPS_IPC_SHM_GROUP,

314 - NETDATA_EBPF_CHART_TYPE_STACKED,

315 - NETDATA_SYSTEMD_SHM_DT_CONTEXT,

316 - 20193,

317 - em->update_every);

318 -

319 - ebpf_write_chart_obsolete(id,

320 - NETDATA_SHMCTL_CHART,

321 - "",

322 - "Calls to syscall shmctl(2).",

323 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

324 - NETDATA_APPS_IPC_SHM_GROUP,

325 - NETDATA_EBPF_CHART_TYPE_STACKED,

326 - NETDATA_SYSTEMD_SHM_CTL_CONTEXT,

327 - 20194,

328 - em->update_every);

282 + ebpf_write_chart_obsolete(

283 + id,

284 + NETDATA_SHMGET_CHART,

285 + "",

286 + "Calls to syscall shmget(2).",

287 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

288 + NETDATA_APPS_IPC_SHM_GROUP,

289 + NETDATA_EBPF_CHART_TYPE_STACKED,

290 + NETDATA_SYSTEMD_SHM_GET_CONTEXT,

291 + 20191,

292 + em->update_every);

293 +

294 + ebpf_write_chart_obsolete(

295 + id,

296 + NETDATA_SHMAT_CHART,

297 + "",

298 + "Calls to syscall shmat(2).",

299 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

300 + NETDATA_APPS_IPC_SHM_GROUP,

301 + NETDATA_EBPF_CHART_TYPE_STACKED,

302 + NETDATA_SYSTEMD_SHM_AT_CONTEXT,

303 + 20192,

304 + em->update_every);

305 +

306 + ebpf_write_chart_obsolete(

307 + id,

308 + NETDATA_SHMDT_CHART,

309 + "",

310 + "Calls to syscall shmdt(2).",

311 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

312 + NETDATA_APPS_IPC_SHM_GROUP,

313 + NETDATA_EBPF_CHART_TYPE_STACKED,

314 + NETDATA_SYSTEMD_SHM_DT_CONTEXT,

315 + 20193,

316 + em->update_every);

317 +

318 + ebpf_write_chart_obsolete(

319 + id,

320 + NETDATA_SHMCTL_CHART,

321 + "",

322 + "Calls to syscall shmctl(2).",

323 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

324 + NETDATA_APPS_IPC_SHM_GROUP,

325 + NETDATA_EBPF_CHART_TYPE_STACKED,

326 + NETDATA_SYSTEMD_SHM_CTL_CONTEXT,

327 + 20194,

328 + em->update_every);

329 }

330

331 /**

@@ -335,11 +335,12 @@ static void ebpf_obsolete_shm_services(ebpf_module_t *em, char *id)

335 *

336 * @param em a pointer to `struct ebpf_module`

337 */

338 -static inline void ebpf_obsolete_shm_cgroup_charts(ebpf_module_t *em) {

338 +static inline void ebpf_obsolete_shm_cgroup_charts(ebpf_module_t *em)

339 +{

340 pthread_mutex_lock(&mutex_cgroup_shm);

341

342 ebpf_cgroup_target_t *ect;

342 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

343 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

344 if (ect->systemd) {

345 ebpf_obsolete_shm_services(em, ect->name);

346

@@ -364,54 +365,58 @@ void ebpf_obsolete_shm_apps_charts(struct ebpf_module *em)

365 int update_every = em->update_every;

366 pthread_mutex_lock(&collect_data_mutex);

367 for (w = apps_groups_root_target; w; w = w->next) {

367 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SHM_IDX))))

368 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_SHM_IDX))))

369 continue;

370

370 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

371 - w->clean_name,

372 - "_ebpf_shmget_call",

373 - "Calls to syscall shmget(2).",

374 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

375 - NETDATA_APPS_IPC_SHM_GROUP,

376 - NETDATA_EBPF_CHART_TYPE_STACKED,

377 - "app.ebpf_shmget_call",

378 - 20191,

379 - update_every);

380 -

381 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

382 - w->clean_name,

383 - "_ebpf_shmat_call",

384 - "Calls to syscall shmat(2).",

385 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

386 - NETDATA_APPS_IPC_SHM_GROUP,

387 - NETDATA_EBPF_CHART_TYPE_STACKED,

388 - "app.ebpf_shmat_call",

389 - 20192,

390 - update_every);

391 -

392 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

393 - w->clean_name,

394 - "_ebpf_shmdt_call",

395 - "Calls to syscall shmdt(2).",

396 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

397 - NETDATA_APPS_IPC_SHM_GROUP,

398 - NETDATA_EBPF_CHART_TYPE_STACKED,

399 - "app.ebpf_shmdt_call",

400 - 20193,

401 - update_every);

402 -

403 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

404 - w->clean_name,

405 - "_ebpf_shmctl_call",

406 - "Calls to syscall shmctl(2).",

407 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

408 - NETDATA_APPS_IPC_SHM_GROUP,

409 - NETDATA_EBPF_CHART_TYPE_STACKED,

410 - "app.ebpf_shmctl_call",

411 - 20194,

412 - update_every);

413 -

414 - w->charts_created &= ~(1<<EBPF_MODULE_SHM_IDX);

371 + ebpf_write_chart_obsolete(

372 + NETDATA_APP_FAMILY,

373 + w->clean_name,

374 + "_ebpf_shmget_call",

375 + "Calls to syscall shmget(2).",

376 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

377 + NETDATA_APPS_IPC_SHM_GROUP,

378 + NETDATA_EBPF_CHART_TYPE_STACKED,

379 + "app.ebpf_shmget_call",

380 + 20191,

381 + update_every);

382 +

383 + ebpf_write_chart_obsolete(

384 + NETDATA_APP_FAMILY,

385 + w->clean_name,

386 + "_ebpf_shmat_call",

387 + "Calls to syscall shmat(2).",

388 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

389 + NETDATA_APPS_IPC_SHM_GROUP,

390 + NETDATA_EBPF_CHART_TYPE_STACKED,

391 + "app.ebpf_shmat_call",

392 + 20192,

393 + update_every);

394 +

395 + ebpf_write_chart_obsolete(

396 + NETDATA_APP_FAMILY,

397 + w->clean_name,

398 + "_ebpf_shmdt_call",

399 + "Calls to syscall shmdt(2).",

400 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

401 + NETDATA_APPS_IPC_SHM_GROUP,

402 + NETDATA_EBPF_CHART_TYPE_STACKED,

403 + "app.ebpf_shmdt_call",

404 + 20193,

405 + update_every);

406 +

407 + ebpf_write_chart_obsolete(

408 + NETDATA_APP_FAMILY,

409 + w->clean_name,

410 + "_ebpf_shmctl_call",

411 + "Calls to syscall shmctl(2).",

412 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

413 + NETDATA_APPS_IPC_SHM_GROUP,

414 + NETDATA_EBPF_CHART_TYPE_STACKED,

415 + "app.ebpf_shmctl_call",

416 + 20194,

417 + update_every);

418 +

419 + w->charts_created &= ~(1 << EBPF_MODULE_SHM_IDX);

420 }

421 pthread_mutex_unlock(&collect_data_mutex);

422 }

@@ -425,16 +430,17 @@ void ebpf_obsolete_shm_apps_charts(struct ebpf_module *em)

430 */

431 static void ebpf_obsolete_shm_global(ebpf_module_t *em)

432 {

428 - ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,

429 - NETDATA_SHM_GLOBAL_CHART,

430 - "",

431 - "Calls to shared memory system calls",

432 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

433 - NETDATA_SYSTEM_IPC_SHM_SUBMENU,

434 - NETDATA_EBPF_CHART_TYPE_LINE,

435 - "system.shared_memory_calls",

436 - NETDATA_CHART_PRIO_SYSTEM_IPC_SHARED_MEM_CALLS,

437 - em->update_every);

433 + ebpf_write_chart_obsolete(

434 + NETDATA_EBPF_SYSTEM_GROUP,

435 + NETDATA_SHM_GLOBAL_CHART,

436 + "",

437 + "Calls to shared memory system calls",

438 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

439 + NETDATA_SYSTEM_IPC_SHM_SUBMENU,

440 + NETDATA_EBPF_CHART_TYPE_LINE,

441 + "system.shared_memory_calls",

442 + NETDATA_CHART_PRIO_SYSTEM_IPC_SHARED_MEM_CALLS,

443 + em->update_every);

444 }

445

446 /**

@@ -447,10 +453,11 @@ static void ebpf_obsolete_shm_global(ebpf_module_t *em)

453 static void ebpf_shm_exit(void *pptr)

454 {

455 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

450 - if(!em) return;

456 + if (!em)

457 + return;

458

459 pthread_mutex_lock(&lock);

453 - collect_pids &= ~(1<<EBPF_MODULE_SHM_IDX);

460 + collect_pids &= ~(1 << EBPF_MODULE_SHM_IDX);

461 pthread_mutex_unlock(&lock);

462

463 if (ebpf_read_shm.thread)

@@ -600,7 +607,7 @@ static void ebpf_read_shm_apps_table(int maps_per_core)

607 }

608 }

609

603 -end_shm_loop:

610 + end_shm_loop:

611 // now that we've consumed the value, zero it out in the map.

612 memset(cv, 0, length);

613 bpf_map_update_elem(fd, &key, cv, BPF_EXIST);

@@ -616,21 +623,13 @@ static void shm_send_global()

623 {

624 ebpf_write_begin_chart(NETDATA_EBPF_SYSTEM_GROUP, NETDATA_SHM_GLOBAL_CHART, "");

625 write_chart_dimension(

619 - shm_publish_aggregated[NETDATA_KEY_SHMGET_CALL].dimension,

620 - (long long) shm_hash_values[NETDATA_KEY_SHMGET_CALL]

621 - );

626 + shm_publish_aggregated[NETDATA_KEY_SHMGET_CALL].dimension, (long long)shm_hash_values[NETDATA_KEY_SHMGET_CALL]);

627 write_chart_dimension(

623 - shm_publish_aggregated[NETDATA_KEY_SHMAT_CALL].dimension,

624 - (long long) shm_hash_values[NETDATA_KEY_SHMAT_CALL]

625 - );

628 + shm_publish_aggregated[NETDATA_KEY_SHMAT_CALL].dimension, (long long)shm_hash_values[NETDATA_KEY_SHMAT_CALL]);

629 write_chart_dimension(

627 - shm_publish_aggregated[NETDATA_KEY_SHMDT_CALL].dimension,

628 - (long long) shm_hash_values[NETDATA_KEY_SHMDT_CALL]

629 - );

630 + shm_publish_aggregated[NETDATA_KEY_SHMDT_CALL].dimension, (long long)shm_hash_values[NETDATA_KEY_SHMDT_CALL]);

631 write_chart_dimension(

631 - shm_publish_aggregated[NETDATA_KEY_SHMCTL_CALL].dimension,

632 - (long long) shm_hash_values[NETDATA_KEY_SHMCTL_CALL]

633 - );

632 + shm_publish_aggregated[NETDATA_KEY_SHMCTL_CALL].dimension, (long long)shm_hash_values[NETDATA_KEY_SHMCTL_CALL]);

633 ebpf_write_end_chart();

634 }

635

@@ -644,19 +643,21 @@ static void shm_send_global()

643 */

644 static void ebpf_shm_read_global_table(netdata_idx_t *stats, int maps_per_core)

645 {

647 - ebpf_read_global_table_stats(shm_hash_values,

648 - shm_values,

649 - shm_maps[NETDATA_SHM_GLOBAL_TABLE].map_fd,

650 - maps_per_core,

651 - NETDATA_KEY_SHMGET_CALL,

652 - NETDATA_SHM_END);

653 -

654 - ebpf_read_global_table_stats(stats,

655 - shm_values,

656 - shm_maps[NETDATA_SHM_CONTROLLER].map_fd,

657 - maps_per_core,

658 - NETDATA_CONTROLLER_PID_TABLE_ADD,

659 - NETDATA_CONTROLLER_END);

646 + ebpf_read_global_table_stats(

647 + shm_hash_values,

648 + shm_values,

649 + shm_maps[NETDATA_SHM_GLOBAL_TABLE].map_fd,

650 + maps_per_core,

651 + NETDATA_KEY_SHMGET_CALL,

652 + NETDATA_SHM_END);

653 +

654 + ebpf_read_global_table_stats(

655 + stats,

656 + shm_values,

657 + shm_maps[NETDATA_SHM_CONTROLLER].map_fd,

658 + maps_per_core,

659 + NETDATA_CONTROLLER_PID_TABLE_ADD,

660 + NETDATA_CONTROLLER_END);

661 }

662

663 /**

@@ -689,23 +690,23 @@ void ebpf_shm_send_apps_data(struct ebpf_target *root)

690 struct ebpf_target *w;

691 pthread_mutex_lock(&collect_data_mutex);

692 for (w = root; w; w = w->next) {

692 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SHM_IDX))))

693 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_SHM_IDX))))

694 continue;

695

696 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_shmget_call");

696 - write_chart_dimension("calls", (long long) w->shm.get);

697 + write_chart_dimension("calls", (long long)w->shm.get);

698 ebpf_write_end_chart();

699

700 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_shmat_call");

700 - write_chart_dimension("calls", (long long) w->shm.at);

701 + write_chart_dimension("calls", (long long)w->shm.at);

702 ebpf_write_end_chart();

703

704 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_shmdt_call");

704 - write_chart_dimension("calls", (long long) w->shm.dt);

705 + write_chart_dimension("calls", (long long)w->shm.dt);

706 ebpf_write_end_chart();

707

708 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_shmctl_call");

708 - write_chart_dimension("calls", (long long) w->shm.ctl);

709 + write_chart_dimension("calls", (long long)w->shm.ctl);

710 ebpf_write_end_chart();

711 }

712 pthread_mutex_unlock(&collect_data_mutex);

@@ -742,63 +743,71 @@ static void ebpf_shm_sum_cgroup_pids(netdata_publish_shm_t *shm, struct pid_on_t

743 static void ebpf_create_specific_shm_charts(char *type, int update_every)

744 {

745 char *label = (!strncmp(type, "cgroup_", 7)) ? &type[7] : type;

745 - ebpf_create_chart(type, NETDATA_SHMGET_CHART,

746 - "Calls to syscall shmget(2).",

747 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

748 - NETDATA_APPS_IPC_SHM_GROUP,

749 - NETDATA_CGROUP_SHM_GET_CONTEXT,

750 - NETDATA_EBPF_CHART_TYPE_LINE,

751 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5800,

752 - ebpf_create_global_dimension,

753 - &shm_publish_aggregated[NETDATA_KEY_SHMGET_CALL],

754 - 1,

755 - update_every,

756 - NETDATA_EBPF_MODULE_NAME_SHM);

746 + ebpf_create_chart(

747 + type,

748 + NETDATA_SHMGET_CHART,

749 + "Calls to syscall shmget(2).",

750 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

751 + NETDATA_APPS_IPC_SHM_GROUP,

752 + NETDATA_CGROUP_SHM_GET_CONTEXT,

753 + NETDATA_EBPF_CHART_TYPE_LINE,

754 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5800,

755 + ebpf_create_global_dimension,

756 + &shm_publish_aggregated[NETDATA_KEY_SHMGET_CALL],

757 + 1,

758 + update_every,

759 + NETDATA_EBPF_MODULE_NAME_SHM);

760 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

761 ebpf_commit_label();

762

760 - ebpf_create_chart(type, NETDATA_SHMAT_CHART,

761 - "Calls to syscall shmat(2).",

762 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

763 - NETDATA_APPS_IPC_SHM_GROUP,

764 - NETDATA_CGROUP_SHM_AT_CONTEXT,

765 - NETDATA_EBPF_CHART_TYPE_LINE,

766 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5801,

767 - ebpf_create_global_dimension,

768 - &shm_publish_aggregated[NETDATA_KEY_SHMAT_CALL],

769 - 1,

770 - update_every,

771 - NETDATA_EBPF_MODULE_NAME_SHM);

763 + ebpf_create_chart(

764 + type,

765 + NETDATA_SHMAT_CHART,

766 + "Calls to syscall shmat(2).",

767 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

768 + NETDATA_APPS_IPC_SHM_GROUP,

769 + NETDATA_CGROUP_SHM_AT_CONTEXT,

770 + NETDATA_EBPF_CHART_TYPE_LINE,

771 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5801,

772 + ebpf_create_global_dimension,

773 + &shm_publish_aggregated[NETDATA_KEY_SHMAT_CALL],

774 + 1,

775 + update_every,

776 + NETDATA_EBPF_MODULE_NAME_SHM);

777 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

778 ebpf_commit_label();

779

775 - ebpf_create_chart(type, NETDATA_SHMDT_CHART,

776 - "Calls to syscall shmdt(2).",

777 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

778 - NETDATA_APPS_IPC_SHM_GROUP,

779 - NETDATA_CGROUP_SHM_DT_CONTEXT,

780 - NETDATA_EBPF_CHART_TYPE_LINE,

781 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5802,

782 - ebpf_create_global_dimension,

783 - &shm_publish_aggregated[NETDATA_KEY_SHMDT_CALL],

784 - 1,

785 - update_every,

786 - NETDATA_EBPF_MODULE_NAME_SHM);

780 + ebpf_create_chart(

781 + type,

782 + NETDATA_SHMDT_CHART,

783 + "Calls to syscall shmdt(2).",

784 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

785 + NETDATA_APPS_IPC_SHM_GROUP,

786 + NETDATA_CGROUP_SHM_DT_CONTEXT,

787 + NETDATA_EBPF_CHART_TYPE_LINE,

788 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5802,

789 + ebpf_create_global_dimension,

790 + &shm_publish_aggregated[NETDATA_KEY_SHMDT_CALL],

791 + 1,

792 + update_every,

793 + NETDATA_EBPF_MODULE_NAME_SHM);

794 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

795 ebpf_commit_label();

796

790 - ebpf_create_chart(type, NETDATA_SHMCTL_CHART,

791 - "Calls to syscall shmctl(2).",

792 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

793 - NETDATA_APPS_IPC_SHM_GROUP,

794 - NETDATA_CGROUP_SHM_CTL_CONTEXT,

795 - NETDATA_EBPF_CHART_TYPE_LINE,

796 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5803,

797 - ebpf_create_global_dimension,

798 - &shm_publish_aggregated[NETDATA_KEY_SHMCTL_CALL],

799 - 1,

800 - update_every,

801 - NETDATA_EBPF_MODULE_NAME_SHM);

797 + ebpf_create_chart(

798 + type,

799 + NETDATA_SHMCTL_CHART,

800 + "Calls to syscall shmctl(2).",

801 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

802 + NETDATA_APPS_IPC_SHM_GROUP,

803 + NETDATA_CGROUP_SHM_CTL_CONTEXT,

804 + NETDATA_EBPF_CHART_TYPE_LINE,

805 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5803,

806 + ebpf_create_global_dimension,

807 + &shm_publish_aggregated[NETDATA_KEY_SHMCTL_CALL],

808 + 1,

809 + update_every,

810 + NETDATA_EBPF_MODULE_NAME_SHM);

811 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

812 ebpf_commit_label();

813 }

@@ -813,37 +822,53 @@ static void ebpf_create_specific_shm_charts(char *type, int update_every)

822 */

823 static void ebpf_obsolete_specific_shm_charts(char *type, int update_every)

824 {

816 - ebpf_write_chart_obsolete(type, NETDATA_SHMGET_CHART,

817 - "",

818 - "Calls to syscall shmget(2).",

819 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

820 - NETDATA_APPS_IPC_SHM_GROUP,

821 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SHM_GET_CONTEXT,

822 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5800, update_every);

823 -

824 - ebpf_write_chart_obsolete(type, NETDATA_SHMAT_CHART,

825 - "",

826 - "Calls to syscall shmat(2).",

827 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

828 - NETDATA_APPS_IPC_SHM_GROUP,

829 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SHM_AT_CONTEXT,

830 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5801, update_every);

831 -

832 - ebpf_write_chart_obsolete(type, NETDATA_SHMDT_CHART,

833 - "",

834 - "Calls to syscall shmdt(2).",

835 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

836 - NETDATA_APPS_IPC_SHM_GROUP,

837 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SHM_DT_CONTEXT,

838 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5802, update_every);

839 -

840 - ebpf_write_chart_obsolete(type, NETDATA_SHMCTL_CHART,

841 - "",

842 - "Calls to syscall shmctl(2).",

843 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

844 - NETDATA_APPS_IPC_SHM_GROUP,

845 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SHM_CTL_CONTEXT,

846 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5803, update_every);

825 + ebpf_write_chart_obsolete(

826 + type,

827 + NETDATA_SHMGET_CHART,

828 + "",

829 + "Calls to syscall shmget(2).",

830 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

831 + NETDATA_APPS_IPC_SHM_GROUP,

832 + NETDATA_EBPF_CHART_TYPE_LINE,

833 + NETDATA_CGROUP_SHM_GET_CONTEXT,

834 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5800,

835 + update_every);

836 +

837 + ebpf_write_chart_obsolete(

838 + type,

839 + NETDATA_SHMAT_CHART,

840 + "",

841 + "Calls to syscall shmat(2).",

842 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

843 + NETDATA_APPS_IPC_SHM_GROUP,

844 + NETDATA_EBPF_CHART_TYPE_LINE,

845 + NETDATA_CGROUP_SHM_AT_CONTEXT,

846 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5801,

847 + update_every);

848 +

849 + ebpf_write_chart_obsolete(

850 + type,

851 + NETDATA_SHMDT_CHART,

852 + "",

853 + "Calls to syscall shmdt(2).",

854 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

855 + NETDATA_APPS_IPC_SHM_GROUP,

856 + NETDATA_EBPF_CHART_TYPE_LINE,

857 + NETDATA_CGROUP_SHM_DT_CONTEXT,

858 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5802,

859 + update_every);

860 +

861 + ebpf_write_chart_obsolete(

862 + type,

863 + NETDATA_SHMCTL_CHART,

864 + "",

865 + "Calls to syscall shmctl(2).",

866 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

867 + NETDATA_APPS_IPC_SHM_GROUP,

868 + NETDATA_EBPF_CHART_TYPE_LINE,

869 + NETDATA_CGROUP_SHM_CTL_CONTEXT,

870 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5803,

871 + update_every);

872 }

873

874 /**

@@ -866,8 +891,7 @@ static void ebpf_create_systemd_shm_charts(int update_every)

891 .module = NETDATA_EBPF_MODULE_NAME_SHM,

892 .update_every = 0,

893 .suffix = NETDATA_SHMGET_CHART,

869 - .dimension = "calls"

870 - };

894 + .dimension = "calls"};

895

896 static ebpf_systemd_args_t data_shmat = {

897 .title = "Calls to syscall shmat(2).",

@@ -880,8 +904,7 @@ static void ebpf_create_systemd_shm_charts(int update_every)

904 .module = NETDATA_EBPF_MODULE_NAME_SHM,

905 .update_every = 0,

906 .suffix = NETDATA_SHMAT_CHART,

883 - .dimension = "calls"

884 - };

907 + .dimension = "calls"};

908

909 static ebpf_systemd_args_t data_shmdt = {

910 .title = "Calls to syscall shmdt(2).",

@@ -894,8 +917,7 @@ static void ebpf_create_systemd_shm_charts(int update_every)

917 .module = NETDATA_EBPF_MODULE_NAME_SHM,

918 .update_every = 0,

919 .suffix = NETDATA_SHMDT_CHART,

897 - .dimension = "calls"

898 - };

920 + .dimension = "calls"};

921

922 static ebpf_systemd_args_t data_shmctl = {

923 .title = "Calls to syscall shmctl(2).",

@@ -908,12 +930,11 @@ static void ebpf_create_systemd_shm_charts(int update_every)

930 .module = NETDATA_EBPF_MODULE_NAME_SHM,

931 .update_every = 0,

932 .suffix = NETDATA_SHMCTL_CHART,

911 - .dimension = "calls"

912 - };

933 + .dimension = "calls"};

934

935 if (!data_shmget.update_every)

915 - data_shmat.update_every = data_shmctl.update_every =

916 - data_shmdt.update_every = data_shmget.update_every = update_every;

936 + data_shmat.update_every = data_shmctl.update_every = data_shmdt.update_every = data_shmget.update_every =

937 + update_every;

938

939 ebpf_cgroup_target_t *w;

940 for (w = ebpf_cgroup_pids; w; w = w->next) {

@@ -942,7 +963,7 @@ static void ebpf_send_systemd_shm_charts()

963 {

964 ebpf_cgroup_target_t *ect;

965 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

945 - if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_SHM_CHART)) ) {

966 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_SHM_CHART))) {

967 continue;

968 }

969

@@ -1000,7 +1021,7 @@ void ebpf_shm_send_cgroup_data(int update_every)

1021 {

1022 pthread_mutex_lock(&mutex_cgroup_shm);

1023 ebpf_cgroup_target_t *ect;

1003 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1024 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1025 ebpf_shm_sum_cgroup_pids(&ect->publish_shm, ect->pids);

1026 }

1027

@@ -1012,7 +1033,7 @@ void ebpf_shm_send_cgroup_data(int update_every)

1033 ebpf_send_systemd_shm_charts();

1034 }

1035

1015 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1036 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1037 if (ect->systemd)

1038 continue;

1039

@@ -1037,7 +1058,8 @@ void ebpf_shm_send_cgroup_data(int update_every)

1058 /**

1059 * Resume apps data

1060 */

1040 -void ebpf_shm_resume_apps_data() {

1061 +void ebpf_shm_resume_apps_data()

1062 +{

1063 struct ebpf_target *w;

1064 for (w = apps_groups_root_target; w; w = w->next) {

1065 if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_SHM_IDX))))

@@ -1171,67 +1193,71 @@ void ebpf_shm_create_apps_charts(struct ebpf_module *em, void *ptr)

1193 if (unlikely(!w->exposed))

1194 continue;

1195

1174 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1175 - w->clean_name,

1176 - "_ebpf_shmget_call",

1177 - "Calls to syscall shmget(2).",

1178 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1179 - NETDATA_APPS_IPC_SHM_GROUP,

1180 - NETDATA_EBPF_CHART_TYPE_STACKED,

1181 - "app.ebpf_shmget_call",

1182 - 20191,

1183 - update_every,

1184 - NETDATA_EBPF_MODULE_NAME_SHM);

1196 + ebpf_write_chart_cmd(

1197 + NETDATA_APP_FAMILY,

1198 + w->clean_name,

1199 + "_ebpf_shmget_call",

1200 + "Calls to syscall shmget(2).",

1201 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1202 + NETDATA_APPS_IPC_SHM_GROUP,

1203 + NETDATA_EBPF_CHART_TYPE_STACKED,

1204 + "app.ebpf_shmget_call",

1205 + 20191,

1206 + update_every,

1207 + NETDATA_EBPF_MODULE_NAME_SHM);

1208 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1209 ebpf_commit_label();

1210 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1211

1189 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1190 - w->clean_name,

1191 - "_ebpf_shmat_call",

1192 - "Calls to syscall shmat(2).",

1193 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1194 - NETDATA_APPS_IPC_SHM_GROUP,

1195 - NETDATA_EBPF_CHART_TYPE_STACKED,

1196 - "app.ebpf_shmat_call",

1197 - 20192,

1198 - update_every,

1199 - NETDATA_EBPF_MODULE_NAME_SHM);

1212 + ebpf_write_chart_cmd(

1213 + NETDATA_APP_FAMILY,

1214 + w->clean_name,

1215 + "_ebpf_shmat_call",

1216 + "Calls to syscall shmat(2).",

1217 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1218 + NETDATA_APPS_IPC_SHM_GROUP,

1219 + NETDATA_EBPF_CHART_TYPE_STACKED,

1220 + "app.ebpf_shmat_call",

1221 + 20192,

1222 + update_every,

1223 + NETDATA_EBPF_MODULE_NAME_SHM);

1224 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1225 ebpf_commit_label();

1226 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1227

1204 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1205 - w->clean_name,

1206 - "_ebpf_shmdt_call",

1207 - "Calls to syscall shmdt(2).",

1208 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1209 - NETDATA_APPS_IPC_SHM_GROUP,

1210 - NETDATA_EBPF_CHART_TYPE_STACKED,

1211 - "app.ebpf_shmdt_call",

1212 - 20193,

1213 - update_every,

1214 - NETDATA_EBPF_MODULE_NAME_SHM);

1228 + ebpf_write_chart_cmd(

1229 + NETDATA_APP_FAMILY,

1230 + w->clean_name,

1231 + "_ebpf_shmdt_call",

1232 + "Calls to syscall shmdt(2).",

1233 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1234 + NETDATA_APPS_IPC_SHM_GROUP,

1235 + NETDATA_EBPF_CHART_TYPE_STACKED,

1236 + "app.ebpf_shmdt_call",

1237 + 20193,

1238 + update_every,

1239 + NETDATA_EBPF_MODULE_NAME_SHM);

1240 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1241 ebpf_commit_label();

1242 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1243

1219 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1220 - w->clean_name,

1221 - "_ebpf_shmctl_call",

1222 - "Calls to syscall shmctl(2).",

1223 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1224 - NETDATA_APPS_IPC_SHM_GROUP,

1225 - NETDATA_EBPF_CHART_TYPE_STACKED,

1226 - "app.ebpf_shmctl_call",

1227 - 20194,

1228 - update_every,

1229 - NETDATA_EBPF_MODULE_NAME_SHM);

1244 + ebpf_write_chart_cmd(

1245 + NETDATA_APP_FAMILY,

1246 + w->clean_name,

1247 + "_ebpf_shmctl_call",

1248 + "Calls to syscall shmctl(2).",

1249 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1250 + NETDATA_APPS_IPC_SHM_GROUP,

1251 + NETDATA_EBPF_CHART_TYPE_STACKED,

1252 + "app.ebpf_shmctl_call",

1253 + 20194,

1254 + update_every,

1255 + NETDATA_EBPF_MODULE_NAME_SHM);

1256 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1257 ebpf_commit_label();

1258 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1259

1234 - w->charts_created |= 1<<EBPF_MODULE_SHM_IDX;

1260 + w->charts_created |= 1 << EBPF_MODULE_SHM_IDX;

1261 }

1262

1263 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;

@@ -1279,8 +1305,8 @@ static void ebpf_create_shm_charts(int update_every)

1305 ebpf_create_global_dimension,

1306 shm_publish_aggregated,

1307 NETDATA_SHM_END,

1282 - update_every, NETDATA_EBPF_MODULE_NAME_SHM

1283 - );

1308 + update_every,

1309 + NETDATA_EBPF_MODULE_NAME_SHM);

1310

1311 fflush(stdout);

1312 }

@@ -1317,7 +1343,6 @@ static int ebpf_shm_load_bpf(ebpf_module_t *em)

1343 }

1344 #endif

1345

1320 -

1346 if (ret)

1347 netdata_log_error("%s %s", EBPF_DEFAULT_ERROR_MSG, em->info.thread_name);

1348

@@ -1354,16 +1379,14 @@ void *ebpf_shm_thread(void *ptr)

1379 NETDATA_EBPF_INCREMENTAL_IDX,

1380 NETDATA_EBPF_INCREMENTAL_IDX,

1381 NETDATA_EBPF_INCREMENTAL_IDX,

1357 - NETDATA_EBPF_INCREMENTAL_IDX

1358 - };

1382 + NETDATA_EBPF_INCREMENTAL_IDX};

1383 ebpf_global_labels(

1384 shm_aggregated_data,

1385 shm_publish_aggregated,

1386 shm_dimension_name,

1387 shm_dimension_name,

1388 algorithms,

1365 - NETDATA_SHM_END

1366 - );

1389 + NETDATA_SHM_END);

1390

1391 pthread_mutex_lock(&lock);

1392 ebpf_create_shm_charts(em->update_every);

@@ -1371,8 +1394,8 @@ void *ebpf_shm_thread(void *ptr)

1394 ebpf_update_kernel_memory_with_vector(&plugin_statistics, em->maps, EBPF_ACTION_STAT_ADD);

1395 pthread_mutex_unlock(&lock);

1396

1374 - ebpf_read_shm.thread = nd_thread_create(ebpf_read_shm.name, NETDATA_THREAD_OPTION_DEFAULT,

1375 - ebpf_read_shm_thread, em);

1397 + ebpf_read_shm.thread =

1398 + nd_thread_create(ebpf_read_shm.name, NETDATA_THREAD_OPTION_DEFAULT, ebpf_read_shm_thread, em);

1399

1400 shm_collector(em);

1401

src/collectors/ebpf.plugin/ebpf_shm.h

+3 -6

@@ -5,7 +5,8 @@

6 // Module name & description

7 #define NETDATA_EBPF_MODULE_NAME_SHM "shm"

8 -#define NETDATA_EBPF_SHM_MODULE_DESC "Show calls to syscalls shmget(2), shmat(2), shmdt(2) and shmctl(2). This thread is integrated with apps and cgroup."

8 +#define NETDATA_EBPF_SHM_MODULE_DESC \

9 + "Show calls to syscalls shmget(2), shmat(2), shmdt(2) and shmctl(2). This thread is integrated with apps and cgroup."

11 // charts

12 #define NETDATA_SHM_GLOBAL_CHART "shared_memory_calls"

@@ -37,11 +38,7 @@ typedef struct __attribute__((packed)) netdata_publish_shm {

38 uint32_t ctl;

39 } netdata_publish_shm_t;

40 -enum shm_tables {

41 - NETDATA_PID_SHM_TABLE,

42 - NETDATA_SHM_CONTROLLER,

43 - NETDATA_SHM_GLOBAL_TABLE

44 -};

41 +enum shm_tables { NETDATA_PID_SHM_TABLE, NETDATA_SHM_CONTROLLER, NETDATA_SHM_GLOBAL_TABLE };

43 enum shm_counters {

44 NETDATA_KEY_SHMGET_CALL,

src/collectors/ebpf.plugin/ebpf_socket.c

+1054 -900

@@ -11,62 +11,82 @@

11 *

12 *****************************************************************/

14 -static char *socket_dimension_names[NETDATA_MAX_SOCKET_VECTOR] = { "received", "sent", "close",

15 - "received", "sent", "retransmitted",

16 - "connected_V4", "connected_V6", "connected_tcp",

17 - "connected_udp"};

18 -static char *socket_id_names[NETDATA_MAX_SOCKET_VECTOR] = { "tcp_cleanup_rbuf", "tcp_sendmsg", "tcp_close",

19 - "udp_recvmsg", "udp_sendmsg", "tcp_retransmit_skb",

20 - "tcp_connect_v4", "tcp_connect_v6", "inet_csk_accept_tcp",

21 - "inet_csk_accept_udp" };

22 -

23 -static ebpf_local_maps_t socket_maps[] = {{.name = "tbl_global_sock",

24 - .internal_input = NETDATA_SOCKET_COUNTER,

25 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

26 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

14 +static char *socket_dimension_names[NETDATA_MAX_SOCKET_VECTOR] = {

15 + "received",

16 + "sent",

17 + "close",

18 + "received",

19 + "sent",

20 + "retransmitted",

21 + "connected_V4",

22 + "connected_V6",

23 + "connected_tcp",

24 + "connected_udp"};

25 +static char *socket_id_names[NETDATA_MAX_SOCKET_VECTOR] = {

26 + "tcp_cleanup_rbuf",

27 + "tcp_sendmsg",

28 + "tcp_close",

29 + "udp_recvmsg",

30 + "udp_sendmsg",

31 + "tcp_retransmit_skb",

32 + "tcp_connect_v4",

33 + "tcp_connect_v6",

34 + "inet_csk_accept_tcp",

35 + "inet_csk_accept_udp"};

36 +

37 +static ebpf_local_maps_t socket_maps[] = {

38 + {.name = "tbl_global_sock",

39 + .internal_input = NETDATA_SOCKET_COUNTER,

40 + .user_input = 0,

41 + .type = NETDATA_EBPF_MAP_STATIC,

42 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

43 #ifdef LIBBPF_MAJOR_VERSION

28 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

44 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

45 #endif

30 - },

31 - {.name = "tbl_lports",

32 - .internal_input = NETDATA_SOCKET_COUNTER,

33 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

34 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

46 + },

47 + {.name = "tbl_lports",

48 + .internal_input = NETDATA_SOCKET_COUNTER,

49 + .user_input = 0,

50 + .type = NETDATA_EBPF_MAP_STATIC,

51 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

52 #ifdef LIBBPF_MAJOR_VERSION

36 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

53 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

54 #endif

38 - },

39 - {.name = "tbl_nd_socket",

40 - .internal_input = NETDATA_COMPILED_CONNECTIONS_ALLOWED,

41 - .user_input = NETDATA_MAXIMUM_CONNECTIONS_ALLOWED,

42 - .type = NETDATA_EBPF_MAP_STATIC,

43 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

55 + },

56 + {.name = "tbl_nd_socket",

57 + .internal_input = NETDATA_COMPILED_CONNECTIONS_ALLOWED,

58 + .user_input = NETDATA_MAXIMUM_CONNECTIONS_ALLOWED,

59 + .type = NETDATA_EBPF_MAP_STATIC,

60 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

61 #ifdef LIBBPF_MAJOR_VERSION

45 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

62 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

63 #endif

47 - },

48 - {.name = "tbl_nv_udp",

49 - .internal_input = NETDATA_COMPILED_UDP_CONNECTIONS_ALLOWED,

50 - .user_input = NETDATA_MAXIMUM_UDP_CONNECTIONS_ALLOWED,

51 - .type = NETDATA_EBPF_MAP_STATIC,

52 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

64 + },

65 + {.name = "tbl_nv_udp",

66 + .internal_input = NETDATA_COMPILED_UDP_CONNECTIONS_ALLOWED,

67 + .user_input = NETDATA_MAXIMUM_UDP_CONNECTIONS_ALLOWED,

68 + .type = NETDATA_EBPF_MAP_STATIC,

69 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

70 #ifdef LIBBPF_MAJOR_VERSION

54 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

71 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

72 #endif

56 - },

57 - {.name = "socket_ctrl", .internal_input = NETDATA_CONTROLLER_END,

58 - .user_input = 0,

59 - .type = NETDATA_EBPF_MAP_CONTROLLER,

60 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

73 + },

74 + {.name = "socket_ctrl",

75 + .internal_input = NETDATA_CONTROLLER_END,

76 + .user_input = 0,

77 + .type = NETDATA_EBPF_MAP_CONTROLLER,

78 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

79 #ifdef LIBBPF_MAJOR_VERSION

62 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

80 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

81 #endif

64 - },

65 - {.name = NULL, .internal_input = 0, .user_input = 0,

82 + },

83 + {.name = NULL,

84 + .internal_input = 0,

85 + .user_input = 0,

86 #ifdef LIBBPF_MAJOR_VERSION

67 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

87 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

88 #endif

69 - }};

89 + }};

91 static netdata_idx_t *socket_hash_values = NULL;

92 static netdata_syscall_stat_t socket_aggregated_data[NETDATA_MAX_SOCKET_VECTOR];

@@ -79,27 +99,27 @@ ebpf_addresses_t tcp_v6_connect_address = {.function = "tcp_v6_connect", .hash =

100 struct config socket_config = APPCONFIG_INITIALIZER;

101

82 -netdata_ebpf_targets_t socket_targets[] = { {.name = "inet_csk_accept", .mode = EBPF_LOAD_PROBE},

83 - {.name = "tcp_retransmit_skb", .mode = EBPF_LOAD_PROBE},

84 - {.name = "tcp_cleanup_rbuf", .mode = EBPF_LOAD_PROBE},

85 - {.name = "tcp_close", .mode = EBPF_LOAD_PROBE},

86 - {.name = "udp_recvmsg", .mode = EBPF_LOAD_PROBE},

87 - {.name = "tcp_sendmsg", .mode = EBPF_LOAD_PROBE},

88 - {.name = "udp_sendmsg", .mode = EBPF_LOAD_PROBE},

89 - {.name = "tcp_v4_connect", .mode = EBPF_LOAD_PROBE},

90 - {.name = "tcp_v6_connect", .mode = EBPF_LOAD_PROBE},

91 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

102 +netdata_ebpf_targets_t socket_targets[] = {

103 + {.name = "inet_csk_accept", .mode = EBPF_LOAD_PROBE},

104 + {.name = "tcp_retransmit_skb", .mode = EBPF_LOAD_PROBE},

105 + {.name = "tcp_cleanup_rbuf", .mode = EBPF_LOAD_PROBE},

106 + {.name = "tcp_close", .mode = EBPF_LOAD_PROBE},

107 + {.name = "udp_recvmsg", .mode = EBPF_LOAD_PROBE},

108 + {.name = "tcp_sendmsg", .mode = EBPF_LOAD_PROBE},

109 + {.name = "udp_sendmsg", .mode = EBPF_LOAD_PROBE},

110 + {.name = "tcp_v4_connect", .mode = EBPF_LOAD_PROBE},

111 + {.name = "tcp_v6_connect", .mode = EBPF_LOAD_PROBE},

112 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

113

114 struct netdata_static_thread ebpf_read_socket = {

94 - .name = "EBPF_READ_SOCKET",

95 - .config_section = NULL,

96 - .config_name = NULL,

97 - .env_name = NULL,

98 - .enabled = 1,

99 - .thread = NULL,

100 - .init_routine = NULL,

101 - .start_routine = NULL

102 -};

115 + .name = "EBPF_READ_SOCKET",

116 + .config_section = NULL,

117 + .config_name = NULL,

118 + .env_name = NULL,

119 + .enabled = 1,

120 + .thread = NULL,

121 + .init_routine = NULL,

122 + .start_routine = NULL};

123

124 ARAL *aral_socket_table = NULL;

125

@@ -161,52 +181,50 @@ static void ebpf_socket_disable_trampoline(struct socket_bpf *obj)

181 */

182 static void ebpf_set_trampoline_target(struct socket_bpf *obj)

183 {

164 - bpf_program__set_attach_target(obj->progs.netdata_inet_csk_accept_fexit, 0,

165 - socket_targets[NETDATA_FCNT_INET_CSK_ACCEPT].name);

184 + bpf_program__set_attach_target(

185 + obj->progs.netdata_inet_csk_accept_fexit, 0, socket_targets[NETDATA_FCNT_INET_CSK_ACCEPT].name);

186

167 - bpf_program__set_attach_target(obj->progs.netdata_tcp_v4_connect_fentry, 0,

168 - socket_targets[NETDATA_FCNT_TCP_V4_CONNECT].name);

187 + bpf_program__set_attach_target(

188 + obj->progs.netdata_tcp_v4_connect_fentry, 0, socket_targets[NETDATA_FCNT_TCP_V4_CONNECT].name);

189

170 - bpf_program__set_attach_target(obj->progs.netdata_tcp_v4_connect_fexit, 0,

171 - socket_targets[NETDATA_FCNT_TCP_V4_CONNECT].name);

190 + bpf_program__set_attach_target(

191 + obj->progs.netdata_tcp_v4_connect_fexit, 0, socket_targets[NETDATA_FCNT_TCP_V4_CONNECT].name);

192

193 if (tcp_v6_connect_address.type == 'T') {

194 bpf_program__set_attach_target(

195 obj->progs.netdata_tcp_v6_connect_fentry, 0, socket_targets[NETDATA_FCNT_TCP_V6_CONNECT].name);

196

177 - bpf_program__set_attach_target(obj->progs.netdata_tcp_v6_connect_fexit, 0,

178 - socket_targets[NETDATA_FCNT_TCP_V6_CONNECT].name);

197 + bpf_program__set_attach_target(

198 + obj->progs.netdata_tcp_v6_connect_fexit, 0, socket_targets[NETDATA_FCNT_TCP_V6_CONNECT].name);

199 }

200

181 - bpf_program__set_attach_target(obj->progs.netdata_tcp_retransmit_skb_fentry, 0,

182 - socket_targets[NETDATA_FCNT_TCP_RETRANSMIT].name);

201 + bpf_program__set_attach_target(

202 + obj->progs.netdata_tcp_retransmit_skb_fentry, 0, socket_targets[NETDATA_FCNT_TCP_RETRANSMIT].name);

203

184 - bpf_program__set_attach_target(obj->progs.netdata_tcp_cleanup_rbuf_fentry, 0,

185 - socket_targets[NETDATA_FCNT_CLEANUP_RBUF].name);

204 + bpf_program__set_attach_target(

205 + obj->progs.netdata_tcp_cleanup_rbuf_fentry, 0, socket_targets[NETDATA_FCNT_CLEANUP_RBUF].name);

206

187 - bpf_program__set_attach_target(obj->progs.netdata_tcp_close_fentry, 0,

188 - socket_targets[NETDATA_FCNT_TCP_CLOSE].name);

207 + bpf_program__set_attach_target(obj->progs.netdata_tcp_close_fentry, 0, socket_targets[NETDATA_FCNT_TCP_CLOSE].name);

208

190 - bpf_program__set_attach_target(obj->progs.netdata_udp_recvmsg_fentry, 0,

191 - socket_targets[NETDATA_FCNT_UDP_RECEVMSG].name);

209 + bpf_program__set_attach_target(

210 + obj->progs.netdata_udp_recvmsg_fentry, 0, socket_targets[NETDATA_FCNT_UDP_RECEVMSG].name);

211

193 - bpf_program__set_attach_target(obj->progs.netdata_udp_recvmsg_fexit, 0,

194 - socket_targets[NETDATA_FCNT_UDP_RECEVMSG].name);

212 + bpf_program__set_attach_target(

213 + obj->progs.netdata_udp_recvmsg_fexit, 0, socket_targets[NETDATA_FCNT_UDP_RECEVMSG].name);

214

196 - bpf_program__set_attach_target(obj->progs.netdata_tcp_sendmsg_fentry, 0,

197 - socket_targets[NETDATA_FCNT_TCP_SENDMSG].name);

215 + bpf_program__set_attach_target(

216 + obj->progs.netdata_tcp_sendmsg_fentry, 0, socket_targets[NETDATA_FCNT_TCP_SENDMSG].name);

217

199 - bpf_program__set_attach_target(obj->progs.netdata_tcp_sendmsg_fexit, 0,

200 - socket_targets[NETDATA_FCNT_TCP_SENDMSG].name);

218 + bpf_program__set_attach_target(

219 + obj->progs.netdata_tcp_sendmsg_fexit, 0, socket_targets[NETDATA_FCNT_TCP_SENDMSG].name);

220

202 - bpf_program__set_attach_target(obj->progs.netdata_udp_sendmsg_fentry, 0,

203 - socket_targets[NETDATA_FCNT_UDP_SENDMSG].name);

221 + bpf_program__set_attach_target(

222 + obj->progs.netdata_udp_sendmsg_fentry, 0, socket_targets[NETDATA_FCNT_UDP_SENDMSG].name);

223

205 - bpf_program__set_attach_target(obj->progs.netdata_udp_sendmsg_fexit, 0,

206 - socket_targets[NETDATA_FCNT_UDP_SENDMSG].name);

224 + bpf_program__set_attach_target(

225 + obj->progs.netdata_udp_sendmsg_fexit, 0, socket_targets[NETDATA_FCNT_UDP_SENDMSG].name);

226 }

227

209 -

228 /**

229 * Disable specific trampoline

230 *

@@ -263,66 +281,57 @@ static inline void ebpf_socket_disable_specific_probe(struct socket_bpf *obj, ne

281 */

282 static long ebpf_socket_attach_probes(struct socket_bpf *obj, netdata_run_mode_t sel)

283 {

266 - obj->links.netdata_inet_csk_accept_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_inet_csk_accept_kretprobe,

267 - true,

268 - socket_targets[NETDATA_FCNT_INET_CSK_ACCEPT].name);

284 + obj->links.netdata_inet_csk_accept_kretprobe = bpf_program__attach_kprobe(

285 + obj->progs.netdata_inet_csk_accept_kretprobe, true, socket_targets[NETDATA_FCNT_INET_CSK_ACCEPT].name);

286 long ret = libbpf_get_error(obj->links.netdata_inet_csk_accept_kretprobe);

287 if (ret)

288 return -1;

289

273 - obj->links.netdata_tcp_retransmit_skb_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_tcp_retransmit_skb_kprobe,

274 - false,

275 - socket_targets[NETDATA_FCNT_TCP_RETRANSMIT].name);

290 + obj->links.netdata_tcp_retransmit_skb_kprobe = bpf_program__attach_kprobe(

291 + obj->progs.netdata_tcp_retransmit_skb_kprobe, false, socket_targets[NETDATA_FCNT_TCP_RETRANSMIT].name);

292 ret = libbpf_get_error(obj->links.netdata_tcp_retransmit_skb_kprobe);

293 if (ret)

294 return -1;

295

280 - obj->links.netdata_tcp_cleanup_rbuf_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_tcp_cleanup_rbuf_kprobe,

281 - false,

282 - socket_targets[NETDATA_FCNT_CLEANUP_RBUF].name);

296 + obj->links.netdata_tcp_cleanup_rbuf_kprobe = bpf_program__attach_kprobe(

297 + obj->progs.netdata_tcp_cleanup_rbuf_kprobe, false, socket_targets[NETDATA_FCNT_CLEANUP_RBUF].name);

298 ret = libbpf_get_error(obj->links.netdata_tcp_cleanup_rbuf_kprobe);

299 if (ret)

300 return -1;

301

287 - obj->links.netdata_tcp_close_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_tcp_close_kprobe,

288 - false,

289 - socket_targets[NETDATA_FCNT_TCP_CLOSE].name);

302 + obj->links.netdata_tcp_close_kprobe = bpf_program__attach_kprobe(

303 + obj->progs.netdata_tcp_close_kprobe, false, socket_targets[NETDATA_FCNT_TCP_CLOSE].name);

304 ret = libbpf_get_error(obj->links.netdata_tcp_close_kprobe);

305 if (ret)

306 return -1;

307

294 - obj->links.netdata_udp_recvmsg_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_udp_recvmsg_kprobe,

295 - false,

296 - socket_targets[NETDATA_FCNT_UDP_RECEVMSG].name);

308 + obj->links.netdata_udp_recvmsg_kprobe = bpf_program__attach_kprobe(

309 + obj->progs.netdata_udp_recvmsg_kprobe, false, socket_targets[NETDATA_FCNT_UDP_RECEVMSG].name);

310 ret = libbpf_get_error(obj->links.netdata_udp_recvmsg_kprobe);

311 if (ret)

312 return -1;

313

301 - obj->links.netdata_udp_recvmsg_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_udp_recvmsg_kretprobe,

302 - true,

303 - socket_targets[NETDATA_FCNT_UDP_RECEVMSG].name);

314 + obj->links.netdata_udp_recvmsg_kretprobe = bpf_program__attach_kprobe(

315 + obj->progs.netdata_udp_recvmsg_kretprobe, true, socket_targets[NETDATA_FCNT_UDP_RECEVMSG].name);

316 ret = libbpf_get_error(obj->links.netdata_udp_recvmsg_kretprobe);

317 if (ret)

318 return -1;

319

320 if (sel == MODE_RETURN) {

309 - obj->links.netdata_tcp_sendmsg_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_tcp_sendmsg_kretprobe,

310 - true,

311 - socket_targets[NETDATA_FCNT_TCP_SENDMSG].name);

321 + obj->links.netdata_tcp_sendmsg_kretprobe = bpf_program__attach_kprobe(

322 + obj->progs.netdata_tcp_sendmsg_kretprobe, true, socket_targets[NETDATA_FCNT_TCP_SENDMSG].name);

323 ret = libbpf_get_error(obj->links.netdata_tcp_sendmsg_kretprobe);

324 if (ret)

325 return -1;

326

316 - obj->links.netdata_udp_sendmsg_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_udp_sendmsg_kretprobe,

317 - true,

318 - socket_targets[NETDATA_FCNT_UDP_SENDMSG].name);

327 + obj->links.netdata_udp_sendmsg_kretprobe = bpf_program__attach_kprobe(

328 + obj->progs.netdata_udp_sendmsg_kretprobe, true, socket_targets[NETDATA_FCNT_UDP_SENDMSG].name);

329 ret = libbpf_get_error(obj->links.netdata_udp_sendmsg_kretprobe);

330 if (ret)

331 return -1;

332

323 - obj->links.netdata_tcp_v4_connect_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_tcp_v4_connect_kretprobe,

324 - true,

325 - socket_targets[NETDATA_FCNT_TCP_V4_CONNECT].name);

333 + obj->links.netdata_tcp_v4_connect_kretprobe = bpf_program__attach_kprobe(

334 + obj->progs.netdata_tcp_v4_connect_kretprobe, true, socket_targets[NETDATA_FCNT_TCP_V4_CONNECT].name);

335 ret = libbpf_get_error(obj->links.netdata_tcp_v4_connect_kretprobe);

336 if (ret)

337 return -1;

@@ -335,31 +344,27 @@ static long ebpf_socket_attach_probes(struct socket_bpf *obj, netdata_run_mode_t

344 return -1;

345 }

346 } else {

338 - obj->links.netdata_tcp_sendmsg_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_tcp_sendmsg_kprobe,

339 - false,

340 - socket_targets[NETDATA_FCNT_TCP_SENDMSG].name);

347 + obj->links.netdata_tcp_sendmsg_kprobe = bpf_program__attach_kprobe(

348 + obj->progs.netdata_tcp_sendmsg_kprobe, false, socket_targets[NETDATA_FCNT_TCP_SENDMSG].name);

349 ret = libbpf_get_error(obj->links.netdata_tcp_sendmsg_kprobe);

350 if (ret)

351 return -1;

352

345 - obj->links.netdata_udp_sendmsg_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_udp_sendmsg_kprobe,

346 - false,

347 - socket_targets[NETDATA_FCNT_UDP_SENDMSG].name);

353 + obj->links.netdata_udp_sendmsg_kprobe = bpf_program__attach_kprobe(

354 + obj->progs.netdata_udp_sendmsg_kprobe, false, socket_targets[NETDATA_FCNT_UDP_SENDMSG].name);

355 ret = libbpf_get_error(obj->links.netdata_udp_sendmsg_kprobe);

356 if (ret)

357 return -1;

358

352 - obj->links.netdata_tcp_v4_connect_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_tcp_v4_connect_kprobe,

353 - false,

354 - socket_targets[NETDATA_FCNT_TCP_V4_CONNECT].name);

359 + obj->links.netdata_tcp_v4_connect_kprobe = bpf_program__attach_kprobe(

360 + obj->progs.netdata_tcp_v4_connect_kprobe, false, socket_targets[NETDATA_FCNT_TCP_V4_CONNECT].name);

361 ret = libbpf_get_error(obj->links.netdata_tcp_v4_connect_kprobe);

362 if (ret)

363 return -1;

364

365 if (tcp_v6_connect_address.type == 'T') {

360 - obj->links.netdata_tcp_v6_connect_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_tcp_v6_connect_kprobe,

361 - false,

362 - socket_targets[NETDATA_FCNT_TCP_V6_CONNECT].name);

366 + obj->links.netdata_tcp_v6_connect_kprobe = bpf_program__attach_kprobe(

367 + obj->progs.netdata_tcp_v6_connect_kprobe, false, socket_targets[NETDATA_FCNT_TCP_V6_CONNECT].name);

368 ret = libbpf_get_error(obj->links.netdata_tcp_v6_connect_kprobe);

369 if (ret)

370 return -1;

@@ -395,11 +400,11 @@ static void ebpf_socket_set_hash_tables(struct socket_bpf *obj)

400 */

401 static void ebpf_socket_adjust_map(struct socket_bpf *obj, ebpf_module_t *em)

402 {

398 - ebpf_update_map_size(obj->maps.tbl_nd_socket, &socket_maps[NETDATA_SOCKET_OPEN_SOCKET],

399 - em, bpf_map__name(obj->maps.tbl_nd_socket));

403 + ebpf_update_map_size(

404 + obj->maps.tbl_nd_socket, &socket_maps[NETDATA_SOCKET_OPEN_SOCKET], em, bpf_map__name(obj->maps.tbl_nd_socket));

405

401 - ebpf_update_map_size(obj->maps.tbl_nv_udp, &socket_maps[NETDATA_SOCKET_TABLE_UDP],

402 - em, bpf_map__name(obj->maps.tbl_nv_udp));

406 + ebpf_update_map_size(

407 + obj->maps.tbl_nv_udp, &socket_maps[NETDATA_SOCKET_TABLE_UDP], em, bpf_map__name(obj->maps.tbl_nv_udp));

408

409 ebpf_update_map_type(obj->maps.tbl_nd_socket, &socket_maps[NETDATA_SOCKET_OPEN_SOCKET]);

410 ebpf_update_map_type(obj->maps.tbl_nv_udp, &socket_maps[NETDATA_SOCKET_TABLE_UDP]);

@@ -486,7 +491,7 @@ static inline int ebpf_socket_load_and_attach(struct socket_bpf *obj, ebpf_modul

491 *

492 * @param ptr thread data.

493 */

489 -static void ebpf_socket_free(ebpf_module_t *em )

494 +static void ebpf_socket_free(ebpf_module_t *em)

495 {

496 pthread_mutex_lock(&ebpf_exit_cleanup);

497 em->enabled = NETDATA_THREAD_EBPF_STOPPED;

@@ -495,7 +500,7 @@ static void ebpf_socket_free(ebpf_module_t *em )

500 pthread_mutex_unlock(&ebpf_exit_cleanup);

501

502 pthread_mutex_lock(&lock);

498 - collect_pids &= ~(1<<EBPF_MODULE_SOCKET_IDX);

503 + collect_pids &= ~(1 << EBPF_MODULE_SOCKET_IDX);

504 pthread_mutex_unlock(&lock);

505 }

506

@@ -509,95 +514,103 @@ static void ebpf_socket_free(ebpf_module_t *em )

514 static void ebpf_obsolete_systemd_socket_charts(int update_every, char *id)

515 {

516 int order = 20080;

512 - ebpf_write_chart_obsolete(id,

513 - NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V4,

514 - "",

515 - "Calls to tcp_v4_connection",

516 - EBPF_COMMON_UNITS_CONNECTIONS,

517 - NETDATA_APPS_NET_GROUP,

518 - NETDATA_EBPF_CHART_TYPE_STACKED,

519 - NETDATA_SERVICES_SOCKET_TCP_V4_CONN_CONTEXT,

520 - order++,

521 - update_every);

517 + ebpf_write_chart_obsolete(

518 + id,

519 + NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V4,

520 + "",

521 + "Calls to tcp_v4_connection",

522 + EBPF_COMMON_UNITS_CONNECTIONS,

523 + NETDATA_APPS_NET_GROUP,

524 + NETDATA_EBPF_CHART_TYPE_STACKED,

525 + NETDATA_SERVICES_SOCKET_TCP_V4_CONN_CONTEXT,

526 + order++,

527 + update_every);

528

529 if (tcp_v6_connect_address.type == 'T') {

524 - ebpf_write_chart_obsolete(id,

525 - NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V6,

526 - "",

527 - "Calls to tcp_v6_connection",

528 - EBPF_COMMON_UNITS_CONNECTIONS,

529 - NETDATA_APPS_NET_GROUP,

530 - NETDATA_EBPF_CHART_TYPE_STACKED,

531 - NETDATA_SERVICES_SOCKET_TCP_V6_CONN_CONTEXT,

532 - order++,

533 - update_every);

530 + ebpf_write_chart_obsolete(

531 + id,

532 + NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V6,

533 + "",

534 + "Calls to tcp_v6_connection",

535 + EBPF_COMMON_UNITS_CONNECTIONS,

536 + NETDATA_APPS_NET_GROUP,

537 + NETDATA_EBPF_CHART_TYPE_STACKED,

538 + NETDATA_SERVICES_SOCKET_TCP_V6_CONN_CONTEXT,

539 + order++,

540 + update_every);

541 }

542

536 - ebpf_write_chart_obsolete(id,

537 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH,

538 - "",

539 - "Bandwidth.",

540 - EBPF_COMMON_UNITS_KILOBITS,

541 - NETDATA_APPS_NET_GROUP,

542 - NETDATA_EBPF_CHART_TYPE_STACKED,

543 - NETDATA_SERVICES_SOCKET_TCP_BANDWIDTH_CONTEXT,

544 - order++,

545 - update_every);

546 -

547 - ebpf_write_chart_obsolete(id,

548 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RECV_CALLS,

549 - "",

550 - "Calls to tcp_cleanup_rbuf.",

551 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

552 - NETDATA_APPS_NET_GROUP,

553 - NETDATA_EBPF_CHART_TYPE_STACKED,

554 - NETDATA_SERVICES_SOCKET_TCP_RECV_CONTEXT,

555 - order++,

556 - update_every);

557 -

558 - ebpf_write_chart_obsolete(id,

559 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_SEND_CALLS,

560 - "",

561 - "Calls to tcp_sendmsg.",

562 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

563 - NETDATA_APPS_NET_GROUP,

564 - NETDATA_EBPF_CHART_TYPE_STACKED,

565 - NETDATA_SERVICES_SOCKET_TCP_SEND_CONTEXT,

566 - order++,

567 - update_every);

568 -

569 - ebpf_write_chart_obsolete(id,

570 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RETRANSMIT,

571 - "",

572 - "Calls to tcp_retransmit",

573 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

574 - NETDATA_APPS_NET_GROUP,

575 - NETDATA_EBPF_CHART_TYPE_STACKED,

576 - NETDATA_SERVICES_SOCKET_TCP_RETRANSMIT_CONTEXT,

577 - order++,

578 - update_every);

579 -

580 - ebpf_write_chart_obsolete(id,

581 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_SEND_CALLS,

582 - "",

583 - "Calls to udp_sendmsg",

584 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

585 - NETDATA_APPS_NET_GROUP,

586 - NETDATA_EBPF_CHART_TYPE_STACKED,

587 - NETDATA_SERVICES_SOCKET_UDP_SEND_CONTEXT,

588 - order++,

589 - update_every);

590 -

591 - ebpf_write_chart_obsolete(id,

592 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_RECV_CALLS,

593 - "",

594 - "Calls to udp_recvmsg",

595 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

596 - NETDATA_APPS_NET_GROUP,

597 - NETDATA_EBPF_CHART_TYPE_STACKED,

598 - NETDATA_SERVICES_SOCKET_UDP_RECV_CONTEXT,

599 - order++,

600 - update_every);

543 + ebpf_write_chart_obsolete(

544 + id,

545 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH,

546 + "",

547 + "Bandwidth.",

548 + EBPF_COMMON_UNITS_KILOBITS,

549 + NETDATA_APPS_NET_GROUP,

550 + NETDATA_EBPF_CHART_TYPE_STACKED,

551 + NETDATA_SERVICES_SOCKET_TCP_BANDWIDTH_CONTEXT,

552 + order++,

553 + update_every);

554 +

555 + ebpf_write_chart_obsolete(

556 + id,

557 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RECV_CALLS,

558 + "",

559 + "Calls to tcp_cleanup_rbuf.",

560 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

561 + NETDATA_APPS_NET_GROUP,

562 + NETDATA_EBPF_CHART_TYPE_STACKED,

563 + NETDATA_SERVICES_SOCKET_TCP_RECV_CONTEXT,

564 + order++,

565 + update_every);

566 +

567 + ebpf_write_chart_obsolete(

568 + id,

569 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_SEND_CALLS,

570 + "",

571 + "Calls to tcp_sendmsg.",

572 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

573 + NETDATA_APPS_NET_GROUP,

574 + NETDATA_EBPF_CHART_TYPE_STACKED,

575 + NETDATA_SERVICES_SOCKET_TCP_SEND_CONTEXT,

576 + order++,

577 + update_every);

578 +

579 + ebpf_write_chart_obsolete(

580 + id,

581 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RETRANSMIT,

582 + "",

583 + "Calls to tcp_retransmit",

584 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

585 + NETDATA_APPS_NET_GROUP,

586 + NETDATA_EBPF_CHART_TYPE_STACKED,

587 + NETDATA_SERVICES_SOCKET_TCP_RETRANSMIT_CONTEXT,

588 + order++,

589 + update_every);

590 +

591 + ebpf_write_chart_obsolete(

592 + id,

593 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_SEND_CALLS,

594 + "",

595 + "Calls to udp_sendmsg",

596 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

597 + NETDATA_APPS_NET_GROUP,

598 + NETDATA_EBPF_CHART_TYPE_STACKED,

599 + NETDATA_SERVICES_SOCKET_UDP_SEND_CONTEXT,

600 + order++,

601 + update_every);

602 +

603 + ebpf_write_chart_obsolete(

604 + id,

605 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_RECV_CALLS,

606 + "",

607 + "Calls to udp_recvmsg",

608 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

609 + NETDATA_APPS_NET_GROUP,

610 + NETDATA_EBPF_CHART_TYPE_STACKED,

611 + NETDATA_SERVICES_SOCKET_UDP_RECV_CONTEXT,

612 + order++,

613 + update_every);

614 }

615

616 static void ebpf_obsolete_specific_socket_charts(char *type, int update_every);

@@ -608,11 +621,12 @@ static void ebpf_obsolete_specific_socket_charts(char *type, int update_every);

621 *

622 * @param em a pointer to `struct ebpf_module`

623 */

611 -static inline void ebpf_obsolete_socket_cgroup_charts(ebpf_module_t *em) {

624 +static inline void ebpf_obsolete_socket_cgroup_charts(ebpf_module_t *em)

625 +{

626 pthread_mutex_lock(&mutex_cgroup_shm);

627

628 ebpf_cgroup_target_t *ect;

615 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

629 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

630 if (ect->systemd) {

631 ebpf_obsolete_systemd_socket_charts(em->update_every, ect->name);

632

@@ -638,100 +652,108 @@ void ebpf_socket_obsolete_apps_charts(struct ebpf_module *em)

652 int update_every = em->update_every;

653 pthread_mutex_lock(&collect_data_mutex);

654 for (w = apps_groups_root_target; w; w = w->next) {

641 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SOCKET_IDX))))

655 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_SOCKET_IDX))))

656 continue;

657

644 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

645 - w->clean_name,

646 - "_ebpf_call_tcp_v4_connection",

647 - "Calls to tcp_v4_connection.",

648 - EBPF_COMMON_UNITS_CONNECTIONS,

649 - NETDATA_APPS_NET_GROUP,

650 - NETDATA_EBPF_CHART_TYPE_STACKED,

651 - "app.ebpf_call_tcp_v4_connection",

652 - order++,

653 - update_every);

658 + ebpf_write_chart_obsolete(

659 + NETDATA_APP_FAMILY,

660 + w->clean_name,

661 + "_ebpf_call_tcp_v4_connection",

662 + "Calls to tcp_v4_connection.",

663 + EBPF_COMMON_UNITS_CONNECTIONS,

664 + NETDATA_APPS_NET_GROUP,

665 + NETDATA_EBPF_CHART_TYPE_STACKED,

666 + "app.ebpf_call_tcp_v4_connection",

667 + order++,

668 + update_every);

669

670 if (tcp_v6_connect_address.type == 'T') {

656 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

657 - w->clean_name,

658 - "_ebpf_call_tcp_v6_connection",

659 - "Calls to tcp_v6_connection.",

660 - EBPF_COMMON_UNITS_CONNECTIONS,

661 - NETDATA_APPS_NET_GROUP,

662 - NETDATA_EBPF_CHART_TYPE_STACKED,

663 - "app.ebpf_call_tcp_v6_connection",

664 - order++,

665 - update_every);

671 + ebpf_write_chart_obsolete(

672 + NETDATA_APP_FAMILY,

673 + w->clean_name,

674 + "_ebpf_call_tcp_v6_connection",

675 + "Calls to tcp_v6_connection.",

676 + EBPF_COMMON_UNITS_CONNECTIONS,

677 + NETDATA_APPS_NET_GROUP,

678 + NETDATA_EBPF_CHART_TYPE_STACKED,

679 + "app.ebpf_call_tcp_v6_connection",

680 + order++,

681 + update_every);

682 }

683

668 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

669 - w->clean_name,

670 - "_ebpf_sock_bandwidth",

671 - "Bandwidth.",

672 - EBPF_COMMON_UNITS_KILOBITS,

673 - NETDATA_APPS_NET_GROUP,

674 - NETDATA_EBPF_CHART_TYPE_STACKED,

675 - "app.ebpf_sock_total_bandwidth",

676 - order++,

677 - update_every);

678 -

679 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

680 - w->clean_name,

681 - "_ebpf_call_tcp_sendmsg",

682 - "Calls to tcp_sendmsg.",

683 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

684 - NETDATA_APPS_NET_GROUP,

685 - NETDATA_EBPF_CHART_TYPE_STACKED,

686 - "app.ebpf_call_tcp_sendmsg",

687 - order++,

688 - update_every);

689 -

690 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

691 - w->clean_name,

692 - "_ebpf_call_tcp_cleanup_rbuf",

693 - "Calls to tcp_cleanup_rbuf.",

694 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

695 - NETDATA_APPS_NET_GROUP,

696 - NETDATA_EBPF_CHART_TYPE_STACKED,

697 - "app.ebpf_call_tcp_cleanup_rbuf",

698 - order++,

699 - update_every);

700 -

701 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

702 - w->clean_name,

703 - "_ebpf_call_tcp_retransmit",

704 - "Calls to tcp_retransmit.",

705 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

706 - NETDATA_APPS_NET_GROUP,

707 - NETDATA_EBPF_CHART_TYPE_STACKED,

708 - "app.ebpf_call_tcp_retransmit",

709 - order++,

710 - update_every);

711 -

712 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

713 - w->clean_name,

714 - "_ebpf_call_udp_sendmsg",

715 - "Calls to udp_sendmsg.",

716 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

717 - NETDATA_APPS_NET_GROUP,

718 - NETDATA_EBPF_CHART_TYPE_STACKED,

719 - "app.ebpf_call_udp_sendmsg",

720 - order++,

721 - update_every);

722 -

723 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

724 - w->clean_name,

725 - "_ebpf_call_udp_recvmsg",

726 - "Calls to udp_recvmsg.",

727 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

728 - NETDATA_APPS_NET_GROUP,

729 - NETDATA_EBPF_CHART_TYPE_STACKED,

730 - "app.ebpf_call_udp_recvmsg",

731 - order++,

732 - update_every);

733 -

734 - w->charts_created &= ~(1<<EBPF_MODULE_SOCKET_IDX);

684 + ebpf_write_chart_obsolete(

685 + NETDATA_APP_FAMILY,

686 + w->clean_name,

687 + "_ebpf_sock_bandwidth",

688 + "Bandwidth.",

689 + EBPF_COMMON_UNITS_KILOBITS,

690 + NETDATA_APPS_NET_GROUP,

691 + NETDATA_EBPF_CHART_TYPE_STACKED,

692 + "app.ebpf_sock_total_bandwidth",

693 + order++,

694 + update_every);

695 +

696 + ebpf_write_chart_obsolete(

697 + NETDATA_APP_FAMILY,

698 + w->clean_name,

699 + "_ebpf_call_tcp_sendmsg",

700 + "Calls to tcp_sendmsg.",

701 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

702 + NETDATA_APPS_NET_GROUP,

703 + NETDATA_EBPF_CHART_TYPE_STACKED,

704 + "app.ebpf_call_tcp_sendmsg",

705 + order++,

706 + update_every);

707 +

708 + ebpf_write_chart_obsolete(

709 + NETDATA_APP_FAMILY,

710 + w->clean_name,

711 + "_ebpf_call_tcp_cleanup_rbuf",

712 + "Calls to tcp_cleanup_rbuf.",

713 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

714 + NETDATA_APPS_NET_GROUP,

715 + NETDATA_EBPF_CHART_TYPE_STACKED,

716 + "app.ebpf_call_tcp_cleanup_rbuf",

717 + order++,

718 + update_every);

719 +

720 + ebpf_write_chart_obsolete(

721 + NETDATA_APP_FAMILY,

722 + w->clean_name,

723 + "_ebpf_call_tcp_retransmit",

724 + "Calls to tcp_retransmit.",

725 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

726 + NETDATA_APPS_NET_GROUP,

727 + NETDATA_EBPF_CHART_TYPE_STACKED,

728 + "app.ebpf_call_tcp_retransmit",

729 + order++,

730 + update_every);

731 +

732 + ebpf_write_chart_obsolete(

733 + NETDATA_APP_FAMILY,

734 + w->clean_name,

735 + "_ebpf_call_udp_sendmsg",

736 + "Calls to udp_sendmsg.",

737 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

738 + NETDATA_APPS_NET_GROUP,

739 + NETDATA_EBPF_CHART_TYPE_STACKED,

740 + "app.ebpf_call_udp_sendmsg",

741 + order++,

742 + update_every);

743 +

744 + ebpf_write_chart_obsolete(

745 + NETDATA_APP_FAMILY,

746 + w->clean_name,

747 + "_ebpf_call_udp_recvmsg",

748 + "Calls to udp_recvmsg.",

749 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

750 + NETDATA_APPS_NET_GROUP,

751 + NETDATA_EBPF_CHART_TYPE_STACKED,

752 + "app.ebpf_call_udp_recvmsg",

753 + order++,

754 + update_every);

755 +

756 + w->charts_created &= ~(1 << EBPF_MODULE_SOCKET_IDX);

757 }

758 pthread_mutex_unlock(&collect_data_mutex);

759 }

@@ -746,108 +768,116 @@ void ebpf_socket_obsolete_apps_charts(struct ebpf_module *em)

768 static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)

769 {

770 int order = 21070;

749 - ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,

750 - NETDATA_INBOUND_CONNECTIONS,

751 - "",

752 - "Inbound connections.",

753 - EBPF_COMMON_UNITS_CONNECTIONS,

754 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

755 - NETDATA_EBPF_CHART_TYPE_LINE,

756 - "ip.inbound_conn",

757 - order++,

758 - em->update_every);

759 -

760 - ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,

761 - NETDATA_TCP_OUTBOUND_CONNECTIONS,

762 - "",

763 - "TCP outbound connections.",

764 - EBPF_COMMON_UNITS_CONNECTIONS,

765 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

766 - NETDATA_EBPF_CHART_TYPE_LINE,

767 - "ip.tcp_outbound_conn",

768 - order++,

769 - em->update_every);

770 -

771 -

772 - ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,

773 - NETDATA_TCP_FUNCTION_COUNT,

774 - "",

775 - "Calls to internal functions",

776 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

777 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

778 - NETDATA_EBPF_CHART_TYPE_LINE,

779 - "ip.tcp_functions",

780 - order++,

781 - em->update_every);

782 -

783 - ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,

784 - NETDATA_TCP_FUNCTION_BITS,

785 - "",

786 - "TCP bandwidth",

787 - EBPF_COMMON_UNITS_KILOBITS,

788 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

789 - NETDATA_EBPF_CHART_TYPE_LINE,

790 - "ip.total_tcp_bandwidth",

791 - order++,

792 - em->update_every);

771 + ebpf_write_chart_obsolete(

772 + NETDATA_EBPF_IP_FAMILY,

773 + NETDATA_INBOUND_CONNECTIONS,

774 + "",

775 + "Inbound connections.",

776 + EBPF_COMMON_UNITS_CONNECTIONS,

777 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

778 + NETDATA_EBPF_CHART_TYPE_LINE,

779 + "ip.inbound_conn",

780 + order++,

781 + em->update_every);

782 +

783 + ebpf_write_chart_obsolete(

784 + NETDATA_EBPF_IP_FAMILY,

785 + NETDATA_TCP_OUTBOUND_CONNECTIONS,

786 + "",

787 + "TCP outbound connections.",

788 + EBPF_COMMON_UNITS_CONNECTIONS,

789 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

790 + NETDATA_EBPF_CHART_TYPE_LINE,

791 + "ip.tcp_outbound_conn",

792 + order++,

793 + em->update_every);

794 +

795 + ebpf_write_chart_obsolete(

796 + NETDATA_EBPF_IP_FAMILY,

797 + NETDATA_TCP_FUNCTION_COUNT,

798 + "",

799 + "Calls to internal functions",

800 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

801 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

802 + NETDATA_EBPF_CHART_TYPE_LINE,

803 + "ip.tcp_functions",

804 + order++,

805 + em->update_every);

806 +

807 + ebpf_write_chart_obsolete(

808 + NETDATA_EBPF_IP_FAMILY,

809 + NETDATA_TCP_FUNCTION_BITS,

810 + "",

811 + "TCP bandwidth",

812 + EBPF_COMMON_UNITS_KILOBITS,

813 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

814 + NETDATA_EBPF_CHART_TYPE_LINE,

815 + "ip.total_tcp_bandwidth",

816 + order++,

817 + em->update_every);

818

819 if (em->mode < MODE_ENTRY) {

795 - ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,

796 - NETDATA_TCP_FUNCTION_ERROR,

797 - "",

798 - "TCP errors",

799 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

800 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

801 - NETDATA_EBPF_CHART_TYPE_LINE,

802 - "ip.tcp_error",

803 - order++,

804 - em->update_every);

820 + ebpf_write_chart_obsolete(

821 + NETDATA_EBPF_IP_FAMILY,

822 + NETDATA_TCP_FUNCTION_ERROR,

823 + "",

824 + "TCP errors",

825 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

826 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

827 + NETDATA_EBPF_CHART_TYPE_LINE,

828 + "ip.tcp_error",

829 + order++,

830 + em->update_every);

831 }

832

807 - ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,

808 - NETDATA_TCP_RETRANSMIT,

809 - "",

810 - "Packages retransmitted",

811 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

812 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

813 - NETDATA_EBPF_CHART_TYPE_LINE,

814 - "ip.tcp_retransmit",

815 - order++,

816 - em->update_every);

817 -

818 - ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,

819 - NETDATA_UDP_FUNCTION_COUNT,

820 - "",

821 - "UDP calls",

822 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

823 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

824 - NETDATA_EBPF_CHART_TYPE_LINE,

825 - "ip.udp_functions",

826 - order++,

827 - em->update_every);

828 -

829 - ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,

830 - NETDATA_UDP_FUNCTION_BITS,

831 - "",

832 - "UDP bandwidth",

833 - EBPF_COMMON_UNITS_KILOBITS,

834 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

835 - NETDATA_EBPF_CHART_TYPE_LINE,

836 - "ip.total_udp_bandwidth",

837 - order++,

838 - em->update_every);

833 + ebpf_write_chart_obsolete(

834 + NETDATA_EBPF_IP_FAMILY,

835 + NETDATA_TCP_RETRANSMIT,

836 + "",

837 + "Packages retransmitted",

838 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

839 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

840 + NETDATA_EBPF_CHART_TYPE_LINE,

841 + "ip.tcp_retransmit",

842 + order++,

843 + em->update_every);

844 +

845 + ebpf_write_chart_obsolete(

846 + NETDATA_EBPF_IP_FAMILY,

847 + NETDATA_UDP_FUNCTION_COUNT,

848 + "",

849 + "UDP calls",

850 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

851 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

852 + NETDATA_EBPF_CHART_TYPE_LINE,

853 + "ip.udp_functions",

854 + order++,

855 + em->update_every);

856 +

857 + ebpf_write_chart_obsolete(

858 + NETDATA_EBPF_IP_FAMILY,

859 + NETDATA_UDP_FUNCTION_BITS,

860 + "",

861 + "UDP bandwidth",

862 + EBPF_COMMON_UNITS_KILOBITS,

863 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

864 + NETDATA_EBPF_CHART_TYPE_LINE,

865 + "ip.total_udp_bandwidth",

866 + order++,

867 + em->update_every);

868

869 if (em->mode < MODE_ENTRY) {

841 - ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,

842 - NETDATA_UDP_FUNCTION_ERROR,

843 - "",

844 - "UDP errors",

845 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

846 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

847 - NETDATA_EBPF_CHART_TYPE_LINE,

848 - "ip.udp_error",

849 - order++,

850 - em->update_every);

870 + ebpf_write_chart_obsolete(

871 + NETDATA_EBPF_IP_FAMILY,

872 + NETDATA_UDP_FUNCTION_ERROR,

873 + "",

874 + "UDP errors",

875 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

876 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

877 + NETDATA_EBPF_CHART_TYPE_LINE,

878 + "ip.udp_error",

879 + order++,

880 + em->update_every);

881 }

882

883 fflush(stdout);

@@ -862,7 +892,8 @@ static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)

892 static void ebpf_socket_exit(void *pptr)

893 {

894 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

865 - if(!em) return;

895 + if (!em)

896 + return;

897

898 if (ebpf_read_socket.thread)

899 nd_thread_signal_cancel(ebpf_read_socket.thread);

@@ -903,7 +934,9 @@ static void ebpf_socket_exit(void *pptr)

934 * @param input the structure with the input data.

935 */

936 static void ebpf_update_global_publish(

906 - netdata_publish_syscall_t *publish, netdata_publish_vfs_common_t *tcp, netdata_publish_vfs_common_t *udp,

937 + netdata_publish_syscall_t *publish,

938 + netdata_publish_vfs_common_t *tcp,

939 + netdata_publish_vfs_common_t *udp,

940 netdata_syscall_stat_t *input)

941 {

942 netdata_publish_syscall_t *move = publish;

@@ -949,8 +982,9 @@ static void ebpf_update_global_publish(

982 *

983 * @return

984 */

952 -static inline collected_number ebpf_socket_bytes2bits(uint64_t value) {

953 - return (collected_number) (value* 8/BITS_IN_A_KILOBIT);

985 +static inline collected_number ebpf_socket_bytes2bits(uint64_t value)

986 +{

987 + return (collected_number)(value * 8 / BITS_IN_A_KILOBIT);

988 }

989

990 /**

@@ -973,8 +1007,8 @@ static void ebpf_socket_send_global_inbound_conn()

1007 }

1008

1009 ebpf_write_begin_chart(NETDATA_EBPF_IP_FAMILY, NETDATA_INBOUND_CONNECTIONS, "");

976 - write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_INCOMING_CONNECTION_TCP].name, (long long) tcp_conn);

977 - write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_INCOMING_CONNECTION_UDP].name, (long long) udp_conn);

1010 + write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_INCOMING_CONNECTION_TCP].name, (long long)tcp_conn);

1011 + write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_INCOMING_CONNECTION_UDP].name, (long long)udp_conn);

1012 ebpf_write_end_chart();

1013 }

1014

@@ -990,29 +1024,40 @@ static void ebpf_socket_send_data(ebpf_module_t *em)

1024 ebpf_update_global_publish(socket_publish_aggregated, &common_tcp, &common_udp, socket_aggregated_data);

1025

1026 ebpf_socket_send_global_inbound_conn();

993 - write_count_chart(NETDATA_TCP_OUTBOUND_CONNECTIONS, NETDATA_EBPF_IP_FAMILY,

994 - &socket_publish_aggregated[NETDATA_IDX_TCP_CONNECTION_V4], 2);

1027 + write_count_chart(

1028 + NETDATA_TCP_OUTBOUND_CONNECTIONS,

1029 + NETDATA_EBPF_IP_FAMILY,

1030 + &socket_publish_aggregated[NETDATA_IDX_TCP_CONNECTION_V4],

1031 + 2);

1032

1033 // We read bytes from function arguments, but bandwidth is given in bits,

1034 // so we need to multiply by 8 to convert for the final value.

1035 write_count_chart(NETDATA_TCP_FUNCTION_COUNT, NETDATA_EBPF_IP_FAMILY, socket_publish_aggregated, 3);

999 - write_io_chart(NETDATA_TCP_FUNCTION_BITS, NETDATA_EBPF_IP_FAMILY, socket_id_names[0],

1000 - ebpf_socket_bytes2bits(common_tcp.read), socket_id_names[1],

1001 - ebpf_socket_bytes2bits(common_tcp.write));

1036 + write_io_chart(

1037 + NETDATA_TCP_FUNCTION_BITS,

1038 + NETDATA_EBPF_IP_FAMILY,

1039 + socket_id_names[0],

1040 + ebpf_socket_bytes2bits(common_tcp.read),

1041 + socket_id_names[1],

1042 + ebpf_socket_bytes2bits(common_tcp.write));

1043 if (em->mode < MODE_ENTRY) {

1044 write_err_chart(NETDATA_TCP_FUNCTION_ERROR, NETDATA_EBPF_IP_FAMILY, socket_publish_aggregated, 2);

1045 }

1005 - write_count_chart(NETDATA_TCP_RETRANSMIT, NETDATA_EBPF_IP_FAMILY,

1006 - &socket_publish_aggregated[NETDATA_IDX_TCP_RETRANSMIT],1);

1007 -

1008 - write_count_chart(NETDATA_UDP_FUNCTION_COUNT, NETDATA_EBPF_IP_FAMILY,

1009 - &socket_publish_aggregated[NETDATA_IDX_UDP_RECVBUF],2);

1010 - write_io_chart(NETDATA_UDP_FUNCTION_BITS, NETDATA_EBPF_IP_FAMILY,

1011 - socket_id_names[3], ebpf_socket_bytes2bits(common_udp.read),

1012 - socket_id_names[4], ebpf_socket_bytes2bits(common_udp.write));

1046 + write_count_chart(

1047 + NETDATA_TCP_RETRANSMIT, NETDATA_EBPF_IP_FAMILY, &socket_publish_aggregated[NETDATA_IDX_TCP_RETRANSMIT], 1);

1048 +

1049 + write_count_chart(

1050 + NETDATA_UDP_FUNCTION_COUNT, NETDATA_EBPF_IP_FAMILY, &socket_publish_aggregated[NETDATA_IDX_UDP_RECVBUF], 2);

1051 + write_io_chart(

1052 + NETDATA_UDP_FUNCTION_BITS,

1053 + NETDATA_EBPF_IP_FAMILY,

1054 + socket_id_names[3],

1055 + ebpf_socket_bytes2bits(common_udp.read),

1056 + socket_id_names[4],

1057 + ebpf_socket_bytes2bits(common_udp.write));

1058 if (em->mode < MODE_ENTRY) {

1014 - write_err_chart(NETDATA_UDP_FUNCTION_ERROR, NETDATA_EBPF_IP_FAMILY,

1015 - &socket_publish_aggregated[NETDATA_UDP_START], 2);

1059 + write_err_chart(

1060 + NETDATA_UDP_FUNCTION_ERROR, NETDATA_EBPF_IP_FAMILY, &socket_publish_aggregated[NETDATA_UDP_START], 2);

1061 }

1062 }

1063

@@ -1024,17 +1069,17 @@ void ebpf_socket_send_apps_data()

1069 struct ebpf_target *w;

1070 pthread_mutex_lock(&collect_data_mutex);

1071 for (w = apps_groups_root_target; w; w = w->next) {

1027 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SOCKET_IDX))))

1072 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_SOCKET_IDX))))

1073 continue;

1074

1075 ebpf_socket_publish_apps_t *values = &w->socket;

1076 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_v4_connection");

1032 - write_chart_dimension("connections", (collected_number) values->call_tcp_v4_connection);

1077 + write_chart_dimension("connections", (collected_number)values->call_tcp_v4_connection);

1078 ebpf_write_end_chart();

1079

1080 if (tcp_v6_connect_address.type == 'T') {

1081 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_call_tcp_v6_connection");

1037 - write_chart_dimension("connections", (collected_number) values->call_tcp_v6_connection);

1082 + write_chart_dimension("connections", (collected_number)values->call_tcp_v6_connection);

1083 ebpf_write_end_chart();

1084 }

1085

@@ -1045,23 +1090,23 @@ void ebpf_socket_send_apps_data()

1090 ebpf_write_end_chart();

1091

1092 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_sendmsg");

1048 - write_chart_dimension("calls", (collected_number) values->call_tcp_sent);

1093 + write_chart_dimension("calls", (collected_number)values->call_tcp_sent);

1094 ebpf_write_end_chart();

1095

1096 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_cleanup_rbuf");

1052 - write_chart_dimension("calls", (collected_number) values->call_tcp_received);

1097 + write_chart_dimension("calls", (collected_number)values->call_tcp_received);

1098 ebpf_write_end_chart();

1099

1100 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_retransmit");

1056 - write_chart_dimension("calls", (collected_number) values->retransmit);

1101 + write_chart_dimension("calls", (collected_number)values->retransmit);

1102 ebpf_write_end_chart();

1103

1104 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_udp_sendmsg");

1060 - write_chart_dimension("calls", (collected_number) values->call_udp_sent);

1105 + write_chart_dimension("calls", (collected_number)values->call_udp_sent);

1106 ebpf_write_end_chart();

1107

1108 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_udp_recvmsg");

1064 - write_chart_dimension("calls", (collected_number) values->call_udp_received);

1109 + write_chart_dimension("calls", (collected_number)values->call_udp_received);

1110 ebpf_write_end_chart();

1111 }

1112 pthread_mutex_unlock(&collect_data_mutex);

@@ -1083,113 +1128,143 @@ void ebpf_socket_send_apps_data()

1128 static void ebpf_socket_create_global_charts(ebpf_module_t *em)

1129 {

1130 int order = 21070;

1086 - ebpf_create_chart(NETDATA_EBPF_IP_FAMILY,

1087 - NETDATA_INBOUND_CONNECTIONS,

1088 - "Inbound connections.",

1089 - EBPF_COMMON_UNITS_CONNECTIONS,

1090 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

1091 - "ip.inbound_conn",

1092 - NETDATA_EBPF_CHART_TYPE_LINE,

1093 - order++,

1094 - ebpf_create_global_dimension,

1095 - &socket_publish_aggregated[NETDATA_IDX_INCOMING_CONNECTION_TCP],

1096 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);

1097 -

1098 - ebpf_create_chart(NETDATA_EBPF_IP_FAMILY,

1099 - NETDATA_TCP_OUTBOUND_CONNECTIONS,

1100 - "TCP outbound connections.",

1101 - EBPF_COMMON_UNITS_CONNECTIONS,

1102 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

1103 - "ip.tcp_outbound_conn",

1104 - NETDATA_EBPF_CHART_TYPE_LINE,

1105 - order++,

1106 - ebpf_create_global_dimension,

1107 - &socket_publish_aggregated[NETDATA_IDX_TCP_CONNECTION_V4],

1108 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);

1109 -

1110 -

1111 - ebpf_create_chart(NETDATA_EBPF_IP_FAMILY,

1112 - NETDATA_TCP_FUNCTION_COUNT,

1113 - "Calls to internal functions",

1114 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1115 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

1116 - "ip.tcp_functions",

1117 - NETDATA_EBPF_CHART_TYPE_LINE,

1118 - order++,

1119 - ebpf_create_global_dimension,

1120 - socket_publish_aggregated,

1121 - 3, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);

1122 -

1123 - ebpf_create_chart(NETDATA_EBPF_IP_FAMILY, NETDATA_TCP_FUNCTION_BITS,

1124 - "TCP bandwidth", EBPF_COMMON_UNITS_KILOBITS,

1125 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

1126 - "ip.total_tcp_bandwidth",

1127 - NETDATA_EBPF_CHART_TYPE_LINE,

1128 - order++,

1129 - ebpf_create_global_dimension,

1130 - socket_publish_aggregated,

1131 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);

1131 + ebpf_create_chart(

1132 + NETDATA_EBPF_IP_FAMILY,

1133 + NETDATA_INBOUND_CONNECTIONS,

1134 + "Inbound connections.",

1135 + EBPF_COMMON_UNITS_CONNECTIONS,

1136 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

1137 + "ip.inbound_conn",

1138 + NETDATA_EBPF_CHART_TYPE_LINE,

1139 + order++,

1140 + ebpf_create_global_dimension,

1141 + &socket_publish_aggregated[NETDATA_IDX_INCOMING_CONNECTION_TCP],

1142 + 2,

1143 + em->update_every,

1144 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1145 +

1146 + ebpf_create_chart(

1147 + NETDATA_EBPF_IP_FAMILY,

1148 + NETDATA_TCP_OUTBOUND_CONNECTIONS,

1149 + "TCP outbound connections.",

1150 + EBPF_COMMON_UNITS_CONNECTIONS,

1151 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

1152 + "ip.tcp_outbound_conn",

1153 + NETDATA_EBPF_CHART_TYPE_LINE,

1154 + order++,

1155 + ebpf_create_global_dimension,

1156 + &socket_publish_aggregated[NETDATA_IDX_TCP_CONNECTION_V4],

1157 + 2,

1158 + em->update_every,

1159 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1160 +

1161 + ebpf_create_chart(

1162 + NETDATA_EBPF_IP_FAMILY,

1163 + NETDATA_TCP_FUNCTION_COUNT,

1164 + "Calls to internal functions",

1165 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1166 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

1167 + "ip.tcp_functions",

1168 + NETDATA_EBPF_CHART_TYPE_LINE,

1169 + order++,

1170 + ebpf_create_global_dimension,

1171 + socket_publish_aggregated,

1172 + 3,

1173 + em->update_every,

1174 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1175 +

1176 + ebpf_create_chart(

1177 + NETDATA_EBPF_IP_FAMILY,

1178 + NETDATA_TCP_FUNCTION_BITS,

1179 + "TCP bandwidth",

1180 + EBPF_COMMON_UNITS_KILOBITS,

1181 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

1182 + "ip.total_tcp_bandwidth",

1183 + NETDATA_EBPF_CHART_TYPE_LINE,

1184 + order++,

1185 + ebpf_create_global_dimension,

1186 + socket_publish_aggregated,

1187 + 2,

1188 + em->update_every,

1189 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1190

1191 if (em->mode < MODE_ENTRY) {

1134 - ebpf_create_chart(NETDATA_EBPF_IP_FAMILY,

1135 - NETDATA_TCP_FUNCTION_ERROR,

1136 - "TCP errors",

1137 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1138 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

1139 - "ip.tcp_error",

1140 - NETDATA_EBPF_CHART_TYPE_LINE,

1141 - order++,

1142 - ebpf_create_global_dimension,

1143 - socket_publish_aggregated,

1144 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);

1192 + ebpf_create_chart(

1193 + NETDATA_EBPF_IP_FAMILY,

1194 + NETDATA_TCP_FUNCTION_ERROR,

1195 + "TCP errors",

1196 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1197 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

1198 + "ip.tcp_error",

1199 + NETDATA_EBPF_CHART_TYPE_LINE,

1200 + order++,

1201 + ebpf_create_global_dimension,

1202 + socket_publish_aggregated,

1203 + 2,

1204 + em->update_every,

1205 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1206 }

1207

1147 - ebpf_create_chart(NETDATA_EBPF_IP_FAMILY,

1148 - NETDATA_TCP_RETRANSMIT,

1149 - "Packages retransmitted",

1150 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1151 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

1152 - "ip.tcp_retransmit",

1153 - NETDATA_EBPF_CHART_TYPE_LINE,

1154 - order++,

1155 - ebpf_create_global_dimension,

1156 - &socket_publish_aggregated[NETDATA_IDX_TCP_RETRANSMIT],

1157 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);

1158 -

1159 - ebpf_create_chart(NETDATA_EBPF_IP_FAMILY,

1160 - NETDATA_UDP_FUNCTION_COUNT,

1161 - "UDP calls",

1162 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1163 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

1164 - "ip.udp_functions",

1165 - NETDATA_EBPF_CHART_TYPE_LINE,

1166 - order++,

1167 - ebpf_create_global_dimension,

1168 - &socket_publish_aggregated[NETDATA_IDX_UDP_RECVBUF],

1169 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);

1170 -

1171 - ebpf_create_chart(NETDATA_EBPF_IP_FAMILY, NETDATA_UDP_FUNCTION_BITS,

1172 - "UDP bandwidth", EBPF_COMMON_UNITS_KILOBITS,

1173 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

1174 - "ip.total_udp_bandwidth",

1175 - NETDATA_EBPF_CHART_TYPE_LINE,

1176 - order++,

1177 - ebpf_create_global_dimension,

1178 - &socket_publish_aggregated[NETDATA_IDX_UDP_RECVBUF],

1179 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);

1208 + ebpf_create_chart(

1209 + NETDATA_EBPF_IP_FAMILY,

1210 + NETDATA_TCP_RETRANSMIT,

1211 + "Packages retransmitted",

1212 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1213 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

1214 + "ip.tcp_retransmit",

1215 + NETDATA_EBPF_CHART_TYPE_LINE,

1216 + order++,

1217 + ebpf_create_global_dimension,

1218 + &socket_publish_aggregated[NETDATA_IDX_TCP_RETRANSMIT],

1219 + 1,

1220 + em->update_every,

1221 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1222 +

1223 + ebpf_create_chart(

1224 + NETDATA_EBPF_IP_FAMILY,

1225 + NETDATA_UDP_FUNCTION_COUNT,

1226 + "UDP calls",

1227 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1228 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

1229 + "ip.udp_functions",

1230 + NETDATA_EBPF_CHART_TYPE_LINE,

1231 + order++,

1232 + ebpf_create_global_dimension,

1233 + &socket_publish_aggregated[NETDATA_IDX_UDP_RECVBUF],

1234 + 2,

1235 + em->update_every,

1236 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1237 +

1238 + ebpf_create_chart(

1239 + NETDATA_EBPF_IP_FAMILY,

1240 + NETDATA_UDP_FUNCTION_BITS,

1241 + "UDP bandwidth",

1242 + EBPF_COMMON_UNITS_KILOBITS,

1243 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

1244 + "ip.total_udp_bandwidth",

1245 + NETDATA_EBPF_CHART_TYPE_LINE,

1246 + order++,

1247 + ebpf_create_global_dimension,

1248 + &socket_publish_aggregated[NETDATA_IDX_UDP_RECVBUF],

1249 + 2,

1250 + em->update_every,

1251 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1252

1253 if (em->mode < MODE_ENTRY) {

1182 - ebpf_create_chart(NETDATA_EBPF_IP_FAMILY,

1183 - NETDATA_UDP_FUNCTION_ERROR,

1184 - "UDP errors",

1185 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1186 - NETDATA_SOCKET_KERNEL_FUNCTIONS,

1187 - "ip.udp_error",

1188 - NETDATA_EBPF_CHART_TYPE_LINE,

1189 - order++,

1190 - ebpf_create_global_dimension,

1191 - &socket_publish_aggregated[NETDATA_IDX_UDP_RECVBUF],

1192 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);

1254 + ebpf_create_chart(

1255 + NETDATA_EBPF_IP_FAMILY,

1256 + NETDATA_UDP_FUNCTION_ERROR,

1257 + "UDP errors",

1258 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1259 + NETDATA_SOCKET_KERNEL_FUNCTIONS,

1260 + "ip.udp_error",

1261 + NETDATA_EBPF_CHART_TYPE_LINE,

1262 + order++,

1263 + ebpf_create_global_dimension,

1264 + &socket_publish_aggregated[NETDATA_IDX_UDP_RECVBUF],

1265 + 2,

1266 + em->update_every,

1267 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1268 }

1269

1270 fflush(stdout);

@@ -1213,130 +1288,138 @@ void ebpf_socket_create_apps_charts(struct ebpf_module *em, void *ptr)

1288 if (unlikely(!w->exposed))

1289 continue;

1290

1216 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1217 - w->clean_name,

1218 - "_ebpf_call_tcp_v4_connection",

1219 - "Calls to tcp_v4_connection.",

1220 - EBPF_COMMON_UNITS_CONNECTIONS,

1221 - NETDATA_APPS_NET_GROUP,

1222 - NETDATA_EBPF_CHART_TYPE_STACKED,

1223 - "app.ebpf_call_tcp_v4_connection",

1224 - order++,

1225 - update_every,

1226 - NETDATA_EBPF_MODULE_NAME_SOCKET);

1291 + ebpf_write_chart_cmd(

1292 + NETDATA_APP_FAMILY,

1293 + w->clean_name,

1294 + "_ebpf_call_tcp_v4_connection",

1295 + "Calls to tcp_v4_connection.",

1296 + EBPF_COMMON_UNITS_CONNECTIONS,

1297 + NETDATA_APPS_NET_GROUP,

1298 + NETDATA_EBPF_CHART_TYPE_STACKED,

1299 + "app.ebpf_call_tcp_v4_connection",

1300 + order++,

1301 + update_every,

1302 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1303 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1304 ebpf_commit_label();

1305 fprintf(stdout, "DIMENSION connections '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1306

1307 if (tcp_v6_connect_address.type == 'T') {

1232 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1233 - w->clean_name,

1234 - "_ebpf_call_tcp_v6_connection",

1235 - "Calls to tcp_v6_connection.",

1236 - EBPF_COMMON_UNITS_CONNECTIONS,

1237 - NETDATA_APPS_NET_GROUP,

1238 - NETDATA_EBPF_CHART_TYPE_STACKED,

1239 - "app.ebpf_call_tcp_v6_connection",

1240 - order++,

1241 - update_every,

1242 - NETDATA_EBPF_MODULE_NAME_SOCKET);

1308 + ebpf_write_chart_cmd(

1309 + NETDATA_APP_FAMILY,

1310 + w->clean_name,

1311 + "_ebpf_call_tcp_v6_connection",

1312 + "Calls to tcp_v6_connection.",

1313 + EBPF_COMMON_UNITS_CONNECTIONS,

1314 + NETDATA_APPS_NET_GROUP,

1315 + NETDATA_EBPF_CHART_TYPE_STACKED,

1316 + "app.ebpf_call_tcp_v6_connection",

1317 + order++,

1318 + update_every,

1319 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1320 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1321 ebpf_commit_label();

1322 fprintf(stdout, "DIMENSION connections '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1323 }

1324

1248 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1249 - w->clean_name,

1250 - "_ebpf_sock_bandwidth",

1251 - "Bandwidth.",

1252 - EBPF_COMMON_UNITS_KILOBITS,

1253 - NETDATA_APPS_NET_GROUP,

1254 - NETDATA_EBPF_CHART_TYPE_STACKED,

1255 - "app.ebpf_sock_total_bandwidth",

1256 - order++,

1257 - update_every,

1258 - NETDATA_EBPF_MODULE_NAME_SOCKET);

1325 + ebpf_write_chart_cmd(

1326 + NETDATA_APP_FAMILY,

1327 + w->clean_name,

1328 + "_ebpf_sock_bandwidth",

1329 + "Bandwidth.",

1330 + EBPF_COMMON_UNITS_KILOBITS,

1331 + NETDATA_APPS_NET_GROUP,

1332 + NETDATA_EBPF_CHART_TYPE_STACKED,

1333 + "app.ebpf_sock_total_bandwidth",

1334 + order++,

1335 + update_every,

1336 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1337 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1338 ebpf_commit_label();

1339 fprintf(stdout, "DIMENSION received '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1340 fprintf(stdout, "DIMENSION sent '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1341

1264 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1265 - w->clean_name,

1266 - "_ebpf_call_tcp_sendmsg",

1267 - "Calls to tcp_sendmsg.",

1268 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1269 - NETDATA_APPS_NET_GROUP,

1270 - NETDATA_EBPF_CHART_TYPE_STACKED,

1271 - "app.ebpf_call_tcp_sendmsg",

1272 - order++,

1273 - update_every,

1274 - NETDATA_EBPF_MODULE_NAME_SOCKET);

1342 + ebpf_write_chart_cmd(

1343 + NETDATA_APP_FAMILY,

1344 + w->clean_name,

1345 + "_ebpf_call_tcp_sendmsg",

1346 + "Calls to tcp_sendmsg.",

1347 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1348 + NETDATA_APPS_NET_GROUP,

1349 + NETDATA_EBPF_CHART_TYPE_STACKED,

1350 + "app.ebpf_call_tcp_sendmsg",

1351 + order++,

1352 + update_every,

1353 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1354 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1355 ebpf_commit_label();

1356 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1357

1279 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1280 - w->clean_name,

1281 - "_ebpf_call_tcp_cleanup_rbuf",

1282 - "Calls to tcp_cleanup_rbuf.",

1283 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1284 - NETDATA_APPS_NET_GROUP,

1285 - NETDATA_EBPF_CHART_TYPE_STACKED,

1286 - "app.ebpf_call_tcp_cleanup_rbuf",

1287 - order++,

1288 - update_every,

1289 - NETDATA_EBPF_MODULE_NAME_SOCKET);

1358 + ebpf_write_chart_cmd(

1359 + NETDATA_APP_FAMILY,

1360 + w->clean_name,

1361 + "_ebpf_call_tcp_cleanup_rbuf",

1362 + "Calls to tcp_cleanup_rbuf.",

1363 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1364 + NETDATA_APPS_NET_GROUP,

1365 + NETDATA_EBPF_CHART_TYPE_STACKED,

1366 + "app.ebpf_call_tcp_cleanup_rbuf",

1367 + order++,

1368 + update_every,

1369 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1370 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1371 ebpf_commit_label();

1372 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1373

1294 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1295 - w->clean_name,

1296 - "_ebpf_call_tcp_retransmit",

1297 - "Calls to tcp_retransmit.",

1298 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1299 - NETDATA_APPS_NET_GROUP,

1300 - NETDATA_EBPF_CHART_TYPE_STACKED,

1301 - "app.ebpf_call_tcp_retransmit",

1302 - order++,

1303 - update_every,

1304 - NETDATA_EBPF_MODULE_NAME_SOCKET);

1374 + ebpf_write_chart_cmd(

1375 + NETDATA_APP_FAMILY,

1376 + w->clean_name,

1377 + "_ebpf_call_tcp_retransmit",

1378 + "Calls to tcp_retransmit.",

1379 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1380 + NETDATA_APPS_NET_GROUP,

1381 + NETDATA_EBPF_CHART_TYPE_STACKED,

1382 + "app.ebpf_call_tcp_retransmit",

1383 + order++,

1384 + update_every,

1385 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1386 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1387 ebpf_commit_label();

1388 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1389

1309 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1310 - w->clean_name,

1311 - "_ebpf_call_udp_sendmsg",

1312 - "Calls to udp_sendmsg.",

1313 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1314 - NETDATA_APPS_NET_GROUP,

1315 - NETDATA_EBPF_CHART_TYPE_STACKED,

1316 - "app.ebpf_call_udp_sendmsg",

1317 - order++,

1318 - update_every,

1319 - NETDATA_EBPF_MODULE_NAME_SOCKET);

1390 + ebpf_write_chart_cmd(

1391 + NETDATA_APP_FAMILY,

1392 + w->clean_name,

1393 + "_ebpf_call_udp_sendmsg",

1394 + "Calls to udp_sendmsg.",

1395 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1396 + NETDATA_APPS_NET_GROUP,

1397 + NETDATA_EBPF_CHART_TYPE_STACKED,

1398 + "app.ebpf_call_udp_sendmsg",

1399 + order++,

1400 + update_every,

1401 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1402 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1403 ebpf_commit_label();

1404 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1405

1324 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1325 - w->clean_name,

1326 - "_ebpf_call_udp_recvmsg",

1327 - "Calls to udp_recvmsg.",

1328 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1329 - NETDATA_APPS_NET_GROUP,

1330 - NETDATA_EBPF_CHART_TYPE_STACKED,

1331 - "app.ebpf_call_udp_recvmsg",

1332 - order,

1333 - update_every,

1334 - NETDATA_EBPF_MODULE_NAME_SOCKET);

1406 + ebpf_write_chart_cmd(

1407 + NETDATA_APP_FAMILY,

1408 + w->clean_name,

1409 + "_ebpf_call_udp_recvmsg",

1410 + "Calls to udp_recvmsg.",

1411 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1412 + NETDATA_APPS_NET_GROUP,

1413 + NETDATA_EBPF_CHART_TYPE_STACKED,

1414 + "app.ebpf_call_udp_recvmsg",

1415 + order,

1416 + update_every,

1417 + NETDATA_EBPF_MODULE_NAME_SOCKET);

1418 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1419 ebpf_commit_label();

1420 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1421

1339 - w->charts_created |= 1<<EBPF_MODULE_SOCKET_IDX;

1422 + w->charts_created |= 1 << EBPF_MODULE_SOCKET_IDX;

1423 }

1424 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;

1425 }

@@ -1366,8 +1449,7 @@ static int ebpf_is_specific_ip_inside_range(union netdata_ip_t *cmp, int family)

1449 ebpf_network_viewer_ip_list_t *move = network_viewer_opt.excluded_ips;

1450 while (move) {

1451 if (family == AF_INET) {

1369 - if (move->first.addr32[0] <= ipv4_test &&

1370 - ipv4_test <= move->last.addr32[0])

1452 + if (move->first.addr32[0] <= ipv4_test && ipv4_test <= move->last.addr32[0])

1453 return 0;

1454 } else {

1455 if (memcmp(move->first.addr8, cmp->addr8, sizeof(union netdata_ip_t)) <= 0 &&

@@ -1381,12 +1463,10 @@ static int ebpf_is_specific_ip_inside_range(union netdata_ip_t *cmp, int family)

1463 move = network_viewer_opt.included_ips;

1464 while (move) {

1465 if (family == AF_INET && move->ver == AF_INET) {

1384 - if (move->first.addr32[0] <= ipv4_test &&

1385 - move->last.addr32[0] >= ipv4_test)

1466 + if (move->first.addr32[0] <= ipv4_test && move->last.addr32[0] >= ipv4_test)

1467 return 1;

1468 } else {

1388 - if (move->ver == AF_INET6 &&

1389 - memcmp(move->first.addr8, cmp->addr8, sizeof(union netdata_ip_t)) <= 0 &&

1469 + if (move->ver == AF_INET6 && memcmp(move->first.addr8, cmp->addr8, sizeof(union netdata_ip_t)) <= 0 &&

1470 memcmp(move->last.addr8, cmp->addr8, sizeof(union netdata_ip_t)) >= 0) {

1471 return 1;

1472 }

@@ -1462,7 +1542,6 @@ int hostname_matches_pattern(char *cmp)

1542 move = move->next;

1543 }

1544

1465 -

1545 return 0;

1546 }

1547

@@ -1510,14 +1589,14 @@ static void ebpf_hash_socket_accumulator(netdata_socket_t *values, int end)

1589 for (i = 1; i < end; i++) {

1590 netdata_socket_t *w = &values[i];

1591

1513 - values[0].tcp.call_tcp_sent += w->tcp.call_tcp_sent;

1514 - values[0].tcp.call_tcp_received += w->tcp.call_tcp_received;

1515 - values[0].tcp.tcp_bytes_received += w->tcp.tcp_bytes_received;

1516 - values[0].tcp.tcp_bytes_sent += w->tcp.tcp_bytes_sent;

1517 - values[0].tcp.close += w->tcp.close;

1518 - values[0].tcp.retransmit += w->tcp.retransmit;

1519 - values[0].tcp.ipv4_connect += w->tcp.ipv4_connect;

1520 - values[0].tcp.ipv6_connect += w->tcp.ipv6_connect;

1592 + values[0].tcp.call_tcp_sent += w->tcp.call_tcp_sent;

1593 + values[0].tcp.call_tcp_received += w->tcp.call_tcp_received;

1594 + values[0].tcp.tcp_bytes_received += w->tcp.tcp_bytes_received;

1595 + values[0].tcp.tcp_bytes_sent += w->tcp.tcp_bytes_sent;

1596 + values[0].tcp.close += w->tcp.close;

1597 + values[0].tcp.retransmit += w->tcp.retransmit;

1598 + values[0].tcp.ipv4_connect += w->tcp.ipv4_connect;

1599 + values[0].tcp.ipv6_connect += w->tcp.ipv6_connect;

1600

1601 if (!protocol)

1602 protocol = w->protocol;

@@ -1535,7 +1614,7 @@ static void ebpf_hash_socket_accumulator(netdata_socket_t *values, int end)

1614 external_origin = NETDATA_EBPF_SRC_IP_ORIGIN_EXTERNAL;

1615 }

1616

1538 - values[0].protocol = (!protocol)?IPPROTO_TCP:protocol;

1617 + values[0].protocol = (!protocol) ? IPPROTO_TCP : protocol;

1618 values[0].current_timestamp = ct;

1619 values[0].first_timestamp = ft;

1620 values[0].external_origin = external_origin;

@@ -1555,14 +1634,20 @@ static void ebpf_socket_translate(netdata_socket_plus_t *dst, netdata_socket_idx

1634 char service[NI_MAXSERV];

1635 int ret;

1636 if (dst->data.family == AF_INET) {

1558 - struct sockaddr_in ipv4_addr = { };

1637 + struct sockaddr_in ipv4_addr = {};

1638 ipv4_addr.sin_port = 0;

1639 ipv4_addr.sin_addr.s_addr = key->saddr.addr32[0];

1640 ipv4_addr.sin_family = AF_INET;

1641 if (resolve) {

1642 // NI_NAMEREQD : It is too slow

1564 - ret = getnameinfo((struct sockaddr *) &ipv4_addr, sizeof(ipv4_addr), dst->socket_string.src_ip,

1565 - INET6_ADDRSTRLEN, service, NI_MAXSERV, NI_NUMERICHOST | NI_NUMERICSERV);

1643 + ret = getnameinfo(

1644 + (struct sockaddr *)&ipv4_addr,

1645 + sizeof(ipv4_addr),

1646 + dst->socket_string.src_ip,

1647 + INET6_ADDRSTRLEN,

1648 + service,

1649 + NI_MAXSERV,

1650 + NI_NUMERICHOST | NI_NUMERICSERV);

1651 if (ret) {

1652 collector_error("Cannot resolve name: %s", gai_strerror(ret));

1653 resolve = 0;

@@ -1570,9 +1655,14 @@ static void ebpf_socket_translate(netdata_socket_plus_t *dst, netdata_socket_idx

1655 ipv4_addr.sin_addr.s_addr = key->daddr.addr32[0];

1656

1657 ipv4_addr.sin_port = key->dport;

1573 - ret = getnameinfo((struct sockaddr *) &ipv4_addr, sizeof(ipv4_addr), dst->socket_string.dst_ip,

1574 - INET6_ADDRSTRLEN, dst->socket_string.dst_port, NI_MAXSERV,

1575 - NI_NUMERICHOST);

1658 + ret = getnameinfo(

1659 + (struct sockaddr *)&ipv4_addr,

1660 + sizeof(ipv4_addr),

1661 + dst->socket_string.dst_ip,

1662 + INET6_ADDRSTRLEN,

1663 + dst->socket_string.dst_port,

1664 + NI_MAXSERV,

1665 + NI_NUMERICHOST);

1666 if (ret) {

1667 collector_error("Cannot resolve name: %s", gai_strerror(ret));

1668 resolve = 0;

@@ -1584,30 +1674,41 @@ static void ebpf_socket_translate(netdata_socket_plus_t *dst, netdata_socket_idx

1674 if (!resolve) {

1675 ipv4_addr.sin_addr.s_addr = key->saddr.addr32[0];

1676

1587 - if(!inet_ntop(AF_INET, &ipv4_addr.sin_addr, dst->socket_string.src_ip, INET6_ADDRSTRLEN))

1677 + if (!inet_ntop(AF_INET, &ipv4_addr.sin_addr, dst->socket_string.src_ip, INET6_ADDRSTRLEN))

1678 netdata_log_info("Cannot convert IP %u .", ipv4_addr.sin_addr.s_addr);

1679

1680 ipv4_addr.sin_addr.s_addr = key->daddr.addr32[0];

1681

1592 - if(!inet_ntop(AF_INET, &ipv4_addr.sin_addr, dst->socket_string.dst_ip, INET6_ADDRSTRLEN))

1682 + if (!inet_ntop(AF_INET, &ipv4_addr.sin_addr, dst->socket_string.dst_ip, INET6_ADDRSTRLEN))

1683 netdata_log_info("Cannot convert IP %u .", ipv4_addr.sin_addr.s_addr);

1594 - snprintfz(dst->socket_string.dst_port, NI_MAXSERV, "%u", ntohs(key->dport));

1684 + snprintfz(dst->socket_string.dst_port, NI_MAXSERV, "%u", ntohs(key->dport));

1685 }

1686 } else {

1597 - struct sockaddr_in6 ipv6_addr = { };

1687 + struct sockaddr_in6 ipv6_addr = {};

1688 memcpy(&ipv6_addr.sin6_addr, key->saddr.addr8, sizeof(key->saddr.addr8));

1689 ipv6_addr.sin6_family = AF_INET6;

1690 if (resolve) {

1601 - ret = getnameinfo((struct sockaddr *) &ipv6_addr, sizeof(ipv6_addr), dst->socket_string.src_ip,

1602 - INET6_ADDRSTRLEN, service, NI_MAXSERV, NI_NUMERICHOST | NI_NUMERICSERV);

1691 + ret = getnameinfo(

1692 + (struct sockaddr *)&ipv6_addr,

1693 + sizeof(ipv6_addr),

1694 + dst->socket_string.src_ip,

1695 + INET6_ADDRSTRLEN,

1696 + service,

1697 + NI_MAXSERV,

1698 + NI_NUMERICHOST | NI_NUMERICSERV);

1699 if (ret) {

1700 collector_error("Cannot resolve name: %s", gai_strerror(ret));

1701 resolve = 0;

1702 } else {

1703 memcpy(&ipv6_addr.sin6_addr, key->daddr.addr8, sizeof(key->daddr.addr8));

1608 - ret = getnameinfo((struct sockaddr *) &ipv6_addr, sizeof(ipv6_addr), dst->socket_string.dst_ip,

1609 - INET6_ADDRSTRLEN, dst->socket_string.dst_port, NI_MAXSERV,

1610 - NI_NUMERICHOST);

1704 + ret = getnameinfo(

1705 + (struct sockaddr *)&ipv6_addr,

1706 + sizeof(ipv6_addr),

1707 + dst->socket_string.dst_ip,

1708 + INET6_ADDRSTRLEN,

1709 + dst->socket_string.dst_port,

1710 + NI_MAXSERV,

1711 + NI_NUMERICHOST);

1712 if (ret) {

1713 collector_error("Cannot resolve name: %s", gai_strerror(ret));

1714 resolve = 0;

@@ -1617,29 +1718,29 @@ static void ebpf_socket_translate(netdata_socket_plus_t *dst, netdata_socket_idx

1718

1719 if (!resolve) {

1720 memcpy(&ipv6_addr.sin6_addr, key->saddr.addr8, sizeof(key->saddr.addr8));

1620 - if(!inet_ntop(AF_INET6, &ipv6_addr.sin6_addr, dst->socket_string.src_ip, INET6_ADDRSTRLEN))

1721 + if (!inet_ntop(AF_INET6, &ipv6_addr.sin6_addr, dst->socket_string.src_ip, INET6_ADDRSTRLEN))

1722 netdata_log_info("Cannot convert IPv6 Address.");

1723

1724 memcpy(&ipv6_addr.sin6_addr, key->daddr.addr8, sizeof(key->daddr.addr8));

1624 - if(!inet_ntop(AF_INET6, &ipv6_addr.sin6_addr, dst->socket_string.dst_ip, INET6_ADDRSTRLEN))

1725 + if (!inet_ntop(AF_INET6, &ipv6_addr.sin6_addr, dst->socket_string.dst_ip, INET6_ADDRSTRLEN))

1726 netdata_log_info("Cannot convert IPv6 Address.");

1626 - snprintfz(dst->socket_string.dst_port, NI_MAXSERV, "%u", ntohs(key->dport));

1727 + snprintfz(dst->socket_string.dst_port, NI_MAXSERV, "%u", ntohs(key->dport));

1728 }

1729 }

1730 dst->pid = key->pid;

1731

1732 if (!strcmp(dst->socket_string.dst_port, "0"))

1632 - snprintfz(dst->socket_string.dst_port, NI_MAXSERV, "%u", ntohs(key->dport));

1733 + snprintfz(dst->socket_string.dst_port, NI_MAXSERV, "%u", ntohs(key->dport));

1734 #ifdef NETDATA_DEV_MODE

1634 - collector_info("New socket: { ORIGIN IP: %s, ORIGIN : %u, DST IP:%s, DST PORT: %s, PID: %u, PROTO: %d, FAMILY: %d}",

1635 - dst->socket_string.src_ip,

1636 - dst->data.external_origin,

1637 - dst->socket_string.dst_ip,

1638 - dst->socket_string.dst_port,

1639 - dst->pid,

1640 - dst->data.protocol,

1641 - dst->data.family

1642 - );

1735 + collector_info(

1736 + "New socket: { ORIGIN IP: %s, ORIGIN : %u, DST IP:%s, DST PORT: %s, PID: %u, PROTO: %d, FAMILY: %d}",

1737 + dst->socket_string.src_ip,

1738 + dst->data.external_origin,

1739 + dst->socket_string.dst_ip,

1740 + dst->socket_string.dst_port,

1741 + dst->pid,

1742 + dst->data.protocol,

1743 + dst->data.family);

1744 #endif

1745 }

1746

@@ -1730,7 +1831,7 @@ static void ebpf_update_array_vectors(ebpf_module_t *em)

1831 if (translate) {

1832 ebpf_socket_translate(socket_ptr, &key);

1833 deleted = false;

1733 - } else { // Check socket was updated

1834 + } else { // Check socket was updated

1835 deleted = false;

1836 if (prev_period) {

1837 if (values[0].current_timestamp > prev_period) // Socket updated

@@ -1748,7 +1849,7 @@ static void ebpf_update_array_vectors(ebpf_module_t *em)

1849 rw_spinlock_write_unlock(&pid_ptr->socket_stats.rw_spinlock);

1850 rw_spinlock_write_unlock(&ebpf_judy_pid.index.rw_spinlock);

1851

1751 -end_socket_loop: ; // the empty statement is here to allow code to be compiled by old compilers

1852 + end_socket_loop:; // the empty statement is here to allow code to be compiled by old compilers

1853 ebpf_pid_data_t *local_pid = ebpf_get_pid_data(key.pid, 0, values[0].name, EBPF_MODULE_SOCKET_IDX);

1854 ebpf_socket_publish_apps_t *curr = local_pid->socket;

1855 if (!curr)

@@ -1772,7 +1873,7 @@ void ebpf_socket_resume_apps_data()

1873 struct ebpf_target *w;

1874

1875 for (w = apps_groups_root_target; w; w = w->next) {

1775 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SOCKET_IDX))))

1876 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_SOCKET_IDX))))

1877 continue;

1878

1879 struct ebpf_pid_on_target *move = w->root_pid;

@@ -1850,8 +1951,8 @@ void *ebpf_read_socket_thread(void *ptr)

1951 * @param proto the protocol used for this connection.

1952 * @param in the structure with values read form different sources.

1953 */

1853 -static inline void fill_nv_port_list(ebpf_network_viewer_port_list_t *out, uint16_t value, uint16_t proto,

1854 - netdata_passive_connection_t *in)

1954 +static inline void

1955 +fill_nv_port_list(ebpf_network_viewer_port_list_t *out, uint16_t value, uint16_t proto, netdata_passive_connection_t *in)

1956 {

1957 out->first = value;

1958 out->protocol = proto;

@@ -1941,19 +2042,21 @@ static void read_listen_table()

2042 static void ebpf_socket_read_hash_global_tables(netdata_idx_t *stats, int maps_per_core)

2043 {

2044 netdata_idx_t res[NETDATA_SOCKET_COUNTER];

1944 - ebpf_read_global_table_stats(res,

1945 - socket_hash_values,

1946 - socket_maps[NETDATA_SOCKET_GLOBAL].map_fd,

1947 - maps_per_core,

1948 - NETDATA_KEY_CALLS_TCP_SENDMSG,

1949 - NETDATA_SOCKET_COUNTER);

1950 -

1951 - ebpf_read_global_table_stats(stats,

1952 - socket_hash_values,

1953 - socket_maps[NETDATA_SOCKET_TABLE_CTRL].map_fd,

1954 - maps_per_core,

1955 - NETDATA_CONTROLLER_PID_TABLE_ADD,

1956 - NETDATA_CONTROLLER_END);

2045 + ebpf_read_global_table_stats(

2046 + res,

2047 + socket_hash_values,

2048 + socket_maps[NETDATA_SOCKET_GLOBAL].map_fd,

2049 + maps_per_core,

2050 + NETDATA_KEY_CALLS_TCP_SENDMSG,

2051 + NETDATA_SOCKET_COUNTER);

2052 +

2053 + ebpf_read_global_table_stats(

2054 + stats,

2055 + socket_hash_values,

2056 + socket_maps[NETDATA_SOCKET_TABLE_CTRL].map_fd,

2057 + maps_per_core,

2058 + NETDATA_CONTROLLER_PID_TABLE_ADD,

2059 + NETDATA_CONTROLLER_END);

2060

2061 socket_aggregated_data[NETDATA_IDX_TCP_SENDMSG].call = res[NETDATA_KEY_CALLS_TCP_SENDMSG];

2062 socket_aggregated_data[NETDATA_IDX_TCP_CLEANUP_RBUF].call = res[NETDATA_KEY_CALLS_TCP_CLEANUP_RBUF];

@@ -2005,7 +2108,7 @@ void ebpf_socket_fill_publish_apps(ebpf_socket_publish_apps_t *curr, netdata_soc

2108 */

2109 static void ebpf_update_socket_cgroup()

2110 {

2008 - ebpf_cgroup_target_t *ect ;

2111 + ebpf_cgroup_target_t *ect;

2112

2113 pthread_mutex_lock(&mutex_cgroup_shm);

2114 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

@@ -2064,17 +2167,26 @@ static void ebpf_socket_sum_cgroup_pids(ebpf_socket_publish_apps_t *socket, stru

2167 }

2168

2169 socket->bytes_sent = (accumulator.bytes_sent >= socket->bytes_sent) ? accumulator.bytes_sent : socket->bytes_sent;

2067 - socket->bytes_received = (accumulator.bytes_received >= socket->bytes_received) ? accumulator.bytes_received : socket->bytes_received;

2068 - socket->call_tcp_sent = (accumulator.call_tcp_sent >= socket->call_tcp_sent) ? accumulator.call_tcp_sent : socket->call_tcp_sent;

2069 - socket->call_tcp_received = (accumulator.call_tcp_received >= socket->call_tcp_received) ? accumulator.call_tcp_received : socket->call_tcp_received;

2170 + socket->bytes_received =

2171 + (accumulator.bytes_received >= socket->bytes_received) ? accumulator.bytes_received : socket->bytes_received;

2172 + socket->call_tcp_sent =

2173 + (accumulator.call_tcp_sent >= socket->call_tcp_sent) ? accumulator.call_tcp_sent : socket->call_tcp_sent;

2174 + socket->call_tcp_received = (accumulator.call_tcp_received >= socket->call_tcp_received) ?

2175 + accumulator.call_tcp_received :

2176 + socket->call_tcp_received;

2177 socket->retransmit = (accumulator.retransmit >= socket->retransmit) ? accumulator.retransmit : socket->retransmit;

2071 - socket->call_udp_sent = (accumulator.call_udp_sent >= socket->call_udp_sent) ? accumulator.call_udp_sent : socket->call_udp_sent;

2072 - socket->call_udp_received = (accumulator.call_udp_received >= socket->call_udp_received) ? accumulator.call_udp_received : socket->call_udp_received;

2178 + socket->call_udp_sent =

2179 + (accumulator.call_udp_sent >= socket->call_udp_sent) ? accumulator.call_udp_sent : socket->call_udp_sent;

2180 + socket->call_udp_received = (accumulator.call_udp_received >= socket->call_udp_received) ?

2181 + accumulator.call_udp_received :

2182 + socket->call_udp_received;

2183 socket->call_close = (accumulator.call_close >= socket->call_close) ? accumulator.call_close : socket->call_close;

2184 socket->call_tcp_v4_connection = (accumulator.call_tcp_v4_connection >= socket->call_tcp_v4_connection) ?

2075 - accumulator.call_tcp_v4_connection : socket->call_tcp_v4_connection;

2185 + accumulator.call_tcp_v4_connection :

2186 + socket->call_tcp_v4_connection;

2187 socket->call_tcp_v6_connection = (accumulator.call_tcp_v6_connection >= socket->call_tcp_v6_connection) ?

2077 - accumulator.call_tcp_v6_connection : socket->call_tcp_v6_connection;

2188 + accumulator.call_tcp_v6_connection :

2189 + socket->call_tcp_v6_connection;

2190 }

2191

2192 /**

@@ -2089,125 +2201,133 @@ static void ebpf_create_specific_socket_charts(char *type, int update_every)

2201 {

2202 int order_basis = 5300;

2203 char *label = (!strncmp(type, "cgroup_", 7)) ? &type[7] : type;

2092 - ebpf_write_chart_cmd(type,

2093 - NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V4,

2094 - "",

2095 - "Calls to tcp_v4_connection",

2096 - EBPF_COMMON_UNITS_CONNECTIONS,

2097 - NETDATA_CGROUP_NET_GROUP,

2098 - NETDATA_EBPF_CHART_TYPE_LINE,

2099 - NETDATA_CGROUP_TCP_V4_CONN_CONTEXT,

2100 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2101 - update_every,

2102 - NETDATA_EBPF_MODULE_NAME_SOCKET);

2204 + ebpf_write_chart_cmd(

2205 + type,

2206 + NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V4,

2207 + "",

2208 + "Calls to tcp_v4_connection",

2209 + EBPF_COMMON_UNITS_CONNECTIONS,

2210 + NETDATA_CGROUP_NET_GROUP,

2211 + NETDATA_EBPF_CHART_TYPE_LINE,

2212 + NETDATA_CGROUP_TCP_V4_CONN_CONTEXT,

2213 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2214 + update_every,

2215 + NETDATA_EBPF_MODULE_NAME_SOCKET);

2216 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

2217 ebpf_commit_label();

2218 fprintf(stdout, "DIMENSION connections '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2219

2220 if (tcp_v6_connect_address.type == 'T') {

2108 - ebpf_write_chart_cmd(type,

2109 - NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V6,

2110 - "",

2111 - "Calls to tcp_v6_connection",

2112 - EBPF_COMMON_UNITS_CONNECTIONS,

2113 - NETDATA_CGROUP_NET_GROUP,

2114 - NETDATA_EBPF_CHART_TYPE_LINE,

2115 - NETDATA_CGROUP_TCP_V6_CONN_CONTEXT,

2116 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2117 - update_every,

2118 - NETDATA_EBPF_MODULE_NAME_SOCKET);

2221 + ebpf_write_chart_cmd(

2222 + type,

2223 + NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V6,

2224 + "",

2225 + "Calls to tcp_v6_connection",

2226 + EBPF_COMMON_UNITS_CONNECTIONS,

2227 + NETDATA_CGROUP_NET_GROUP,

2228 + NETDATA_EBPF_CHART_TYPE_LINE,

2229 + NETDATA_CGROUP_TCP_V6_CONN_CONTEXT,

2230 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2231 + update_every,

2232 + NETDATA_EBPF_MODULE_NAME_SOCKET);

2233 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

2234 ebpf_commit_label();

2235 fprintf(stdout, "DIMENSION connections '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2236 }

2237

2124 - ebpf_write_chart_cmd(type,

2125 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH,

2126 - "",

2127 - "Bandwidth.",

2128 - EBPF_COMMON_UNITS_KILOBITS,

2129 - NETDATA_CGROUP_NET_GROUP,

2130 - NETDATA_EBPF_CHART_TYPE_LINE,

2131 - NETDATA_CGROUP_SOCKET_TCP_BANDWIDTH_CONTEXT,

2132 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2133 - update_every,

2134 - NETDATA_EBPF_MODULE_NAME_SOCKET);

2238 + ebpf_write_chart_cmd(

2239 + type,

2240 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH,

2241 + "",

2242 + "Bandwidth.",

2243 + EBPF_COMMON_UNITS_KILOBITS,

2244 + NETDATA_CGROUP_NET_GROUP,

2245 + NETDATA_EBPF_CHART_TYPE_LINE,

2246 + NETDATA_CGROUP_SOCKET_TCP_BANDWIDTH_CONTEXT,

2247 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2248 + update_every,

2249 + NETDATA_EBPF_MODULE_NAME_SOCKET);

2250 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

2251 ebpf_commit_label();

2252 fprintf(stdout, "DIMENSION received '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2253 fprintf(stdout, "DIMENSION sent '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2254

2140 - ebpf_write_chart_cmd(type,

2141 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RECV_CALLS,

2142 - "",

2143 - "Calls to tcp_cleanup_rbuf.",

2144 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2145 - NETDATA_CGROUP_NET_GROUP,

2146 - NETDATA_EBPF_CHART_TYPE_LINE,

2147 - NETDATA_CGROUP_SOCKET_TCP_RECV_CONTEXT,

2148 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2149 - update_every,

2150 - NETDATA_EBPF_MODULE_NAME_SOCKET);

2255 + ebpf_write_chart_cmd(

2256 + type,

2257 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RECV_CALLS,

2258 + "",

2259 + "Calls to tcp_cleanup_rbuf.",

2260 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2261 + NETDATA_CGROUP_NET_GROUP,

2262 + NETDATA_EBPF_CHART_TYPE_LINE,

2263 + NETDATA_CGROUP_SOCKET_TCP_RECV_CONTEXT,

2264 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2265 + update_every,

2266 + NETDATA_EBPF_MODULE_NAME_SOCKET);

2267 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

2268 ebpf_commit_label();

2269 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2270

2155 - ebpf_write_chart_cmd(type,

2156 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_SEND_CALLS,

2157 - "",

2158 - "Calls to tcp_sendmsg.",

2159 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2160 - NETDATA_CGROUP_NET_GROUP,

2161 - NETDATA_EBPF_CHART_TYPE_LINE,

2162 - NETDATA_CGROUP_SOCKET_TCP_SEND_CONTEXT,

2163 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2164 - update_every,

2165 - NETDATA_EBPF_MODULE_NAME_SOCKET);

2271 + ebpf_write_chart_cmd(

2272 + type,

2273 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_SEND_CALLS,

2274 + "",

2275 + "Calls to tcp_sendmsg.",

2276 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2277 + NETDATA_CGROUP_NET_GROUP,

2278 + NETDATA_EBPF_CHART_TYPE_LINE,

2279 + NETDATA_CGROUP_SOCKET_TCP_SEND_CONTEXT,

2280 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2281 + update_every,

2282 + NETDATA_EBPF_MODULE_NAME_SOCKET);

2283 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

2284 ebpf_commit_label();

2285 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2286

2170 - ebpf_write_chart_cmd(type,

2171 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RETRANSMIT,

2172 - "",

2173 - "Calls to tcp_retransmit.",

2174 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2175 - NETDATA_CGROUP_NET_GROUP,

2176 - NETDATA_EBPF_CHART_TYPE_LINE,

2177 - NETDATA_CGROUP_SOCKET_TCP_RETRANSMIT_CONTEXT,

2178 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2179 - update_every,

2180 - NETDATA_EBPF_MODULE_NAME_SOCKET);

2287 + ebpf_write_chart_cmd(

2288 + type,

2289 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RETRANSMIT,

2290 + "",

2291 + "Calls to tcp_retransmit.",

2292 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2293 + NETDATA_CGROUP_NET_GROUP,

2294 + NETDATA_EBPF_CHART_TYPE_LINE,

2295 + NETDATA_CGROUP_SOCKET_TCP_RETRANSMIT_CONTEXT,

2296 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2297 + update_every,

2298 + NETDATA_EBPF_MODULE_NAME_SOCKET);

2299 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

2300 ebpf_commit_label();

2301 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2302

2185 - ebpf_write_chart_cmd(type,

2186 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_SEND_CALLS,

2187 - "",

2188 - "Calls to udp_sendmsg.",

2189 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2190 - NETDATA_CGROUP_NET_GROUP,

2191 - NETDATA_EBPF_CHART_TYPE_LINE,

2192 - NETDATA_CGROUP_SOCKET_UDP_SEND_CONTEXT,

2193 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2194 - update_every,

2195 - NETDATA_EBPF_MODULE_NAME_SOCKET);

2303 + ebpf_write_chart_cmd(

2304 + type,

2305 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_SEND_CALLS,

2306 + "",

2307 + "Calls to udp_sendmsg.",

2308 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2309 + NETDATA_CGROUP_NET_GROUP,

2310 + NETDATA_EBPF_CHART_TYPE_LINE,

2311 + NETDATA_CGROUP_SOCKET_UDP_SEND_CONTEXT,

2312 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2313 + update_every,

2314 + NETDATA_EBPF_MODULE_NAME_SOCKET);

2315 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

2316 ebpf_commit_label();

2317 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2318

2200 - ebpf_write_chart_cmd(type,

2201 - NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_RECV_CALLS,

2202 - "",

2203 - "Calls to udp_recvmsg.",

2204 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2205 - NETDATA_CGROUP_NET_GROUP,

2206 - NETDATA_EBPF_CHART_TYPE_LINE,

2207 - NETDATA_CGROUP_SOCKET_UDP_RECV_CONTEXT,

2208 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2209 - update_every,

2210 - NETDATA_EBPF_MODULE_NAME_SOCKET);

2319 + ebpf_write_chart_cmd(

2320 + type,

2321 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_RECV_CALLS,

2322 + "",

2323 + "Calls to udp_recvmsg.",

2324 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2325 + NETDATA_CGROUP_NET_GROUP,

2326 + NETDATA_EBPF_CHART_TYPE_LINE,

2327 + NETDATA_CGROUP_SOCKET_UDP_RECV_CONTEXT,

2328 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2329 + update_every,

2330 + NETDATA_EBPF_MODULE_NAME_SOCKET);

2331 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

2332 ebpf_commit_label();

2333 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

@@ -2224,66 +2344,103 @@ static void ebpf_create_specific_socket_charts(char *type, int update_every)

2344 static void ebpf_obsolete_specific_socket_charts(char *type, int update_every)

2345 {

2346 int order_basis = 5300;

2227 - ebpf_write_chart_obsolete(type,

2228 - NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V4,

2229 - "",

2230 - "Calls to tcp_v4_connection",

2231 - EBPF_COMMON_UNITS_CONNECTIONS,

2232 - NETDATA_APPS_NET_GROUP,

2233 - NETDATA_EBPF_CHART_TYPE_LINE,

2234 - NETDATA_CGROUP_TCP_V4_CONN_CONTEXT,

2235 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2236 - update_every);

2347 + ebpf_write_chart_obsolete(

2348 + type,

2349 + NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V4,

2350 + "",

2351 + "Calls to tcp_v4_connection",

2352 + EBPF_COMMON_UNITS_CONNECTIONS,

2353 + NETDATA_APPS_NET_GROUP,

2354 + NETDATA_EBPF_CHART_TYPE_LINE,

2355 + NETDATA_CGROUP_TCP_V4_CONN_CONTEXT,

2356 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2357 + update_every);

2358

2359 if (tcp_v6_connect_address.type == 'T') {

2239 - ebpf_write_chart_obsolete(type,

2240 - NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V6,

2241 - "",

2242 - "Calls to tcp_v6_connection",

2243 - EBPF_COMMON_UNITS_CONNECTIONS,

2244 - NETDATA_APPS_NET_GROUP,

2245 - NETDATA_EBPF_CHART_TYPE_LINE,

2246 - NETDATA_CGROUP_TCP_V6_CONN_CONTEXT,

2247 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2248 - update_every);

2360 + ebpf_write_chart_obsolete(

2361 + type,

2362 + NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V6,

2363 + "",

2364 + "Calls to tcp_v6_connection",

2365 + EBPF_COMMON_UNITS_CONNECTIONS,

2366 + NETDATA_APPS_NET_GROUP,

2367 + NETDATA_EBPF_CHART_TYPE_LINE,

2368 + NETDATA_CGROUP_TCP_V6_CONN_CONTEXT,

2369 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2370 + update_every);

2371 }

2372

2251 - ebpf_write_chart_obsolete(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH,

2252 - "",

2253 - "Bandwidth.",

2254 - EBPF_COMMON_UNITS_KILOBITS, NETDATA_APPS_NET_GROUP,

2255 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SOCKET_TCP_BANDWIDTH_CONTEXT,

2256 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);

2257 -

2258 - ebpf_write_chart_obsolete(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RECV_CALLS, "",

2259 - "Calls to tcp_cleanup_rbuf.",

2260 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_NET_GROUP,

2261 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SOCKET_TCP_RECV_CONTEXT,

2262 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);

2263 -

2264 - ebpf_write_chart_obsolete(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_SEND_CALLS, "",

2265 - "Calls to tcp_sendmsg.",

2266 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_NET_GROUP,

2267 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SOCKET_TCP_SEND_CONTEXT,

2268 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);

2269 -

2270 - ebpf_write_chart_obsolete(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RETRANSMIT, "",

2271 - "Calls to tcp_retransmit.",

2272 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_NET_GROUP,

2273 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SOCKET_TCP_RETRANSMIT_CONTEXT,

2274 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);

2275 -

2276 - ebpf_write_chart_obsolete(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_SEND_CALLS, "",

2277 - "Calls to udp_sendmsg.",

2278 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_NET_GROUP,

2279 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SOCKET_UDP_SEND_CONTEXT,

2280 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);

2281 -

2282 - ebpf_write_chart_obsolete(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_RECV_CALLS, "",

2283 - "Calls to udp_recvmsg.",

2284 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_APPS_NET_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,

2285 - NETDATA_CGROUP_SOCKET_UDP_RECV_CONTEXT,

2286 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);

2373 + ebpf_write_chart_obsolete(

2374 + type,

2375 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH,

2376 + "",

2377 + "Bandwidth.",

2378 + EBPF_COMMON_UNITS_KILOBITS,

2379 + NETDATA_APPS_NET_GROUP,

2380 + NETDATA_EBPF_CHART_TYPE_LINE,

2381 + NETDATA_CGROUP_SOCKET_TCP_BANDWIDTH_CONTEXT,

2382 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2383 + update_every);

2384 +

2385 + ebpf_write_chart_obsolete(

2386 + type,

2387 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RECV_CALLS,

2388 + "",

2389 + "Calls to tcp_cleanup_rbuf.",

2390 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2391 + NETDATA_APPS_NET_GROUP,

2392 + NETDATA_EBPF_CHART_TYPE_LINE,

2393 + NETDATA_CGROUP_SOCKET_TCP_RECV_CONTEXT,

2394 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2395 + update_every);

2396 +

2397 + ebpf_write_chart_obsolete(

2398 + type,

2399 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_SEND_CALLS,

2400 + "",

2401 + "Calls to tcp_sendmsg.",

2402 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2403 + NETDATA_APPS_NET_GROUP,

2404 + NETDATA_EBPF_CHART_TYPE_LINE,

2405 + NETDATA_CGROUP_SOCKET_TCP_SEND_CONTEXT,

2406 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2407 + update_every);

2408 +

2409 + ebpf_write_chart_obsolete(

2410 + type,

2411 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RETRANSMIT,

2412 + "",

2413 + "Calls to tcp_retransmit.",

2414 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2415 + NETDATA_APPS_NET_GROUP,

2416 + NETDATA_EBPF_CHART_TYPE_LINE,

2417 + NETDATA_CGROUP_SOCKET_TCP_RETRANSMIT_CONTEXT,

2418 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2419 + update_every);

2420 +

2421 + ebpf_write_chart_obsolete(

2422 + type,

2423 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_SEND_CALLS,

2424 + "",

2425 + "Calls to udp_sendmsg.",

2426 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2427 + NETDATA_APPS_NET_GROUP,

2428 + NETDATA_EBPF_CHART_TYPE_LINE,

2429 + NETDATA_CGROUP_SOCKET_UDP_SEND_CONTEXT,

2430 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2431 + update_every);

2432 +

2433 + ebpf_write_chart_obsolete(

2434 + type,

2435 + NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_RECV_CALLS,

2436 + "",

2437 + "Calls to udp_recvmsg.",

2438 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2439 + NETDATA_APPS_NET_GROUP,

2440 + NETDATA_EBPF_CHART_TYPE_LINE,

2441 + NETDATA_CGROUP_SOCKET_UDP_RECV_CONTEXT,

2442 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++,

2443 + update_every);

2444 }

2445

2446 /*

@@ -2297,7 +2454,7 @@ static void ebpf_obsolete_specific_socket_charts(char *type, int update_every)

2454 static void ebpf_send_specific_socket_data(char *type, ebpf_socket_publish_apps_t *values)

2455 {

2456 ebpf_write_begin_chart(type, NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V4, "");

2300 - write_chart_dimension("connections", (long long) values->call_tcp_v4_connection);

2457 + write_chart_dimension("connections", (long long)values->call_tcp_v4_connection);

2458 ebpf_write_end_chart();

2459

2460 if (tcp_v6_connect_address.type == 'T') {

@@ -2307,28 +2464,28 @@ static void ebpf_send_specific_socket_data(char *type, ebpf_socket_publish_apps_

2464 }

2465

2466 ebpf_write_begin_chart(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH, "");

2310 - write_chart_dimension("received", (long long) ebpf_socket_bytes2bits(values->bytes_received));

2311 - write_chart_dimension("sent", (long long) ebpf_socket_bytes2bits(values->bytes_sent));

2467 + write_chart_dimension("received", (long long)ebpf_socket_bytes2bits(values->bytes_received));

2468 + write_chart_dimension("sent", (long long)ebpf_socket_bytes2bits(values->bytes_sent));

2469 ebpf_write_end_chart();

2470

2471 ebpf_write_begin_chart(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RECV_CALLS, "");

2315 - write_chart_dimension("calls", (long long) values->call_tcp_received);

2472 + write_chart_dimension("calls", (long long)values->call_tcp_received);

2473 ebpf_write_end_chart();

2474

2475 ebpf_write_begin_chart(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_SEND_CALLS, "");

2319 - write_chart_dimension("calls", (long long) values->call_tcp_sent);

2476 + write_chart_dimension("calls", (long long)values->call_tcp_sent);

2477 ebpf_write_end_chart();

2478

2479 ebpf_write_begin_chart(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RETRANSMIT, "");

2323 - write_chart_dimension("calls", (long long) values->retransmit);

2480 + write_chart_dimension("calls", (long long)values->retransmit);

2481 ebpf_write_end_chart();

2482

2483 ebpf_write_begin_chart(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_SEND_CALLS, "");

2327 - write_chart_dimension("calls", (long long) values->call_udp_sent);

2484 + write_chart_dimension("calls", (long long)values->call_udp_sent);

2485 ebpf_write_end_chart();

2486

2487 ebpf_write_begin_chart(type, NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_RECV_CALLS, "");

2331 - write_chart_dimension("calls", (long long) values->call_udp_received);

2488 + write_chart_dimension("calls", (long long)values->call_udp_received);

2489 ebpf_write_end_chart();

2490 }

2491

@@ -2352,8 +2509,7 @@ static void ebpf_create_systemd_socket_charts(int update_every)

2509 .module = NETDATA_EBPF_MODULE_NAME_SOCKET,

2510 .update_every = 0,

2511 .suffix = NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V4,

2355 - .dimension = "connections"

2356 - };

2512 + .dimension = "connections"};

2513

2514 static ebpf_systemd_args_t data_tcp_v6 = {

2515 .title = "Calls to tcp_v6_connection",

@@ -2366,8 +2522,7 @@ static void ebpf_create_systemd_socket_charts(int update_every)

2522 .module = NETDATA_EBPF_MODULE_NAME_SOCKET,

2523 .update_every = 0,

2524 .suffix = NETDATA_SOCK_ID_OR_SUFFIX_CONNECTION_TCP_V6,

2369 - .dimension = "connections"

2370 - };

2525 + .dimension = "connections"};

2526

2527 static ebpf_systemd_args_t data_bandwidth = {

2528 .title = "Bandwidth.",

@@ -2380,8 +2535,7 @@ static void ebpf_create_systemd_socket_charts(int update_every)

2535 .module = NETDATA_EBPF_MODULE_NAME_SOCKET,

2536 .update_every = 0,

2537 .suffix = NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH,

2383 - .dimension = "received,sent"

2384 - };

2538 + .dimension = "received,sent"};

2539

2540 static ebpf_systemd_args_t data_tcp_cleanup = {

2541 .title = "Calls to tcp_cleanup_rbuf.",

@@ -2394,8 +2548,7 @@ static void ebpf_create_systemd_socket_charts(int update_every)

2548 .module = NETDATA_EBPF_MODULE_NAME_SOCKET,

2549 .update_every = 0,

2550 .suffix = NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RECV_CALLS,

2397 - .dimension = "calls"

2398 - };

2551 + .dimension = "calls"};

2552

2553 static ebpf_systemd_args_t data_tcp_sendmsg = {

2554 .title = "Calls to tcp_sendmsg.",

@@ -2408,8 +2561,7 @@ static void ebpf_create_systemd_socket_charts(int update_every)

2561 .module = NETDATA_EBPF_MODULE_NAME_SOCKET,

2562 .update_every = 0,

2563 .suffix = NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_SEND_CALLS,

2411 - .dimension = "calls"

2412 - };

2564 + .dimension = "calls"};

2565

2566 static ebpf_systemd_args_t data_tcp_retransmit = {

2567 .title = "Calls to tcp_retransmit",

@@ -2422,8 +2574,7 @@ static void ebpf_create_systemd_socket_charts(int update_every)

2574 .module = NETDATA_EBPF_MODULE_NAME_SOCKET,

2575 .update_every = 0,

2576 .suffix = NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_TCP_RETRANSMIT,

2425 - .dimension = "calls"

2426 - };

2577 + .dimension = "calls"};

2578

2579 static ebpf_systemd_args_t data_udp_send = {

2580 .title = "Calls to udp_sendmsg",

@@ -2436,8 +2587,7 @@ static void ebpf_create_systemd_socket_charts(int update_every)

2587 .module = NETDATA_EBPF_MODULE_NAME_SOCKET,

2588 .update_every = 0,

2589 .suffix = NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_SEND_CALLS,

2439 - .dimension = "calls"

2440 - };

2590 + .dimension = "calls"};

2591

2592 static ebpf_systemd_args_t data_udp_recv = {

2593 .title = "Calls to udp_recvmsg",

@@ -2450,22 +2600,20 @@ static void ebpf_create_systemd_socket_charts(int update_every)

2600 .module = NETDATA_EBPF_MODULE_NAME_SOCKET,

2601 .update_every = 0,

2602 .suffix = NETDATA_SOCK_ID_OR_SUFFIX_BANDWIDTH_UDP_RECV_CALLS,

2453 - .dimension = "calls"

2454 - };

2603 + .dimension = "calls"};

2604

2605 if (!data_tcp_v4.update_every)

2606 data_tcp_v4.update_every = data_tcp_v6.update_every = data_bandwidth.update_every =

2458 - data_tcp_cleanup.update_every = data_tcp_sendmsg.update_every =

2459 - data_tcp_retransmit.update_every = data_udp_send.update_every = data_udp_recv.update_every = update_every;

2607 + data_tcp_cleanup.update_every = data_tcp_sendmsg.update_every = data_tcp_retransmit.update_every =

2608 + data_udp_send.update_every = data_udp_recv.update_every = update_every;

2609

2610 ebpf_cgroup_target_t *w;

2462 - for (w = ebpf_cgroup_pids; w ; w = w->next) {

2611 + for (w = ebpf_cgroup_pids; w; w = w->next) {

2612 if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART))

2613 continue;

2614

2466 - data_tcp_v4.id = data_tcp_v6.id = data_bandwidth.id =

2467 - data_tcp_cleanup.id = data_tcp_sendmsg.id =

2468 - data_tcp_retransmit.id = data_udp_send.id = data_udp_recv.id = w->name;

2615 + data_tcp_v4.id = data_tcp_v6.id = data_bandwidth.id = data_tcp_cleanup.id = data_tcp_sendmsg.id =

2616 + data_tcp_retransmit.id = data_udp_send.id = data_udp_recv.id = w->name;

2617

2618 ebpf_create_charts_on_systemd(&data_tcp_v4);

2619 if (tcp_v6_connect_address.type == 'T') {

@@ -2496,8 +2644,8 @@ static void ebpf_create_systemd_socket_charts(int update_every)

2644 static void ebpf_send_systemd_socket_charts()

2645 {

2646 ebpf_cgroup_target_t *ect;

2499 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

2500 - if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART)) ) {

2647 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

2648 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_SOCKET_CHART))) {

2649 continue;

2650 }

2651

@@ -2561,7 +2709,7 @@ static void ebpf_socket_send_cgroup_data(int update_every)

2709 {

2710 pthread_mutex_lock(&mutex_cgroup_shm);

2711 ebpf_cgroup_target_t *ect;

2564 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

2712 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

2713 ebpf_socket_sum_cgroup_pids(&ect->publish_socket, ect->pids);

2714 }

2715

@@ -2572,7 +2720,7 @@ static void ebpf_socket_send_cgroup_data(int update_every)

2720 ebpf_send_systemd_socket_charts();

2721 }

2722

2575 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

2723 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

2724 if (ect->systemd)

2725 continue;

2726

@@ -2673,12 +2821,11 @@ static void socket_collector(ebpf_module_t *em)

2821 */

2822 static void ebpf_socket_initialize_global_vectors()

2823 {

2676 - memset(socket_aggregated_data, 0 ,NETDATA_MAX_SOCKET_VECTOR * sizeof(netdata_syscall_stat_t));

2677 - memset(socket_publish_aggregated, 0 ,NETDATA_MAX_SOCKET_VECTOR * sizeof(netdata_publish_syscall_t));

2824 + memset(socket_aggregated_data, 0, NETDATA_MAX_SOCKET_VECTOR * sizeof(netdata_syscall_stat_t));

2825 + memset(socket_publish_aggregated, 0, NETDATA_MAX_SOCKET_VECTOR * sizeof(netdata_publish_syscall_t));

2826 socket_hash_values = callocz(ebpf_nprocs, sizeof(netdata_idx_t));

2827

2680 - aral_socket_table = ebpf_allocate_pid_aral(NETDATA_EBPF_SOCKET_ARAL_TABLE_NAME,

2681 - sizeof(netdata_socket_plus_t));

2828 + aral_socket_table = ebpf_allocate_pid_aral(NETDATA_EBPF_SOCKET_ARAL_TABLE_NAME, sizeof(netdata_socket_plus_t));

2829

2830 socket_values = callocz((size_t)ebpf_nprocs, sizeof(netdata_socket_t));

2831

@@ -2703,7 +2850,7 @@ static void ebpf_socket_initialize_global_vectors()

2850 static void ebpf_link_dimension_name(const char *port, uint32_t hash, const char *value)

2851 {

2852 int test = str2i(port);

2706 - if (test < NETDATA_MINIMUM_PORT_VALUE || test > NETDATA_MAXIMUM_PORT_VALUE){

2853 + if (test < NETDATA_MINIMUM_PORT_VALUE || test > NETDATA_MAXIMUM_PORT_VALUE) {

2854 netdata_log_error("The dimension given (%s = %s) has an invalid value and it will be ignored.", port, value);

2855 return;

2856 }

@@ -2714,7 +2861,7 @@ static void ebpf_link_dimension_name(const char *port, uint32_t hash, const char

2861 w->name = strdupz(value);

2862 w->hash = hash;

2863

2717 - w->port = (uint16_t) htons(test);

2864 + w->port = (uint16_t)htons(test);

2865

2866 ebpf_network_viewer_dim_name_t *names = network_viewer_opt.names;

2867 if (unlikely(!names)) {

@@ -2746,7 +2893,8 @@ static void ebpf_link_dimension_name(const char *port, uint32_t hash, const char

2893 * @param cfg the configuration structure

2894 */

2895

2749 -static bool config_service_value_cb(void *data __maybe_unused, const char *name, const char *value) {

2896 +static bool config_service_value_cb(void *data __maybe_unused, const char *name, const char *value)

2897 +{

2898 ebpf_link_dimension_name(name, simple_hash(name), value);

2899 return true;

2900 }

@@ -2783,14 +2931,11 @@ void ebpf_parse_service_name_section(struct config *cfg)

2931 */

2932 void parse_table_size_options(struct config *cfg)

2933 {

2786 - socket_maps[NETDATA_SOCKET_OPEN_SOCKET].user_input = (uint32_t) appconfig_get_number(cfg,

2787 - EBPF_GLOBAL_SECTION,

2788 - EBPF_CONFIG_SOCKET_MONITORING_SIZE,

2789 - NETDATA_MAXIMUM_CONNECTIONS_ALLOWED);

2790 -

2791 - socket_maps[NETDATA_SOCKET_TABLE_UDP].user_input = (uint32_t) appconfig_get_number(cfg,

2792 - EBPF_GLOBAL_SECTION,

2793 - EBPF_CONFIG_UDP_SIZE, NETDATA_MAXIMUM_UDP_CONNECTIONS_ALLOWED);

2934 + socket_maps[NETDATA_SOCKET_OPEN_SOCKET].user_input = (uint32_t)appconfig_get_number(

2935 + cfg, EBPF_GLOBAL_SECTION, EBPF_CONFIG_SOCKET_MONITORING_SIZE, NETDATA_MAXIMUM_CONNECTIONS_ALLOWED);

2936 +

2937 + socket_maps[NETDATA_SOCKET_TABLE_UDP].user_input = (uint32_t)appconfig_get_number(

2938 + cfg, EBPF_GLOBAL_SECTION, EBPF_CONFIG_UDP_SIZE, NETDATA_MAXIMUM_UDP_CONNECTIONS_ALLOWED);

2939 }

2940

2941 /*

@@ -2857,8 +3002,8 @@ void *ebpf_socket_thread(void *ptr)

3002 rw_spinlock_write_lock(&network_viewer_opt.rw_spinlock);

3003 // It was not enabled from main config file (ebpf.d.conf)

3004 if (!network_viewer_opt.enabled)

2860 - network_viewer_opt.enabled = appconfig_get_boolean(&socket_config, EBPF_NETWORK_VIEWER_SECTION, "enabled",

2861 - CONFIG_BOOLEAN_YES);

3005 + network_viewer_opt.enabled =

3006 + appconfig_get_boolean(&socket_config, EBPF_NETWORK_VIEWER_SECTION, "enabled", CONFIG_BOOLEAN_YES);

3007 rw_spinlock_write_unlock(&network_viewer_opt.rw_spinlock);

3008

3009 parse_table_size_options(&socket_config);

@@ -2876,17 +3021,26 @@ void *ebpf_socket_thread(void *ptr)

3021 }

3022

3023 int algorithms[NETDATA_MAX_SOCKET_VECTOR] = {

2879 - NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX,

2880 - NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX,

2881 - NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_INCREMENTAL_IDX,

2882 - NETDATA_EBPF_INCREMENTAL_IDX

2883 - };

3024 + NETDATA_EBPF_ABSOLUTE_IDX,

3025 + NETDATA_EBPF_ABSOLUTE_IDX,

3026 + NETDATA_EBPF_ABSOLUTE_IDX,

3027 + NETDATA_EBPF_ABSOLUTE_IDX,

3028 + NETDATA_EBPF_ABSOLUTE_IDX,

3029 + NETDATA_EBPF_ABSOLUTE_IDX,

3030 + NETDATA_EBPF_ABSOLUTE_IDX,

3031 + NETDATA_EBPF_ABSOLUTE_IDX,

3032 + NETDATA_EBPF_INCREMENTAL_IDX,

3033 + NETDATA_EBPF_INCREMENTAL_IDX};

3034 ebpf_global_labels(

2885 - socket_aggregated_data, socket_publish_aggregated, socket_dimension_names, socket_id_names,

2886 - algorithms, NETDATA_MAX_SOCKET_VECTOR);

2887 -

2888 - ebpf_read_socket.thread = nd_thread_create(ebpf_read_socket.name, NETDATA_THREAD_OPTION_DEFAULT,

2889 - ebpf_read_socket_thread, em);

3035 + socket_aggregated_data,

3036 + socket_publish_aggregated,

3037 + socket_dimension_names,

3038 + socket_id_names,

3039 + algorithms,

3040 + NETDATA_MAX_SOCKET_VECTOR);

3041 +

3042 + ebpf_read_socket.thread =

3043 + nd_thread_create(ebpf_read_socket.name, NETDATA_THREAD_OPTION_DEFAULT, ebpf_read_socket_thread, em);

3044

3045 pthread_mutex_lock(&lock);

3046 ebpf_socket_create_global_charts(em);

src/collectors/ebpf.plugin/ebpf_socket.h

+27 -28

@@ -11,7 +11,8 @@

12 // Module name & description

13 #define NETDATA_EBPF_MODULE_NAME_SOCKET "socket"

14 -#define NETDATA_EBPF_SOCKET_MODULE_DESC "Monitors TCP and UDP bandwidth. This thread is integrated with apps and cgroup."

14 +#define NETDATA_EBPF_SOCKET_MODULE_DESC \

15 + "Monitors TCP and UDP bandwidth. This thread is integrated with apps and cgroup."

17 // Vector indexes

18 #define NETDATA_UDP_START 3

@@ -159,16 +160,16 @@ typedef enum ebpf_socket_idx {

160

161 typedef struct __attribute__((packed)) ebpf_socket_publish_apps {

162 // Data read

162 - uint64_t bytes_sent; // Bytes sent

163 - uint64_t bytes_received; // Bytes received

164 - uint64_t call_tcp_sent; // Number of times tcp_sendmsg was called

165 - uint64_t call_tcp_received; // Number of times tcp_cleanup_rbuf was called

166 - uint64_t retransmit; // Number of times tcp_retransmit was called

167 - uint64_t call_udp_sent; // Number of times udp_sendmsg was called

168 - uint64_t call_udp_received; // Number of times udp_recvmsg was called

169 - uint64_t call_close; // Number of times tcp_close was called

170 - uint64_t call_tcp_v4_connection;// Number of times tcp_v4_connect was called

171 - uint64_t call_tcp_v6_connection;// Number of times tcp_v6_connect was called

163 + uint64_t bytes_sent; // Bytes sent

164 + uint64_t bytes_received; // Bytes received

165 + uint64_t call_tcp_sent; // Number of times tcp_sendmsg was called

166 + uint64_t call_tcp_received; // Number of times tcp_cleanup_rbuf was called

167 + uint64_t retransmit; // Number of times tcp_retransmit was called

168 + uint64_t call_udp_sent; // Number of times udp_sendmsg was called

169 + uint64_t call_udp_received; // Number of times udp_recvmsg was called

170 + uint64_t call_close; // Number of times tcp_close was called

171 + uint64_t call_tcp_v4_connection; // Number of times tcp_v4_connect was called

172 + uint64_t call_tcp_v6_connection; // Number of times tcp_v6_connect was called

173 } ebpf_socket_publish_apps_t;

174

175 typedef struct ebpf_network_viewer_dimension_names {

@@ -178,7 +179,7 @@ typedef struct ebpf_network_viewer_dimension_names {

179 uint16_t port;

180

181 struct ebpf_network_viewer_dimension_names *next;

181 -} ebpf_network_viewer_dim_name_t ;

182 +} ebpf_network_viewer_dim_name_t;

183

184 typedef struct ebpf_network_viewer_port_list {

185 char *value;

@@ -212,27 +213,27 @@ typedef struct netdata_passive_connection_idx {

213 * Union used to store ip addresses

214 */

215 union netdata_ip_t {

215 - uint8_t addr8[16];

216 + uint8_t addr8[16];

217 uint16_t addr16[8];

218 uint32_t addr32[4];

219 uint64_t addr64[2];

220 };

221

222 typedef struct ebpf_network_viewer_ip_list {

222 - char *value; // IP value

223 - uint32_t hash; // IP hash

223 + char *value; // IP value

224 + uint32_t hash; // IP hash

225

225 - uint8_t ver; // IP version

226 + uint8_t ver; // IP version

227

227 - union netdata_ip_t first; // The IP address informed

228 - union netdata_ip_t last; // The IP address informed

228 + union netdata_ip_t first; // The IP address informed

229 + union netdata_ip_t last; // The IP address informed

230

231 struct ebpf_network_viewer_ip_list *next;

232 } ebpf_network_viewer_ip_list_t;

233

234 typedef struct ebpf_network_viewer_hostname_list {

234 - char *value; // IP value

235 - uint32_t hash; // IP hash

235 + char *value; // IP value

236 + uint32_t hash; // IP hash

237

238 SIMPLE_PATTERN *value_pattern;

239

@@ -243,7 +244,7 @@ typedef struct ebpf_network_viewer_options {

244 RW_SPINLOCK rw_spinlock;

245

246 uint32_t enabled;

246 - uint32_t family; // AF_INET, AF_INET6 or AF_UNSPEC (both)

247 + uint32_t family; // AF_INET, AF_INET6 or AF_UNSPEC (both)

248

249 uint32_t hostname_resolution_enabled;

250 uint32_t service_resolution_enabled;

@@ -265,9 +266,7 @@ typedef struct ebpf_network_viewer_options {

266

267 extern ebpf_network_viewer_options_t network_viewer_opt;

268

268 -typedef enum netdata_socket_flags {

269 - NETDATA_SOCKET_FLAGS_ALREADY_OPEN = (1<<0)

270 -} netdata_socket_flags_t;

269 +typedef enum netdata_socket_flags { NETDATA_SOCKET_FLAGS_ALREADY_OPEN = (1 << 0) } netdata_socket_flags_t;

270

271 typedef enum netdata_socket_src_ip_origin {

272 NETDATA_EBPF_SRC_IP_ORIGIN_LOCAL,

@@ -275,15 +274,15 @@ typedef enum netdata_socket_src_ip_origin {

274 } netdata_socket_src_ip_origin_t;

275

276 typedef struct netata_socket_plus {

278 - netdata_socket_t data; // Data read from database

277 + netdata_socket_t data; // Data read from database

278 uint32_t pid;

279 time_t last_update;

280 netdata_socket_flags_t flags;

281

283 - struct {

282 + struct {

283 char src_ip[INET6_ADDRSTRLEN + 1];

285 - // uint16_t src_port;

286 - char dst_ip[INET6_ADDRSTRLEN+ 1];

284 + // uint16_t src_port;

285 + char dst_ip[INET6_ADDRSTRLEN + 1];

286 char dst_port[NI_MAXSERV + 1];

287 } socket_string;

288 } netdata_socket_plus_t;

src/collectors/ebpf.plugin/ebpf_softirq.c

+35 -37

@@ -7,36 +7,32 @@ struct config softirq_config = APPCONFIG_INITIALIZER;

8 #define SOFTIRQ_MAP_LATENCY 0

9 static ebpf_local_maps_t softirq_maps[] = {

10 - {

11 - .name = "tbl_softirq",

12 - .internal_input = NETDATA_SOFTIRQ_MAX_IRQS,

13 - .user_input = 0,

14 - .type = NETDATA_EBPF_MAP_STATIC,

15 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

10 + {.name = "tbl_softirq",

11 + .internal_input = NETDATA_SOFTIRQ_MAX_IRQS,

12 + .user_input = 0,

13 + .type = NETDATA_EBPF_MAP_STATIC,

14 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

15 #ifdef LIBBPF_MAJOR_VERSION

17 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

16 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

17 #endif

18 },

19 /* end */

21 - {

22 - .name = NULL,

23 - .internal_input = 0,

24 - .user_input = 0,

25 - .type = NETDATA_EBPF_MAP_CONTROLLER,

26 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

20 + {.name = NULL,

21 + .internal_input = 0,

22 + .user_input = 0,

23 + .type = NETDATA_EBPF_MAP_CONTROLLER,

24 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

25 #ifdef LIBBPF_MAJOR_VERSION

28 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

26 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

27 #endif

30 - }

31 -};

28 + }};

30 #define SOFTIRQ_TP_CLASS_IRQ "irq"

31 static ebpf_tracepoint_t softirq_tracepoints[] = {

32 {.enabled = false, .class = SOFTIRQ_TP_CLASS_IRQ, .event = "softirq_entry"},

33 {.enabled = false, .class = SOFTIRQ_TP_CLASS_IRQ, .event = "softirq_exit"},

34 /* end */

38 - {.enabled = false, .class = NULL, .event = NULL}

39 -};

35 + {.enabled = false, .class = NULL, .event = NULL}};

37 // these must be in the order defined by the kernel:

38 // https://elixir.bootlin.com/linux/v5.12.19/source/include/trace/events/irq.h#L13

@@ -65,16 +61,17 @@ static softirq_ebpf_val_t *softirq_ebpf_vals = NULL;

61 */

62 static void ebpf_obsolete_softirq_global(ebpf_module_t *em)

63 {

68 - ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,

69 - "softirq_latency",

70 - "",

71 - "Software IRQ latency",

72 - EBPF_COMMON_UNITS_MILLISECONDS,

73 - "softirqs",

74 - NETDATA_EBPF_CHART_TYPE_STACKED,

75 - "system.softirq_latency",

76 - NETDATA_CHART_PRIO_SYSTEM_SOFTIRQS+1,

77 - em->update_every);

64 + ebpf_write_chart_obsolete(

65 + NETDATA_EBPF_SYSTEM_GROUP,

66 + "softirq_latency",

67 + "",

68 + "Software IRQ latency",

69 + EBPF_COMMON_UNITS_MILLISECONDS,

70 + "softirqs",

71 + NETDATA_EBPF_CHART_TYPE_STACKED,

72 + "system.softirq_latency",

73 + NETDATA_CHART_PRIO_SYSTEM_SOFTIRQS + 1,

74 + em->update_every);

75 }

77 /**

@@ -87,7 +84,8 @@ static void ebpf_obsolete_softirq_global(ebpf_module_t *em)

84 static void softirq_cleanup(void *pptr)

85 {

86 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

90 - if(!em) return;

87 + if (!em)

88 + return;

90 if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) {

91 pthread_mutex_lock(&lock);

@@ -147,7 +145,7 @@ static void softirq_read_latency_map(int maps_per_core)

145 int cpu_i;

146 int end = (maps_per_core) ? ebpf_nprocs : 1;

147 for (cpu_i = 0; cpu_i < end; cpu_i++) {

150 - total_latency += softirq_ebpf_vals[cpu_i].latency/1000;

148 + total_latency += softirq_ebpf_vals[cpu_i].latency / 1000;

149 }

150

151 softirq_vals[i].latency = total_latency;

@@ -165,10 +163,12 @@ static void softirq_create_charts(int update_every)

163 "softirqs",

164 "system.softirq_latency",

165 NETDATA_EBPF_CHART_TYPE_STACKED,

168 - NETDATA_CHART_PRIO_SYSTEM_SOFTIRQS+1,

169 - NULL, NULL, 0, update_every,

170 - NETDATA_EBPF_MODULE_NAME_SOFTIRQ

171 - );

166 + NETDATA_CHART_PRIO_SYSTEM_SOFTIRQS + 1,

167 + NULL,

168 + NULL,

169 + 0,

170 + update_every,

171 + NETDATA_EBPF_MODULE_NAME_SOFTIRQ);

172

173 fflush(stdout);

174 }

@@ -178,9 +178,7 @@ static void softirq_create_dims()

178 uint32_t i;

179 for (i = 0; i < NETDATA_SOFTIRQ_MAX_IRQS; i++) {

180 ebpf_write_global_dimension(

181 - softirq_vals[i].name, softirq_vals[i].name,

182 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]

183 - );

181 + softirq_vals[i].name, softirq_vals[i].name, ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

182 }

183 }

184

src/collectors/ebpf.plugin/ebpf_swap.c

+259 -212

@@ -3,7 +3,7 @@

3 #include "ebpf.h"

4 #include "ebpf_swap.h"

6 -static char *swap_dimension_name[NETDATA_SWAP_END] = { "read", "write" };

6 +static char *swap_dimension_name[NETDATA_SWAP_END] = {"read", "write"};

7 static netdata_syscall_stat_t swap_aggregated_data[NETDATA_SWAP_END];

8 static netdata_publish_syscall_t swap_publish_aggregated[NETDATA_SWAP_END];

@@ -14,42 +14,48 @@ netdata_ebpf_swap_t *swap_vector = NULL;

15 struct config swap_config = APPCONFIG_INITIALIZER;

17 -static ebpf_local_maps_t swap_maps[] = {{.name = "tbl_pid_swap", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

18 - .user_input = 0,

19 - .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

20 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

17 +static ebpf_local_maps_t swap_maps[] = {

18 + {.name = "tbl_pid_swap",

19 + .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

20 + .user_input = 0,

21 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

22 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

23 #ifdef LIBBPF_MAJOR_VERSION

22 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

24 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

25 #endif

24 - },

25 - {.name = "swap_ctrl", .internal_input = NETDATA_CONTROLLER_END,

26 - .user_input = 0,

27 - .type = NETDATA_EBPF_MAP_CONTROLLER,

28 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

26 + },

27 + {.name = "swap_ctrl",

28 + .internal_input = NETDATA_CONTROLLER_END,

29 + .user_input = 0,

30 + .type = NETDATA_EBPF_MAP_CONTROLLER,

31 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

32 #ifdef LIBBPF_MAJOR_VERSION

30 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

33 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

34 #endif

32 - },

33 - {.name = "tbl_swap", .internal_input = NETDATA_SWAP_END,

34 - .user_input = 0,

35 - .type = NETDATA_EBPF_MAP_STATIC,

36 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

35 + },

36 + {.name = "tbl_swap",

37 + .internal_input = NETDATA_SWAP_END,

38 + .user_input = 0,

39 + .type = NETDATA_EBPF_MAP_STATIC,

40 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

41 #ifdef LIBBPF_MAJOR_VERSION

38 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

42 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

43 #endif

40 - },

41 - {.name = NULL, .internal_input = 0, .user_input = 0,

44 + },

45 + {.name = NULL,

46 + .internal_input = 0,

47 + .user_input = 0,

48 #ifdef LIBBPF_MAJOR_VERSION

43 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

49 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

50 #endif

45 - }};

51 + }};

47 -netdata_ebpf_targets_t swap_targets[] = { {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE},

48 - {.name = "swap_writepage", .mode = EBPF_LOAD_TRAMPOLINE},

49 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

50 -

51 -static char *swap_read[] ={ "swap_readpage", "swap_read_folio", NULL };

53 +netdata_ebpf_targets_t swap_targets[] = {

54 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE},

55 + {.name = "swap_writepage", .mode = EBPF_LOAD_TRAMPOLINE},

56 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

58 +static char *swap_read[] = {"swap_readpage", "swap_read_folio", NULL};

60 struct netdata_static_thread ebpf_read_swap = {

61 .name = "EBPF_READ_SWAP",

@@ -59,8 +65,7 @@ struct netdata_static_thread ebpf_read_swap = {

65 .enabled = 1,

66 .thread = NULL,

67 .init_routine = NULL,

62 - .start_routine = NULL

63 -};

68 + .start_routine = NULL};

70 #ifdef LIBBPF_MAJOR_VERSION

71 /**

@@ -86,10 +91,9 @@ static void ebpf_swap_disable_probe(struct swap_bpf *obj)

91 */

92 static inline void ebpf_swap_disable_specific_probe(struct swap_bpf *obj)

93 {

89 - if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name,

90 - swap_read[NETDATA_KEY_SWAP_READPAGE_CALL])) {

94 + if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name, swap_read[NETDATA_KEY_SWAP_READPAGE_CALL])) {

95 bpf_program__set_autoload(obj->progs.netdata_swap_read_folio_probe, false);

92 - } else {

96 + } else {

97 bpf_program__set_autoload(obj->progs.netdata_swap_readpage_probe, false);

98 }

99 }

@@ -117,10 +121,9 @@ static void ebpf_swap_disable_trampoline(struct swap_bpf *obj)

121 */

122 static inline void ebpf_swap_disable_specific_trampoline(struct swap_bpf *obj)

123 {

120 - if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name,

121 - swap_read[NETDATA_KEY_SWAP_READPAGE_CALL])) {

124 + if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name, swap_read[NETDATA_KEY_SWAP_READPAGE_CALL])) {

125 bpf_program__set_autoload(obj->progs.netdata_swap_read_folio_fentry, false);

123 - } else {

126 + } else {

127 bpf_program__set_autoload(obj->progs.netdata_swap_readpage_fentry, false);

128 }

129 }

@@ -134,11 +137,11 @@ static inline void ebpf_swap_disable_specific_trampoline(struct swap_bpf *obj)

137 */

138 static void ebpf_swap_set_trampoline_target(struct swap_bpf *obj)

139 {

137 - bpf_program__set_attach_target(obj->progs.netdata_swap_readpage_fentry, 0,

138 - swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name);

140 + bpf_program__set_attach_target(

141 + obj->progs.netdata_swap_readpage_fentry, 0, swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name);

142

140 - bpf_program__set_attach_target(obj->progs.netdata_swap_writepage_fentry, 0,

141 - swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name);

143 + bpf_program__set_attach_target(

144 + obj->progs.netdata_swap_writepage_fentry, 0, swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name);

145 }

146

147 /**

@@ -153,24 +156,20 @@ static void ebpf_swap_set_trampoline_target(struct swap_bpf *obj)

156 static int ebpf_swap_attach_kprobe(struct swap_bpf *obj)

157 {

158 int ret;

156 - if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name,

157 - swap_read[NETDATA_KEY_SWAP_READPAGE_CALL])) {

158 - obj->links.netdata_swap_readpage_probe = bpf_program__attach_kprobe(obj->progs.netdata_swap_readpage_probe,

159 - false,

160 - swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name);

159 + if (!strcmp(swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name, swap_read[NETDATA_KEY_SWAP_READPAGE_CALL])) {

160 + obj->links.netdata_swap_readpage_probe = bpf_program__attach_kprobe(

161 + obj->progs.netdata_swap_readpage_probe, false, swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name);

162 ret = libbpf_get_error(obj->links.netdata_swap_readpage_probe);

163 } else {

163 - obj->links.netdata_swap_read_folio_probe = bpf_program__attach_kprobe(obj->progs.netdata_swap_read_folio_probe,

164 - false,

165 - swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name);

164 + obj->links.netdata_swap_read_folio_probe = bpf_program__attach_kprobe(

165 + obj->progs.netdata_swap_read_folio_probe, false, swap_targets[NETDATA_KEY_SWAP_READPAGE_CALL].name);

166 ret = libbpf_get_error(obj->links.netdata_swap_read_folio_probe);

167 }

168 if (ret)

169 return -1;

170

171 - obj->links.netdata_swap_writepage_probe = bpf_program__attach_kprobe(obj->progs.netdata_swap_writepage_probe,

172 - false,

173 - swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name);

171 + obj->links.netdata_swap_writepage_probe = bpf_program__attach_kprobe(

172 + obj->progs.netdata_swap_writepage_probe, false, swap_targets[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name);

173 ret = libbpf_get_error(obj->links.netdata_swap_writepage_probe);

174 if (ret)

175 return -1;

@@ -202,8 +201,8 @@ static void ebpf_swap_set_hash_tables(struct swap_bpf *obj)

201 */

202 static void ebpf_swap_adjust_map(struct swap_bpf *obj, ebpf_module_t *em)

203 {

205 - ebpf_update_map_size(obj->maps.tbl_pid_swap, &swap_maps[NETDATA_PID_SWAP_TABLE],

206 - em, bpf_map__name(obj->maps.tbl_pid_swap));

204 + ebpf_update_map_size(

205 + obj->maps.tbl_pid_swap, &swap_maps[NETDATA_PID_SWAP_TABLE], em, bpf_map__name(obj->maps.tbl_pid_swap));

206

207 ebpf_update_map_type(obj->maps.tbl_pid_swap, &swap_maps[NETDATA_PID_SWAP_TABLE]);

208 ebpf_update_map_type(obj->maps.tbl_swap, &swap_maps[NETDATA_SWAP_GLOBAL_TABLE]);

@@ -227,12 +226,12 @@ static inline int ebpf_swap_load_and_attach(struct swap_bpf *obj, ebpf_module_t

226

227 if (test == EBPF_LOAD_TRAMPOLINE) {

228 ebpf_swap_disable_probe(obj);

230 - ebpf_swap_disable_specific_trampoline(obj);

229 + ebpf_swap_disable_specific_trampoline(obj);

230

231 ebpf_swap_set_trampoline_target(obj);

232 } else {

233 ebpf_swap_disable_trampoline(obj);

235 - ebpf_swap_disable_specific_probe(obj);

234 + ebpf_swap_disable_specific_probe(obj);

235 }

236

237 ebpf_swap_adjust_map(obj, em);

@@ -270,27 +269,29 @@ static void ebpf_obsolete_specific_swap_charts(char *type, int update_every);

269 */

270 static void ebpf_obsolete_swap_services(ebpf_module_t *em, char *id)

271 {

273 - ebpf_write_chart_obsolete(id,

274 - NETDATA_MEM_SWAP_READ_CHART,

275 - "",

276 - "Calls to function swap_readpage.",

277 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

278 - NETDATA_SYSTEM_SWAP_SUBMENU,

279 - NETDATA_EBPF_CHART_TYPE_LINE,

280 - NETDATA_SYSTEMD_SWAP_READ_CONTEXT,

281 - 20191,

282 - em->update_every);

283 -

284 - ebpf_write_chart_obsolete(id,

285 - NETDATA_MEM_SWAP_WRITE_CHART,

286 - "",

287 - "Calls to function swap_writepage.",

288 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

289 - NETDATA_SYSTEM_SWAP_SUBMENU,

290 - NETDATA_EBPF_CHART_TYPE_LINE,

291 - NETDATA_CGROUP_SWAP_WRITE_CONTEXT,

292 - 20192,

293 - em->update_every);

272 + ebpf_write_chart_obsolete(

273 + id,

274 + NETDATA_MEM_SWAP_READ_CHART,

275 + "",

276 + "Calls to function swap_readpage.",

277 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

278 + NETDATA_SYSTEM_SWAP_SUBMENU,

279 + NETDATA_EBPF_CHART_TYPE_LINE,

280 + NETDATA_SYSTEMD_SWAP_READ_CONTEXT,

281 + 20191,

282 + em->update_every);

283 +

284 + ebpf_write_chart_obsolete(

285 + id,

286 + NETDATA_MEM_SWAP_WRITE_CHART,

287 + "",

288 + "Calls to function swap_writepage.",

289 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

290 + NETDATA_SYSTEM_SWAP_SUBMENU,

291 + NETDATA_EBPF_CHART_TYPE_LINE,

292 + NETDATA_CGROUP_SWAP_WRITE_CONTEXT,

293 + 20192,

294 + em->update_every);

295 }

296

297 /**

@@ -300,11 +301,12 @@ static void ebpf_obsolete_swap_services(ebpf_module_t *em, char *id)

301 *

302 * @param em a pointer to `struct ebpf_module`

303 */

303 -static inline void ebpf_obsolete_swap_cgroup_charts(ebpf_module_t *em) {

304 +static inline void ebpf_obsolete_swap_cgroup_charts(ebpf_module_t *em)

305 +{

306 pthread_mutex_lock(&mutex_cgroup_shm);

307

308 ebpf_cgroup_target_t *ect;

307 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

309 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

310 if (ect->systemd) {

311 ebpf_obsolete_swap_services(em, ect->name);

312

@@ -329,31 +331,33 @@ void ebpf_obsolete_swap_apps_charts(struct ebpf_module *em)

331 int update_every = em->update_every;

332 pthread_mutex_lock(&collect_data_mutex);

333 for (w = apps_groups_root_target; w; w = w->next) {

332 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SWAP_IDX))))

334 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_SWAP_IDX))))

335 continue;

336

335 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

336 - w->clean_name,

337 - "_ebpf_call_swap_readpage",

338 - "Calls to function swap_readpage.",

339 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

340 - NETDATA_EBPF_MEMORY_GROUP,

341 - NETDATA_EBPF_CHART_TYPE_STACKED,

342 - "app.ebpf_call_swap_readpage",

343 - 20070,

344 - update_every);

345 -

346 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

347 - w->clean_name,

348 - "_ebpf_call_swap_writepage",

349 - "Calls to function swap_writepage.",

350 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

351 - NETDATA_EBPF_MEMORY_GROUP,

352 - NETDATA_EBPF_CHART_TYPE_STACKED,

353 - "app.ebpf_call_swap_writepage",

354 - 20071,

355 - update_every);

356 - w->charts_created &= ~(1<<EBPF_MODULE_SWAP_IDX);

337 + ebpf_write_chart_obsolete(

338 + NETDATA_APP_FAMILY,

339 + w->clean_name,

340 + "_ebpf_call_swap_readpage",

341 + "Calls to function swap_readpage.",

342 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

343 + NETDATA_EBPF_MEMORY_GROUP,

344 + NETDATA_EBPF_CHART_TYPE_STACKED,

345 + "app.ebpf_call_swap_readpage",

346 + 20070,

347 + update_every);

348 +

349 + ebpf_write_chart_obsolete(

350 + NETDATA_APP_FAMILY,

351 + w->clean_name,

352 + "_ebpf_call_swap_writepage",

353 + "Calls to function swap_writepage.",

354 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

355 + NETDATA_EBPF_MEMORY_GROUP,

356 + NETDATA_EBPF_CHART_TYPE_STACKED,

357 + "app.ebpf_call_swap_writepage",

358 + 20071,

359 + update_every);

360 + w->charts_created &= ~(1 << EBPF_MODULE_SWAP_IDX);

361 }

362 pthread_mutex_unlock(&collect_data_mutex);

363 }

@@ -367,15 +371,17 @@ void ebpf_obsolete_swap_apps_charts(struct ebpf_module *em)

371 */

372 static void ebpf_obsolete_swap_global(ebpf_module_t *em)

373 {

370 - ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,

371 - NETDATA_MEM_SWAP_CHART,

372 - "",

373 - "Calls to access swap memory",

374 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_SYSTEM_SWAP_SUBMENU,

375 - NETDATA_EBPF_CHART_TYPE_LINE,

376 - "mem.swapcalls",

377 - NETDATA_CHART_PRIO_MEM_SWAP_CALLS,

378 - em->update_every);

374 + ebpf_write_chart_obsolete(

375 + NETDATA_EBPF_MEMORY_GROUP,

376 + NETDATA_MEM_SWAP_CHART,

377 + "",

378 + "Calls to access swap memory",

379 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

380 + NETDATA_SYSTEM_SWAP_SUBMENU,

381 + NETDATA_EBPF_CHART_TYPE_LINE,

382 + "mem.swapcalls",

383 + NETDATA_CHART_PRIO_MEM_SWAP_CALLS,

384 + em->update_every);

385 }

386

387 /**

@@ -391,7 +397,7 @@ static void ebpf_swap_exit(void *ptr)

397 ebpf_module_t *em = (ebpf_module_t *)ptr;

398

399 pthread_mutex_lock(&lock);

394 - collect_pids &= ~(1<<EBPF_MODULE_SWAP_IDX);

400 + collect_pids &= ~(1 << EBPF_MODULE_SWAP_IDX);

401 pthread_mutex_unlock(&lock);

402

403 if (ebpf_read_swap.thread)

@@ -473,7 +479,7 @@ static void swap_apps_accumulator(netdata_ebpf_swap_t *out, int maps_per_core)

479 */

480 static void ebpf_update_swap_cgroup()

481 {

476 - ebpf_cgroup_target_t *ect ;

482 + ebpf_cgroup_target_t *ect;

483 pthread_mutex_lock(&mutex_cgroup_shm);

484 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

485 struct pid_on_target2 *pids;

@@ -517,13 +523,13 @@ static void ebpf_swap_sum_pids(netdata_publish_swap_t *swap, struct ebpf_pid_on_

523 // These conditions were added, because we are using incremental algorithm

524 swap->write = (local_write >= swap->write) ? local_write : swap->write;

525 swap->read = (local_read >= swap->read) ? local_read : swap->read;

520 - }

521 -

526 +}

527

528 /**

529 * Resume apps data

530 */

526 -void ebpf_swap_resume_apps_data() {

531 +void ebpf_swap_resume_apps_data()

532 +{

533 struct ebpf_target *w;

534 for (w = apps_groups_root_target; w; w = w->next) {

535 if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_SWAP_IDX))))

@@ -575,7 +581,7 @@ static void ebpf_read_swap_apps_table(int maps_per_core)

581 }

582

583 // We are cleaning to avoid passing data read from one process to other.

578 -end_swap_loop:

584 + end_swap_loop:

585 memset(cv, 0, length);

586 key = next_key;

587 }

@@ -640,11 +646,13 @@ void *ebpf_read_swap_thread(void *ptr)

646 */

647 static void swap_send_global()

648 {

643 - write_io_chart(NETDATA_MEM_SWAP_CHART, NETDATA_EBPF_MEMORY_GROUP,

644 - swap_publish_aggregated[NETDATA_KEY_SWAP_WRITEPAGE_CALL].dimension,

645 - (long long) swap_hash_values[NETDATA_KEY_SWAP_WRITEPAGE_CALL],

646 - swap_publish_aggregated[NETDATA_KEY_SWAP_READPAGE_CALL].dimension,

647 - (long long) swap_hash_values[NETDATA_KEY_SWAP_READPAGE_CALL]);

649 + write_io_chart(

650 + NETDATA_MEM_SWAP_CHART,

651 + NETDATA_EBPF_MEMORY_GROUP,

652 + swap_publish_aggregated[NETDATA_KEY_SWAP_WRITEPAGE_CALL].dimension,

653 + (long long)swap_hash_values[NETDATA_KEY_SWAP_WRITEPAGE_CALL],

654 + swap_publish_aggregated[NETDATA_KEY_SWAP_READPAGE_CALL].dimension,

655 + (long long)swap_hash_values[NETDATA_KEY_SWAP_READPAGE_CALL]);

656 }

657

658 /**

@@ -657,19 +665,21 @@ static void swap_send_global()

665 */

666 static void ebpf_swap_read_global_table(netdata_idx_t *stats, int maps_per_core)

667 {

660 - ebpf_read_global_table_stats(swap_hash_values,

661 - swap_values,

662 - swap_maps[NETDATA_SWAP_GLOBAL_TABLE].map_fd,

663 - maps_per_core,

664 - NETDATA_KEY_SWAP_READPAGE_CALL,

665 - NETDATA_SWAP_END);

666 -

667 - ebpf_read_global_table_stats(stats,

668 - swap_values,

669 - swap_maps[NETDATA_SWAP_CONTROLLER].map_fd,

670 - maps_per_core,

671 - NETDATA_CONTROLLER_PID_TABLE_ADD,

672 - NETDATA_CONTROLLER_END);

668 + ebpf_read_global_table_stats(

669 + swap_hash_values,

670 + swap_values,

671 + swap_maps[NETDATA_SWAP_GLOBAL_TABLE].map_fd,

672 + maps_per_core,

673 + NETDATA_KEY_SWAP_READPAGE_CALL,

674 + NETDATA_SWAP_END);

675 +

676 + ebpf_read_global_table_stats(

677 + stats,

678 + swap_values,

679 + swap_maps[NETDATA_SWAP_CONTROLLER].map_fd,

680 + maps_per_core,

681 + NETDATA_CONTROLLER_PID_TABLE_ADD,

682 + NETDATA_CONTROLLER_END);

683 }

684

685 /**

@@ -682,15 +692,15 @@ void ebpf_swap_send_apps_data(struct ebpf_target *root)

692 struct ebpf_target *w;

693 pthread_mutex_lock(&collect_data_mutex);

694 for (w = root; w; w = w->next) {

685 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SWAP_IDX))))

695 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_SWAP_IDX))))

696 continue;

697

698 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_swap_readpage");

689 - write_chart_dimension("calls", (long long) w->swap.read);

699 + write_chart_dimension("calls", (long long)w->swap.read);

700 ebpf_write_end_chart();

701

702 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_swap_writepage");

693 - write_chart_dimension("calls", (long long) w->swap.write);

703 + write_chart_dimension("calls", (long long)w->swap.write);

704 ebpf_write_end_chart();

705 }

706 pthread_mutex_unlock(&collect_data_mutex);

@@ -730,17 +740,17 @@ static void ebpf_swap_sum_cgroup_pids(netdata_publish_swap_t *swap, struct pid_o

740 static void ebpf_send_systemd_swap_charts()

741 {

742 ebpf_cgroup_target_t *ect;

733 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

734 - if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_SWAP_CHART)) ) {

743 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

744 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_SWAP_CHART))) {

745 continue;

746 }

747

748 ebpf_write_begin_chart(ect->name, NETDATA_MEM_SWAP_READ_CHART, "");

739 - write_chart_dimension("calls", (long long) ect->publish_systemd_swap.read);

749 + write_chart_dimension("calls", (long long)ect->publish_systemd_swap.read);

750 ebpf_write_end_chart();

751

752 ebpf_write_begin_chart(ect->name, NETDATA_MEM_SWAP_WRITE_CHART, "");

743 - write_chart_dimension("calls", (long long) ect->publish_systemd_swap.write);

753 + write_chart_dimension("calls", (long long)ect->publish_systemd_swap.write);

754 ebpf_write_end_chart();

755 }

756 }

@@ -756,24 +766,37 @@ static void ebpf_send_systemd_swap_charts()

766 static void ebpf_create_specific_swap_charts(char *type, int update_every)

767 {

768 char *label = (!strncmp(type, "cgroup_", 7)) ? &type[7] : type;

759 - ebpf_create_chart(type, NETDATA_MEM_SWAP_READ_CHART,

760 - "Calls to function swap_readpage.",

761 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_SYSTEM_SWAP_SUBMENU,

762 - NETDATA_CGROUP_SWAP_READ_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

763 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5100,

764 - ebpf_create_global_dimension,

765 - swap_publish_aggregated, 1, update_every, NETDATA_EBPF_MODULE_NAME_SWAP);

769 + ebpf_create_chart(

770 + type,

771 + NETDATA_MEM_SWAP_READ_CHART,

772 + "Calls to function swap_readpage.",

773 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

774 + NETDATA_SYSTEM_SWAP_SUBMENU,

775 + NETDATA_CGROUP_SWAP_READ_CONTEXT,

776 + NETDATA_EBPF_CHART_TYPE_LINE,

777 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5100,

778 + ebpf_create_global_dimension,

779 + swap_publish_aggregated,

780 + 1,

781 + update_every,

782 + NETDATA_EBPF_MODULE_NAME_SWAP);

783 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

784 ebpf_commit_label();

785

769 - ebpf_create_chart(type, NETDATA_MEM_SWAP_WRITE_CHART,

770 - "Calls to function swap_writepage.",

771 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_SYSTEM_SWAP_SUBMENU,

772 - NETDATA_CGROUP_SWAP_WRITE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,

773 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5101,

774 - ebpf_create_global_dimension,

775 - &swap_publish_aggregated[NETDATA_KEY_SWAP_WRITEPAGE_CALL], 1,

776 - update_every, NETDATA_EBPF_MODULE_NAME_SWAP);

786 + ebpf_create_chart(

787 + type,

788 + NETDATA_MEM_SWAP_WRITE_CHART,

789 + "Calls to function swap_writepage.",

790 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

791 + NETDATA_SYSTEM_SWAP_SUBMENU,

792 + NETDATA_CGROUP_SWAP_WRITE_CONTEXT,

793 + NETDATA_EBPF_CHART_TYPE_LINE,

794 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5101,

795 + ebpf_create_global_dimension,

796 + &swap_publish_aggregated[NETDATA_KEY_SWAP_WRITEPAGE_CALL],

797 + 1,

798 + update_every,

799 + NETDATA_EBPF_MODULE_NAME_SWAP);

800 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

801 ebpf_commit_label();

802 }

@@ -788,15 +811,29 @@ static void ebpf_create_specific_swap_charts(char *type, int update_every)

811 */

812 static void ebpf_obsolete_specific_swap_charts(char *type, int update_every)

813 {

791 - ebpf_write_chart_obsolete(type, NETDATA_MEM_SWAP_READ_CHART, "", "Calls to function swap_readpage.",

792 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_SYSTEM_SWAP_SUBMENU,

793 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SWAP_READ_CONTEXT,

794 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5100, update_every);

795 -

796 - ebpf_write_chart_obsolete(type, NETDATA_MEM_SWAP_WRITE_CHART, "", "Calls to function swap_writepage.",

797 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_SYSTEM_SWAP_SUBMENU,

798 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SWAP_WRITE_CONTEXT,

799 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5101, update_every);

814 + ebpf_write_chart_obsolete(

815 + type,

816 + NETDATA_MEM_SWAP_READ_CHART,

817 + "",

818 + "Calls to function swap_readpage.",

819 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

820 + NETDATA_SYSTEM_SWAP_SUBMENU,

821 + NETDATA_EBPF_CHART_TYPE_LINE,

822 + NETDATA_CGROUP_SWAP_READ_CONTEXT,

823 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5100,

824 + update_every);

825 +

826 + ebpf_write_chart_obsolete(

827 + type,

828 + NETDATA_MEM_SWAP_WRITE_CHART,

829 + "",

830 + "Calls to function swap_writepage.",

831 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

832 + NETDATA_SYSTEM_SWAP_SUBMENU,

833 + NETDATA_EBPF_CHART_TYPE_LINE,

834 + NETDATA_CGROUP_SWAP_WRITE_CONTEXT,

835 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5101,

836 + update_every);

837 }

838

839 /*

@@ -810,11 +847,11 @@ static void ebpf_obsolete_specific_swap_charts(char *type, int update_every)

847 static void ebpf_send_specific_swap_data(char *type, netdata_publish_swap_t *values)

848 {

849 ebpf_write_begin_chart(type, NETDATA_MEM_SWAP_READ_CHART, "");

813 - write_chart_dimension(swap_publish_aggregated[NETDATA_KEY_SWAP_READPAGE_CALL].name, (long long) values->read);

850 + write_chart_dimension(swap_publish_aggregated[NETDATA_KEY_SWAP_READPAGE_CALL].name, (long long)values->read);

851 ebpf_write_end_chart();

852

853 ebpf_write_begin_chart(type, NETDATA_MEM_SWAP_WRITE_CHART, "");

817 - write_chart_dimension(swap_publish_aggregated[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name, (long long) values->write);

854 + write_chart_dimension(swap_publish_aggregated[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name, (long long)values->write);

855 ebpf_write_end_chart();

856 }

857

@@ -838,8 +875,7 @@ static void ebpf_create_systemd_swap_charts(int update_every)

875 .module = NETDATA_EBPF_MODULE_NAME_SWAP,

876 .update_every = 0,

877 .suffix = NETDATA_MEM_SWAP_READ_CHART,

841 - .dimension = "calls"

842 - };

878 + .dimension = "calls"};

879

880 static ebpf_systemd_args_t data_write = {

881 .title = "Calls to function swap_writepage.",

@@ -852,14 +888,13 @@ static void ebpf_create_systemd_swap_charts(int update_every)

888 .module = NETDATA_EBPF_MODULE_NAME_SWAP,

889 .update_every = 0,

890 .suffix = NETDATA_MEM_SWAP_WRITE_CHART,

855 - .dimension = "calls"

856 - };

891 + .dimension = "calls"};

892

893 if (!data_write.update_every)

894 data_read.update_every = data_write.update_every = update_every;

895

896 ebpf_cgroup_target_t *w;

862 - for (w = ebpf_cgroup_pids; w ; w = w->next) {

897 + for (w = ebpf_cgroup_pids; w; w = w->next) {

898 if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_SWAP_CHART))

899 continue;

900

@@ -881,7 +916,7 @@ void ebpf_swap_send_cgroup_data(int update_every)

916 {

917 pthread_mutex_lock(&mutex_cgroup_shm);

918 ebpf_cgroup_target_t *ect;

884 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

919 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

920 ebpf_swap_sum_cgroup_pids(&ect->publish_systemd_swap, ect->pids);

921 }

922

@@ -893,7 +928,7 @@ void ebpf_swap_send_cgroup_data(int update_every)

928 ebpf_send_systemd_swap_charts();

929 }

930

896 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

931 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

932 if (ect->systemd)

933 continue;

934

@@ -988,37 +1023,39 @@ void ebpf_swap_create_apps_charts(struct ebpf_module *em, void *ptr)

1023 if (unlikely(!w->exposed))

1024 continue;

1025

991 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

992 - w->clean_name,

993 - "_ebpf_call_swap_readpage",

994 - "Calls to function swap_readpage.",

995 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

996 - NETDATA_EBPF_MEMORY_GROUP,

997 - NETDATA_EBPF_CHART_TYPE_STACKED,

998 - "app.ebpf_call_swap_readpage",

999 - 20070,

1000 - update_every,

1001 - NETDATA_EBPF_MODULE_NAME_SWAP);

1026 + ebpf_write_chart_cmd(

1027 + NETDATA_APP_FAMILY,

1028 + w->clean_name,

1029 + "_ebpf_call_swap_readpage",

1030 + "Calls to function swap_readpage.",

1031 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1032 + NETDATA_EBPF_MEMORY_GROUP,

1033 + NETDATA_EBPF_CHART_TYPE_STACKED,

1034 + "app.ebpf_call_swap_readpage",

1035 + 20070,

1036 + update_every,

1037 + NETDATA_EBPF_MODULE_NAME_SWAP);

1038 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1039 ebpf_commit_label();

1040 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1041

1006 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

1007 - w->clean_name,

1008 - "_ebpf_call_swap_writepage",

1009 - "Calls to function swap_writepage.",

1010 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

1011 - NETDATA_EBPF_MEMORY_GROUP,

1012 - NETDATA_EBPF_CHART_TYPE_STACKED,

1013 - "app.ebpf_call_swap_writepage",

1014 - 20071,

1015 - update_every,

1016 - NETDATA_EBPF_MODULE_NAME_SWAP);

1042 + ebpf_write_chart_cmd(

1043 + NETDATA_APP_FAMILY,

1044 + w->clean_name,

1045 + "_ebpf_call_swap_writepage",

1046 + "Calls to function swap_writepage.",

1047 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1048 + NETDATA_EBPF_MEMORY_GROUP,

1049 + NETDATA_EBPF_CHART_TYPE_STACKED,

1050 + "app.ebpf_call_swap_writepage",

1051 + 20071,

1052 + update_every,

1053 + NETDATA_EBPF_MODULE_NAME_SWAP);

1054 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

1055 ebpf_commit_label();

1056 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

1057

1021 - w->charts_created |= 1<<EBPF_MODULE_SWAP_IDX;

1058 + w->charts_created |= 1 << EBPF_MODULE_SWAP_IDX;

1059 }

1060 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;

1061 }

@@ -1053,15 +1090,20 @@ static void ebpf_swap_allocate_global_vectors()

1090 */

1091 static void ebpf_create_swap_charts(int update_every)

1092 {

1056 - ebpf_create_chart(NETDATA_EBPF_MEMORY_GROUP, NETDATA_MEM_SWAP_CHART,

1057 - "Calls to access swap memory",

1058 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_SYSTEM_SWAP_SUBMENU,

1059 - "mem.swapcalls",

1060 - NETDATA_EBPF_CHART_TYPE_LINE,

1061 - NETDATA_CHART_PRIO_MEM_SWAP_CALLS,

1062 - ebpf_create_global_dimension,

1063 - swap_publish_aggregated, NETDATA_SWAP_END,

1064 - update_every, NETDATA_EBPF_MODULE_NAME_SWAP);

1093 + ebpf_create_chart(

1094 + NETDATA_EBPF_MEMORY_GROUP,

1095 + NETDATA_MEM_SWAP_CHART,

1096 + "Calls to access swap memory",

1097 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1098 + NETDATA_SYSTEM_SWAP_SUBMENU,

1099 + "mem.swapcalls",

1100 + NETDATA_EBPF_CHART_TYPE_LINE,

1101 + NETDATA_CHART_PRIO_MEM_SWAP_CALLS,

1102 + ebpf_create_global_dimension,

1103 + swap_publish_aggregated,

1104 + NETDATA_SWAP_END,

1105 + update_every,

1106 + NETDATA_EBPF_MODULE_NAME_SWAP);

1107

1108 fflush(stdout);

1109 }

@@ -1114,7 +1156,7 @@ static int ebpf_swap_set_internal_value()

1156 {

1157 ebpf_addresses_t address = {.function = NULL, .hash = 0, .addr = 0};

1158 int i;

1117 - for (i = 0; swap_read[i] ; i++) {

1159 + for (i = 0; swap_read[i]; i++) {

1160 address.function = swap_read[i];

1161 ebpf_load_addresses(&address, -1);

1162 if (address.addr)

@@ -1157,15 +1199,20 @@ void *ebpf_swap_thread(void *ptr)

1199 #ifdef LIBBPF_MAJOR_VERSION

1200 ebpf_adjust_thread_load(em, default_btf);

1201 #endif

1160 - if (ebpf_swap_load_bpf(em)) {

1202 + if (ebpf_swap_load_bpf(em)) {

1203 goto endswap;

1204 }

1205

1206 ebpf_swap_allocate_global_vectors();

1207

1166 - int algorithms[NETDATA_SWAP_END] = { NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX };

1167 - ebpf_global_labels(swap_aggregated_data, swap_publish_aggregated, swap_dimension_name, swap_dimension_name,

1168 - algorithms, NETDATA_SWAP_END);

1208 + int algorithms[NETDATA_SWAP_END] = {NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX};

1209 + ebpf_global_labels(

1210 + swap_aggregated_data,

1211 + swap_publish_aggregated,

1212 + swap_dimension_name,

1213 + swap_dimension_name,

1214 + algorithms,

1215 + NETDATA_SWAP_END);

1216

1217 pthread_mutex_lock(&lock);

1218 ebpf_create_swap_charts(em->update_every);

@@ -1173,8 +1220,8 @@ void *ebpf_swap_thread(void *ptr)

1220 ebpf_update_kernel_memory_with_vector(&plugin_statistics, em->maps, EBPF_ACTION_STAT_ADD);

1221 pthread_mutex_unlock(&lock);

1222

1176 - ebpf_read_swap.thread = nd_thread_create(ebpf_read_swap.name, NETDATA_THREAD_OPTION_DEFAULT,

1177 - ebpf_read_swap_thread, em);

1223 + ebpf_read_swap.thread =

1224 + nd_thread_create(ebpf_read_swap.name, NETDATA_THREAD_OPTION_DEFAULT, ebpf_read_swap_thread, em);

1225

1226 swap_collector(em);

1227

src/collectors/ebpf.plugin/ebpf_swap.h

+1 -5

@@ -31,11 +31,7 @@ typedef struct __attribute__((packed)) netdata_publish_swap {

31 uint32_t write;

32 } netdata_publish_swap_t;

34 -enum swap_tables {

35 - NETDATA_PID_SWAP_TABLE,

36 - NETDATA_SWAP_CONTROLLER,

37 - NETDATA_SWAP_GLOBAL_TABLE

38 -};

34 +enum swap_tables { NETDATA_PID_SWAP_TABLE, NETDATA_SWAP_CONTROLLER, NETDATA_SWAP_GLOBAL_TABLE };

36 enum swap_counters {

37 NETDATA_KEY_SWAP_READPAGE_CALL,

src/collectors/ebpf.plugin/ebpf_sync.c

+232 -172

@@ -3,112 +3,143 @@

3 #include "ebpf.h"

4 #include "ebpf_sync.h"

6 -static char *sync_counter_dimension_name[NETDATA_SYNC_IDX_END] = { "sync", "syncfs", "msync", "fsync", "fdatasync",

7 - "sync_file_range" };

6 +static char *sync_counter_dimension_name[NETDATA_SYNC_IDX_END] =

7 + {"sync", "syncfs", "msync", "fsync", "fdatasync", "sync_file_range"};

8 static netdata_syscall_stat_t sync_counter_aggregated_data[NETDATA_SYNC_IDX_END];

9 static netdata_publish_syscall_t sync_counter_publish_aggregated[NETDATA_SYNC_IDX_END];

11 static netdata_idx_t sync_hash_values[NETDATA_SYNC_IDX_END];

13 -ebpf_local_maps_t sync_maps[] = {{.name = "tbl_sync", .internal_input = NETDATA_SYNC_END,

14 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

15 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

13 +ebpf_local_maps_t sync_maps[] = {

14 + {.name = "tbl_sync",

15 + .internal_input = NETDATA_SYNC_END,

16 + .user_input = 0,

17 + .type = NETDATA_EBPF_MAP_STATIC,

18 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

19 #ifdef LIBBPF_MAJOR_VERSION

17 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

20 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

21 #endif

19 - },

20 - {.name = NULL, .internal_input = 0, .user_input = 0,

21 - .type = NETDATA_EBPF_MAP_CONTROLLER,

22 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

22 + },

23 + {.name = NULL,

24 + .internal_input = 0,

25 + .user_input = 0,

26 + .type = NETDATA_EBPF_MAP_CONTROLLER,

27 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

28 #ifdef LIBBPF_MAJOR_VERSION

24 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

29 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

30 #endif

26 - }};

27 -

28 -ebpf_local_maps_t syncfs_maps[] = {{.name = "tbl_syncfs", .internal_input = NETDATA_SYNC_END,

29 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

30 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

31 + }};

32 +

33 +ebpf_local_maps_t syncfs_maps[] = {

34 + {.name = "tbl_syncfs",

35 + .internal_input = NETDATA_SYNC_END,

36 + .user_input = 0,

37 + .type = NETDATA_EBPF_MAP_STATIC,

38 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

39 #ifdef LIBBPF_MAJOR_VERSION

32 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

40 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

41 #endif

34 - },

35 - {.name = NULL, .internal_input = 0, .user_input = 0,

36 - .type = NETDATA_EBPF_MAP_CONTROLLER,

37 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

42 + },

43 + {.name = NULL,

44 + .internal_input = 0,

45 + .user_input = 0,

46 + .type = NETDATA_EBPF_MAP_CONTROLLER,

47 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

48 #ifdef LIBBPF_MAJOR_VERSION

39 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

49 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

50 #endif

41 - }};

42 -

43 -ebpf_local_maps_t msync_maps[] = {{.name = "tbl_msync", .internal_input = NETDATA_SYNC_END,

44 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

45 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

51 + }};

52 +

53 +ebpf_local_maps_t msync_maps[] = {

54 + {.name = "tbl_msync",

55 + .internal_input = NETDATA_SYNC_END,

56 + .user_input = 0,

57 + .type = NETDATA_EBPF_MAP_STATIC,

58 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

59 #ifdef LIBBPF_MAJOR_VERSION

47 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

60 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

61 #endif

49 - },

50 - {.name = NULL, .internal_input = 0, .user_input = 0,

51 - .type = NETDATA_EBPF_MAP_CONTROLLER,

52 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

62 + },

63 + {.name = NULL,

64 + .internal_input = 0,

65 + .user_input = 0,

66 + .type = NETDATA_EBPF_MAP_CONTROLLER,

67 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

68 #ifdef LIBBPF_MAJOR_VERSION

54 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

69 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

70 #endif

56 - }};

57 -

58 -ebpf_local_maps_t fsync_maps[] = {{.name = "tbl_fsync", .internal_input = NETDATA_SYNC_END,

59 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

60 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

71 + }};

72 +

73 +ebpf_local_maps_t fsync_maps[] = {

74 + {.name = "tbl_fsync",

75 + .internal_input = NETDATA_SYNC_END,

76 + .user_input = 0,

77 + .type = NETDATA_EBPF_MAP_STATIC,

78 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

79 #ifdef LIBBPF_MAJOR_VERSION

62 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

80 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

81 #endif

64 - },

65 - {.name = NULL, .internal_input = 0, .user_input = 0,

66 - .type = NETDATA_EBPF_MAP_CONTROLLER,

67 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

82 + },

83 + {.name = NULL,

84 + .internal_input = 0,

85 + .user_input = 0,

86 + .type = NETDATA_EBPF_MAP_CONTROLLER,

87 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

88 #ifdef LIBBPF_MAJOR_VERSION

69 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

89 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

90 #endif

71 - }};

72 -

73 -ebpf_local_maps_t fdatasync_maps[] = {{.name = "tbl_fdatasync", .internal_input = NETDATA_SYNC_END,

74 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

75 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

91 + }};

92 +

93 +ebpf_local_maps_t fdatasync_maps[] = {

94 + {.name = "tbl_fdatasync",

95 + .internal_input = NETDATA_SYNC_END,

96 + .user_input = 0,

97 + .type = NETDATA_EBPF_MAP_STATIC,

98 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

99 #ifdef LIBBPF_MAJOR_VERSION

77 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

100 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

101 #endif

79 - },

80 - {.name = NULL, .internal_input = 0, .user_input = 0,

81 - .type = NETDATA_EBPF_MAP_CONTROLLER,

82 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

102 + },

103 + {.name = NULL,

104 + .internal_input = 0,

105 + .user_input = 0,

106 + .type = NETDATA_EBPF_MAP_CONTROLLER,

107 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

108 #ifdef LIBBPF_MAJOR_VERSION

84 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

109 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

110 #endif

86 - }};

87 -

88 -ebpf_local_maps_t sync_file_range_maps[] = {{.name = "tbl_syncfr", .internal_input = NETDATA_SYNC_END,

89 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

90 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

111 + }};

112 +

113 +ebpf_local_maps_t sync_file_range_maps[] = {

114 + {.name = "tbl_syncfr",

115 + .internal_input = NETDATA_SYNC_END,

116 + .user_input = 0,

117 + .type = NETDATA_EBPF_MAP_STATIC,

118 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

119 #ifdef LIBBPF_MAJOR_VERSION

92 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

120 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

121 #endif

94 - },

95 - {.name = NULL, .internal_input = 0, .user_input = 0,

96 - .type = NETDATA_EBPF_MAP_CONTROLLER,

97 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

122 + },

123 + {.name = NULL,

124 + .internal_input = 0,

125 + .user_input = 0,

126 + .type = NETDATA_EBPF_MAP_CONTROLLER,

127 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

128 #ifdef LIBBPF_MAJOR_VERSION

99 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

129 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

130 #endif

101 - }};

131 + }};

132

133 struct config sync_config = APPCONFIG_INITIALIZER;

134

105 -netdata_ebpf_targets_t sync_targets[] = { {.name = NETDATA_SYSCALLS_SYNC, .mode = EBPF_LOAD_TRAMPOLINE},

106 - {.name = NETDATA_SYSCALLS_SYNCFS, .mode = EBPF_LOAD_TRAMPOLINE},

107 - {.name = NETDATA_SYSCALLS_MSYNC, .mode = EBPF_LOAD_TRAMPOLINE},

108 - {.name = NETDATA_SYSCALLS_FSYNC, .mode = EBPF_LOAD_TRAMPOLINE},

109 - {.name = NETDATA_SYSCALLS_FDATASYNC, .mode = EBPF_LOAD_TRAMPOLINE},

110 - {.name = NETDATA_SYSCALLS_SYNC_FILE_RANGE, .mode = EBPF_LOAD_TRAMPOLINE},

111 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

135 +netdata_ebpf_targets_t sync_targets[] = {

136 + {.name = NETDATA_SYSCALLS_SYNC, .mode = EBPF_LOAD_TRAMPOLINE},

137 + {.name = NETDATA_SYSCALLS_SYNCFS, .mode = EBPF_LOAD_TRAMPOLINE},

138 + {.name = NETDATA_SYSCALLS_MSYNC, .mode = EBPF_LOAD_TRAMPOLINE},

139 + {.name = NETDATA_SYSCALLS_FSYNC, .mode = EBPF_LOAD_TRAMPOLINE},

140 + {.name = NETDATA_SYSCALLS_FDATASYNC, .mode = EBPF_LOAD_TRAMPOLINE},

141 + {.name = NETDATA_SYSCALLS_SYNC_FILE_RANGE, .mode = EBPF_LOAD_TRAMPOLINE},

142 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

143

144 #ifdef LIBBPF_MAJOR_VERSION

145 /*****************************************************************

@@ -195,8 +226,8 @@ static void ebpf_sync_set_hash_tables(ebpf_local_maps_t *map, struct sync_bpf *o

226 *

227 * @return it returns 0 on success and -1 otherwise

228 */

198 -static inline int ebpf_sync_load_and_attach(struct sync_bpf *obj, ebpf_module_t *em, char *target,

199 - sync_syscalls_index_t idx)

229 +static inline int

230 +ebpf_sync_load_and_attach(struct sync_bpf *obj, ebpf_module_t *em, char *target, sync_syscalls_index_t idx)

231 {

232 netdata_ebpf_targets_t *synct = em->targets;

233 netdata_ebpf_program_loaded_t test = synct[NETDATA_SYNC_SYNC_IDX].mode;

@@ -205,10 +236,8 @@ static inline int ebpf_sync_load_and_attach(struct sync_bpf *obj, ebpf_module_t

236 ebpf_sync_disable_probe(obj);

237 ebpf_sync_disable_tracepoints(obj, NETDATA_SYNC_IDX_END);

238

208 - bpf_program__set_attach_target(obj->progs.netdata_sync_fentry, 0,

209 - target);

210 - } else if (test == EBPF_LOAD_PROBE ||

211 - test == EBPF_LOAD_RETPROBE) {

239 + bpf_program__set_attach_target(obj->progs.netdata_sync_fentry, 0, target);

240 + } else if (test == EBPF_LOAD_PROBE || test == EBPF_LOAD_RETPROBE) {

241 ebpf_sync_disable_tracepoints(obj, NETDATA_SYNC_IDX_END);

242 ebpf_sync_disable_trampoline(obj);

243 } else {

@@ -225,8 +254,7 @@ static inline int ebpf_sync_load_and_attach(struct sync_bpf *obj, ebpf_module_t

254 if (test != EBPF_LOAD_PROBE && test != EBPF_LOAD_RETPROBE) {

255 ret = sync_bpf__attach(obj);

256 } else {

228 - obj->links.netdata_sync_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_sync_kprobe,

229 - false, target);

257 + obj->links.netdata_sync_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_sync_kprobe, false, target);

258 ret = (int)libbpf_get_error(obj->links.netdata_sync_kprobe);

259 }

260

@@ -292,52 +320,56 @@ void ebpf_sync_cleanup_objects()

320 static void ebpf_obsolete_sync_global(ebpf_module_t *em)

321 {

322 if (local_syscalls[NETDATA_SYNC_FSYNC_IDX].enabled && local_syscalls[NETDATA_SYNC_FDATASYNC_IDX].enabled)

295 - ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,

296 - NETDATA_EBPF_FILE_SYNC_CHART,

297 - "",

298 - "Monitor calls to fsync(2) and fdatasync(2).",

299 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

300 - NETDATA_EBPF_SYNC_SUBMENU,

301 - NETDATA_EBPF_CHART_TYPE_LINE,

302 - "mem.file_sync",

303 - 21300,

304 - em->update_every);

323 + ebpf_write_chart_obsolete(

324 + NETDATA_EBPF_MEMORY_GROUP,

325 + NETDATA_EBPF_FILE_SYNC_CHART,

326 + "",

327 + "Monitor calls to fsync(2) and fdatasync(2).",

328 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

329 + NETDATA_EBPF_SYNC_SUBMENU,

330 + NETDATA_EBPF_CHART_TYPE_LINE,

331 + "mem.file_sync",

332 + 21300,

333 + em->update_every);

334

335 if (local_syscalls[NETDATA_SYNC_MSYNC_IDX].enabled)

307 - ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,

308 - NETDATA_EBPF_MSYNC_CHART,

309 - "",

310 - "Monitor calls to msync(2).",

311 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

312 - NETDATA_EBPF_SYNC_SUBMENU,

313 - NETDATA_EBPF_CHART_TYPE_LINE,

314 - "mem.memory_map",

315 - 21301,

316 - em->update_every);

336 + ebpf_write_chart_obsolete(

337 + NETDATA_EBPF_MEMORY_GROUP,

338 + NETDATA_EBPF_MSYNC_CHART,

339 + "",

340 + "Monitor calls to msync(2).",

341 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

342 + NETDATA_EBPF_SYNC_SUBMENU,

343 + NETDATA_EBPF_CHART_TYPE_LINE,

344 + "mem.memory_map",

345 + 21301,

346 + em->update_every);

347

348 if (local_syscalls[NETDATA_SYNC_SYNC_IDX].enabled && local_syscalls[NETDATA_SYNC_SYNCFS_IDX].enabled)

319 - ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,

320 - NETDATA_EBPF_SYNC_CHART,

321 - "",

322 - "Monitor calls to sync(2) and syncfs(2).",

323 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

324 - NETDATA_EBPF_SYNC_SUBMENU,

325 - NETDATA_EBPF_CHART_TYPE_LINE,

326 - "mem.sync",

327 - 21302,

328 - em->update_every);

349 + ebpf_write_chart_obsolete(

350 + NETDATA_EBPF_MEMORY_GROUP,

351 + NETDATA_EBPF_SYNC_CHART,

352 + "",

353 + "Monitor calls to sync(2) and syncfs(2).",

354 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

355 + NETDATA_EBPF_SYNC_SUBMENU,

356 + NETDATA_EBPF_CHART_TYPE_LINE,

357 + "mem.sync",

358 + 21302,

359 + em->update_every);

360

361 if (local_syscalls[NETDATA_SYNC_SYNC_FILE_RANGE_IDX].enabled)

331 - ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,

332 - NETDATA_EBPF_FILE_SEGMENT_CHART,

333 - "",

334 - "Monitor calls to sync_file_range(2).",

335 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

336 - NETDATA_EBPF_SYNC_SUBMENU,

337 - NETDATA_EBPF_CHART_TYPE_LINE,

338 - "mem.file_segment",

339 - 21303,

340 - em->update_every);

362 + ebpf_write_chart_obsolete(

363 + NETDATA_EBPF_MEMORY_GROUP,

364 + NETDATA_EBPF_FILE_SEGMENT_CHART,

365 + "",

366 + "Monitor calls to sync_file_range(2).",

367 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

368 + NETDATA_EBPF_SYNC_SUBMENU,

369 + NETDATA_EBPF_CHART_TYPE_LINE,

370 + "mem.file_segment",

371 + 21303,

372 + em->update_every);

373 }

374

375 /**

@@ -350,7 +382,8 @@ static void ebpf_obsolete_sync_global(ebpf_module_t *em)

382 static void ebpf_sync_exit(void *pptr)

383 {

384 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

353 - if(!em) return;

385 + if (!em)

386 + return;

387

388 if (em->enabled == NETDATA_THREAD_EBPF_FUNCTION_RUNNING) {

389 pthread_mutex_lock(&lock);

@@ -454,9 +487,9 @@ static int ebpf_sync_initialize_syscall(ebpf_module_t *em)

487 }

488 em->info.thread_name = saved_name;

489

457 - memset(sync_counter_aggregated_data, 0 , NETDATA_SYNC_IDX_END * sizeof(netdata_syscall_stat_t));

458 - memset(sync_counter_publish_aggregated, 0 , NETDATA_SYNC_IDX_END * sizeof(netdata_publish_syscall_t));

459 - memset(sync_hash_values, 0 , NETDATA_SYNC_IDX_END * sizeof(netdata_idx_t));

490 + memset(sync_counter_aggregated_data, 0, NETDATA_SYNC_IDX_END * sizeof(netdata_syscall_stat_t));

491 + memset(sync_counter_publish_aggregated, 0, NETDATA_SYNC_IDX_END * sizeof(netdata_publish_syscall_t));

492 + memset(sync_hash_values, 0, NETDATA_SYNC_IDX_END * sizeof(netdata_idx_t));

493

494 return (errors) ? -1 : 0;

495 }

@@ -486,7 +519,7 @@ static void ebpf_sync_read_global_table(int maps_per_core)

519 if (!bpf_map_lookup_elem(fd, &idx, &stored)) {

520 int j, end = (maps_per_core) ? ebpf_nprocs : 1;

521 netdata_idx_t total = 0;

489 - for (j = 0; j < end ;j++ )

522 + for (j = 0; j < end; j++)

523 total += stored[j];

524

525 sync_hash_values[i] = total;

@@ -504,9 +537,7 @@ static void ebpf_sync_read_global_table(int maps_per_core)

537 * @param idx the first index with data.

538 * @param end the last index with data.

539 */

507 -static void ebpf_send_sync_chart(char *id,

508 - int idx,

509 - int end)

540 +static void ebpf_send_sync_chart(char *id, int idx, int end)

541 {

542 ebpf_write_begin_chart(NETDATA_EBPF_MEMORY_GROUP, id, "");

543

@@ -535,18 +566,22 @@ static void sync_send_data()

566 }

567

568 if (local_syscalls[NETDATA_SYNC_MSYNC_IDX].enabled)

538 - ebpf_one_dimension_write_charts(NETDATA_EBPF_MEMORY_GROUP, NETDATA_EBPF_MSYNC_CHART,

539 - sync_counter_publish_aggregated[NETDATA_SYNC_MSYNC_IDX].dimension,

540 - sync_hash_values[NETDATA_SYNC_MSYNC_IDX]);

569 + ebpf_one_dimension_write_charts(

570 + NETDATA_EBPF_MEMORY_GROUP,

571 + NETDATA_EBPF_MSYNC_CHART,

572 + sync_counter_publish_aggregated[NETDATA_SYNC_MSYNC_IDX].dimension,

573 + sync_hash_values[NETDATA_SYNC_MSYNC_IDX]);

574

575 if (local_syscalls[NETDATA_SYNC_SYNC_IDX].enabled && local_syscalls[NETDATA_SYNC_SYNCFS_IDX].enabled) {

576 ebpf_send_sync_chart(NETDATA_EBPF_SYNC_CHART, NETDATA_SYNC_SYNC_IDX, NETDATA_SYNC_SYNCFS_IDX);

577 }

578

579 if (local_syscalls[NETDATA_SYNC_SYNC_FILE_RANGE_IDX].enabled)

547 - ebpf_one_dimension_write_charts(NETDATA_EBPF_MEMORY_GROUP, NETDATA_EBPF_FILE_SEGMENT_CHART,

548 - sync_counter_publish_aggregated[NETDATA_SYNC_SYNC_FILE_RANGE_IDX].dimension,

549 - sync_hash_values[NETDATA_SYNC_SYNC_FILE_RANGE_IDX]);

580 + ebpf_one_dimension_write_charts(

581 + NETDATA_EBPF_MEMORY_GROUP,

582 + NETDATA_EBPF_FILE_SEGMENT_CHART,

583 + sync_counter_publish_aggregated[NETDATA_SYNC_SYNC_FILE_RANGE_IDX].dimension,

584 + sync_hash_values[NETDATA_SYNC_SYNC_FILE_RANGE_IDX]);

585 }

586

587 /**

@@ -585,7 +620,6 @@ static void sync_collector(ebpf_module_t *em)

620 }

621 }

622

588 -

623 /*****************************************************************

624 *

625 * MAIN THREAD

@@ -605,18 +639,20 @@ static void sync_collector(ebpf_module_t *em)

639 * @param update_every value to overwrite the update frequency set by the server.

640 * @param context the chart context

641 */

608 -static void ebpf_create_sync_chart(char *id,

609 - char *title,

610 - int order,

611 - int idx,

612 - int end,

613 - int update_every,

614 - char *context)

642 +static void ebpf_create_sync_chart(char *id, char *title, int order, int idx, int end, int update_every, char *context)

643 {

616 - ebpf_write_chart_cmd(NETDATA_EBPF_MEMORY_GROUP, id, "", title, EBPF_COMMON_UNITS_CALLS_PER_SEC,

617 - NETDATA_EBPF_SYNC_SUBMENU, NETDATA_EBPF_CHART_TYPE_LINE, context, order,

618 - update_every,

619 - NETDATA_EBPF_MODULE_NAME_SYNC);

644 + ebpf_write_chart_cmd(

645 + NETDATA_EBPF_MEMORY_GROUP,

646 + id,

647 + "",

648 + title,

649 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

650 + NETDATA_EBPF_SYNC_SUBMENU,

651 + NETDATA_EBPF_CHART_TYPE_LINE,

652 + context,

653 + order,

654 + update_every,

655 + NETDATA_EBPF_MODULE_NAME_SYNC);

656

657 netdata_publish_syscall_t *move = &sync_counter_publish_aggregated[idx];

658

@@ -639,28 +675,44 @@ static void ebpf_create_sync_chart(char *id,

675 static void ebpf_create_sync_charts(int update_every)

676 {

677 if (local_syscalls[NETDATA_SYNC_FSYNC_IDX].enabled && local_syscalls[NETDATA_SYNC_FDATASYNC_IDX].enabled)

642 - ebpf_create_sync_chart(NETDATA_EBPF_FILE_SYNC_CHART,

643 - "Monitor calls to fsync(2) and fdatasync(2).", 21300,

644 - NETDATA_SYNC_FSYNC_IDX, NETDATA_SYNC_FDATASYNC_IDX, update_every,

645 - "mem.file_sync");

678 + ebpf_create_sync_chart(

679 + NETDATA_EBPF_FILE_SYNC_CHART,

680 + "Monitor calls to fsync(2) and fdatasync(2).",

681 + 21300,

682 + NETDATA_SYNC_FSYNC_IDX,

683 + NETDATA_SYNC_FDATASYNC_IDX,

684 + update_every,

685 + "mem.file_sync");

686

687 if (local_syscalls[NETDATA_SYNC_MSYNC_IDX].enabled)

648 - ebpf_create_sync_chart(NETDATA_EBPF_MSYNC_CHART,

649 - "Monitor calls to msync(2).", 21301,

650 - NETDATA_SYNC_MSYNC_IDX, NETDATA_SYNC_MSYNC_IDX, update_every,

651 - "mem.memory_map");

688 + ebpf_create_sync_chart(

689 + NETDATA_EBPF_MSYNC_CHART,

690 + "Monitor calls to msync(2).",

691 + 21301,

692 + NETDATA_SYNC_MSYNC_IDX,

693 + NETDATA_SYNC_MSYNC_IDX,

694 + update_every,

695 + "mem.memory_map");

696

697 if (local_syscalls[NETDATA_SYNC_SYNC_IDX].enabled && local_syscalls[NETDATA_SYNC_SYNCFS_IDX].enabled)

654 - ebpf_create_sync_chart(NETDATA_EBPF_SYNC_CHART,

655 - "Monitor calls to sync(2) and syncfs(2).", 21302,

656 - NETDATA_SYNC_SYNC_IDX, NETDATA_SYNC_SYNCFS_IDX, update_every,

657 - "mem.sync");

698 + ebpf_create_sync_chart(

699 + NETDATA_EBPF_SYNC_CHART,

700 + "Monitor calls to sync(2) and syncfs(2).",

701 + 21302,

702 + NETDATA_SYNC_SYNC_IDX,

703 + NETDATA_SYNC_SYNCFS_IDX,

704 + update_every,

705 + "mem.sync");

706

707 if (local_syscalls[NETDATA_SYNC_SYNC_FILE_RANGE_IDX].enabled)

660 - ebpf_create_sync_chart(NETDATA_EBPF_FILE_SEGMENT_CHART,

661 - "Monitor calls to sync_file_range(2).", 21303,

662 - NETDATA_SYNC_SYNC_FILE_RANGE_IDX, NETDATA_SYNC_SYNC_FILE_RANGE_IDX, update_every,

663 - "mem.file_segment");

708 + ebpf_create_sync_chart(

709 + NETDATA_EBPF_FILE_SEGMENT_CHART,

710 + "Monitor calls to sync_file_range(2).",

711 + 21303,

712 + NETDATA_SYNC_SYNC_FILE_RANGE_IDX,

713 + NETDATA_SYNC_SYNC_FILE_RANGE_IDX,

714 + update_every,

715 + "mem.file_segment");

716

717 fflush(stdout);

718 }

@@ -674,8 +726,8 @@ static void ebpf_sync_parse_syscalls()

726 {

727 int i;

728 for (i = 0; local_syscalls[i].syscall; i++) {

677 - local_syscalls[i].enabled = appconfig_get_boolean(&sync_config, NETDATA_SYNC_CONFIG_NAME,

678 - local_syscalls[i].syscall, CONFIG_BOOLEAN_YES);

729 + local_syscalls[i].enabled = appconfig_get_boolean(

730 + &sync_config, NETDATA_SYNC_CONFIG_NAME, local_syscalls[i].syscall, CONFIG_BOOLEAN_YES);

731 }

732 }

733

@@ -720,12 +772,20 @@ void *ebpf_sync_thread(void *ptr)

772 goto endsync;

773 }

774

723 - int algorithms[NETDATA_SYNC_IDX_END] = { NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX,

724 - NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX,

725 - NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX };

726 - ebpf_global_labels(sync_counter_aggregated_data, sync_counter_publish_aggregated,

727 - sync_counter_dimension_name, sync_counter_dimension_name,

728 - algorithms, NETDATA_SYNC_IDX_END);

775 + int algorithms[NETDATA_SYNC_IDX_END] = {

776 + NETDATA_EBPF_INCREMENTAL_IDX,

777 + NETDATA_EBPF_INCREMENTAL_IDX,

778 + NETDATA_EBPF_INCREMENTAL_IDX,

779 + NETDATA_EBPF_INCREMENTAL_IDX,

780 + NETDATA_EBPF_INCREMENTAL_IDX,

781 + NETDATA_EBPF_INCREMENTAL_IDX};

782 + ebpf_global_labels(

783 + sync_counter_aggregated_data,

784 + sync_counter_publish_aggregated,

785 + sync_counter_dimension_name,

786 + sync_counter_dimension_name,

787 + algorithms,

788 + NETDATA_SYNC_IDX_END);

789

790 pthread_mutex_lock(&lock);

791 ebpf_create_sync_charts(em->update_every);

src/collectors/ebpf.plugin/ebpf_sync.h

+8 -9

@@ -5,7 +5,8 @@

6 // Module name & description

7 #define NETDATA_EBPF_MODULE_NAME_SYNC "sync"

8 -#define NETDATA_EBPF_SYNC_MODULE_DESC "Monitor calls to syscalls sync(2), fsync(2), fdatasync(2), syncfs(2), msync(2), and sync_file_range(2)."

8 +#define NETDATA_EBPF_SYNC_MODULE_DESC \

9 + "Monitor calls to syscalls sync(2), fsync(2), fdatasync(2), syncfs(2), msync(2), and sync_file_range(2)."

11 // charts

12 #define NETDATA_EBPF_SYNC_CHART "sync"

@@ -14,12 +15,12 @@

15 #define NETDATA_EBPF_FILE_SEGMENT_CHART "file_segment"

16 #define NETDATA_EBPF_SYNC_SUBMENU "synchronization (eBPF)"

17 -#define NETDATA_SYSCALLS_SYNC "sync"

18 +#define NETDATA_SYSCALLS_SYNC "sync"

19 #define NETDATA_SYSCALLS_SYNCFS "syncfs"

19 -#define NETDATA_SYSCALLS_MSYNC "msync"

20 -#define NETDATA_SYSCALLS_FSYNC "fsync"

21 -#define NETDATA_SYSCALLS_FDATASYNC "fdatasync"

22 -#define NETDATA_SYSCALLS_SYNC_FILE_RANGE "sync_file_range"

20 +#define NETDATA_SYSCALLS_MSYNC "msync"

21 +#define NETDATA_SYSCALLS_FSYNC "fsync"

22 +#define NETDATA_SYSCALLS_FDATASYNC "fdatasync"

23 +#define NETDATA_SYSCALLS_SYNC_FILE_RANGE "sync_file_range"

25 #define NETDATA_EBPF_SYNC_SLEEP_MS 800000ULL

@@ -45,9 +46,7 @@ enum netdata_sync_charts {

46 NETDATA_SYNC_END

47 };

48 -enum netdata_sync_table {

49 - NETDATA_SYNC_GLOBAL_TABLE

50 -};

49 +enum netdata_sync_table { NETDATA_SYNC_GLOBAL_TABLE };

51 void *ebpf_sync_thread(void *ptr);

52 extern struct config sync_config;

src/collectors/ebpf.plugin/ebpf_unittest.c

+2 -2

@@ -14,8 +14,8 @@ void ebpf_ut_initialize_structure(netdata_run_mode_t mode)

14 memset(&test_em, 0, sizeof(ebpf_module_t));

15 test_em.info.thread_name = strdupz("process");

16 test_em.info.config_name = test_em.info.thread_name;

18 - NETDATA_V5_14;

17 + test_em.kernels =

19 test_em.pid_map_size = ND_EBPF_DEFAULT_PID_SIZE;

20 test_em.apps_level = NETDATA_APPS_LEVEL_REAL_PARENT;

21 test_em.mode = mode;

src/collectors/ebpf.plugin/ebpf_unittest.h

+1 -1

@@ -1,5 +1,5 @@

1 #ifndef NETDATA_EBPF_PLUGIN_UNITTEST_H_

2 -# define NETDATA_EBPF_PLUGIN_UNITTEST_H_ 1

2 +#define NETDATA_EBPF_PLUGIN_UNITTEST_H_ 1

4 #include "ebpf.h"

src/collectors/ebpf.plugin/ebpf_vfs.c

+1287 -986

@@ -3,43 +3,50 @@

3 #include "ebpf.h"

4 #include "ebpf_vfs.h"

6 -static char *vfs_dimension_names[NETDATA_KEY_PUBLISH_VFS_END] = { "delete", "read", "write",

7 - "fsync", "open", "create" };

8 -static char *vfs_id_names[NETDATA_KEY_PUBLISH_VFS_END] = { "vfs_unlink", "vfs_read", "vfs_write",

9 - "vfs_fsync", "vfs_open", "vfs_create"};

6 +static char *vfs_dimension_names[NETDATA_KEY_PUBLISH_VFS_END] = {"delete", "read", "write", "fsync", "open", "create"};

7 +static char *vfs_id_names[NETDATA_KEY_PUBLISH_VFS_END] =

8 + {"vfs_unlink", "vfs_read", "vfs_write", "vfs_fsync", "vfs_open", "vfs_create"};

10 static netdata_idx_t *vfs_hash_values = NULL;

11 static netdata_syscall_stat_t vfs_aggregated_data[NETDATA_KEY_PUBLISH_VFS_END];

12 static netdata_publish_syscall_t vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_END];

13 netdata_ebpf_vfs_t *vfs_vector = NULL;

16 -static ebpf_local_maps_t vfs_maps[] = {{.name = "tbl_vfs_pid", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

17 - .user_input = 0, .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

18 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

15 +static ebpf_local_maps_t vfs_maps[] = {

16 + {.name = "tbl_vfs_pid",

17 + .internal_input = ND_EBPF_DEFAULT_PID_SIZE,

18 + .user_input = 0,

19 + .type = NETDATA_EBPF_MAP_RESIZABLE | NETDATA_EBPF_MAP_PID,

20 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

21 #ifdef LIBBPF_MAJOR_VERSION

20 - .map_type = BPF_MAP_TYPE_PERCPU_HASH

22 + .map_type = BPF_MAP_TYPE_PERCPU_HASH

23 #endif

22 - },

23 - {.name = "tbl_vfs_stats", .internal_input = NETDATA_VFS_COUNTER,

24 - .user_input = 0, .type = NETDATA_EBPF_MAP_STATIC,

25 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

24 + },

25 + {.name = "tbl_vfs_stats",

26 + .internal_input = NETDATA_VFS_COUNTER,

27 + .user_input = 0,

28 + .type = NETDATA_EBPF_MAP_STATIC,

29 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

30 #ifdef LIBBPF_MAJOR_VERSION

27 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

31 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

32 #endif

29 - },

30 - {.name = "vfs_ctrl", .internal_input = NETDATA_CONTROLLER_END,

31 - .user_input = 0,

32 - .type = NETDATA_EBPF_MAP_CONTROLLER,

33 - .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

33 + },

34 + {.name = "vfs_ctrl",

35 + .internal_input = NETDATA_CONTROLLER_END,

36 + .user_input = 0,

37 + .type = NETDATA_EBPF_MAP_CONTROLLER,

38 + .map_fd = ND_EBPF_MAP_FD_NOT_INITIALIZED,

39 #ifdef LIBBPF_MAJOR_VERSION

35 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

40 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

41 #endif

37 - },

38 - {.name = NULL, .internal_input = 0, .user_input = 0,

42 + },

43 + {.name = NULL,

44 + .internal_input = 0,

45 + .user_input = 0,

46 #ifdef LIBBPF_MAJOR_VERSION

40 - .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

47 + .map_type = BPF_MAP_TYPE_PERCPU_ARRAY

48 #endif

42 - }};

49 + }};

51 struct netdata_static_thread ebpf_read_vfs = {

52 .name = "EBPF_READ_VFS",

@@ -49,21 +56,21 @@ struct netdata_static_thread ebpf_read_vfs = {

56 .enabled = 1,

57 .thread = NULL,

58 .init_routine = NULL,

52 - .start_routine = NULL

53 -};

59 + .start_routine = NULL};

61 struct config vfs_config = APPCONFIG_INITIALIZER;

57 -netdata_ebpf_targets_t vfs_targets[] = { {.name = "vfs_write", .mode = EBPF_LOAD_TRAMPOLINE},

58 - {.name = "vfs_writev", .mode = EBPF_LOAD_TRAMPOLINE},

59 - {.name = "vfs_read", .mode = EBPF_LOAD_TRAMPOLINE},

60 - {.name = "vfs_readv", .mode = EBPF_LOAD_TRAMPOLINE},

61 - {.name = "vfs_unlink", .mode = EBPF_LOAD_TRAMPOLINE},

62 - {.name = "vfs_fsync", .mode = EBPF_LOAD_TRAMPOLINE},

63 - {.name = "vfs_open", .mode = EBPF_LOAD_TRAMPOLINE},

64 - {.name = "vfs_create", .mode = EBPF_LOAD_TRAMPOLINE},

65 - {.name = "release_task", .mode = EBPF_LOAD_TRAMPOLINE},

66 - {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

63 +netdata_ebpf_targets_t vfs_targets[] = {

64 + {.name = "vfs_write", .mode = EBPF_LOAD_TRAMPOLINE},

65 + {.name = "vfs_writev", .mode = EBPF_LOAD_TRAMPOLINE},

66 + {.name = "vfs_read", .mode = EBPF_LOAD_TRAMPOLINE},

67 + {.name = "vfs_readv", .mode = EBPF_LOAD_TRAMPOLINE},

68 + {.name = "vfs_unlink", .mode = EBPF_LOAD_TRAMPOLINE},

69 + {.name = "vfs_fsync", .mode = EBPF_LOAD_TRAMPOLINE},

70 + {.name = "vfs_open", .mode = EBPF_LOAD_TRAMPOLINE},

71 + {.name = "vfs_create", .mode = EBPF_LOAD_TRAMPOLINE},

72 + {.name = "release_task", .mode = EBPF_LOAD_TRAMPOLINE},

73 + {.name = NULL, .mode = EBPF_LOAD_TRAMPOLINE}};

75 #ifdef LIBBPF_MAJOR_VERSION

76 /**

@@ -167,134 +174,134 @@ static void ebpf_vfs_set_trampoline_target(struct vfs_bpf *obj)

174 */

175 static int ebpf_vfs_attach_probe(struct vfs_bpf *obj)

176 {

170 - obj->links.netdata_vfs_write_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_write_kprobe, false,

171 - vfs_targets[NETDATA_EBPF_VFS_WRITE].name);

177 + obj->links.netdata_vfs_write_kprobe = bpf_program__attach_kprobe(

178 + obj->progs.netdata_vfs_write_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_WRITE].name);

179 long ret = libbpf_get_error(obj->links.netdata_vfs_write_kprobe);

180 if (ret)

181 return -1;

182

176 - obj->links.netdata_vfs_write_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_write_kretprobe, true,

177 - vfs_targets[NETDATA_EBPF_VFS_WRITE].name);

183 + obj->links.netdata_vfs_write_kretprobe = bpf_program__attach_kprobe(

184 + obj->progs.netdata_vfs_write_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_WRITE].name);

185 ret = libbpf_get_error(obj->links.netdata_vfs_write_kretprobe);

186 if (ret)

187 return -1;

188

182 - obj->links.netdata_vfs_writev_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_writev_kprobe, false,

183 - vfs_targets[NETDATA_EBPF_VFS_WRITEV].name);

189 + obj->links.netdata_vfs_writev_kprobe = bpf_program__attach_kprobe(

190 + obj->progs.netdata_vfs_writev_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_WRITEV].name);

191 ret = libbpf_get_error(obj->links.netdata_vfs_writev_kprobe);

192 if (ret)

193 return -1;

194

188 - obj->links.netdata_vfs_writev_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_writev_kretprobe, true,

189 - vfs_targets[NETDATA_EBPF_VFS_WRITEV].name);

195 + obj->links.netdata_vfs_writev_kretprobe = bpf_program__attach_kprobe(

196 + obj->progs.netdata_vfs_writev_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_WRITEV].name);

197 ret = libbpf_get_error(obj->links.netdata_vfs_writev_kretprobe);

198 if (ret)

199 return -1;

200

194 - obj->links.netdata_vfs_read_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_read_kprobe, false,

195 - vfs_targets[NETDATA_EBPF_VFS_READ].name);

201 + obj->links.netdata_vfs_read_kprobe =

202 + bpf_program__attach_kprobe(obj->progs.netdata_vfs_read_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_READ].name);

203 ret = libbpf_get_error(obj->links.netdata_vfs_read_kprobe);

204 if (ret)

205 return -1;

206

200 - obj->links.netdata_vfs_read_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_read_kretprobe, true,

201 - vfs_targets[NETDATA_EBPF_VFS_READ].name);

207 + obj->links.netdata_vfs_read_kretprobe = bpf_program__attach_kprobe(

208 + obj->progs.netdata_vfs_read_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_READ].name);

209 ret = libbpf_get_error(obj->links.netdata_vfs_read_kretprobe);

210 if (ret)

211 return -1;

212

206 - obj->links.netdata_vfs_readv_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_readv_kprobe, false,

207 - vfs_targets[NETDATA_EBPF_VFS_READV].name);

213 + obj->links.netdata_vfs_readv_kprobe = bpf_program__attach_kprobe(

214 + obj->progs.netdata_vfs_readv_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_READV].name);

215 ret = libbpf_get_error(obj->links.netdata_vfs_readv_kprobe);

216 if (ret)

217 return -1;

218

212 - obj->links.netdata_vfs_readv_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_readv_kretprobe, true,

213 - vfs_targets[NETDATA_EBPF_VFS_READV].name);

219 + obj->links.netdata_vfs_readv_kretprobe = bpf_program__attach_kprobe(

220 + obj->progs.netdata_vfs_readv_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_READV].name);

221 ret = libbpf_get_error(obj->links.netdata_vfs_readv_kretprobe);

222 if (ret)

223 return -1;

224

218 - obj->links.netdata_vfs_unlink_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_unlink_kprobe, false,

219 - vfs_targets[NETDATA_EBPF_VFS_UNLINK].name);

225 + obj->links.netdata_vfs_unlink_kprobe = bpf_program__attach_kprobe(

226 + obj->progs.netdata_vfs_unlink_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_UNLINK].name);

227 ret = libbpf_get_error(obj->links.netdata_vfs_unlink_kprobe);

228 if (ret)

229 return -1;

230

224 - obj->links.netdata_vfs_unlink_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_unlink_kretprobe, true,

225 - vfs_targets[NETDATA_EBPF_VFS_UNLINK].name);

231 + obj->links.netdata_vfs_unlink_kretprobe = bpf_program__attach_kprobe(

232 + obj->progs.netdata_vfs_unlink_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_UNLINK].name);

233 ret = libbpf_get_error(obj->links.netdata_vfs_unlink_kretprobe);

234 if (ret)

235 return -1;

236

230 - obj->links.netdata_vfs_fsync_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_fsync_kprobe, false,

231 - vfs_targets[NETDATA_EBPF_VFS_FSYNC].name);

237 + obj->links.netdata_vfs_fsync_kprobe = bpf_program__attach_kprobe(

238 + obj->progs.netdata_vfs_fsync_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_FSYNC].name);

239 ret = libbpf_get_error(obj->links.netdata_vfs_fsync_kprobe);

240 if (ret)

241 return -1;

242

236 - obj->links.netdata_vfs_fsync_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_fsync_kretprobe, true,

237 - vfs_targets[NETDATA_EBPF_VFS_FSYNC].name);

243 + obj->links.netdata_vfs_fsync_kretprobe = bpf_program__attach_kprobe(

244 + obj->progs.netdata_vfs_fsync_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_FSYNC].name);

245 ret = libbpf_get_error(obj->links.netdata_vfs_fsync_kretprobe);

246 if (ret)

247 return -1;

248

242 - obj->links.netdata_vfs_open_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_open_kprobe, false,

243 - vfs_targets[NETDATA_EBPF_VFS_OPEN].name);

249 + obj->links.netdata_vfs_open_kprobe =

250 + bpf_program__attach_kprobe(obj->progs.netdata_vfs_open_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_OPEN].name);

251 ret = libbpf_get_error(obj->links.netdata_vfs_open_kprobe);

252 if (ret)

253 return -1;

254

248 - obj->links.netdata_vfs_open_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_open_kretprobe, true,

249 - vfs_targets[NETDATA_EBPF_VFS_OPEN].name);

255 + obj->links.netdata_vfs_open_kretprobe = bpf_program__attach_kprobe(

256 + obj->progs.netdata_vfs_open_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_OPEN].name);

257 ret = libbpf_get_error(obj->links.netdata_vfs_open_kretprobe);

258 if (ret)

259 return -1;

260

254 - obj->links.netdata_vfs_create_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_create_kprobe, false,

255 - vfs_targets[NETDATA_EBPF_VFS_CREATE].name);

261 + obj->links.netdata_vfs_create_kprobe = bpf_program__attach_kprobe(

262 + obj->progs.netdata_vfs_create_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_CREATE].name);

263 ret = libbpf_get_error(obj->links.netdata_vfs_create_kprobe);

264 if (ret)

265 return -1;

266

260 - obj->links.netdata_vfs_create_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_create_kretprobe, true,

261 - vfs_targets[NETDATA_EBPF_VFS_CREATE].name);

267 + obj->links.netdata_vfs_create_kretprobe = bpf_program__attach_kprobe(

268 + obj->progs.netdata_vfs_create_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_CREATE].name);

269 ret = libbpf_get_error(obj->links.netdata_vfs_create_kretprobe);

270 if (ret)

271 return -1;

272

266 - obj->links.netdata_vfs_fsync_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_fsync_kprobe, false,

267 - vfs_targets[NETDATA_EBPF_VFS_FSYNC].name);

273 + obj->links.netdata_vfs_fsync_kprobe = bpf_program__attach_kprobe(

274 + obj->progs.netdata_vfs_fsync_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_FSYNC].name);

275 ret = libbpf_get_error(obj->links.netdata_vfs_fsync_kprobe);

276 if (ret)

277 return -1;

278

272 - obj->links.netdata_vfs_fsync_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_fsync_kretprobe, true,

273 - vfs_targets[NETDATA_EBPF_VFS_FSYNC].name);

279 + obj->links.netdata_vfs_fsync_kretprobe = bpf_program__attach_kprobe(

280 + obj->progs.netdata_vfs_fsync_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_FSYNC].name);

281 ret = libbpf_get_error(obj->links.netdata_vfs_fsync_kretprobe);

282 if (ret)

283 return -1;

284

278 - obj->links.netdata_vfs_open_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_open_kprobe, false,

279 - vfs_targets[NETDATA_EBPF_VFS_OPEN].name);

285 + obj->links.netdata_vfs_open_kprobe =

286 + bpf_program__attach_kprobe(obj->progs.netdata_vfs_open_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_OPEN].name);

287 ret = libbpf_get_error(obj->links.netdata_vfs_open_kprobe);

288 if (ret)

289 return -1;

290

284 - obj->links.netdata_vfs_open_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_open_kretprobe, true,

285 - vfs_targets[NETDATA_EBPF_VFS_OPEN].name);

291 + obj->links.netdata_vfs_open_kretprobe = bpf_program__attach_kprobe(

292 + obj->progs.netdata_vfs_open_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_OPEN].name);

293 ret = libbpf_get_error(obj->links.netdata_vfs_open_kretprobe);

294 if (ret)

295 return -1;

296

290 - obj->links.netdata_vfs_create_kprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_create_kprobe, false,

291 - vfs_targets[NETDATA_EBPF_VFS_CREATE].name);

297 + obj->links.netdata_vfs_create_kprobe = bpf_program__attach_kprobe(

298 + obj->progs.netdata_vfs_create_kprobe, false, vfs_targets[NETDATA_EBPF_VFS_CREATE].name);

299 ret = libbpf_get_error(obj->links.netdata_vfs_create_kprobe);

300 if (ret)

301 return -1;

302

296 - obj->links.netdata_vfs_create_kretprobe = bpf_program__attach_kprobe(obj->progs.netdata_vfs_create_kretprobe, true,

297 - vfs_targets[NETDATA_EBPF_VFS_CREATE].name);

303 + obj->links.netdata_vfs_create_kretprobe = bpf_program__attach_kprobe(

304 + obj->progs.netdata_vfs_create_kretprobe, true, vfs_targets[NETDATA_EBPF_VFS_CREATE].name);

305 ret = libbpf_get_error(obj->links.netdata_vfs_create_kretprobe);

306 if (ret)

307 return -1;

@@ -312,8 +319,7 @@ static int ebpf_vfs_attach_probe(struct vfs_bpf *obj)

319 */

320 static void ebpf_vfs_adjust_map(struct vfs_bpf *obj, ebpf_module_t *em)

321 {

315 - ebpf_update_map_size(obj->maps.tbl_vfs_pid, &vfs_maps[NETDATA_VFS_PID],

316 - em, bpf_map__name(obj->maps.tbl_vfs_pid));

322 + ebpf_update_map_size(obj->maps.tbl_vfs_pid, &vfs_maps[NETDATA_VFS_PID], em, bpf_map__name(obj->maps.tbl_vfs_pid));

323

324 ebpf_update_map_type(obj->maps.tbl_vfs_pid, &vfs_maps[NETDATA_VFS_PID]);

325 ebpf_update_map_type(obj->maps.tbl_vfs_stats, &vfs_maps[NETDATA_VFS_ALL]);

@@ -392,157 +398,170 @@ static void ebpf_obsolete_specific_vfs_charts(char *type, ebpf_module_t *em);

398 */

399 static void ebpf_obsolete_vfs_services(ebpf_module_t *em, char *id)

400 {

395 - ebpf_write_chart_obsolete(id,

396 - NETDATA_SYSCALL_APPS_FILE_DELETED,

397 - "",

398 - "Files deleted",

399 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

400 - NETDATA_VFS_GROUP,

401 - NETDATA_EBPF_CHART_TYPE_STACKED,

402 - NETDATA_SYSTEMD_VFS_UNLINK_CONTEXT,

403 - 20065,

404 - em->update_every);

405 -

406 - ebpf_write_chart_obsolete(id,

407 - NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS,

408 - "",

409 - "Write to disk",

410 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

411 - NETDATA_VFS_GROUP,

412 - NETDATA_EBPF_CHART_TYPE_STACKED,

413 - NETDATA_SYSTEMD_VFS_WRITE_CONTEXT,

414 - 20066,

415 - em->update_every);

401 + ebpf_write_chart_obsolete(

402 + id,

403 + NETDATA_SYSCALL_APPS_FILE_DELETED,

404 + "",

405 + "Files deleted",

406 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

407 + NETDATA_VFS_GROUP,

408 + NETDATA_EBPF_CHART_TYPE_STACKED,

409 + NETDATA_SYSTEMD_VFS_UNLINK_CONTEXT,

410 + 20065,

411 + em->update_every);

412 +

413 + ebpf_write_chart_obsolete(

414 + id,

415 + NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS,

416 + "",

417 + "Write to disk",

418 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

419 + NETDATA_VFS_GROUP,

420 + NETDATA_EBPF_CHART_TYPE_STACKED,

421 + NETDATA_SYSTEMD_VFS_WRITE_CONTEXT,

422 + 20066,

423 + em->update_every);

424

425 if (em->mode < MODE_ENTRY) {

418 - ebpf_write_chart_obsolete(id,

419 - NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR,

420 - "",

421 - "Fails to write",

422 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

423 - NETDATA_VFS_GROUP,

424 - NETDATA_EBPF_CHART_TYPE_STACKED,

425 - NETDATA_SYSTEMD_VFS_WRITE_ERROR_CONTEXT,

426 - 20067,

427 - em->update_every);

426 + ebpf_write_chart_obsolete(

427 + id,

428 + NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR,

429 + "",

430 + "Fails to write",

431 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

432 + NETDATA_VFS_GROUP,

433 + NETDATA_EBPF_CHART_TYPE_STACKED,

434 + NETDATA_SYSTEMD_VFS_WRITE_ERROR_CONTEXT,

435 + 20067,

436 + em->update_every);

437 }

438

430 - ebpf_write_chart_obsolete(id,

431 - NETDATA_SYSCALL_APPS_VFS_READ_CALLS,

432 - "",

433 - "Read from disk",

434 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

435 - NETDATA_VFS_GROUP,

436 - NETDATA_EBPF_CHART_TYPE_STACKED,

437 - NETDATA_SYSTEMD_VFS_READ_CONTEXT,

438 - 20068,

439 - em->update_every);

439 + ebpf_write_chart_obsolete(

440 + id,

441 + NETDATA_SYSCALL_APPS_VFS_READ_CALLS,

442 + "",

443 + "Read from disk",

444 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

445 + NETDATA_VFS_GROUP,

446 + NETDATA_EBPF_CHART_TYPE_STACKED,

447 + NETDATA_SYSTEMD_VFS_READ_CONTEXT,

448 + 20068,

449 + em->update_every);

450

451 if (em->mode < MODE_ENTRY) {

442 - ebpf_write_chart_obsolete(id,

443 - NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR,

444 - "",

445 - "Fails to read",

446 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

447 - NETDATA_VFS_GROUP,

448 - NETDATA_EBPF_CHART_TYPE_STACKED,

449 - NETDATA_SYSTEMD_VFS_READ_ERROR_CONTEXT,

450 - 20069,

451 - em->update_every);

452 + ebpf_write_chart_obsolete(

453 + id,

454 + NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR,

455 + "",

456 + "Fails to read",

457 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

458 + NETDATA_VFS_GROUP,

459 + NETDATA_EBPF_CHART_TYPE_STACKED,

460 + NETDATA_SYSTEMD_VFS_READ_ERROR_CONTEXT,

461 + 20069,

462 + em->update_every);

463 }

464

454 - ebpf_write_chart_obsolete(id,

455 - NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES,

456 - "",

457 - "Bytes written on disk",

458 - EBPF_COMMON_UNITS_BYTES,

459 - NETDATA_VFS_GROUP,

460 - NETDATA_EBPF_CHART_TYPE_STACKED,

461 - NETDATA_SYSTEMD_VFS_WRITE_BYTES_CONTEXT,

462 - 20070,

463 - em->update_every);

464 -

465 - ebpf_write_chart_obsolete(id,

466 - NETDATA_SYSCALL_APPS_VFS_READ_BYTES,

467 - "",

468 - "Bytes read from disk",

469 - EBPF_COMMON_UNITS_BYTES,

470 - NETDATA_VFS_GROUP,

471 - NETDATA_EBPF_CHART_TYPE_STACKED,

472 - NETDATA_SYSTEMD_VFS_READ_BYTES_CONTEXT,

473 - 20071,

474 - em->update_every);

475 -

476 - ebpf_write_chart_obsolete(id,

477 - NETDATA_SYSCALL_APPS_VFS_FSYNC,

478 - "",

479 - "Calls to vfs_fsync.",

480 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

481 - NETDATA_VFS_GROUP,

482 - NETDATA_EBPF_CHART_TYPE_STACKED,

483 - NETDATA_SYSTEMD_VFS_FSYNC_CONTEXT,

484 - 20072,

485 - em->update_every);

465 + ebpf_write_chart_obsolete(

466 + id,

467 + NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES,

468 + "",

469 + "Bytes written on disk",

470 + EBPF_COMMON_UNITS_BYTES,

471 + NETDATA_VFS_GROUP,

472 + NETDATA_EBPF_CHART_TYPE_STACKED,

473 + NETDATA_SYSTEMD_VFS_WRITE_BYTES_CONTEXT,

474 + 20070,

475 + em->update_every);

476 +

477 + ebpf_write_chart_obsolete(

478 + id,

479 + NETDATA_SYSCALL_APPS_VFS_READ_BYTES,

480 + "",

481 + "Bytes read from disk",

482 + EBPF_COMMON_UNITS_BYTES,

483 + NETDATA_VFS_GROUP,

484 + NETDATA_EBPF_CHART_TYPE_STACKED,

485 + NETDATA_SYSTEMD_VFS_READ_BYTES_CONTEXT,

486 + 20071,

487 + em->update_every);

488 +

489 + ebpf_write_chart_obsolete(

490 + id,

491 + NETDATA_SYSCALL_APPS_VFS_FSYNC,

492 + "",

493 + "Calls to vfs_fsync.",

494 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

495 + NETDATA_VFS_GROUP,

496 + NETDATA_EBPF_CHART_TYPE_STACKED,

497 + NETDATA_SYSTEMD_VFS_FSYNC_CONTEXT,

498 + 20072,

499 + em->update_every);

500

501 if (em->mode < MODE_ENTRY) {

488 - ebpf_write_chart_obsolete(id,

489 - NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR,

490 - "",

491 - "Sync error",

492 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

493 - NETDATA_VFS_GROUP,

494 - NETDATA_EBPF_CHART_TYPE_STACKED,

495 - NETDATA_SYSTEMD_VFS_FSYNC_ERROR_CONTEXT,

496 - 20073,

497 - em->update_every);

502 + ebpf_write_chart_obsolete(

503 + id,

504 + NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR,

505 + "",

506 + "Sync error",

507 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

508 + NETDATA_VFS_GROUP,

509 + NETDATA_EBPF_CHART_TYPE_STACKED,

510 + NETDATA_SYSTEMD_VFS_FSYNC_ERROR_CONTEXT,

511 + 20073,

512 + em->update_every);

513 }

514

500 - ebpf_write_chart_obsolete(id,

501 - NETDATA_SYSCALL_APPS_VFS_OPEN,

502 - "",

503 - "Calls to vfs_open.",

504 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

505 - NETDATA_VFS_GROUP,

506 - NETDATA_EBPF_CHART_TYPE_STACKED,

507 - NETDATA_SYSTEMD_VFS_OPEN_CONTEXT,

508 - 20074,

509 - em->update_every);

515 + ebpf_write_chart_obsolete(

516 + id,

517 + NETDATA_SYSCALL_APPS_VFS_OPEN,

518 + "",

519 + "Calls to vfs_open.",

520 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

521 + NETDATA_VFS_GROUP,

522 + NETDATA_EBPF_CHART_TYPE_STACKED,

523 + NETDATA_SYSTEMD_VFS_OPEN_CONTEXT,

524 + 20074,

525 + em->update_every);

526

527 if (em->mode < MODE_ENTRY) {

512 - ebpf_write_chart_obsolete(id,

513 - NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR,

514 - "",

515 - "Open error",

516 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

517 - NETDATA_VFS_GROUP,

518 - NETDATA_EBPF_CHART_TYPE_STACKED,

519 - NETDATA_SYSTEMD_VFS_OPEN_ERROR_CONTEXT,

520 - 20075,

521 - em->update_every);

528 + ebpf_write_chart_obsolete(

529 + id,

530 + NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR,

531 + "",

532 + "Open error",

533 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

534 + NETDATA_VFS_GROUP,

535 + NETDATA_EBPF_CHART_TYPE_STACKED,

536 + NETDATA_SYSTEMD_VFS_OPEN_ERROR_CONTEXT,

537 + 20075,

538 + em->update_every);

539 }

540

524 - ebpf_write_chart_obsolete(id,

525 - NETDATA_SYSCALL_APPS_VFS_CREATE,

526 - "",

527 - "Calls to vfs_create.",

528 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

529 - NETDATA_VFS_GROUP,

530 - NETDATA_EBPF_CHART_TYPE_STACKED,

531 - NETDATA_SYSTEMD_VFS_OPEN_ERROR_CONTEXT,

532 - 20076,

533 - em->update_every);

541 + ebpf_write_chart_obsolete(

542 + id,

543 + NETDATA_SYSCALL_APPS_VFS_CREATE,

544 + "",

545 + "Calls to vfs_create.",

546 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

547 + NETDATA_VFS_GROUP,

548 + NETDATA_EBPF_CHART_TYPE_STACKED,

549 + NETDATA_SYSTEMD_VFS_OPEN_ERROR_CONTEXT,

550 + 20076,

551 + em->update_every);

552

553 if (em->mode < MODE_ENTRY) {

536 - ebpf_write_chart_obsolete(id,

537 - NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR,

538 - "",

539 - "Create error",

540 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

541 - NETDATA_VFS_GROUP,

542 - NETDATA_EBPF_CHART_TYPE_STACKED,

543 - NETDATA_SYSTEMD_VFS_CREATE_ERROR_CONTEXT,

544 - 20077,

545 - em->update_every);

554 + ebpf_write_chart_obsolete(

555 + id,

556 + NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR,

557 + "",

558 + "Create error",

559 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

560 + NETDATA_VFS_GROUP,

561 + NETDATA_EBPF_CHART_TYPE_STACKED,

562 + NETDATA_SYSTEMD_VFS_CREATE_ERROR_CONTEXT,

563 + 20077,

564 + em->update_every);

565 }

566 }

567

@@ -553,11 +572,12 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em, char *id)

572 *

573 * @param em a pointer to `struct ebpf_module`

574 */

556 -static inline void ebpf_obsolete_vfs_cgroup_charts(ebpf_module_t *em) {

575 +static inline void ebpf_obsolete_vfs_cgroup_charts(ebpf_module_t *em)

576 +{

577 pthread_mutex_lock(&mutex_cgroup_shm);

578

579 ebpf_cgroup_target_t *ect;

560 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

580 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

581 if (ect->systemd) {

582 ebpf_obsolete_vfs_services(em, ect->name);

583

@@ -583,162 +603,175 @@ void ebpf_obsolete_vfs_apps_charts(struct ebpf_module *em)

603 int update_every = em->update_every;

604 pthread_mutex_lock(&collect_data_mutex);

605 for (w = apps_groups_root_target; w; w = w->next) {

586 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_VFS_IDX))))

606 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_VFS_IDX))))

607 continue;

608

589 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

590 - w->clean_name,

591 - "_ebpf_call_vfs_unlink",

592 - "Files deleted.",

593 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

594 - NETDATA_VFS_GROUP,

595 - NETDATA_EBPF_CHART_TYPE_STACKED,

596 - "app.ebpf_call_vfs_unlink",

597 - order++,

598 - update_every);

599 -

600 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

601 - w->clean_name,

602 - "_ebpf_call_vfs_write",

603 - "Write to disk.",

604 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

605 - NETDATA_VFS_GROUP,

606 - NETDATA_EBPF_CHART_TYPE_STACKED,

607 - "app.ebpf_call_vfs_write",

608 - order++,

609 - update_every);

609 + ebpf_write_chart_obsolete(

610 + NETDATA_APP_FAMILY,

611 + w->clean_name,

612 + "_ebpf_call_vfs_unlink",

613 + "Files deleted.",

614 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

615 + NETDATA_VFS_GROUP,

616 + NETDATA_EBPF_CHART_TYPE_STACKED,

617 + "app.ebpf_call_vfs_unlink",

618 + order++,

619 + update_every);

620 +

621 + ebpf_write_chart_obsolete(

622 + NETDATA_APP_FAMILY,

623 + w->clean_name,

624 + "_ebpf_call_vfs_write",

625 + "Write to disk.",

626 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

627 + NETDATA_VFS_GROUP,

628 + NETDATA_EBPF_CHART_TYPE_STACKED,

629 + "app.ebpf_call_vfs_write",

630 + order++,

631 + update_every);

632

633 if (em->mode < MODE_ENTRY) {

612 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

613 - w->clean_name,

614 - "_ebpf_call_vfs_write_error",

615 - "Fails to write.",

616 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

617 - NETDATA_VFS_GROUP,

618 - NETDATA_EBPF_CHART_TYPE_STACKED,

619 - "app.ebpf_call_vfs_write_error",

620 - order++,

621 - update_every);

634 + ebpf_write_chart_obsolete(

635 + NETDATA_APP_FAMILY,

636 + w->clean_name,

637 + "_ebpf_call_vfs_write_error",

638 + "Fails to write.",

639 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

640 + NETDATA_VFS_GROUP,

641 + NETDATA_EBPF_CHART_TYPE_STACKED,

642 + "app.ebpf_call_vfs_write_error",

643 + order++,

644 + update_every);

645 }

646

624 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

625 - w->clean_name,

626 - "_ebpf_call_vfs_read",

627 - "Read from disk.",

628 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

629 - NETDATA_VFS_GROUP,

630 - NETDATA_EBPF_CHART_TYPE_STACKED,

631 - "app.ebpf_call_vfs_read",

632 - order++,

633 - update_every);

647 + ebpf_write_chart_obsolete(

648 + NETDATA_APP_FAMILY,

649 + w->clean_name,

650 + "_ebpf_call_vfs_read",

651 + "Read from disk.",

652 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

653 + NETDATA_VFS_GROUP,

654 + NETDATA_EBPF_CHART_TYPE_STACKED,

655 + "app.ebpf_call_vfs_read",

656 + order++,

657 + update_every);

658

659 if (em->mode < MODE_ENTRY) {

636 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

637 - w->clean_name,

638 - "_ebpf_call_vfs_read_error",

639 - "Fails to read.",

640 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

641 - NETDATA_VFS_GROUP,

642 - NETDATA_EBPF_CHART_TYPE_STACKED,

643 - "app.ebpf_call_vfs_read_error",

644 - order++,

645 - update_every);

660 + ebpf_write_chart_obsolete(

661 + NETDATA_APP_FAMILY,

662 + w->clean_name,

663 + "_ebpf_call_vfs_read_error",

664 + "Fails to read.",

665 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

666 + NETDATA_VFS_GROUP,

667 + NETDATA_EBPF_CHART_TYPE_STACKED,

668 + "app.ebpf_call_vfs_read_error",

669 + order++,

670 + update_every);

671 }

672

648 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

649 - w->clean_name,

650 - "_ebpf_call_vfs_write_bytes",

651 - "Bytes written on disk.",

652 - EBPF_COMMON_UNITS_BYTES,

653 - NETDATA_VFS_GROUP,

654 - NETDATA_EBPF_CHART_TYPE_STACKED,

655 - "app.ebpf_call_vfs_write_bytes",

656 - order++,

657 - update_every);

658 -

659 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

660 - w->clean_name,

661 - "_ebpf_call_vfs_read_bytes",

662 - "Bytes read from disk.",

663 - EBPF_COMMON_UNITS_BYTES,

664 - NETDATA_VFS_GROUP,

665 - NETDATA_EBPF_CHART_TYPE_STACKED,

666 - "app.ebpf_call_vfs_read_bytes",

667 - order++,

668 - update_every);

669 -

670 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

671 - w->clean_name,

672 - "_ebpf_call_vfs_fsync",

673 - "Calls to vfs_fsync.",

674 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

675 - NETDATA_VFS_GROUP,

676 - NETDATA_EBPF_CHART_TYPE_STACKED,

677 - "app.ebpf_call_vfs_fsync",

678 - order++,

679 - update_every);

673 + ebpf_write_chart_obsolete(

674 + NETDATA_APP_FAMILY,

675 + w->clean_name,

676 + "_ebpf_call_vfs_write_bytes",

677 + "Bytes written on disk.",

678 + EBPF_COMMON_UNITS_BYTES,

679 + NETDATA_VFS_GROUP,

680 + NETDATA_EBPF_CHART_TYPE_STACKED,

681 + "app.ebpf_call_vfs_write_bytes",

682 + order++,

683 + update_every);

684 +

685 + ebpf_write_chart_obsolete(

686 + NETDATA_APP_FAMILY,

687 + w->clean_name,

688 + "_ebpf_call_vfs_read_bytes",

689 + "Bytes read from disk.",

690 + EBPF_COMMON_UNITS_BYTES,

691 + NETDATA_VFS_GROUP,

692 + NETDATA_EBPF_CHART_TYPE_STACKED,

693 + "app.ebpf_call_vfs_read_bytes",

694 + order++,

695 + update_every);

696 +

697 + ebpf_write_chart_obsolete(

698 + NETDATA_APP_FAMILY,

699 + w->clean_name,

700 + "_ebpf_call_vfs_fsync",

701 + "Calls to vfs_fsync.",

702 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

703 + NETDATA_VFS_GROUP,

704 + NETDATA_EBPF_CHART_TYPE_STACKED,

705 + "app.ebpf_call_vfs_fsync",

706 + order++,

707 + update_every);

708

709 if (em->mode < MODE_ENTRY) {

682 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

683 - w->clean_name,

684 - "_ebpf_call_vfs_fsync_error",

685 - "Fails to sync.",

686 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

687 - NETDATA_VFS_GROUP,

688 - NETDATA_EBPF_CHART_TYPE_STACKED,

689 - "app.ebpf_call_vfs_fsync_error",

690 - order++,

691 - update_every);

710 + ebpf_write_chart_obsolete(

711 + NETDATA_APP_FAMILY,

712 + w->clean_name,

713 + "_ebpf_call_vfs_fsync_error",

714 + "Fails to sync.",

715 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

716 + NETDATA_VFS_GROUP,

717 + NETDATA_EBPF_CHART_TYPE_STACKED,

718 + "app.ebpf_call_vfs_fsync_error",

719 + order++,

720 + update_every);

721 }

722

694 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

695 - w->clean_name,

696 - "_ebpf_call_vfs_open",

697 - "Calls to vfs_open.",

698 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

699 - NETDATA_VFS_GROUP,

700 - NETDATA_EBPF_CHART_TYPE_STACKED,

701 - "app.ebpf_call_vfs_open",

702 - order++,

703 - update_every);

723 + ebpf_write_chart_obsolete(

724 + NETDATA_APP_FAMILY,

725 + w->clean_name,

726 + "_ebpf_call_vfs_open",

727 + "Calls to vfs_open.",

728 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

729 + NETDATA_VFS_GROUP,

730 + NETDATA_EBPF_CHART_TYPE_STACKED,

731 + "app.ebpf_call_vfs_open",

732 + order++,

733 + update_every);

734

735 if (em->mode < MODE_ENTRY) {

706 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

707 - w->clean_name,

708 - "_ebpf_call_vfs_open_error",

709 - "Fails to open.",

710 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

711 - NETDATA_VFS_GROUP,

712 - NETDATA_EBPF_CHART_TYPE_STACKED,

713 - "app.ebpf_call_vfs_open_error",

714 - order++,

715 - update_every);

736 + ebpf_write_chart_obsolete(

737 + NETDATA_APP_FAMILY,

738 + w->clean_name,

739 + "_ebpf_call_vfs_open_error",

740 + "Fails to open.",

741 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

742 + NETDATA_VFS_GROUP,

743 + NETDATA_EBPF_CHART_TYPE_STACKED,

744 + "app.ebpf_call_vfs_open_error",

745 + order++,

746 + update_every);

747 }

748

718 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

719 - w->clean_name,

720 - "_ebpf_call_vfs_create",

721 - "Calls to vfs_create.",

722 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

723 - NETDATA_VFS_GROUP,

724 - NETDATA_EBPF_CHART_TYPE_STACKED,

725 - "app.ebpf_call_vfs_create",

726 - order++,

727 - update_every);

749 + ebpf_write_chart_obsolete(

750 + NETDATA_APP_FAMILY,

751 + w->clean_name,

752 + "_ebpf_call_vfs_create",

753 + "Calls to vfs_create.",

754 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

755 + NETDATA_VFS_GROUP,

756 + NETDATA_EBPF_CHART_TYPE_STACKED,

757 + "app.ebpf_call_vfs_create",

758 + order++,

759 + update_every);

760

761 if (em->mode < MODE_ENTRY) {

730 - ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,

731 - w->clean_name,

732 - "_ebpf_call_vfs_create_error",

733 - "Fails to create.",

734 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

735 - NETDATA_VFS_GROUP,

736 - NETDATA_EBPF_CHART_TYPE_STACKED,

737 - "app.ebpf_call_vfs_create_error",

738 - order++,

739 - update_every);

762 + ebpf_write_chart_obsolete(

763 + NETDATA_APP_FAMILY,

764 + w->clean_name,

765 + "_ebpf_call_vfs_create_error",

766 + "Fails to create.",

767 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

768 + NETDATA_VFS_GROUP,

769 + NETDATA_EBPF_CHART_TYPE_STACKED,

770 + "app.ebpf_call_vfs_create_error",

771 + order++,

772 + update_every);

773 }

741 - w->charts_created &= ~(1<<EBPF_MODULE_VFS_IDX);

774 + w->charts_created &= ~(1 << EBPF_MODULE_VFS_IDX);

775 }

776 pthread_mutex_unlock(&collect_data_mutex);

777 }

@@ -752,116 +785,126 @@ void ebpf_obsolete_vfs_apps_charts(struct ebpf_module *em)

785 */

786 static void ebpf_obsolete_vfs_global(ebpf_module_t *em)

787 {

755 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

756 - NETDATA_VFS_FILE_CLEAN_COUNT,

757 - "",

758 - "Remove files",

759 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

760 - NETDATA_VFS_GROUP,

761 - NETDATA_EBPF_CHART_TYPE_LINE,

762 - "filesystem.vfs_deleted_objects",

763 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_CLEAN,

764 - em->update_every);

765 -

766 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

767 - NETDATA_VFS_FILE_IO_COUNT,

768 - "",

769 - "Calls to IO",

770 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

771 - NETDATA_VFS_GROUP,

772 - NETDATA_EBPF_CHART_TYPE_LINE,

773 - "filesystem.vfs_io",

774 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_COUNT,

775 - em->update_every);

776 -

777 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

778 - NETDATA_VFS_IO_FILE_BYTES,

779 - "",

780 - "Bytes written and read",

781 - EBPF_COMMON_UNITS_BYTES,

782 - NETDATA_VFS_GROUP,

783 - NETDATA_EBPF_CHART_TYPE_LINE,

784 - "filesystem.vfs_io_bytes",

785 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_BYTES,

786 - em->update_every);

787 -

788 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

789 - NETDATA_VFS_FSYNC,

790 - "",

791 - "Calls to vfs_fsync.",

792 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

793 - NETDATA_VFS_GROUP,

794 - NETDATA_EBPF_CHART_TYPE_LINE,

795 - "filesystem.vfs_fsync",

796 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_FSYNC,

797 - em->update_every);

798 -

799 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

800 - NETDATA_VFS_OPEN,

801 - "",

802 - "Calls to vfs_open.",

803 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

804 - NETDATA_VFS_GROUP,

805 - NETDATA_EBPF_CHART_TYPE_LINE,

806 - "filesystem.vfs_open",

807 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_OPEN,

808 - em->update_every);

809 -

810 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

811 - NETDATA_VFS_CREATE,

812 - "",

813 - "Calls to vfs_create.",

814 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

815 - NETDATA_VFS_GROUP,

816 - NETDATA_EBPF_CHART_TYPE_LINE,

817 - "filesystem.vfs_create",

818 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_CREATE,

819 - em->update_every);

788 + ebpf_write_chart_obsolete(

789 + NETDATA_FILESYSTEM_FAMILY,

790 + NETDATA_VFS_FILE_CLEAN_COUNT,

791 + "",

792 + "Remove files",

793 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

794 + NETDATA_VFS_GROUP,

795 + NETDATA_EBPF_CHART_TYPE_LINE,

796 + "filesystem.vfs_deleted_objects",

797 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_CLEAN,

798 + em->update_every);

799 +

800 + ebpf_write_chart_obsolete(

801 + NETDATA_FILESYSTEM_FAMILY,

802 + NETDATA_VFS_FILE_IO_COUNT,

803 + "",

804 + "Calls to IO",

805 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

806 + NETDATA_VFS_GROUP,

807 + NETDATA_EBPF_CHART_TYPE_LINE,

808 + "filesystem.vfs_io",

809 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_COUNT,

810 + em->update_every);

811 +

812 + ebpf_write_chart_obsolete(

813 + NETDATA_FILESYSTEM_FAMILY,

814 + NETDATA_VFS_IO_FILE_BYTES,

815 + "",

816 + "Bytes written and read",

817 + EBPF_COMMON_UNITS_BYTES,

818 + NETDATA_VFS_GROUP,

819 + NETDATA_EBPF_CHART_TYPE_LINE,

820 + "filesystem.vfs_io_bytes",

821 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_BYTES,

822 + em->update_every);

823 +

824 + ebpf_write_chart_obsolete(

825 + NETDATA_FILESYSTEM_FAMILY,

826 + NETDATA_VFS_FSYNC,

827 + "",

828 + "Calls to vfs_fsync.",

829 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

830 + NETDATA_VFS_GROUP,

831 + NETDATA_EBPF_CHART_TYPE_LINE,

832 + "filesystem.vfs_fsync",

833 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_FSYNC,

834 + em->update_every);

835 +

836 + ebpf_write_chart_obsolete(

837 + NETDATA_FILESYSTEM_FAMILY,

838 + NETDATA_VFS_OPEN,

839 + "",

840 + "Calls to vfs_open.",

841 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

842 + NETDATA_VFS_GROUP,

843 + NETDATA_EBPF_CHART_TYPE_LINE,

844 + "filesystem.vfs_open",

845 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_OPEN,

846 + em->update_every);

847 +

848 + ebpf_write_chart_obsolete(

849 + NETDATA_FILESYSTEM_FAMILY,

850 + NETDATA_VFS_CREATE,

851 + "",

852 + "Calls to vfs_create.",

853 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

854 + NETDATA_VFS_GROUP,

855 + NETDATA_EBPF_CHART_TYPE_LINE,

856 + "filesystem.vfs_create",

857 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_CREATE,

858 + em->update_every);

859

860 if (em->mode < MODE_ENTRY) {

822 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

823 - NETDATA_VFS_FILE_ERR_COUNT,

824 - "",

825 - "Fails to write or read",

826 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

827 - NETDATA_VFS_GROUP,

828 - NETDATA_EBPF_CHART_TYPE_LINE,

829 - "filesystem.vfs_io_error",

830 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EBYTES,

831 - em->update_every);

832 -

833 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

834 - NETDATA_VFS_OPEN_ERR,

835 - "",

836 - "Fails to open a file",

837 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

838 - NETDATA_VFS_GROUP,

839 - NETDATA_EBPF_CHART_TYPE_LINE,

840 - "filesystem.vfs_open_error",

841 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EOPEN,

842 - em->update_every);

843 -

844 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

845 - NETDATA_VFS_FSYNC_ERR,

846 - "",

847 - "Fails to synchronize",

848 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

849 - NETDATA_VFS_GROUP,

850 - NETDATA_EBPF_CHART_TYPE_LINE,

851 - "filesystem.vfs_fsync_error",

852 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EFSYNC,

853 - em->update_every);

854 -

855 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,

856 - NETDATA_VFS_CREATE_ERR,

857 - "",

858 - "Fails to create a file.",

859 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

860 - NETDATA_VFS_GROUP,

861 - NETDATA_EBPF_CHART_TYPE_LINE,

862 - "filesystem.vfs_create_error",

863 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_ECREATE,

864 - em->update_every);

861 + ebpf_write_chart_obsolete(

862 + NETDATA_FILESYSTEM_FAMILY,

863 + NETDATA_VFS_FILE_ERR_COUNT,

864 + "",

865 + "Fails to write or read",

866 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

867 + NETDATA_VFS_GROUP,

868 + NETDATA_EBPF_CHART_TYPE_LINE,

869 + "filesystem.vfs_io_error",

870 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EBYTES,

871 + em->update_every);

872 +

873 + ebpf_write_chart_obsolete(

874 + NETDATA_FILESYSTEM_FAMILY,

875 + NETDATA_VFS_OPEN_ERR,

876 + "",

877 + "Fails to open a file",

878 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

879 + NETDATA_VFS_GROUP,

880 + NETDATA_EBPF_CHART_TYPE_LINE,

881 + "filesystem.vfs_open_error",

882 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EOPEN,

883 + em->update_every);

884 +

885 + ebpf_write_chart_obsolete(

886 + NETDATA_FILESYSTEM_FAMILY,

887 + NETDATA_VFS_FSYNC_ERR,

888 + "",

889 + "Fails to synchronize",

890 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

891 + NETDATA_VFS_GROUP,

892 + NETDATA_EBPF_CHART_TYPE_LINE,

893 + "filesystem.vfs_fsync_error",

894 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EFSYNC,

895 + em->update_every);

896 +

897 + ebpf_write_chart_obsolete(

898 + NETDATA_FILESYSTEM_FAMILY,

899 + NETDATA_VFS_CREATE_ERR,

900 + "",

901 + "Fails to create a file.",

902 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

903 + NETDATA_VFS_GROUP,

904 + NETDATA_EBPF_CHART_TYPE_LINE,

905 + "filesystem.vfs_create_error",

906 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_ECREATE,

907 + em->update_every);

908 }

909 }

910

@@ -875,10 +918,11 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)

918 static void ebpf_vfs_exit(void *pptr)

919 {

920 ebpf_module_t *em = CLEANUP_FUNCTION_GET_PTR(pptr);

878 - if(!em) return;

921 + if (!em)

922 + return;

923

924 pthread_mutex_lock(&lock);

881 - collect_pids &= ~(1<<EBPF_MODULE_VFS_IDX);

925 + collect_pids &= ~(1 << EBPF_MODULE_VFS_IDX);

926 pthread_mutex_unlock(&lock);

927

928 if (ebpf_read_vfs.thread)

@@ -939,38 +983,49 @@ static void ebpf_vfs_send_data(ebpf_module_t *em)

983 pvc.write = (long)vfs_aggregated_data[NETDATA_KEY_PUBLISH_VFS_WRITE].bytes;

984 pvc.read = (long)vfs_aggregated_data[NETDATA_KEY_PUBLISH_VFS_READ].bytes;

985

942 - write_count_chart(NETDATA_VFS_FILE_CLEAN_COUNT, NETDATA_FILESYSTEM_FAMILY,

943 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK], 1);

986 + write_count_chart(

987 + NETDATA_VFS_FILE_CLEAN_COUNT,

988 + NETDATA_FILESYSTEM_FAMILY,

989 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK],

990 + 1);

991

945 - write_count_chart(NETDATA_VFS_FILE_IO_COUNT, NETDATA_FILESYSTEM_FAMILY,

946 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ], 2);

992 + write_count_chart(

993 + NETDATA_VFS_FILE_IO_COUNT, NETDATA_FILESYSTEM_FAMILY, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ], 2);

994

995 if (em->mode < MODE_ENTRY) {

949 - write_err_chart(NETDATA_VFS_FILE_ERR_COUNT, NETDATA_FILESYSTEM_FAMILY,

950 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ], 2);

996 + write_err_chart(

997 + NETDATA_VFS_FILE_ERR_COUNT,

998 + NETDATA_FILESYSTEM_FAMILY,

999 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

1000 + 2);

1001 }

1002

953 - write_io_chart(NETDATA_VFS_IO_FILE_BYTES, NETDATA_FILESYSTEM_FAMILY, vfs_id_names[NETDATA_KEY_PUBLISH_VFS_WRITE],

954 - (long long)pvc.write, vfs_id_names[NETDATA_KEY_PUBLISH_VFS_READ], (long long)pvc.read);

1003 + write_io_chart(

1004 + NETDATA_VFS_IO_FILE_BYTES,

1005 + NETDATA_FILESYSTEM_FAMILY,

1006 + vfs_id_names[NETDATA_KEY_PUBLISH_VFS_WRITE],

1007 + (long long)pvc.write,

1008 + vfs_id_names[NETDATA_KEY_PUBLISH_VFS_READ],

1009 + (long long)pvc.read);

1010

956 - write_count_chart(NETDATA_VFS_FSYNC, NETDATA_FILESYSTEM_FAMILY,

957 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC], 1);

1011 + write_count_chart(

1012 + NETDATA_VFS_FSYNC, NETDATA_FILESYSTEM_FAMILY, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC], 1);

1013

1014 if (em->mode < MODE_ENTRY) {

960 - write_err_chart(NETDATA_VFS_FSYNC_ERR, NETDATA_FILESYSTEM_FAMILY,

961 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC], 1);

1015 + write_err_chart(

1016 + NETDATA_VFS_FSYNC_ERR, NETDATA_FILESYSTEM_FAMILY, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC], 1);

1017 }

1018

964 - write_count_chart(NETDATA_VFS_OPEN, NETDATA_FILESYSTEM_FAMILY,

965 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN], 1);

1019 + write_count_chart(

1020 + NETDATA_VFS_OPEN, NETDATA_FILESYSTEM_FAMILY, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN], 1);

1021

1022 if (em->mode < MODE_ENTRY) {

968 - write_err_chart(NETDATA_VFS_OPEN_ERR, NETDATA_FILESYSTEM_FAMILY,

969 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN], 1);

1023 + write_err_chart(

1024 + NETDATA_VFS_OPEN_ERR, NETDATA_FILESYSTEM_FAMILY, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN], 1);

1025 }

1026

972 - write_count_chart(NETDATA_VFS_CREATE, NETDATA_FILESYSTEM_FAMILY,

973 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE], 1);

1027 + write_count_chart(

1028 + NETDATA_VFS_CREATE, NETDATA_FILESYSTEM_FAMILY, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE], 1);

1029

1030 if (em->mode < MODE_ENTRY) {

1031 write_err_chart(

@@ -990,42 +1045,44 @@ static void ebpf_vfs_send_data(ebpf_module_t *em)

1045 static void ebpf_vfs_read_global_table(netdata_idx_t *stats, int maps_per_core)

1046 {

1047 netdata_idx_t res[NETDATA_VFS_COUNTER];

993 - ebpf_read_global_table_stats(res,

994 - vfs_hash_values,

995 - vfs_maps[NETDATA_VFS_ALL].map_fd,

996 - maps_per_core,

997 - NETDATA_KEY_CALLS_VFS_WRITE,

998 - NETDATA_VFS_COUNTER);

999 -

1000 - ebpf_read_global_table_stats(stats,

1001 - vfs_hash_values,

1002 - vfs_maps[NETDATA_VFS_CTRL].map_fd,

1003 - maps_per_core,

1004 - NETDATA_CONTROLLER_PID_TABLE_ADD,

1005 - NETDATA_CONTROLLER_END);

1048 + ebpf_read_global_table_stats(

1049 + res,

1050 + vfs_hash_values,

1051 + vfs_maps[NETDATA_VFS_ALL].map_fd,

1052 + maps_per_core,

1053 + NETDATA_KEY_CALLS_VFS_WRITE,

1054 + NETDATA_VFS_COUNTER);

1055 +

1056 + ebpf_read_global_table_stats(

1057 + stats,

1058 + vfs_hash_values,

1059 + vfs_maps[NETDATA_VFS_CTRL].map_fd,

1060 + maps_per_core,

1061 + NETDATA_CONTROLLER_PID_TABLE_ADD,

1062 + NETDATA_CONTROLLER_END);

1063

1064 vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK].ncall = res[NETDATA_KEY_CALLS_VFS_UNLINK];

1008 - vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].ncall = res[NETDATA_KEY_CALLS_VFS_READ] +

1009 - res[NETDATA_KEY_CALLS_VFS_READV];

1010 - vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].ncall = res[NETDATA_KEY_CALLS_VFS_WRITE] +

1011 - res[NETDATA_KEY_CALLS_VFS_WRITEV];

1065 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].ncall =

1066 + res[NETDATA_KEY_CALLS_VFS_READ] + res[NETDATA_KEY_CALLS_VFS_READV];

1067 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].ncall =

1068 + res[NETDATA_KEY_CALLS_VFS_WRITE] + res[NETDATA_KEY_CALLS_VFS_WRITEV];

1069 vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC].ncall = res[NETDATA_KEY_CALLS_VFS_FSYNC];

1070 vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN].ncall = res[NETDATA_KEY_CALLS_VFS_OPEN];

1071 vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE].ncall = res[NETDATA_KEY_CALLS_VFS_CREATE];

1072

1073 vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK].nerr = res[NETDATA_KEY_ERROR_VFS_UNLINK];

1017 - vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].nerr = res[NETDATA_KEY_ERROR_VFS_READ] +

1018 - res[NETDATA_KEY_ERROR_VFS_READV];

1019 - vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].nerr = res[NETDATA_KEY_ERROR_VFS_WRITE] +

1020 - res[NETDATA_KEY_ERROR_VFS_WRITEV];

1074 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].nerr =

1075 + res[NETDATA_KEY_ERROR_VFS_READ] + res[NETDATA_KEY_ERROR_VFS_READV];

1076 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].nerr =

1077 + res[NETDATA_KEY_ERROR_VFS_WRITE] + res[NETDATA_KEY_ERROR_VFS_WRITEV];

1078 vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC].nerr = res[NETDATA_KEY_ERROR_VFS_FSYNC];

1079 vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN].nerr = res[NETDATA_KEY_ERROR_VFS_OPEN];

1080 vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE].nerr = res[NETDATA_KEY_ERROR_VFS_CREATE];

1081

1025 - vfs_aggregated_data[NETDATA_KEY_PUBLISH_VFS_WRITE].bytes = (uint64_t)res[NETDATA_KEY_BYTES_VFS_WRITE] +

1026 - (uint64_t)res[NETDATA_KEY_BYTES_VFS_WRITEV];

1027 - vfs_aggregated_data[NETDATA_KEY_PUBLISH_VFS_READ].bytes = (uint64_t)res[NETDATA_KEY_BYTES_VFS_READ] +

1028 - (uint64_t)res[NETDATA_KEY_BYTES_VFS_READV];

1082 + vfs_aggregated_data[NETDATA_KEY_PUBLISH_VFS_WRITE].bytes =

1083 + (uint64_t)res[NETDATA_KEY_BYTES_VFS_WRITE] + (uint64_t)res[NETDATA_KEY_BYTES_VFS_WRITEV];

1084 + vfs_aggregated_data[NETDATA_KEY_PUBLISH_VFS_READ].bytes =

1085 + (uint64_t)res[NETDATA_KEY_BYTES_VFS_READ] + (uint64_t)res[NETDATA_KEY_BYTES_VFS_READV];

1086 }

1087

1088 /**

@@ -1130,7 +1187,7 @@ void ebpf_vfs_send_apps_data(ebpf_module_t *em, struct ebpf_target *root)

1187 struct ebpf_target *w;

1188 pthread_mutex_lock(&collect_data_mutex);

1189 for (w = root; w; w = w->next) {

1133 - if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_VFS_IDX))))

1190 + if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_VFS_IDX))))

1191 continue;

1192

1193 ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_unlink");

@@ -1265,7 +1322,7 @@ static void ebpf_vfs_read_apps(int maps_per_core, uint32_t max_period)

1322 if (!publish->ct || publish->ct != vv->ct) {

1323 vfs_aggregate_set_vfs(publish, vv);

1324 local_pid->not_updated = 0;

1268 - } else if (++local_pid->not_updated >= max_period){

1325 + } else if (++local_pid->not_updated >= max_period) {

1326 if (kill(key, 0)) { // No PID found

1327 ebpf_reset_specific_pid_data(local_pid);

1328 } else { // There is PID, but there is not data anymore

@@ -1275,7 +1332,7 @@ static void ebpf_vfs_read_apps(int maps_per_core, uint32_t max_period)

1332 }

1333 }

1334

1278 -end_vfs_loop:

1335 + end_vfs_loop:

1336 // We are cleaning to avoid passing data read from one process to other.

1337 memset(vv, 0, length);

1338 key = next_key;

@@ -1291,7 +1348,7 @@ end_vfs_loop:

1348 */

1349 static void read_update_vfs_cgroup()

1350 {

1294 - ebpf_cgroup_target_t *ect ;

1351 + ebpf_cgroup_target_t *ect;

1352 pthread_mutex_lock(&mutex_cgroup_shm);

1353 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

1354 struct pid_on_target2 *pids;

@@ -1389,116 +1446,233 @@ static void ebpf_vfs_sum_cgroup_pids(netdata_publish_vfs_t *vfs, struct pid_on_t

1446 static void ebpf_create_specific_vfs_charts(char *type, ebpf_module_t *em)

1447 {

1448 char *label = (!strncmp(type, "cgroup_", 7)) ? &type[7] : type;

1392 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_FILE_DELETED,"Files deleted",

1393 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_UNLINK_CONTEXT,

1394 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5500,

1395 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK],

1396 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1449 + ebpf_create_chart(

1450 + type,

1451 + NETDATA_SYSCALL_APPS_FILE_DELETED,

1452 + "Files deleted",

1453 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1454 + NETDATA_VFS_GROUP,

1455 + NETDATA_CGROUP_VFS_UNLINK_CONTEXT,

1456 + NETDATA_EBPF_CHART_TYPE_LINE,

1457 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5500,

1458 + ebpf_create_global_dimension,

1459 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK],

1460 + 1,

1461 + em->update_every,

1462 + NETDATA_EBPF_MODULE_NAME_VFS);

1463 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1464 ebpf_commit_label();

1465

1400 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "Write to disk",

1401 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_WRITE_CONTEXT,

1402 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5501,

1403 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE],

1404 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1466 + ebpf_create_chart(

1467 + type,

1468 + NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS,

1469 + "Write to disk",

1470 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1471 + NETDATA_VFS_GROUP,

1472 + NETDATA_CGROUP_VFS_WRITE_CONTEXT,

1473 + NETDATA_EBPF_CHART_TYPE_LINE,

1474 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5501,

1475 + ebpf_create_global_dimension,

1476 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE],

1477 + 1,

1478 + em->update_every,

1479 + NETDATA_EBPF_MODULE_NAME_VFS);

1480 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1481 ebpf_commit_label();

1482

1483 if (em->mode < MODE_ENTRY) {

1409 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "Fails to write",

1410 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_WRITE_ERROR_CONTEXT,

1411 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5502,

1412 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE],

1413 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1484 + ebpf_create_chart(

1485 + type,

1486 + NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR,

1487 + "Fails to write",

1488 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1489 + NETDATA_VFS_GROUP,

1490 + NETDATA_CGROUP_VFS_WRITE_ERROR_CONTEXT,

1491 + NETDATA_EBPF_CHART_TYPE_LINE,

1492 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5502,

1493 + ebpf_create_global_dimension,

1494 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE],

1495 + 1,

1496 + em->update_every,

1497 + NETDATA_EBPF_MODULE_NAME_VFS);

1498 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1499 ebpf_commit_label();

1500 }

1501

1418 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "Read from disk",

1419 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_READ_CONTEXT,

1420 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5503,

1421 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

1422 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1502 + ebpf_create_chart(

1503 + type,

1504 + NETDATA_SYSCALL_APPS_VFS_READ_CALLS,

1505 + "Read from disk",

1506 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1507 + NETDATA_VFS_GROUP,

1508 + NETDATA_CGROUP_VFS_READ_CONTEXT,

1509 + NETDATA_EBPF_CHART_TYPE_LINE,

1510 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5503,

1511 + ebpf_create_global_dimension,

1512 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

1513 + 1,

1514 + em->update_every,

1515 + NETDATA_EBPF_MODULE_NAME_VFS);

1516 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1517 ebpf_commit_label();

1518

1519 if (em->mode < MODE_ENTRY) {

1427 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "Fails to read",

1428 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_READ_ERROR_CONTEXT,

1429 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5504,

1430 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

1431 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1520 + ebpf_create_chart(

1521 + type,

1522 + NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR,

1523 + "Fails to read",

1524 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1525 + NETDATA_VFS_GROUP,

1526 + NETDATA_CGROUP_VFS_READ_ERROR_CONTEXT,

1527 + NETDATA_EBPF_CHART_TYPE_LINE,

1528 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5504,

1529 + ebpf_create_global_dimension,

1530 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

1531 + 1,

1532 + em->update_every,

1533 + NETDATA_EBPF_MODULE_NAME_VFS);

1534 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1535 ebpf_commit_label();

1536 }

1537

1436 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "Bytes written on disk",

1437 - EBPF_COMMON_UNITS_BYTES, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_WRITE_BYTES_CONTEXT,

1438 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5505,

1439 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE],

1440 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1538 + ebpf_create_chart(

1539 + type,

1540 + NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES,

1541 + "Bytes written on disk",

1542 + EBPF_COMMON_UNITS_BYTES,

1543 + NETDATA_VFS_GROUP,

1544 + NETDATA_CGROUP_VFS_WRITE_BYTES_CONTEXT,

1545 + NETDATA_EBPF_CHART_TYPE_LINE,

1546 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5505,

1547 + ebpf_create_global_dimension,

1548 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE],

1549 + 1,

1550 + em->update_every,

1551 + NETDATA_EBPF_MODULE_NAME_VFS);

1552 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1553 ebpf_commit_label();

1554

1444 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "Bytes read from disk",

1445 - EBPF_COMMON_UNITS_BYTES, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_READ_BYTES_CONTEXT,

1446 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5506,

1447 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

1448 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1555 + ebpf_create_chart(

1556 + type,

1557 + NETDATA_SYSCALL_APPS_VFS_READ_BYTES,

1558 + "Bytes read from disk",

1559 + EBPF_COMMON_UNITS_BYTES,

1560 + NETDATA_VFS_GROUP,

1561 + NETDATA_CGROUP_VFS_READ_BYTES_CONTEXT,

1562 + NETDATA_EBPF_CHART_TYPE_LINE,

1563 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5506,

1564 + ebpf_create_global_dimension,

1565 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

1566 + 1,

1567 + em->update_every,

1568 + NETDATA_EBPF_MODULE_NAME_VFS);

1569 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1570 ebpf_commit_label();

1571

1452 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC, "Calls to vfs_fsync.",

1453 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_FSYNC_CONTEXT,

1454 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5507,

1455 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],

1456 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1572 + ebpf_create_chart(

1573 + type,

1574 + NETDATA_SYSCALL_APPS_VFS_FSYNC,

1575 + "Calls to vfs_fsync.",

1576 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1577 + NETDATA_VFS_GROUP,

1578 + NETDATA_CGROUP_VFS_FSYNC_CONTEXT,

1579 + NETDATA_EBPF_CHART_TYPE_LINE,

1580 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5507,

1581 + ebpf_create_global_dimension,

1582 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],

1583 + 1,

1584 + em->update_every,

1585 + NETDATA_EBPF_MODULE_NAME_VFS);

1586 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1587 ebpf_commit_label();

1588

1589 if (em->mode < MODE_ENTRY) {

1461 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "Sync error",

1462 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_FSYNC_ERROR_CONTEXT,

1463 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5508,

1464 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],

1465 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1590 + ebpf_create_chart(

1591 + type,

1592 + NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR,

1593 + "Sync error",

1594 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1595 + NETDATA_VFS_GROUP,

1596 + NETDATA_CGROUP_VFS_FSYNC_ERROR_CONTEXT,

1597 + NETDATA_EBPF_CHART_TYPE_LINE,

1598 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5508,

1599 + ebpf_create_global_dimension,

1600 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],

1601 + 1,

1602 + em->update_every,

1603 + NETDATA_EBPF_MODULE_NAME_VFS);

1604 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1605 ebpf_commit_label();

1606 }

1607

1470 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN, "Calls to vfs_open.",

1471 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_OPEN_CONTEXT,

1472 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5509,

1473 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],

1474 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1608 + ebpf_create_chart(

1609 + type,

1610 + NETDATA_SYSCALL_APPS_VFS_OPEN,

1611 + "Calls to vfs_open.",

1612 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1613 + NETDATA_VFS_GROUP,

1614 + NETDATA_CGROUP_VFS_OPEN_CONTEXT,

1615 + NETDATA_EBPF_CHART_TYPE_LINE,

1616 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5509,

1617 + ebpf_create_global_dimension,

1618 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],

1619 + 1,

1620 + em->update_every,

1621 + NETDATA_EBPF_MODULE_NAME_VFS);

1622 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1623 ebpf_commit_label();

1624

1625 if (em->mode < MODE_ENTRY) {

1479 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "Open error",

1480 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_OPEN_ERROR_CONTEXT,

1481 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5510,

1482 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],

1483 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1626 + ebpf_create_chart(

1627 + type,

1628 + NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR,

1629 + "Open error",

1630 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1631 + NETDATA_VFS_GROUP,

1632 + NETDATA_CGROUP_VFS_OPEN_ERROR_CONTEXT,

1633 + NETDATA_EBPF_CHART_TYPE_LINE,

1634 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5510,

1635 + ebpf_create_global_dimension,

1636 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],

1637 + 1,

1638 + em->update_every,

1639 + NETDATA_EBPF_MODULE_NAME_VFS);

1640 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1641 ebpf_commit_label();

1642 }

1643

1488 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE, "Calls to vfs_create.",

1489 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_CREATE_CONTEXT,

1490 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5511,

1491 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],

1492 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1644 + ebpf_create_chart(

1645 + type,

1646 + NETDATA_SYSCALL_APPS_VFS_CREATE,

1647 + "Calls to vfs_create.",

1648 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1649 + NETDATA_VFS_GROUP,

1650 + NETDATA_CGROUP_VFS_CREATE_CONTEXT,

1651 + NETDATA_EBPF_CHART_TYPE_LINE,

1652 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5511,

1653 + ebpf_create_global_dimension,

1654 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],

1655 + 1,

1656 + em->update_every,

1657 + NETDATA_EBPF_MODULE_NAME_VFS);

1658 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1659 ebpf_commit_label();

1660

1661 if (em->mode < MODE_ENTRY) {

1497 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "Create error",

1498 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP, NETDATA_CGROUP_VFS_CREATE_ERROR_CONTEXT,

1499 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5512,

1500 - ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],

1501 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

1662 + ebpf_create_chart(

1663 + type,

1664 + NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR,

1665 + "Create error",

1666 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1667 + NETDATA_VFS_GROUP,

1668 + NETDATA_CGROUP_VFS_CREATE_ERROR_CONTEXT,

1669 + NETDATA_EBPF_CHART_TYPE_LINE,

1670 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5512,

1671 + ebpf_create_global_dimension,

1672 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],

1673 + 1,

1674 + em->update_every,

1675 + NETDATA_EBPF_MODULE_NAME_VFS);

1676 ebpf_create_chart_labels("cgroup_name", label, RRDLABEL_SRC_AUTO);

1677 ebpf_commit_label();

1678 }

@@ -1514,79 +1688,170 @@ static void ebpf_create_specific_vfs_charts(char *type, ebpf_module_t *em)

1688 */

1689 static void ebpf_obsolete_specific_vfs_charts(char *type, ebpf_module_t *em)

1690 {

1517 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_DELETED, "", "Files deleted",

1518 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1519 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_UNLINK_CONTEXT,

1520 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5500, em->update_every);

1521 -

1522 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "", "Write to disk",

1523 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1524 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_WRITE_CONTEXT,

1525 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5501, em->update_every);

1691 + ebpf_write_chart_obsolete(

1692 + type,

1693 + NETDATA_SYSCALL_APPS_FILE_DELETED,

1694 + "",

1695 + "Files deleted",

1696 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1697 + NETDATA_VFS_GROUP,

1698 + NETDATA_EBPF_CHART_TYPE_LINE,

1699 + NETDATA_CGROUP_VFS_UNLINK_CONTEXT,

1700 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5500,

1701 + em->update_every);

1702 +

1703 + ebpf_write_chart_obsolete(

1704 + type,

1705 + NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS,

1706 + "",

1707 + "Write to disk",

1708 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1709 + NETDATA_VFS_GROUP,

1710 + NETDATA_EBPF_CHART_TYPE_LINE,

1711 + NETDATA_CGROUP_VFS_WRITE_CONTEXT,

1712 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5501,

1713 + em->update_every);

1714

1715 if (em->mode < MODE_ENTRY) {

1528 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "", "Fails to write",

1529 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1530 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_WRITE_ERROR_CONTEXT,

1531 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5502, em->update_every);

1716 + ebpf_write_chart_obsolete(

1717 + type,

1718 + NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR,

1719 + "",

1720 + "Fails to write",

1721 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1722 + NETDATA_VFS_GROUP,

1723 + NETDATA_EBPF_CHART_TYPE_LINE,

1724 + NETDATA_CGROUP_VFS_WRITE_ERROR_CONTEXT,

1725 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5502,

1726 + em->update_every);

1727 }

1728

1534 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "", "Read from disk",

1535 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1536 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_READ_CONTEXT,

1537 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5503, em->update_every);

1729 + ebpf_write_chart_obsolete(

1730 + type,

1731 + NETDATA_SYSCALL_APPS_VFS_READ_CALLS,

1732 + "",

1733 + "Read from disk",

1734 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1735 + NETDATA_VFS_GROUP,

1736 + NETDATA_EBPF_CHART_TYPE_LINE,

1737 + NETDATA_CGROUP_VFS_READ_CONTEXT,

1738 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5503,

1739 + em->update_every);

1740

1741 if (em->mode < MODE_ENTRY) {

1540 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "", "Fails to read",

1541 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1542 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_READ_ERROR_CONTEXT,

1543 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5504, em->update_every);

1742 + ebpf_write_chart_obsolete(

1743 + type,

1744 + NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR,

1745 + "",

1746 + "Fails to read",

1747 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1748 + NETDATA_VFS_GROUP,

1749 + NETDATA_EBPF_CHART_TYPE_LINE,

1750 + NETDATA_CGROUP_VFS_READ_ERROR_CONTEXT,

1751 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5504,

1752 + em->update_every);

1753 }

1754

1546 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "", "Bytes written on disk",

1547 - EBPF_COMMON_UNITS_BYTES, NETDATA_VFS_GROUP,

1548 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_WRITE_BYTES_CONTEXT,

1549 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5505, em->update_every);

1550 -

1551 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "", "Bytes read from disk",

1552 - EBPF_COMMON_UNITS_BYTES, NETDATA_VFS_GROUP,

1553 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_READ_BYTES_CONTEXT,

1554 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5506, em->update_every);

1555 -

1556 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_FSYNC, "", "Calls to vfs_fsync.",

1557 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1558 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_FSYNC_CONTEXT,

1559 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5507, em->update_every);

1755 + ebpf_write_chart_obsolete(

1756 + type,

1757 + NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES,

1758 + "",

1759 + "Bytes written on disk",

1760 + EBPF_COMMON_UNITS_BYTES,

1761 + NETDATA_VFS_GROUP,

1762 + NETDATA_EBPF_CHART_TYPE_LINE,

1763 + NETDATA_CGROUP_VFS_WRITE_BYTES_CONTEXT,

1764 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5505,

1765 + em->update_every);

1766 +

1767 + ebpf_write_chart_obsolete(

1768 + type,

1769 + NETDATA_SYSCALL_APPS_VFS_READ_BYTES,

1770 + "",

1771 + "Bytes read from disk",

1772 + EBPF_COMMON_UNITS_BYTES,

1773 + NETDATA_VFS_GROUP,

1774 + NETDATA_EBPF_CHART_TYPE_LINE,

1775 + NETDATA_CGROUP_VFS_READ_BYTES_CONTEXT,

1776 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5506,

1777 + em->update_every);

1778 +

1779 + ebpf_write_chart_obsolete(

1780 + type,

1781 + NETDATA_SYSCALL_APPS_VFS_FSYNC,

1782 + "",

1783 + "Calls to vfs_fsync.",

1784 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1785 + NETDATA_VFS_GROUP,

1786 + NETDATA_EBPF_CHART_TYPE_LINE,

1787 + NETDATA_CGROUP_VFS_FSYNC_CONTEXT,

1788 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5507,

1789 + em->update_every);

1790

1791 if (em->mode < MODE_ENTRY) {

1562 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "", "Sync error",

1563 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1564 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_FSYNC_ERROR_CONTEXT,

1565 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5508, em->update_every);

1792 + ebpf_write_chart_obsolete(

1793 + type,

1794 + NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR,

1795 + "",

1796 + "Sync error",

1797 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1798 + NETDATA_VFS_GROUP,

1799 + NETDATA_EBPF_CHART_TYPE_LINE,

1800 + NETDATA_CGROUP_VFS_FSYNC_ERROR_CONTEXT,

1801 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5508,

1802 + em->update_every);

1803 }

1804

1568 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_OPEN, "", "Calls to vfs_open.",

1569 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1570 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_OPEN_CONTEXT,

1571 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5509, em->update_every);

1805 + ebpf_write_chart_obsolete(

1806 + type,

1807 + NETDATA_SYSCALL_APPS_VFS_OPEN,

1808 + "",

1809 + "Calls to vfs_open.",

1810 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1811 + NETDATA_VFS_GROUP,

1812 + NETDATA_EBPF_CHART_TYPE_LINE,

1813 + NETDATA_CGROUP_VFS_OPEN_CONTEXT,

1814 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5509,

1815 + em->update_every);

1816

1817 if (em->mode < MODE_ENTRY) {

1574 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "", "Open error",

1575 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1576 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_OPEN_ERROR_CONTEXT,

1577 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5510, em->update_every);

1818 + ebpf_write_chart_obsolete(

1819 + type,

1820 + NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR,

1821 + "",

1822 + "Open error",

1823 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1824 + NETDATA_VFS_GROUP,

1825 + NETDATA_EBPF_CHART_TYPE_LINE,

1826 + NETDATA_CGROUP_VFS_OPEN_ERROR_CONTEXT,

1827 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5510,

1828 + em->update_every);

1829 }

1830

1580 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_CREATE, "", "Calls to vfs_create.",

1581 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1582 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_CREATE_CONTEXT,

1583 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5511, em->update_every);

1831 + ebpf_write_chart_obsolete(

1832 + type,

1833 + NETDATA_SYSCALL_APPS_VFS_CREATE,

1834 + "",

1835 + "Calls to vfs_create.",

1836 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1837 + NETDATA_VFS_GROUP,

1838 + NETDATA_EBPF_CHART_TYPE_LINE,

1839 + NETDATA_CGROUP_VFS_CREATE_CONTEXT,

1840 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5511,

1841 + em->update_every);

1842

1843 if (em->mode < MODE_ENTRY) {

1586 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "", "Create error",

1587 - EBPF_COMMON_UNITS_CALLS_PER_SEC, NETDATA_VFS_GROUP,

1588 - NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_CREATE_ERROR_CONTEXT,

1589 - NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5512, em->update_every);

1844 + ebpf_write_chart_obsolete(

1845 + type,

1846 + NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR,

1847 + "",

1848 + "Create error",

1849 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

1850 + NETDATA_VFS_GROUP,

1851 + NETDATA_EBPF_CHART_TYPE_LINE,

1852 + NETDATA_CGROUP_VFS_CREATE_ERROR_CONTEXT,

1853 + NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5512,

1854 + em->update_every);

1855 }

1856 }

1857

@@ -1605,72 +1870,73 @@ static void ebpf_send_specific_vfs_data(char *type, netdata_publish_vfs_t *value

1870 ebpf_write_end_chart();

1871

1872 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "");

1608 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].name,

1609 - (long long)values->write_call + (long long)values->writev_call);

1873 + write_chart_dimension(

1874 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].name,

1875 + (long long)values->write_call + (long long)values->writev_call);

1876 ebpf_write_end_chart();

1877

1878 if (em->mode < MODE_ENTRY) {

1879 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "");

1614 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].name,

1615 - (long long)values->write_err + (long long)values->writev_err);

1880 + write_chart_dimension(

1881 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].name,

1882 + (long long)values->write_err + (long long)values->writev_err);

1883 ebpf_write_end_chart();

1884 }

1885

1886 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "");

1620 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].name,

1621 - (long long)values->read_call + (long long)values->readv_call);

1887 + write_chart_dimension(

1888 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].name,

1889 + (long long)values->read_call + (long long)values->readv_call);

1890 ebpf_write_end_chart();

1891

1892 if (em->mode < MODE_ENTRY) {

1893 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "");

1626 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].name,

1627 - (long long)values->read_err + (long long)values->readv_err);

1894 + write_chart_dimension(

1895 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].name,

1896 + (long long)values->read_err + (long long)values->readv_err);

1897 ebpf_write_end_chart();

1898 }

1899

1900 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "");

1632 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].name,

1633 - (long long)values->write_bytes + (long long)values->writev_bytes);

1901 + write_chart_dimension(

1902 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].name,

1903 + (long long)values->write_bytes + (long long)values->writev_bytes);

1904 ebpf_write_end_chart();

1905

1906 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "");

1637 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].name,

1638 - (long long)values->read_bytes + (long long)values->readv_bytes);

1907 + write_chart_dimension(

1908 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].name,

1909 + (long long)values->read_bytes + (long long)values->readv_bytes);

1910 ebpf_write_end_chart();

1911

1912 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC, "");

1642 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC].name,

1643 - (long long)values->fsync_call);

1913 + write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC].name, (long long)values->fsync_call);

1914 ebpf_write_end_chart();

1915

1916 if (em->mode < MODE_ENTRY) {

1917 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "");

1648 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC].name,

1649 - (long long)values->fsync_err);

1918 + write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC].name, (long long)values->fsync_err);

1919 ebpf_write_end_chart();

1920 }

1921

1922 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN, "");

1654 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN].name,

1655 - (long long)values->open_call);

1923 + write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN].name, (long long)values->open_call);

1924 ebpf_write_end_chart();

1925

1926 if (em->mode < MODE_ENTRY) {

1927 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "");

1660 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN].name,

1661 - (long long)values->open_err);

1928 + write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN].name, (long long)values->open_err);

1929 ebpf_write_end_chart();

1930 }

1931

1932 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE, "");

1666 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE].name,

1667 - (long long)values->create_call);

1933 + write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE].name, (long long)values->create_call);

1934 ebpf_write_end_chart();

1935

1936 if (em->mode < MODE_ENTRY) {

1937 ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "");

1672 - write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE].name,

1673 - (long long)values->create_err);

1938 + write_chart_dimension(

1939 + vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE].name, (long long)values->create_err);

1940 ebpf_write_end_chart();

1941 }

1942 }

@@ -1695,8 +1961,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

1961 .module = NETDATA_EBPF_MODULE_NAME_VFS,

1962 .update_every = 0,

1963 .suffix = NETDATA_SYSCALL_APPS_FILE_DELETED,

1698 - .dimension = "calls"

1699 - };

1964 + .dimension = "calls"};

1965

1966 static ebpf_systemd_args_t data_vfs_write = {

1967 .title = "Write to disk",

@@ -1709,8 +1974,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

1974 .module = NETDATA_EBPF_MODULE_NAME_VFS,

1975 .update_every = 0,

1976 .suffix = NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS,

1712 - .dimension = "calls"

1713 - };

1977 + .dimension = "calls"};

1978

1979 static ebpf_systemd_args_t data_vfs_write_err = {

1980 .title = "Fails to write",

@@ -1723,8 +1987,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

1987 .module = NETDATA_EBPF_MODULE_NAME_VFS,

1988 .update_every = 0,

1989 .suffix = NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR,

1726 - .dimension = "calls"

1727 - };

1990 + .dimension = "calls"};

1991

1992 static ebpf_systemd_args_t data_vfs_read = {

1993 .title = "Read from disk",

@@ -1737,8 +2000,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2000 .module = NETDATA_EBPF_MODULE_NAME_VFS,

2001 .update_every = 0,

2002 .suffix = NETDATA_SYSCALL_APPS_VFS_READ_CALLS,

1740 - .dimension = "calls"

1741 - };

2003 + .dimension = "calls"};

2004

2005 static ebpf_systemd_args_t data_vfs_read_err = {

2006 .title = "Fails to read",

@@ -1751,8 +2013,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2013 .module = NETDATA_EBPF_MODULE_NAME_VFS,

2014 .update_every = 0,

2015 .suffix = NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR,

1754 - .dimension = "calls"

1755 - };

2016 + .dimension = "calls"};

2017

2018 static ebpf_systemd_args_t data_vfs_write_bytes = {

2019 .title = "Bytes written on disk",

@@ -1765,8 +2026,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2026 .module = NETDATA_EBPF_MODULE_NAME_VFS,

2027 .update_every = 0,

2028 .suffix = NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES,

1768 - .dimension = "bytes"

1769 - };

2029 + .dimension = "bytes"};

2030

2031 static ebpf_systemd_args_t data_vfs_read_bytes = {

2032 .title = "Bytes read from disk",

@@ -1779,8 +2039,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2039 .module = NETDATA_EBPF_MODULE_NAME_VFS,

2040 .update_every = 0,

2041 .suffix = NETDATA_SYSCALL_APPS_VFS_READ_BYTES,

1782 - .dimension = "bytes"

1783 - };

2042 + .dimension = "bytes"};

2043

2044 static ebpf_systemd_args_t data_vfs_fsync = {

2045 .title = "Calls to vfs_fsync.",

@@ -1793,8 +2052,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2052 .module = NETDATA_EBPF_MODULE_NAME_VFS,

2053 .update_every = 0,

2054 .suffix = NETDATA_SYSCALL_APPS_VFS_FSYNC,

1796 - .dimension = "calls"

1797 - };

2055 + .dimension = "calls"};

2056

2057 static ebpf_systemd_args_t data_vfs_fsync_err = {

2058 .title = "Sync error",

@@ -1807,8 +2065,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2065 .module = NETDATA_EBPF_MODULE_NAME_VFS,

2066 .update_every = 0,

2067 .suffix = NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR,

1810 - .dimension = "calls"

1811 - };

2068 + .dimension = "calls"};

2069

2070 static ebpf_systemd_args_t data_vfs_open = {

2071 .title = "Calls to vfs_open.",

@@ -1821,8 +2078,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2078 .module = NETDATA_EBPF_MODULE_NAME_VFS,

2079 .update_every = 0,

2080 .suffix = NETDATA_SYSCALL_APPS_VFS_OPEN,

1824 - .dimension = "calls"

1825 - };

2081 + .dimension = "calls"};

2082

2083 static ebpf_systemd_args_t data_vfs_open_err = {

2084 .title = "Open error",

@@ -1835,8 +2091,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2091 .module = NETDATA_EBPF_MODULE_NAME_VFS,

2092 .update_every = 0,

2093 .suffix = NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR,

1838 - .dimension = "calls"

1839 - };

2094 + .dimension = "calls"};

2095

2096 static ebpf_systemd_args_t data_vfs_create = {

2097 .title = "Calls to vfs_create.",

@@ -1849,8 +2104,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2104 .module = NETDATA_EBPF_MODULE_NAME_VFS,

2105 .update_every = 0,

2106 .suffix = NETDATA_SYSCALL_APPS_VFS_CREATE,

1852 - .dimension = "calls"

1853 - };

2107 + .dimension = "calls"};

2108

2109 static ebpf_systemd_args_t data_vfs_create_err = {

2110 .title = "Create error",

@@ -1863,25 +2117,23 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2117 .module = NETDATA_EBPF_MODULE_NAME_VFS,

2118 .update_every = 0,

2119 .suffix = NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR,

1866 - .dimension = "calls"

1867 - };

2120 + .dimension = "calls"};

2121

2122 if (!data_vfs_create.update_every)

2123 data_vfs_unlink.update_every = data_vfs_write.update_every = data_vfs_write_err.update_every =

1871 - data_vfs_read.update_every = data_vfs_read_err.update_every = data_vfs_write_bytes.update_every =

1872 - data_vfs_read_bytes.update_every = data_vfs_fsync.update_every = data_vfs_fsync_err.update_every =

1873 - data_vfs_open.update_every = data_vfs_open_err.update_every = data_vfs_create.update_every =

1874 - data_vfs_create_err.update_every = em->update_every;

2124 + data_vfs_read.update_every = data_vfs_read_err.update_every = data_vfs_write_bytes.update_every =

2125 + data_vfs_read_bytes.update_every = data_vfs_fsync.update_every = data_vfs_fsync_err.update_every =

2126 + data_vfs_open.update_every = data_vfs_open_err.update_every = data_vfs_create.update_every =

2127 + data_vfs_create_err.update_every = em->update_every;

2128

2129 ebpf_cgroup_target_t *w;

1877 - for (w = ebpf_cgroup_pids; w ; w = w->next) {

2130 + for (w = ebpf_cgroup_pids; w; w = w->next) {

2131 if (unlikely(!w->systemd || w->flags & NETDATA_EBPF_SERVICES_HAS_VFS_CHART))

2132 continue;

2133

1881 - data_vfs_unlink.id = data_vfs_write.id = data_vfs_write_err.id =

1882 - data_vfs_read.id = data_vfs_read_err.id = data_vfs_write_bytes.id = data_vfs_read_bytes.id =

1883 - data_vfs_fsync.id = data_vfs_fsync_err.id = data_vfs_open.id =

1884 - data_vfs_open_err.id = data_vfs_create.id = data_vfs_create_err.id = w->name;

2134 + data_vfs_unlink.id = data_vfs_write.id = data_vfs_write_err.id = data_vfs_read.id = data_vfs_read_err.id =

2135 + data_vfs_write_bytes.id = data_vfs_read_bytes.id = data_vfs_fsync.id = data_vfs_fsync_err.id =

2136 + data_vfs_open.id = data_vfs_open_err.id = data_vfs_create.id = data_vfs_create_err.id = w->name;

2137 ebpf_create_charts_on_systemd(&data_vfs_unlink);

2138

2139 ebpf_create_charts_on_systemd(&data_vfs_write);

@@ -1919,8 +2171,8 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)

2171 static void ebpf_send_systemd_vfs_charts(ebpf_module_t *em)

2172 {

2173 ebpf_cgroup_target_t *ect;

1922 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

1923 - if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_VFS_CHART)) ) {

2174 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

2175 + if (unlikely(!(ect->flags & NETDATA_EBPF_SERVICES_HAS_VFS_CHART))) {

2176 continue;

2177 }

2178

@@ -1929,37 +2181,31 @@ static void ebpf_send_systemd_vfs_charts(ebpf_module_t *em)

2181 ebpf_write_end_chart();

2182

2183 ebpf_write_begin_chart(ect->name, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "");

1932 - write_chart_dimension("calls", ect->publish_systemd_vfs.write_call +

1933 - ect->publish_systemd_vfs.writev_call);

2184 + write_chart_dimension("calls", ect->publish_systemd_vfs.write_call + ect->publish_systemd_vfs.writev_call);

2185 ebpf_write_end_chart();

2186

2187 if (em->mode < MODE_ENTRY) {

2188 ebpf_write_begin_chart(ect->name, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "");

1938 - write_chart_dimension("calls", ect->publish_systemd_vfs.write_err +

1939 - ect->publish_systemd_vfs.writev_err);

2189 + write_chart_dimension("calls", ect->publish_systemd_vfs.write_err + ect->publish_systemd_vfs.writev_err);

2190 ebpf_write_end_chart();

2191 }

2192

2193 ebpf_write_begin_chart(ect->name, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "");

1944 - write_chart_dimension("calls", ect->publish_systemd_vfs.read_call +

1945 - ect->publish_systemd_vfs.readv_call);

2194 + write_chart_dimension("calls", ect->publish_systemd_vfs.read_call + ect->publish_systemd_vfs.readv_call);

2195 ebpf_write_end_chart();

2196

2197 if (em->mode < MODE_ENTRY) {

2198 ebpf_write_begin_chart(ect->name, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "");

1950 - write_chart_dimension("calls", ect->publish_systemd_vfs.read_err +

1951 - ect->publish_systemd_vfs.readv_err);

2199 + write_chart_dimension("calls", ect->publish_systemd_vfs.read_err + ect->publish_systemd_vfs.readv_err);

2200 ebpf_write_end_chart();

2201 }

2202

2203 ebpf_write_begin_chart(ect->name, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "");

1956 - write_chart_dimension("bytes", ect->publish_systemd_vfs.write_bytes +

1957 - ect->publish_systemd_vfs.writev_bytes);

2204 + write_chart_dimension("bytes", ect->publish_systemd_vfs.write_bytes + ect->publish_systemd_vfs.writev_bytes);

2205 ebpf_write_end_chart();

2206

2207 ebpf_write_begin_chart(ect->name, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "");

1961 - write_chart_dimension("bytes", ect->publish_systemd_vfs.read_bytes +

1962 - ect->publish_systemd_vfs.readv_bytes);

2208 + write_chart_dimension("bytes", ect->publish_systemd_vfs.read_bytes + ect->publish_systemd_vfs.readv_bytes);

2209 ebpf_write_end_chart();

2210

2211 ebpf_write_begin_chart(ect->name, NETDATA_SYSCALL_APPS_VFS_FSYNC, "");

@@ -2003,7 +2249,7 @@ static void ebpf_vfs_send_cgroup_data(ebpf_module_t *em)

2249 {

2250 pthread_mutex_lock(&mutex_cgroup_shm);

2251 ebpf_cgroup_target_t *ect;

2006 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

2252 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

2253 ebpf_vfs_sum_cgroup_pids(&ect->publish_systemd_vfs, ect->pids);

2254 }

2255

@@ -2014,7 +2260,7 @@ static void ebpf_vfs_send_cgroup_data(ebpf_module_t *em)

2260 ebpf_send_systemd_vfs_charts(em);

2261 }

2262

2017 - for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {

2263 + for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {

2264 if (ect->systemd)

2265 continue;

2266

@@ -2039,7 +2285,8 @@ static void ebpf_vfs_send_cgroup_data(ebpf_module_t *em)

2285 /**

2286 * Resume apps data

2287 */

2042 -void ebpf_vfs_resume_apps_data() {

2288 +void ebpf_vfs_resume_apps_data()

2289 +{

2290 struct ebpf_target *w;

2291 for (w = apps_groups_root_target; w; w = w->next) {

2292 if (unlikely(!(w->charts_created & (1 << EBPF_MODULE_VFS_IDX))))

@@ -2172,25 +2419,28 @@ static void vfs_collector(ebpf_module_t *em)

2419 * @param algorithm the algorithm used to make the charts.

2420 * @param update_every value to overwrite the update frequency set by the server.

2421 */

2175 -static void ebpf_create_io_chart(char *family, char *name, char *axis, char *web,

2176 - int order, int algorithm, int update_every)

2422 +static void

2423 +ebpf_create_io_chart(char *family, char *name, char *axis, char *web, int order, int algorithm, int update_every)

2424 {

2178 - printf("CHART %s.%s '' 'Bytes written and read' '%s' '%s' 'filesystem.vfs_io_bytes' line %d %d '' 'ebpf.plugin' 'filesystem'\n",

2179 - family,

2180 - name,

2181 - axis,

2182 - web,

2183 - order,

2184 - update_every);

2185 -

2186 - printf("DIMENSION %s %s %s 1 1\n",

2187 - vfs_id_names[NETDATA_KEY_PUBLISH_VFS_READ],

2188 - vfs_dimension_names[NETDATA_KEY_PUBLISH_VFS_READ],

2189 - ebpf_algorithms[algorithm]);

2190 - printf("DIMENSION %s %s %s -1 1\n",

2191 - vfs_id_names[NETDATA_KEY_PUBLISH_VFS_WRITE],

2192 - vfs_dimension_names[NETDATA_KEY_PUBLISH_VFS_WRITE],

2193 - ebpf_algorithms[algorithm]);

2425 + printf(

2426 + "CHART %s.%s '' 'Bytes written and read' '%s' '%s' 'filesystem.vfs_io_bytes' line %d %d '' 'ebpf.plugin' 'filesystem'\n",

2427 + family,

2428 + name,

2429 + axis,

2430 + web,

2431 + order,

2432 + update_every);

2433 +

2434 + printf(

2435 + "DIMENSION %s %s %s 1 1\n",

2436 + vfs_id_names[NETDATA_KEY_PUBLISH_VFS_READ],

2437 + vfs_dimension_names[NETDATA_KEY_PUBLISH_VFS_READ],

2438 + ebpf_algorithms[algorithm]);

2439 + printf(

2440 + "DIMENSION %s %s %s -1 1\n",

2441 + vfs_id_names[NETDATA_KEY_PUBLISH_VFS_WRITE],

2442 + vfs_dimension_names[NETDATA_KEY_PUBLISH_VFS_WRITE],

2443 + ebpf_algorithms[algorithm]);

2444 }

2445

2446 /**

@@ -2202,120 +2452,150 @@ static void ebpf_create_io_chart(char *family, char *name, char *axis, char *web

2452 */

2453 static void ebpf_create_global_charts(ebpf_module_t *em)

2454 {

2205 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

2206 - NETDATA_VFS_FILE_CLEAN_COUNT,

2207 - "Remove files",

2208 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2209 - NETDATA_VFS_GROUP,

2210 - "filesystem.vfs_deleted_objects",

2211 - NETDATA_EBPF_CHART_TYPE_LINE,

2212 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_CLEAN,

2213 - ebpf_create_global_dimension,

2214 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK],

2215 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

2216 -

2217 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

2218 - NETDATA_VFS_FILE_IO_COUNT,

2219 - "Calls to IO",

2220 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2221 - NETDATA_VFS_GROUP,

2222 - "filesystem.vfs_io",

2223 - NETDATA_EBPF_CHART_TYPE_LINE,

2224 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_COUNT,

2225 - ebpf_create_global_dimension,

2226 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

2227 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

2228 -

2229 - ebpf_create_io_chart(NETDATA_FILESYSTEM_FAMILY,

2230 - NETDATA_VFS_IO_FILE_BYTES, EBPF_COMMON_UNITS_BYTES,

2231 - NETDATA_VFS_GROUP,

2232 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_BYTES,

2233 - NETDATA_EBPF_INCREMENTAL_IDX, em->update_every);

2234 -

2235 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

2236 - NETDATA_VFS_FSYNC,

2237 - "Calls to vfs_fsync.",

2238 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2239 - NETDATA_VFS_GROUP,

2240 - "filesystem.vfs_fsync",

2241 - NETDATA_EBPF_CHART_TYPE_LINE,

2242 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_FSYNC,

2243 - ebpf_create_global_dimension,

2244 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],

2245 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

2246 -

2247 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

2248 - NETDATA_VFS_OPEN,

2249 - "Calls to vfs_open.",

2250 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2251 - NETDATA_VFS_GROUP,

2252 - "filesystem.vfs_open",

2253 - NETDATA_EBPF_CHART_TYPE_LINE,

2254 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_OPEN,

2255 - ebpf_create_global_dimension,

2256 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],

2257 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

2258 -

2259 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

2260 - NETDATA_VFS_CREATE,

2261 - "Calls to vfs_create.",

2262 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2263 - NETDATA_VFS_GROUP,

2264 - "filesystem.vfs_create",

2265 - NETDATA_EBPF_CHART_TYPE_LINE,

2266 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_CREATE,

2267 - ebpf_create_global_dimension,

2268 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],

2269 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

2455 + ebpf_create_chart(

2456 + NETDATA_FILESYSTEM_FAMILY,

2457 + NETDATA_VFS_FILE_CLEAN_COUNT,

2458 + "Remove files",

2459 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2460 + NETDATA_VFS_GROUP,

2461 + "filesystem.vfs_deleted_objects",

2462 + NETDATA_EBPF_CHART_TYPE_LINE,

2463 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_CLEAN,

2464 + ebpf_create_global_dimension,

2465 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK],

2466 + 1,

2467 + em->update_every,

2468 + NETDATA_EBPF_MODULE_NAME_VFS);

2469 +

2470 + ebpf_create_chart(

2471 + NETDATA_FILESYSTEM_FAMILY,

2472 + NETDATA_VFS_FILE_IO_COUNT,

2473 + "Calls to IO",

2474 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2475 + NETDATA_VFS_GROUP,

2476 + "filesystem.vfs_io",

2477 + NETDATA_EBPF_CHART_TYPE_LINE,

2478 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_COUNT,

2479 + ebpf_create_global_dimension,

2480 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

2481 + 2,

2482 + em->update_every,

2483 + NETDATA_EBPF_MODULE_NAME_VFS);

2484 +

2485 + ebpf_create_io_chart(

2486 + NETDATA_FILESYSTEM_FAMILY,

2487 + NETDATA_VFS_IO_FILE_BYTES,

2488 + EBPF_COMMON_UNITS_BYTES,

2489 + NETDATA_VFS_GROUP,

2490 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_BYTES,

2491 + NETDATA_EBPF_INCREMENTAL_IDX,

2492 + em->update_every);

2493 +

2494 + ebpf_create_chart(

2495 + NETDATA_FILESYSTEM_FAMILY,

2496 + NETDATA_VFS_FSYNC,

2497 + "Calls to vfs_fsync.",

2498 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2499 + NETDATA_VFS_GROUP,

2500 + "filesystem.vfs_fsync",

2501 + NETDATA_EBPF_CHART_TYPE_LINE,

2502 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_FSYNC,

2503 + ebpf_create_global_dimension,

2504 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],

2505 + 1,

2506 + em->update_every,

2507 + NETDATA_EBPF_MODULE_NAME_VFS);

2508 +

2509 + ebpf_create_chart(

2510 + NETDATA_FILESYSTEM_FAMILY,

2511 + NETDATA_VFS_OPEN,

2512 + "Calls to vfs_open.",

2513 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2514 + NETDATA_VFS_GROUP,

2515 + "filesystem.vfs_open",

2516 + NETDATA_EBPF_CHART_TYPE_LINE,

2517 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_OPEN,

2518 + ebpf_create_global_dimension,

2519 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],

2520 + 1,

2521 + em->update_every,

2522 + NETDATA_EBPF_MODULE_NAME_VFS);

2523 +

2524 + ebpf_create_chart(

2525 + NETDATA_FILESYSTEM_FAMILY,

2526 + NETDATA_VFS_CREATE,

2527 + "Calls to vfs_create.",

2528 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2529 + NETDATA_VFS_GROUP,

2530 + "filesystem.vfs_create",

2531 + NETDATA_EBPF_CHART_TYPE_LINE,

2532 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_CREATE,

2533 + ebpf_create_global_dimension,

2534 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],

2535 + 1,

2536 + em->update_every,

2537 + NETDATA_EBPF_MODULE_NAME_VFS);

2538

2539 if (em->mode < MODE_ENTRY) {

2272 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

2273 - NETDATA_VFS_FILE_ERR_COUNT,

2274 - "Fails to write or read",

2275 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2276 - NETDATA_VFS_GROUP,

2277 - "filesystem.vfs_io_error",

2278 - NETDATA_EBPF_CHART_TYPE_LINE,

2279 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EBYTES,

2280 - ebpf_create_global_dimension,

2281 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

2282 - 2, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

2283 -

2284 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

2285 - NETDATA_VFS_FSYNC_ERR,

2286 - "Fails to synchronize",

2287 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2288 - NETDATA_VFS_GROUP,

2289 - "filesystem.vfs_fsync_error",

2290 - NETDATA_EBPF_CHART_TYPE_LINE,

2291 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EFSYNC,

2292 - ebpf_create_global_dimension,

2293 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],

2294 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

2295 -

2296 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

2297 - NETDATA_VFS_OPEN_ERR,

2298 - "Fails to open a file",

2299 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2300 - NETDATA_VFS_GROUP,

2301 - "filesystem.vfs_open_error",

2302 - NETDATA_EBPF_CHART_TYPE_LINE,

2303 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EOPEN,

2304 - ebpf_create_global_dimension,

2305 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],

2306 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

2307 -

2308 - ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,

2309 - NETDATA_VFS_CREATE_ERR,

2310 - "Fails to create a file.",

2311 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2312 - NETDATA_VFS_GROUP,

2313 - "filesystem.vfs_create_error",

2314 - NETDATA_EBPF_CHART_TYPE_LINE,

2315 - NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_ECREATE,

2316 - ebpf_create_global_dimension,

2317 - &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],

2318 - 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);

2540 + ebpf_create_chart(

2541 + NETDATA_FILESYSTEM_FAMILY,

2542 + NETDATA_VFS_FILE_ERR_COUNT,

2543 + "Fails to write or read",

2544 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2545 + NETDATA_VFS_GROUP,

2546 + "filesystem.vfs_io_error",

2547 + NETDATA_EBPF_CHART_TYPE_LINE,

2548 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EBYTES,

2549 + ebpf_create_global_dimension,

2550 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],

2551 + 2,

2552 + em->update_every,

2553 + NETDATA_EBPF_MODULE_NAME_VFS);

2554 +

2555 + ebpf_create_chart(

2556 + NETDATA_FILESYSTEM_FAMILY,

2557 + NETDATA_VFS_FSYNC_ERR,

2558 + "Fails to synchronize",

2559 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2560 + NETDATA_VFS_GROUP,

2561 + "filesystem.vfs_fsync_error",

2562 + NETDATA_EBPF_CHART_TYPE_LINE,

2563 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EFSYNC,

2564 + ebpf_create_global_dimension,

2565 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],

2566 + 1,

2567 + em->update_every,

2568 + NETDATA_EBPF_MODULE_NAME_VFS);

2569 +

2570 + ebpf_create_chart(

2571 + NETDATA_FILESYSTEM_FAMILY,

2572 + NETDATA_VFS_OPEN_ERR,

2573 + "Fails to open a file",

2574 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2575 + NETDATA_VFS_GROUP,

2576 + "filesystem.vfs_open_error",

2577 + NETDATA_EBPF_CHART_TYPE_LINE,

2578 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_EOPEN,

2579 + ebpf_create_global_dimension,

2580 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],

2581 + 1,

2582 + em->update_every,

2583 + NETDATA_EBPF_MODULE_NAME_VFS);

2584 +

2585 + ebpf_create_chart(

2586 + NETDATA_FILESYSTEM_FAMILY,

2587 + NETDATA_VFS_CREATE_ERR,

2588 + "Fails to create a file.",

2589 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2590 + NETDATA_VFS_GROUP,

2591 + "filesystem.vfs_create_error",

2592 + NETDATA_EBPF_CHART_TYPE_LINE,

2593 + NETDATA_CHART_PRIO_FILESYSTEM_VFS_IO_ECREATE,

2594 + ebpf_create_global_dimension,

2595 + &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],

2596 + 1,

2597 + em->update_every,

2598 + NETDATA_EBPF_MODULE_NAME_VFS);

2599 }

2600

2601 fflush(stdout);

@@ -2339,212 +2619,225 @@ void ebpf_vfs_create_apps_charts(struct ebpf_module *em, void *ptr)

2619 if (unlikely(!w->exposed))

2620 continue;

2621

2342 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2343 - w->clean_name,

2344 - "_ebpf_call_vfs_unlink",

2345 - "Files deleted.",

2346 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2347 - NETDATA_VFS_GROUP,

2348 - NETDATA_EBPF_CHART_TYPE_STACKED,

2349 - "app.ebpf_call_vfs_unlink",

2350 - order++,

2351 - update_every,

2352 - NETDATA_EBPF_MODULE_NAME_VFS);

2622 + ebpf_write_chart_cmd(

2623 + NETDATA_APP_FAMILY,

2624 + w->clean_name,

2625 + "_ebpf_call_vfs_unlink",

2626 + "Files deleted.",

2627 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2628 + NETDATA_VFS_GROUP,

2629 + NETDATA_EBPF_CHART_TYPE_STACKED,

2630 + "app.ebpf_call_vfs_unlink",

2631 + order++,

2632 + update_every,

2633 + NETDATA_EBPF_MODULE_NAME_VFS);

2634 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2635 ebpf_commit_label();

2636 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2637

2357 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2358 - w->clean_name,

2359 - "_ebpf_call_vfs_write",

2360 - "Write to disk.",

2361 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2362 - NETDATA_VFS_GROUP,

2363 - NETDATA_EBPF_CHART_TYPE_STACKED,

2364 - "app.ebpf_call_vfs_write",

2365 - order++,

2366 - update_every,

2367 - NETDATA_EBPF_MODULE_NAME_VFS);

2638 + ebpf_write_chart_cmd(

2639 + NETDATA_APP_FAMILY,

2640 + w->clean_name,

2641 + "_ebpf_call_vfs_write",

2642 + "Write to disk.",

2643 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2644 + NETDATA_VFS_GROUP,

2645 + NETDATA_EBPF_CHART_TYPE_STACKED,

2646 + "app.ebpf_call_vfs_write",

2647 + order++,

2648 + update_every,

2649 + NETDATA_EBPF_MODULE_NAME_VFS);

2650 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2651 ebpf_commit_label();

2652 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2653

2654 if (em->mode < MODE_ENTRY) {

2373 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2374 - w->clean_name,

2375 - "_ebpf_call_vfs_write_error",

2376 - "Fails to write.",

2377 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2378 - NETDATA_VFS_GROUP,

2379 - NETDATA_EBPF_CHART_TYPE_STACKED,

2380 - "app.ebpf_call_vfs_write_error",

2381 - order++,

2382 - update_every,

2383 - NETDATA_EBPF_MODULE_NAME_VFS);

2655 + ebpf_write_chart_cmd(

2656 + NETDATA_APP_FAMILY,

2657 + w->clean_name,

2658 + "_ebpf_call_vfs_write_error",

2659 + "Fails to write.",

2660 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2661 + NETDATA_VFS_GROUP,

2662 + NETDATA_EBPF_CHART_TYPE_STACKED,

2663 + "app.ebpf_call_vfs_write_error",

2664 + order++,

2665 + update_every,

2666 + NETDATA_EBPF_MODULE_NAME_VFS);

2667 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2668 ebpf_commit_label();

2669 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2670 }

2671

2389 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2390 - w->clean_name,

2391 - "_ebpf_call_vfs_read",

2392 - "Read from disk.",

2393 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2394 - NETDATA_VFS_GROUP,

2395 - NETDATA_EBPF_CHART_TYPE_STACKED,

2396 - "app.ebpf_call_vfs_read",

2397 - order++,

2398 - update_every,

2399 - NETDATA_EBPF_MODULE_NAME_VFS);

2672 + ebpf_write_chart_cmd(

2673 + NETDATA_APP_FAMILY,

2674 + w->clean_name,

2675 + "_ebpf_call_vfs_read",

2676 + "Read from disk.",

2677 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2678 + NETDATA_VFS_GROUP,

2679 + NETDATA_EBPF_CHART_TYPE_STACKED,

2680 + "app.ebpf_call_vfs_read",

2681 + order++,

2682 + update_every,

2683 + NETDATA_EBPF_MODULE_NAME_VFS);

2684 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2685 ebpf_commit_label();

2686 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2687

2688 if (em->mode < MODE_ENTRY) {

2405 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2406 - w->clean_name,

2407 - "_ebpf_call_vfs_read_error",

2408 - "Fails to read.",

2409 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2410 - NETDATA_VFS_GROUP,

2411 - NETDATA_EBPF_CHART_TYPE_STACKED,

2412 - "app.ebpf_call_vfs_read_error",

2413 - order++,

2414 - update_every,

2415 - NETDATA_EBPF_MODULE_NAME_VFS);

2689 + ebpf_write_chart_cmd(

2690 + NETDATA_APP_FAMILY,

2691 + w->clean_name,

2692 + "_ebpf_call_vfs_read_error",

2693 + "Fails to read.",

2694 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2695 + NETDATA_VFS_GROUP,

2696 + NETDATA_EBPF_CHART_TYPE_STACKED,

2697 + "app.ebpf_call_vfs_read_error",

2698 + order++,

2699 + update_every,

2700 + NETDATA_EBPF_MODULE_NAME_VFS);

2701 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2702 ebpf_commit_label();

2703 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2704 }

2705

2421 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2422 - w->clean_name,

2423 - "_ebpf_call_vfs_write_bytes",

2424 - "Bytes written on disk.",

2425 - EBPF_COMMON_UNITS_BYTES,

2426 - NETDATA_VFS_GROUP,

2427 - NETDATA_EBPF_CHART_TYPE_STACKED,

2428 - "app.ebpf_call_vfs_write_bytes",

2429 - order++,

2430 - update_every,

2431 - NETDATA_EBPF_MODULE_NAME_VFS);

2706 + ebpf_write_chart_cmd(

2707 + NETDATA_APP_FAMILY,

2708 + w->clean_name,

2709 + "_ebpf_call_vfs_write_bytes",

2710 + "Bytes written on disk.",

2711 + EBPF_COMMON_UNITS_BYTES,

2712 + NETDATA_VFS_GROUP,

2713 + NETDATA_EBPF_CHART_TYPE_STACKED,

2714 + "app.ebpf_call_vfs_write_bytes",

2715 + order++,

2716 + update_every,

2717 + NETDATA_EBPF_MODULE_NAME_VFS);

2718 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2719 ebpf_commit_label();

2720 fprintf(stdout, "DIMENSION writes '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2721

2436 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2437 - w->clean_name,

2438 - "_ebpf_call_vfs_read_bytes",

2439 - "Bytes read from disk.",

2440 - EBPF_COMMON_UNITS_BYTES,

2441 - NETDATA_VFS_GROUP,

2442 - NETDATA_EBPF_CHART_TYPE_STACKED,

2443 - "app.ebpf_call_vfs_read_bytes",

2444 - order++,

2445 - update_every,

2446 - NETDATA_EBPF_MODULE_NAME_VFS);

2722 + ebpf_write_chart_cmd(

2723 + NETDATA_APP_FAMILY,

2724 + w->clean_name,

2725 + "_ebpf_call_vfs_read_bytes",

2726 + "Bytes read from disk.",

2727 + EBPF_COMMON_UNITS_BYTES,

2728 + NETDATA_VFS_GROUP,

2729 + NETDATA_EBPF_CHART_TYPE_STACKED,

2730 + "app.ebpf_call_vfs_read_bytes",

2731 + order++,

2732 + update_every,

2733 + NETDATA_EBPF_MODULE_NAME_VFS);

2734 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2735 ebpf_commit_label();

2736 fprintf(stdout, "DIMENSION reads '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2737

2451 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2452 - w->clean_name,

2453 - "_ebpf_call_vfs_fsync",

2454 - "Calls to vfs_fsync.",

2455 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2456 - NETDATA_VFS_GROUP,

2457 - NETDATA_EBPF_CHART_TYPE_STACKED,

2458 - "app.ebpf_call_vfs_fsync",

2459 - order++,

2460 - update_every,

2461 - NETDATA_EBPF_MODULE_NAME_VFS);

2738 + ebpf_write_chart_cmd(

2739 + NETDATA_APP_FAMILY,

2740 + w->clean_name,

2741 + "_ebpf_call_vfs_fsync",

2742 + "Calls to vfs_fsync.",

2743 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2744 + NETDATA_VFS_GROUP,

2745 + NETDATA_EBPF_CHART_TYPE_STACKED,

2746 + "app.ebpf_call_vfs_fsync",

2747 + order++,

2748 + update_every,

2749 + NETDATA_EBPF_MODULE_NAME_VFS);

2750 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2751 ebpf_commit_label();

2752 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2753

2754 if (em->mode < MODE_ENTRY) {

2467 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2468 - w->clean_name,

2469 - "_ebpf_call_vfs_fsync_error",

2470 - "Fails to sync.",

2471 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2472 - NETDATA_VFS_GROUP,

2473 - NETDATA_EBPF_CHART_TYPE_STACKED,

2474 - "app.ebpf_call_vfs_fsync_error",

2475 - order++,

2476 - update_every,

2477 - NETDATA_EBPF_MODULE_NAME_VFS);

2755 + ebpf_write_chart_cmd(

2756 + NETDATA_APP_FAMILY,

2757 + w->clean_name,

2758 + "_ebpf_call_vfs_fsync_error",

2759 + "Fails to sync.",

2760 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2761 + NETDATA_VFS_GROUP,

2762 + NETDATA_EBPF_CHART_TYPE_STACKED,

2763 + "app.ebpf_call_vfs_fsync_error",

2764 + order++,

2765 + update_every,

2766 + NETDATA_EBPF_MODULE_NAME_VFS);

2767 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2768 ebpf_commit_label();

2769 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2770 }

2771

2483 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2484 - w->clean_name,

2485 - "_ebpf_call_vfs_open",

2486 - "Calls to vfs_open.",

2487 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2488 - NETDATA_VFS_GROUP,

2489 - NETDATA_EBPF_CHART_TYPE_STACKED,

2490 - "app.ebpf_call_vfs_open",

2491 - order++,

2492 - update_every,

2493 - NETDATA_EBPF_MODULE_NAME_VFS);

2772 + ebpf_write_chart_cmd(

2773 + NETDATA_APP_FAMILY,

2774 + w->clean_name,

2775 + "_ebpf_call_vfs_open",

2776 + "Calls to vfs_open.",

2777 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2778 + NETDATA_VFS_GROUP,

2779 + NETDATA_EBPF_CHART_TYPE_STACKED,

2780 + "app.ebpf_call_vfs_open",

2781 + order++,

2782 + update_every,

2783 + NETDATA_EBPF_MODULE_NAME_VFS);

2784 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2785 ebpf_commit_label();

2786 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2787

2788 if (em->mode < MODE_ENTRY) {

2499 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2500 - w->clean_name,

2501 - "_ebpf_call_vfs_open_error",

2502 - "Fails to open.",

2503 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2504 - NETDATA_VFS_GROUP,

2505 - NETDATA_EBPF_CHART_TYPE_STACKED,

2506 - "app.ebpf_call_vfs_open_error",

2507 - order++,

2508 - update_every,

2509 - NETDATA_EBPF_MODULE_NAME_VFS);

2789 + ebpf_write_chart_cmd(

2790 + NETDATA_APP_FAMILY,

2791 + w->clean_name,

2792 + "_ebpf_call_vfs_open_error",

2793 + "Fails to open.",

2794 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2795 + NETDATA_VFS_GROUP,

2796 + NETDATA_EBPF_CHART_TYPE_STACKED,

2797 + "app.ebpf_call_vfs_open_error",

2798 + order++,

2799 + update_every,

2800 + NETDATA_EBPF_MODULE_NAME_VFS);

2801 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2802 ebpf_commit_label();

2803 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2804 }

2805

2515 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2516 - w->clean_name,

2517 - "_ebpf_call_vfs_create",

2518 - "Calls to vfs_create.",

2519 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2520 - NETDATA_VFS_GROUP,

2521 - NETDATA_EBPF_CHART_TYPE_STACKED,

2522 - "app.ebpf_call_vfs_create",

2523 - order++,

2524 - update_every,

2525 - NETDATA_EBPF_MODULE_NAME_VFS);

2806 + ebpf_write_chart_cmd(

2807 + NETDATA_APP_FAMILY,

2808 + w->clean_name,

2809 + "_ebpf_call_vfs_create",

2810 + "Calls to vfs_create.",

2811 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2812 + NETDATA_VFS_GROUP,

2813 + NETDATA_EBPF_CHART_TYPE_STACKED,

2814 + "app.ebpf_call_vfs_create",

2815 + order++,

2816 + update_every,

2817 + NETDATA_EBPF_MODULE_NAME_VFS);

2818 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2819 ebpf_commit_label();

2820 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2821

2822 if (em->mode < MODE_ENTRY) {

2531 - ebpf_write_chart_cmd(NETDATA_APP_FAMILY,

2532 - w->clean_name,

2533 - "_ebpf_call_vfs_create_error",

2534 - "Fails to create a file.",

2535 - EBPF_COMMON_UNITS_CALLS_PER_SEC,

2536 - NETDATA_VFS_GROUP,

2537 - NETDATA_EBPF_CHART_TYPE_STACKED,

2538 - "app.ebpf_call_vfs_create_error",

2539 - order++,

2540 - update_every,

2541 - NETDATA_EBPF_MODULE_NAME_VFS);

2823 + ebpf_write_chart_cmd(

2824 + NETDATA_APP_FAMILY,

2825 + w->clean_name,

2826 + "_ebpf_call_vfs_create_error",

2827 + "Fails to create a file.",

2828 + EBPF_COMMON_UNITS_CALLS_PER_SEC,

2829 + NETDATA_VFS_GROUP,

2830 + NETDATA_EBPF_CHART_TYPE_STACKED,

2831 + "app.ebpf_call_vfs_create_error",

2832 + order++,

2833 + update_every,

2834 + NETDATA_EBPF_MODULE_NAME_VFS);

2835 ebpf_create_chart_labels("app_group", w->name, RRDLABEL_SRC_AUTO);

2836 ebpf_commit_label();

2837 fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);

2838 }

2839

2547 - w->charts_created |= 1<<EBPF_MODULE_VFS_IDX;

2840 + w->charts_created |= 1 << EBPF_MODULE_VFS_IDX;

2841 }

2842

2843 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;

@@ -2643,12 +2936,20 @@ void *ebpf_vfs_thread(void *ptr)

2936 }

2937

2938 int algorithms[NETDATA_KEY_PUBLISH_VFS_END] = {

2646 - NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX,NETDATA_EBPF_INCREMENTAL_IDX,

2647 - NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX,NETDATA_EBPF_INCREMENTAL_IDX

2648 - };

2649 -

2650 - ebpf_global_labels(vfs_aggregated_data, vfs_publish_aggregated, vfs_dimension_names,

2651 - vfs_id_names, algorithms, NETDATA_KEY_PUBLISH_VFS_END);

2939 + NETDATA_EBPF_INCREMENTAL_IDX,

2940 + NETDATA_EBPF_INCREMENTAL_IDX,

2941 + NETDATA_EBPF_INCREMENTAL_IDX,

2942 + NETDATA_EBPF_INCREMENTAL_IDX,

2943 + NETDATA_EBPF_INCREMENTAL_IDX,

2944 + NETDATA_EBPF_INCREMENTAL_IDX};

2945 +

2946 + ebpf_global_labels(

2947 + vfs_aggregated_data,

2948 + vfs_publish_aggregated,

2949 + vfs_dimension_names,

2950 + vfs_id_names,

2951 + algorithms,

2952 + NETDATA_KEY_PUBLISH_VFS_END);

2953

2954 pthread_mutex_lock(&lock);

2955 ebpf_create_global_charts(em);

@@ -2657,8 +2958,8 @@ void *ebpf_vfs_thread(void *ptr)

2958

2959 pthread_mutex_unlock(&lock);

2960

2660 - ebpf_read_vfs.thread = nd_thread_create(ebpf_read_vfs.name, NETDATA_THREAD_OPTION_DEFAULT,

2661 - ebpf_read_vfs_thread, em);

2961 + ebpf_read_vfs.thread =

2962 + nd_thread_create(ebpf_read_vfs.name, NETDATA_THREAD_OPTION_DEFAULT, ebpf_read_vfs_thread, em);

2963

2964 vfs_collector(em);

2965

src/collectors/ebpf.plugin/ebpf_vfs.h

+3 -6

@@ -5,7 +5,8 @@

6 // Module name & description

7 #define NETDATA_EBPF_MODULE_NAME_VFS "vfs"

8 -#define NETDATA_EBPF_VFS_MODULE_DESC "Monitor VFS (Virtual File System) functions. This thread is integrated with apps and cgroup."

8 +#define NETDATA_EBPF_VFS_MODULE_DESC \

9 + "Monitor VFS (Virtual File System) functions. This thread is integrated with apps and cgroup."

11 #define NETDATA_DIRECTORY_VFS_CONFIG_FILE "vfs.conf"

@@ -150,11 +151,7 @@ enum vfs_counters {

151 NETDATA_VFS_COUNTER

152 };

153

153 -enum netdata_vfs_tables {

154 - NETDATA_VFS_PID,

155 - NETDATA_VFS_ALL,

156 - NETDATA_VFS_CTRL

157 -};

154 +enum netdata_vfs_tables { NETDATA_VFS_PID, NETDATA_VFS_ALL, NETDATA_VFS_CTRL };

155

156 enum netdata_vfs_calls_name {

157 NETDATA_EBPF_VFS_WRITE,