ebpf_sync.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389
  1. // SPDX-License-Identifier: GPL-3.0-or-later
  2. #include "ebpf.h"
  3. #include "ebpf_sync.h"
  4. static ebpf_data_t sync_data;
  5. static char *sync_counter_dimension_name[NETDATA_SYNC_IDX_END] = { "sync", "syncfs", "msync", "fsync", "fdatasync",
  6. "sync_file_range" };
  7. static netdata_syscall_stat_t sync_counter_aggregated_data[NETDATA_SYNC_IDX_END];
  8. static netdata_publish_syscall_t sync_counter_publish_aggregated[NETDATA_SYNC_IDX_END];
  9. static int read_thread_closed = 1;
  10. static netdata_idx_t sync_hash_values[NETDATA_SYNC_IDX_END];
  11. struct netdata_static_thread sync_threads = {"SYNC KERNEL", NULL, NULL, 1,
  12. NULL, NULL, NULL};
  13. struct config sync_config = { .first_section = NULL,
  14. .last_section = NULL,
  15. .mutex = NETDATA_MUTEX_INITIALIZER,
  16. .index = { .avl_tree = { .root = NULL, .compar = appconfig_section_compare },
  17. .rwlock = AVL_LOCK_INITIALIZER } };
  18. ebpf_sync_syscalls_t local_syscalls[] = {
  19. {.syscall = "sync", .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL},
  20. {.syscall = "syncfs", .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL},
  21. {.syscall = "msync", .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL},
  22. {.syscall = "fsync", .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL},
  23. {.syscall = "fdatasync", .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL},
  24. {.syscall = "sync_file_range", .enabled = CONFIG_BOOLEAN_YES, .objects = NULL, .probe_links = NULL},
  25. {.syscall = NULL, .enabled = CONFIG_BOOLEAN_NO, .objects = NULL, .probe_links = NULL}
  26. };
  27. /*****************************************************************
  28. *
  29. * INITIALIZE THREAD
  30. *
  31. *****************************************************************/
  32. /*
  33. * Initialize Syscalls
  34. *
  35. * Load the eBPF programs to monitor syscalls
  36. *
  37. * @return 0 on success and -1 otherwise.
  38. */
  39. static int ebpf_sync_initialize_syscall(ebpf_module_t *em)
  40. {
  41. int i;
  42. const char *saved_name = em->thread_name;
  43. for (i = 0; local_syscalls[i].syscall; i++) {
  44. ebpf_sync_syscalls_t *w = &local_syscalls[i];
  45. if (!w->probe_links && w->enabled) {
  46. fill_ebpf_data(&w->kernel_info);
  47. if (ebpf_update_kernel(&w->kernel_info)) {
  48. em->thread_name = saved_name;
  49. error("Cannot update the kernel for eBPF module %s", w->syscall);
  50. return -1;
  51. }
  52. em->thread_name = w->syscall;
  53. w->probe_links = ebpf_load_program(ebpf_plugin_dir, em, kernel_string, &w->objects, w->kernel_info.map_fd);
  54. if (!w->probe_links) {
  55. em->thread_name = saved_name;
  56. return -1;
  57. }
  58. }
  59. }
  60. em->thread_name = saved_name;
  61. memset(sync_counter_aggregated_data, 0 , NETDATA_SYNC_IDX_END * sizeof(netdata_syscall_stat_t));
  62. memset(sync_counter_publish_aggregated, 0 , NETDATA_SYNC_IDX_END * sizeof(netdata_publish_syscall_t));
  63. memset(sync_hash_values, 0 , NETDATA_SYNC_IDX_END * sizeof(netdata_idx_t));
  64. return 0;
  65. }
  66. /*****************************************************************
  67. *
  68. * DATA THREAD
  69. *
  70. *****************************************************************/
  71. /**
  72. * Read global table
  73. *
  74. * Read the table with number of calls for all functions
  75. */
  76. static void read_global_table()
  77. {
  78. netdata_idx_t stored;
  79. uint32_t idx = NETDATA_SYNC_CALL;
  80. int i;
  81. for (i = 0; local_syscalls[i].syscall; i++) {
  82. if (local_syscalls[i].enabled) {
  83. int fd = local_syscalls[i].kernel_info.map_fd[NETDATA_SYNC_GLOBLAL_TABLE];
  84. if (!bpf_map_lookup_elem(fd, &idx, &stored)) {
  85. sync_hash_values[i] = stored;
  86. }
  87. }
  88. }
  89. }
  90. /**
  91. * Sync read hash
  92. *
  93. * This is the thread callback.
  94. *
  95. * @param ptr It is a NULL value for this thread.
  96. *
  97. * @return It always returns NULL.
  98. */
  99. void *ebpf_sync_read_hash(void *ptr)
  100. {
  101. ebpf_module_t *em = (ebpf_module_t *)ptr;
  102. read_thread_closed = 0;
  103. heartbeat_t hb;
  104. heartbeat_init(&hb);
  105. usec_t step = NETDATA_EBPF_SYNC_SLEEP_MS * em->update_time;
  106. while (!close_ebpf_plugin) {
  107. usec_t dt = heartbeat_next(&hb, step);
  108. (void)dt;
  109. read_global_table();
  110. }
  111. read_thread_closed = 1;
  112. return NULL;
  113. }
  114. /**
  115. * Create Sync charts
  116. *
  117. * Create charts and dimensions according user input.
  118. *
  119. * @param id chart id
  120. * @param idx the first index with data.
  121. * @param end the last index with data.
  122. */
  123. static void ebpf_send_sync_chart(char *id,
  124. int idx,
  125. int end)
  126. {
  127. write_begin_chart(NETDATA_EBPF_MEMORY_GROUP, id);
  128. netdata_publish_syscall_t *move = &sync_counter_publish_aggregated[idx];
  129. while (move && idx <= end) {
  130. if (local_syscalls[idx].enabled)
  131. write_chart_dimension(move->name, sync_hash_values[idx]);
  132. move = move->next;
  133. idx++;
  134. }
  135. write_end_chart();
  136. }
  137. /**
  138. * Send data
  139. *
  140. * Send global charts to Netdata
  141. */
  142. static void sync_send_data()
  143. {
  144. if (local_syscalls[NETDATA_SYNC_FSYNC_IDX].enabled || local_syscalls[NETDATA_SYNC_FDATASYNC_IDX].enabled) {
  145. ebpf_send_sync_chart(NETDATA_EBPF_FILE_SYNC_CHART, NETDATA_SYNC_FSYNC_IDX, NETDATA_SYNC_FDATASYNC_IDX);
  146. }
  147. if (local_syscalls[NETDATA_SYNC_MSYNC_IDX].enabled)
  148. ebpf_one_dimension_write_charts(NETDATA_EBPF_MEMORY_GROUP, NETDATA_EBPF_MSYNC_CHART,
  149. sync_counter_publish_aggregated[NETDATA_SYNC_MSYNC_IDX].dimension,
  150. sync_hash_values[NETDATA_SYNC_MSYNC_IDX]);
  151. if (local_syscalls[NETDATA_SYNC_SYNC_IDX].enabled || local_syscalls[NETDATA_SYNC_SYNCFS_IDX].enabled) {
  152. ebpf_send_sync_chart(NETDATA_EBPF_SYNC_CHART, NETDATA_SYNC_SYNC_IDX, NETDATA_SYNC_SYNCFS_IDX);
  153. }
  154. if (local_syscalls[NETDATA_SYNC_SYNC_FILE_RANGE_IDX].enabled)
  155. ebpf_one_dimension_write_charts(NETDATA_EBPF_MEMORY_GROUP, NETDATA_EBPF_FILE_SEGMENT_CHART,
  156. sync_counter_publish_aggregated[NETDATA_SYNC_SYNC_FILE_RANGE_IDX].dimension,
  157. sync_hash_values[NETDATA_SYNC_SYNC_FILE_RANGE_IDX]);
  158. }
  159. /**
  160. * Main loop for this collector.
  161. */
  162. static void sync_collector(ebpf_module_t *em)
  163. {
  164. sync_threads.thread = mallocz(sizeof(netdata_thread_t));
  165. sync_threads.start_routine = ebpf_sync_read_hash;
  166. netdata_thread_create(sync_threads.thread, sync_threads.name, NETDATA_THREAD_OPTION_JOINABLE,
  167. ebpf_sync_read_hash, em);
  168. while (!close_ebpf_plugin) {
  169. pthread_mutex_lock(&collect_data_mutex);
  170. pthread_cond_wait(&collect_data_cond_var, &collect_data_mutex);
  171. pthread_mutex_lock(&lock);
  172. sync_send_data();
  173. pthread_mutex_unlock(&lock);
  174. pthread_mutex_unlock(&collect_data_mutex);
  175. }
  176. }
  177. /*****************************************************************
  178. *
  179. * CLEANUP THREAD
  180. *
  181. *****************************************************************/
  182. /**
  183. * Cleanup Objects
  184. *
  185. * Cleanup loaded objects when thread was initialized.
  186. */
  187. void ebpf_sync_cleanup_objects()
  188. {
  189. int i;
  190. for (i = 0; local_syscalls[i].syscall; i++) {
  191. ebpf_sync_syscalls_t *w = &local_syscalls[i];
  192. if (w->probe_links) {
  193. freez(w->kernel_info.map_fd);
  194. struct bpf_program *prog;
  195. size_t j = 0 ;
  196. bpf_object__for_each_program(prog, w->objects) {
  197. bpf_link__destroy(w->probe_links[j]);
  198. j++;
  199. }
  200. bpf_object__close(w->objects);
  201. }
  202. }
  203. }
  204. /**
  205. * Clean up the main thread.
  206. *
  207. * @param ptr thread data.
  208. */
  209. static void ebpf_sync_cleanup(void *ptr)
  210. {
  211. ebpf_module_t *em = (ebpf_module_t *)ptr;
  212. if (!em->enabled)
  213. return;
  214. heartbeat_t hb;
  215. heartbeat_init(&hb);
  216. uint32_t tick = 2*USEC_PER_MS;
  217. while (!read_thread_closed) {
  218. usec_t dt = heartbeat_next(&hb, tick);
  219. UNUSED(dt);
  220. }
  221. ebpf_sync_cleanup_objects();
  222. freez(sync_threads.thread);
  223. }
  224. /*****************************************************************
  225. *
  226. * MAIN THREAD
  227. *
  228. *****************************************************************/
  229. /**
  230. * Create Sync charts
  231. *
  232. * Create charts and dimensions according user input.
  233. *
  234. * @param id chart id
  235. * @param title chart title
  236. * @param order order number of the specified chart
  237. * @param idx the first index with data.
  238. * @param end the last index with data.
  239. */
  240. static void ebpf_create_sync_chart(char *id,
  241. char *title,
  242. int order,
  243. int idx,
  244. int end)
  245. {
  246. ebpf_write_chart_cmd(NETDATA_EBPF_MEMORY_GROUP, id, title, EBPF_COMMON_DIMENSION_CALL,
  247. NETDATA_EBPF_SYNC_SUBMENU, NETDATA_EBPF_CHART_TYPE_LINE, NULL, order);
  248. netdata_publish_syscall_t *move = &sync_counter_publish_aggregated[idx];
  249. while (move && idx <= end) {
  250. if (local_syscalls[idx].enabled)
  251. ebpf_write_global_dimension(move->name, move->dimension, move->algorithm);
  252. move = move->next;
  253. idx++;
  254. }
  255. }
  256. /**
  257. * Create global charts
  258. *
  259. * Call ebpf_create_chart to create the charts for the collector.
  260. */
  261. static void ebpf_create_sync_charts()
  262. {
  263. if (local_syscalls[NETDATA_SYNC_FSYNC_IDX].enabled || local_syscalls[NETDATA_SYNC_FDATASYNC_IDX].enabled)
  264. ebpf_create_sync_chart(NETDATA_EBPF_FILE_SYNC_CHART,
  265. "Monitor calls for <code>fsync(2)</code> and <code>fdatasync(2)</code>.", 21300,
  266. NETDATA_SYNC_FSYNC_IDX, NETDATA_SYNC_FDATASYNC_IDX);
  267. if (local_syscalls[NETDATA_SYNC_MSYNC_IDX].enabled)
  268. ebpf_create_sync_chart(NETDATA_EBPF_MSYNC_CHART,
  269. "Monitor calls for <code>msync(2)</code>.", 21301,
  270. NETDATA_SYNC_MSYNC_IDX, NETDATA_SYNC_MSYNC_IDX);
  271. if (local_syscalls[NETDATA_SYNC_SYNC_IDX].enabled || local_syscalls[NETDATA_SYNC_SYNCFS_IDX].enabled)
  272. ebpf_create_sync_chart(NETDATA_EBPF_SYNC_CHART,
  273. "Monitor calls for <code>sync(2)</code> and <code>syncfs(2)</code>.", 21302,
  274. NETDATA_SYNC_SYNC_IDX, NETDATA_SYNC_SYNCFS_IDX);
  275. if (local_syscalls[NETDATA_SYNC_SYNC_FILE_RANGE_IDX].enabled)
  276. ebpf_create_sync_chart(NETDATA_EBPF_FILE_SEGMENT_CHART,
  277. "Monitor calls for <code>sync_file_range(2)</code>.", 21303,
  278. NETDATA_SYNC_SYNC_FILE_RANGE_IDX, NETDATA_SYNC_SYNC_FILE_RANGE_IDX);
  279. }
  280. /**
  281. * Parse Syscalls
  282. *
  283. * Parse syscall options available inside ebpf.d/sync.conf
  284. */
  285. static void ebpf_sync_parse_syscalls()
  286. {
  287. int i;
  288. for (i = 0; local_syscalls[i].syscall; i++) {
  289. local_syscalls[i].enabled = appconfig_get_boolean(&sync_config, NETDATA_SYNC_CONFIG_NAME,
  290. local_syscalls[i].syscall, CONFIG_BOOLEAN_YES);
  291. }
  292. }
  293. /**
  294. * Sync thread
  295. *
  296. * Thread used to make sync thread
  297. *
  298. * @param ptr a pointer to `struct ebpf_module`
  299. *
  300. * @return It always return NULL
  301. */
  302. void *ebpf_sync_thread(void *ptr)
  303. {
  304. netdata_thread_cleanup_push(ebpf_sync_cleanup, ptr);
  305. ebpf_module_t *em = (ebpf_module_t *)ptr;
  306. fill_ebpf_data(&sync_data);
  307. ebpf_update_module(em, &sync_config, NETDATA_SYNC_CONFIG_FILE);
  308. ebpf_sync_parse_syscalls();
  309. if (!em->enabled)
  310. goto endsync;
  311. if (ebpf_sync_initialize_syscall(em)) {
  312. pthread_mutex_unlock(&lock);
  313. goto endsync;
  314. }
  315. int algorithms[NETDATA_SYNC_IDX_END] = { NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX,
  316. NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX,
  317. NETDATA_EBPF_INCREMENTAL_IDX, NETDATA_EBPF_INCREMENTAL_IDX };
  318. ebpf_global_labels(sync_counter_aggregated_data, sync_counter_publish_aggregated,
  319. sync_counter_dimension_name, sync_counter_dimension_name,
  320. algorithms, NETDATA_SYNC_IDX_END);
  321. pthread_mutex_lock(&lock);
  322. ebpf_create_sync_charts();
  323. pthread_mutex_unlock(&lock);
  324. sync_collector(em);
  325. endsync:
  326. netdata_thread_cleanup_pop(1);
  327. return NULL;
  328. }