Ebpf directory cache (#10855)

Add new thread to ebpf.plugin.

10 files changed, 733 insertions, 3 deletions

diff --git a/collectors/ebpf.plugin/Makefile.am b/collectors/ebpf.plugin/Makefile.am
index 4fb2056fd8..18b1fc6c83 100644
--- a/collectors/ebpf.plugin/Makefile.am
+++ b/collectors/ebpf.plugin/Makefile.am
@@ -33,6 +33,7 @@ dist_libconfig_DATA = \
 dist_ebpfconfig_DATA = \
     ebpf.d/ebpf_kernel_reject_list.txt \
     ebpf.d/cachestat.conf \
+    ebpf.d/dcstat.conf \
     ebpf.d/network.conf \
     ebpf.d/process.conf \
     ebpf.d/sync.conf \
diff --git a/collectors/ebpf.plugin/README.md b/collectors/ebpf.plugin/README.md
index fb5c8b8d90..1e593786b1 100644
--- a/collectors/ebpf.plugin/README.md
+++ b/collectors/ebpf.plugin/README.md
@@ -200,6 +200,9 @@ The eBPF collector enables and runs the following eBPF programs by default:
 -   `cachestat`: Netdata's eBPF data collector creates charts about the memory page cache. When the integration with
     [`apps.plugin`](/collectors/apps.plugin/README.md) is enabled, this collector creates charts for the whole host _and_
     for each application.
+-   `dcstat` : This eBPF program creates charts that show information about file access using directory cache. It appends
+    `kprobes` for `lookup_fast()` and `d_lookup()` to identify if files are inside directory cache, outside and 
+    files are not found.
 -   `process`: This eBPF program creates charts that show information about process creation, VFS IO, and files removed.
     When in `return` mode, it also creates charts showing errors when these operations are executed.
 -   `network viewer`: This eBPF program creates charts with information about `TCP` and `UDP` functions, including the
@@ -221,6 +224,7 @@ cd /etc/netdata/   # Replace with your Netdata configuration directory, if not /
 The following configuration files are available:
 
 - `cachestat.conf`: Configuration for the `cachestat` thread.
+- `dcstat.conf`: Configuration for the `dcstat` thread.
 - `process.conf`: Configuration for the `process` thread.
 - `network.conf`: Configuration for the `network viewer` thread. This config file overwrites the global options and
   also lets you specify which network the eBPF collector monitors.
diff --git a/collectors/ebpf.plugin/ebpf.c b/collectors/ebpf.plugin/ebpf.c
index 7fb403ff94..5cc005f30b 100644
--- a/collectors/ebpf.plugin/ebpf.c
+++ b/collectors/ebpf.plugin/ebpf.c
@@ -90,6 +90,10 @@ ebpf_module_t ebpf_modules[] = {
     { .thread_name = "sync", .config_name = "sync", .enabled = 0, .start_routine = ebpf_sync_thread,
       .update_time = 1, .global_charts = 1, .apps_charts = 1, .mode = MODE_ENTRY,
       .optional = 0, .apps_routine = NULL, .maps = NULL, .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE, .names = NULL },
+    { .thread_name = "dc", .config_name = "dc", .enabled = 0, .start_routine = ebpf_dcstat_thread,
+      .update_time = 1, .global_charts = 1, .apps_charts = 1, .mode = MODE_ENTRY,
+      .optional = 0, .apps_routine = ebpf_dcstat_create_apps_charts, .maps = NULL,
+      .pid_map_size = ND_EBPF_DEFAULT_PID_SIZE },
     { .thread_name = NULL, .enabled = 0, .start_routine = NULL, .update_time = 1,
       .global_charts = 0, .apps_charts = 1, .mode = MODE_ENTRY,
       .optional = 0, .apps_routine = NULL, .maps = NULL, .pid_map_size = 0, .names = NULL },
@@ -145,6 +149,12 @@ static void ebpf_exit(int sig)
         freez(cachestat_pid);
     }
 
+    if (ebpf_modules[EBPF_MODULE_DCSTAT_IDX].enabled) {
+        ebpf_modules[EBPF_MODULE_DCSTAT_IDX].enabled = 0;
+        clean_dcstat_pid_structures();
+        freez(dcstat_pid);
+    }
+
     /*
     int ret = fork();
     if (ret < 0) // error
@@ -585,6 +595,8 @@ void ebpf_print_help()
             "\n"
             " --cachestat or -c   Enable charts related to process run time.\n"
             "\n"
+            " --dcstat or -d      Enable charts related to directory cache.\n"
+            "\n"
             " --net or -n         Enable network viewer charts.\n"
             "\n"
             " --process or -p     Enable charts related to process run time.\n"
@@ -875,6 +887,13 @@ static void read_collector_values(int *disable_apps)
         started++;
     }
 
+    enabled = appconfig_get_boolean(&collector_config, EBPF_PROGRAMS_SECTION, "dcstat",
+                                    CONFIG_BOOLEAN_NO);
+    if (enabled) {
+        ebpf_enable_chart(EBPF_MODULE_DCSTAT_IDX, *disable_apps);
+        started++;
+    }
+
     if (!started){
         ebpf_enable_all_charts(*disable_apps);
         // Read network viewer section
@@ -958,6 +977,7 @@ static void parse_args(int argc, char **argv)
         {"global",    no_argument,    0,  'g' },
         {"all",       no_argument,    0,  'a' },
         {"cachestat", no_argument,    0,  'c' },
+        {"dcstat",    no_argument,    0,  'd' },
         {"net",       no_argument,    0,  'n' },
         {"process",   no_argument,    0,  'p' },
         {"return",    no_argument,    0,  'r' },
@@ -976,7 +996,7 @@ static void parse_args(int argc, char **argv)
     }
 
     while (1) {
-        int c = getopt_long(argc, argv, "hvgcanprs", long_options, &option_index);
+        int c = getopt_long(argc, argv, "hvgacdnprs", long_options, &option_index);
         if (c == -1)
             break;
 
@@ -1014,6 +1034,15 @@ static void parse_args(int argc, char **argv)
 #endif
                 break;
             }
+            case 'd': {
+                enabled = 1;
+                ebpf_enable_chart(EBPF_MODULE_DCSTAT_IDX, disable_apps);
+#ifdef NETDATA_INTERNAL_CHECKS
+                info(
+                    "EBPF enabling \"DCSTAT\" charts, because it was started with the option \"--dcstat\" or \"-d\".");
+#endif
+                break;
+            }
             case 'n': {
                 enabled = 1;
                 ebpf_enable_chart(EBPF_MODULE_SOCKET_IDX, disable_apps);
@@ -1172,6 +1201,8 @@ int main(int argc, char **argv)
             NULL, NULL, ebpf_modules[EBPF_MODULE_CACHESTAT_IDX].start_routine},
         {"EBPF SYNC" , NULL, NULL, 1,
             NULL, NULL, ebpf_modules[EBPF_MODULE_SYNC_IDX].start_routine},
+        {"EBPF DCSTAT" , NULL, NULL, 1,
+            NULL, NULL, ebpf_modules[EBPF_MODULE_DCSTAT_IDX].start_routine},
         {NULL          , NULL, NULL, 0,
           NULL, NULL, NULL}
     };
diff --git a/collectors/ebpf.plugin/ebpf.d.conf b/collectors/ebpf.plugin/ebpf.d.conf
index 4f436790d6..ef6ff8145d 100644
--- a/collectors/ebpf.plugin/ebpf.d.conf
+++ b/collectors/ebpf.plugin/ebpf.d.conf
@@ -33,6 +33,7 @@
 #  `sync`     : Montitor calls for syscall sync(2).             
 [ebpf programs]
     cachestat = no
+    dcstat = no
     process = yes
     socket = yes
     sync = yes
diff --git a/collectors/ebpf.plugin/ebpf.d/dcstat.conf b/collectors/ebpf.plugin/ebpf.d/dcstat.conf
new file mode 100644
index 0000000000..2607b98fdb
--- /dev/null
+++ b/collectors/ebpf.plugin/ebpf.d/dcstat.conf
@@ -0,0 +1,13 @@
+# The `ebpf load mode` option accepts the following values :
+#  `entry` : The eBPF collector only monitors calls for the functions, and does not show charts related to errors.
+#  `return : In the `return` mode, the eBPF collector monitors the same kernel functions as `entry`, but also creates
+#            new charts for the return of these functions, such as errors.
+#
+# The eBPF collector also creates charts for each running application through an integration with the `apps plugin`.
+# If you want to disable the integration with `apps.plugin` along with the above charts, change the setting `apps` to
+# 'no'.
+#
+[global]
+    ebpf load mode = entry
+    apps = yes
+    update every = 2
diff --git a/collectors/ebpf.plugin/ebpf.h b/collectors/ebpf.plugin/ebpf.h
index 59cb1f2359..841701e20f 100644
--- a/collectors/ebpf.plugin/ebpf.h
+++ b/collectors/ebpf.plugin/ebpf.h
@@ -77,7 +77,8 @@ enum ebpf_module_indexes {
     EBPF_MODULE_PROCESS_IDX,
     EBPF_MODULE_SOCKET_IDX,
     EBPF_MODULE_CACHESTAT_IDX,
-    EBPF_MODULE_SYNC_IDX
+    EBPF_MODULE_SYNC_IDX,
+    EBPF_MODULE_DCSTAT_IDX
 };
 
 // Copied from musl header
@@ -91,6 +92,7 @@ enum ebpf_module_indexes {
 
 // Chart definitions
 #define NETDATA_EBPF_FAMILY "ebpf"
+#define NETDATA_FILESYSTEM_FAMILY "filesystem"
 #define NETDATA_EBPF_CHART_TYPE_LINE "line"
 #define NETDATA_EBPF_CHART_TYPE_STACKED "stacked"
 #define NETDATA_EBPF_MEMORY_GROUP "mem"
@@ -196,6 +198,7 @@ extern void ebpf_cleanup_publish_syscall(netdata_publish_syscall_t *nps);
 #define EBPF_COMMON_DIMENSION_BYTES "bytes/s"
 #define EBPF_COMMON_DIMENSION_DIFFERENCE "difference"
 #define EBPF_COMMON_DIMENSION_PACKETS "packets"
+#define EBPF_COMMON_DIMENSION_FILES "files"
 
 // Common variables
 extern int debug_enabled;
diff --git a/collectors/ebpf.plugin/ebpf_apps.c b/collectors/ebpf.plugin/ebpf_apps.c
index 8c9362479d..6459bad0d3 100644
--- a/collectors/ebpf.plugin/ebpf_apps.c
+++ b/collectors/ebpf.plugin/ebpf_apps.c
@@ -927,6 +927,12 @@ void cleanup_variables_from_other_threads(uint32_t pid)
         freez(cachestat_pid[pid]);
         cachestat_pid[pid] = NULL;
     }
+
+    // Clean directory cache structure
+    if (dcstat_pid) {
+        freez(dcstat_pid[pid]);
+        dcstat_pid[pid] = NULL;
+    }
 }
 
 /**
diff --git a/collectors/ebpf.plugin/ebpf_apps.h b/collectors/ebpf.plugin/ebpf_apps.h
index 495891ff54..edcdef6057 100644
--- a/collectors/ebpf.plugin/ebpf_apps.h
+++ b/collectors/ebpf.plugin/ebpf_apps.h
@@ -16,8 +16,10 @@
 #define NETDATA_APPS_PROCESS_GROUP "process (eBPF)"
 #define NETDATA_APPS_NET_GROUP "net (eBPF)"
 #define NETDATA_APPS_CACHESTAT_GROUP "page cache (eBPF)"
+#define NETDATA_APPS_DCSTAT_GROUP "directory cache (eBPF)"
 
 #include "ebpf_process.h"
+#include "ebpf_dcstat.h"
 #include "ebpf_cachestat.h"
 #include "ebpf_sync.h"
 
@@ -108,8 +110,9 @@ struct target {
     uid_t uid;
     gid_t gid;
 
-    // Page cache statistic per process
+    // Changes made to simplify integration between apps and eBPF.
     netdata_publish_cachestat_t cachestat;
+    netdata_publish_dcstat_t dcstat;
 
     /* These variables are not necessary for eBPF collector
     kernel_uint_t minflt;
@@ -435,5 +438,6 @@ extern void clean_global_memory();
 extern ebpf_process_stat_t **global_process_stats;
 extern ebpf_process_publish_apps_t **current_apps_data;
 extern netdata_publish_cachestat_t **cachestat_pid;
+extern netdata_publish_dcstat_t **dcstat_pid;
 
 #endif /* NETDATA_EBPF_APPS_H */
diff --git a/collectors/ebpf.plugin/ebpf_dcstat.c b/collectors/ebpf.plugin/ebpf_dcstat.c
new file mode 100644
index 0000000000..01fd979723
--- /dev/null
+++ b/collectors/ebpf.plugin/ebpf_dcstat.c
@@ -0,0 +1,603 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "ebpf.h"
+#include "ebpf_dcstat.h"
+
+static char *dcstat_counter_dimension_name[NETDATA_DCSTAT_IDX_END] = { "ratio", "reference", "slow", "miss" };
+static netdata_syscall_stat_t dcstat_counter_aggregated_data[NETDATA_DCSTAT_IDX_END];
+static netdata_publish_syscall_t dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_END];
+
+static ebpf_data_t dcstat_data;
+
+netdata_dcstat_pid_t *dcstat_vector = NULL;
+netdata_publish_dcstat_t **dcstat_pid = NULL;
+
+static struct bpf_link **probe_links = NULL;
+static struct bpf_object *objects = NULL;
+
+static int *map_fd = NULL;
+static netdata_idx_t dcstat_hash_values[NETDATA_DCSTAT_IDX_END];
+
+static int read_thread_closed = 1;
+
+struct config dcstat_config = { .first_section = NULL,
+    .last_section = NULL,
+    .mutex = NETDATA_MUTEX_INITIALIZER,
+    .index = { .avl_tree = { .root = NULL, .compar = appconfig_section_compare },
+        .rwlock = AVL_LOCK_INITIALIZER } };
+
+struct netdata_static_thread dcstat_threads = {"DCSTAT KERNEL",
+                                               NULL, NULL, 1, NULL,
+                                               NULL,  NULL};
+
+static ebpf_local_maps_t dcstat_maps[] = {{.name = "dcstat_pid", .internal_input = ND_EBPF_DEFAULT_PID_SIZE,
+                                           .user_input = 0},
+                                          {.name = NULL, .internal_input = 0, .user_input = 0}};
+
+static ebpf_specify_name_t dc_optional_name[] = { {.program_name = "netdata_lookup_fast",
+                                                   .function_to_attach = "lookup_fast",
+                                                   .optional = NULL,
+                                                   .retprobe = CONFIG_BOOLEAN_NO},
+                                                  {.program_name = NULL}};
+
+/*****************************************************************
+ *
+ *  COMMON FUNCTIONS
+ *
+ *****************************************************************/
+
+/**
+ * Update publish
+ *
+ * Update publish values before to write dimension.
+ *
+ * @param out           strcuture that will receive data.
+ * @param cache_access  number of access to directory cache.
+ * @param not_found     number of files not found on the file system
+ */
+void dcstat_update_publish(netdata_publish_dcstat_t *out, uint64_t cache_access, uint64_t not_found)
+{
+    calculated_number successful_access = (calculated_number) (((long long)cache_access) - ((long long)not_found));
+    calculated_number ratio = (cache_access) ? successful_access/(calculated_number)cache_access : 0;
+
+    out->ratio = (long long )(ratio*100);
+}
+
+/*****************************************************************
+ *
+ *  FUNCTIONS TO CLOSE THE THREAD
+ *
+ *****************************************************************/
+
+/**
+ * Clean PID structures
+ *
+ * Clean the allocated structures.
+ */
+void clean_dcstat_pid_structures() {
+    struct pid_stat *pids = root_of_pids;
+    while (pids) {
+        freez(dcstat_pid[pids->pid]);
+
+        pids = pids->next;
+    }
+}
+
+/**
+ *  Clean names
+ *
+ *  Clean the optional names allocated during startup.
+ */
+void ebpf_dcstat_clean_names()
+{
+    size_t i = 0;
+    while (dc_optional_name[i].program_name) {
+        freez(dc_optional_name[i].optional);
+        i++;
+    }
+}
+
+/**
+ * Clean up the main thread.
+ *
+ * @param ptr thread data.
+ */
+static void ebpf_dcstat_cleanup(void *ptr)
+{
+    ebpf_module_t *em = (ebpf_module_t *)ptr;
+    if (!em->enabled)
+        return;
+
+    heartbeat_t hb;
+    heartbeat_init(&hb);
+    uint32_t tick = 2 * USEC_PER_MS;
+    while (!read_thread_closed) {
+        usec_t dt = heartbeat_next(&hb, tick);
+        UNUSED(dt);
+    }
+
+    freez(dcstat_vector);
+
+    ebpf_cleanup_publish_syscall(dcstat_counter_publish_aggregated);
+
+    ebpf_dcstat_clean_names();
+
+    struct bpf_program *prog;
+    size_t i = 0 ;
+    bpf_object__for_each_program(prog, objects) {
+        bpf_link__destroy(probe_links[i]);
+        i++;
+    }
+    bpf_object__close(objects);
+}
+
+/*****************************************************************
+ *
+ *  APPS
+ *
+ *****************************************************************/
+
+/**
+ * Create apps charts
+ *
+ * Call ebpf_create_chart to create the charts on apps submenu.
+ *
+ * @param em a pointer to the structure with the default values.
+ */
+void ebpf_dcstat_create_apps_charts(struct ebpf_module *em, void *ptr)
+{
+    UNUSED(em);
+    struct target *root = ptr;
+    ebpf_create_charts_on_apps(NETDATA_DC_HIT_CHART,
+                               "Percentage of files listed inside directory cache",
+                               EBPF_COMMON_DIMENSION_PERCENTAGE,
+                               NETDATA_APPS_DCSTAT_GROUP,
+                               NETDATA_EBPF_CHART_TYPE_LINE,
+                               20100,
+                               ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
+                               root);
+
+    ebpf_create_charts_on_apps(NETDATA_DC_REFERENCE_CHART,
+                               "Count file access.",
+                               EBPF_COMMON_DIMENSION_FILES,
+                               NETDATA_APPS_DCSTAT_GROUP,
+                               NETDATA_EBPF_CHART_TYPE_STACKED,
+                               20101,
+                               ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
+                               root);
+
+    ebpf_create_charts_on_apps(NETDATA_DC_REQUEST_NOT_CACHE_CHART,
+                               "Access to files that were not present inside directory cache.",
+                               EBPF_COMMON_DIMENSION_FILES,
+                               NETDATA_APPS_DCSTAT_GROUP,
+                               NETDATA_EBPF_CHART_TYPE_STACKED,
+                               20102,
+                               ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
+                               root);
+
+    ebpf_create_charts_on_apps(NETDATA_DC_REQUEST_NOT_FOUND_CHART,
+                               "Number of requests for files that were not found on filesystem.",
+                               EBPF_COMMON_DIMENSION_FILES,
+                               NETDATA_APPS_DCSTAT_GROUP,
+                               NETDATA_EBPF_CHART_TYPE_STACKED,
+                               20103,
+                               ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
+                               root);
+}
+
+/*****************************************************************
+ *
+ *  MAIN LOOP
+ *
+ *****************************************************************/
+
+/**
+ * Apps Accumulator
+ *
+ * Sum all values read from kernel and store in the first address.
+ *
+ * @param out the vector with read values.
+ */
+static void dcstat_apps_accumulator(netdata_dcstat_pid_t *out)
+{
+    int i, end = (running_on_kernel >= NETDATA_KERNEL_V4_15) ? ebpf_nprocs : 1;
+    netdata_dcstat_pid_t *total = &out[0];
+    for (i = 1; i < end; i++) {
+        netdata_dcstat_pid_t *w = &out[i];
+        total->cache_access += w->cache_access;
+        total->file_system += w->file_system;
+        total->not_found += w->not_found;
+    }
+}
+
+/**
+ * Save PID values
+ *
+ * Save the current values inside the structure
+ *
+ * @param out     vector used to plot charts
+ * @param publish vector with values read from hash tables.
+ */
+static inline void dcstat_save_pid_values(netdata_publish_dcstat_t *out, netdata_dcstat_pid_t *publish)
+{
+    memcpy(&out->curr, &publish[0], sizeof(netdata_dcstat_pid_t));
+}
+
+/**
+ * Fill PID
+ *
+ * Fill PID structures
+ *
+ * @param current_pid pid that we are collecting data
+ * @param out         values read from hash tables;
+ */
+static void dcstat_fill_pid(uint32_t current_pid, netdata_dcstat_pid_t *publish)
+{
+    netdata_publish_dcstat_t *curr = dcstat_pid[current_pid];
+    if (!curr) {
+        curr = callocz(1, sizeof(netdata_publish_dcstat_t));
+        dcstat_pid[current_pid] = curr;
+    }
+
+    dcstat_save_pid_values(curr, publish);
+}
+
+/**
+ * Read APPS table
+ *
+ * Read the apps table and store data inside the structure.
+ */
+static void read_apps_table()
+{
+    netdata_dcstat_pid_t *cv = dcstat_vector;
+    uint32_t key;
+    struct pid_stat *pids = root_of_pids;
+    int fd = map_fd[NETDATA_DCSTAT_PID_STATS];
+    size_t length = sizeof(netdata_dcstat_pid_t)*ebpf_nprocs;
+    while (pids) {
+        key = pids->pid;
+
+        if (bpf_map_lookup_elem(fd, &key, cv)) {
+            pids = pids->next;
+            continue;
+        }
+
+        dcstat_apps_accumulator(cv);
+
+        dcstat_fill_pid(key, cv);
+
+        // We are cleaning to avoid passing data read from one process to other.
+        memset(cv, 0, length);
+
+        pids = pids->next;
+    }
+}
+
+/**
+ * Read global table
+ *
+ * Read the table with number of calls for all functions
+ */
+static void read_global_table()
+{
+    uint32_t idx;
+    netdata_idx_t *val = dcstat_hash_values;
+    netdata_idx_t stored;
+    int fd = map_fd[NETDATA_DCSTAT_GLOBAL_STATS];
+
+    for (idx = NETDATA_KEY_DC_REFERENCE; idx < NETDATA_DIRECTORY_CACHE_END; idx++) {
+        if (!bpf_map_lookup_elem(fd, &idx, &stored)) {
+            val[idx] = stored;
+        }
+    }
+}
+
+/**
+ * DCstat read hash
+ *
+ * This is the thread callback.
+ * This thread is necessary, because we cannot freeze the whole plugin to read the data.
+ *
+ * @param ptr It is a NULL value for this thread.
+ *
+ * @return It always returns NULL.
+ */
+void *ebpf_dcstat_read_hash(void *ptr)
+{
+    read_thread_closed = 0;
+
+    heartbeat_t hb;
+    heartbeat_init(&hb);
+
+    ebpf_module_t *em = (ebpf_module_t *)ptr;
+
+    usec_t step = NETDATA_LATENCY_DCSTAT_SLEEP_MS * em->update_time;
+    while (!close_ebpf_plugin) {
+        usec_t dt = heartbeat_next(&hb, step);
+        (void)dt;
+
+        read_global_table();
+    }
+    read_thread_closed = 1;
+
+    return NULL;
+}
+
+/**
+ * Cachestat sum PIDs
+ *
+ * Sum values for all PIDs associated to a group
+ *
+ * @param publish  output structure.
+ * @param root     structure with listed IPs
+ */
+void ebpf_dcstat_sum_pids(netdata_publish_dcstat_t *publish, struct pid_on_target *root)
+{
+    memset(&publish->curr, 0, sizeof(netdata_dcstat_pid_t));
+    netdata_dcstat_pid_t *dst = &publish->curr;
+    while (root) {
+        int32_t pid = root->pid;
+        netdata_publish_dcstat_t *w = dcstat_pid[pid];
+        if (w) {
+            netdata_dcstat_pid_t *src = &w->curr;
+            dst->cache_access += src->cache_access;
+            dst->file_system += src->file_system;
+            dst->not_found += src->not_found;
+        }
+
+        root = root->next;
+    }
+}
+
+/**
+ * Send data to Netdata calling auxiliar functions.
+ *
+ * @param root the target list.
+*/
+void ebpf_dcache_send_apps_data(struct target *root)
+{
+    struct target *w;
+    collected_number value;
+
+    write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_DC_HIT_CHART);
+    for (w = root; w; w = w->next) {
+        if (unlikely(w->exposed && w->processes)) {
+            ebpf_dcstat_sum_pids(&w->dcstat, w->root_pid);
+
+            uint64_t cache = w->dcstat.curr.cache_access;
+            uint64_t not_found = w->dcstat.curr.not_found;
+
+            dcstat_update_publish(&w->dcstat, cache, not_found);
+            value = (collected_number) w->dcstat.ratio;
+            write_chart_dimension(w->name, value);
+        }
+    }
+    write_end_chart();
+
+    write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_DC_REFERENCE_CHART);
+    for (w = root; w; w = w->next) {
+        if (unlikely(w->exposed && w->processes)) {
+            if (w->dcstat.curr.cache_access < w->dcstat.prev.cache_access) {
+                w->dcstat.prev.cache_access = 0;
+            }
+
+            w->dcstat.cache_access = (long long)w->dcstat.curr.cache_access - (long long)w->dcstat.prev.cache_access;
+            value = (collected_number) w->dcstat.cache_access;
+            write_chart_dimension(w->name, value);
+            w->dcstat.prev.cache_access = w->dcstat.curr.cache_access;
+        }
+    }
+    write_end_chart();
+
+    write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_DC_REQUEST_NOT_CACHE_CHART);
+    for (w = root; w; w = w->next) {
+        if (unlikely(w->exposed && w->processes)) {
+            if (w->dcstat.curr.file_system < w->dcstat.prev.file_system) {
+                w->dcstat.prev.file_system = 0;
+            }
+
+            value = (collected_number) (!w->dcstat.cache_access) ? 0 :
+                    (long long )w->dcstat.curr.file_system - (long long)w->dcstat.prev.file_system;
+            write_chart_dimension(w->name, value);
+            w->dcstat.prev.file_system = w->dcstat.curr.file_system;
+        }
+    }
+    write_end_chart();
+
+    write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_DC_REQUEST_NOT_FOUND_CHART);
+    for (w = root; w; w = w->next) {
+        if (unlikely(w->exposed && w->processes)) {
+            if (w->dcstat.curr.not_found < w->dcstat.prev.not_found) {
+                w->dcstat.prev.not_found = 0;
+            }
+            value = (collected_number) (!w->dcstat.cache_access) ? 0 :
+                    (long long)w->dcstat.curr.not_found - (long long)w->dcstat.prev.not_found;
+            write_chart_dimension(w->name, value);
+            w->dcstat.prev.not_found = w->dcstat.curr.not_found;
+        }
+    }
+    write_end_chart();
+}
+
+/**
+ * Send global
+ *
+ * Send global charts to Netdata
+ */
+static void dcstat_send_global(netdata_publish_dcstat_t *publish)
+{
+    dcstat_update_publish(publish, dcstat_hash_values[NETDATA_KEY_DC_REFERENCE],
+                          dcstat_hash_values[NETDATA_KEY_DC_MISS]);
+
+    netdata_publish_syscall_t *ptr = dcstat_counter_publish_aggregated;
+    netdata_idx_t value = dcstat_hash_values[NETDATA_KEY_DC_REFERENCE];
+    if (value != ptr[NETDATA_DCSTAT_IDX_REFERENCE].pcall) {
+        ptr[NETDATA_DCSTAT_IDX_REFERENCE].ncall = value - ptr[NETDATA_DCSTAT_IDX_REFERENCE].pcall;
+        ptr[NETDATA_DCSTAT_IDX_REFERENCE].pcall = value;
+
+        value = dcstat_hash_values[NETDATA_KEY_DC_SLOW];
+        ptr[NETDATA_DCSTAT_IDX_SLOW].ncall =  value - ptr[NETDATA_DCSTAT_IDX_SLOW].pcall;
+        ptr[NETDATA_DCSTAT_IDX_SLOW].pcall = value;
+
+        value = dcstat_hash_values[NETDATA_KEY_DC_MISS];
+        ptr[NETDATA_DCSTAT_IDX_MISS].ncall = value - ptr[NETDATA_DCSTAT_IDX_MISS].pcall;
+        ptr[NETDATA_DCSTAT_IDX_MISS].pcall = value;
+    } else {
+        ptr[NETDATA_DCSTAT_IDX_REFERENCE].ncall = 0;
+        ptr[NETDATA_DCSTAT_IDX_SLOW].ncall = 0;
+        ptr[NETDATA_DCSTAT_IDX_MISS].ncall = 0;
+    }
+
+    ebpf_one_dimension_write_charts(NETDATA_FILESYSTEM_FAMILY, NETDATA_DC_HIT_CHART,
+                                    ptr[NETDATA_DCSTAT_IDX_RATIO].dimension, publish->ratio);
+
+    write_count_chart(
+        NETDATA_DC_REFERENCE_CHART, NETDATA_FILESYSTEM_FAMILY,
+                      &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE], 3);
+}
+
+/**
+* Main loop for this collector.
+*/
+static void dcstat_collector(ebpf_module_t *em)
+{
+    dcstat_threads.thread = mallocz(sizeof(netdata_thread_t));
+    dcstat_threads.start_routine = ebpf_dcstat_read_hash;
+
+    map_fd = dcstat_data.map_fd;
+
+    netdata_thread_create(dcstat_threads.thread, dcstat_threads.name, NETDATA_THREAD_OPTION_JOINABLE,
+                          ebpf_dcstat_read_hash, em);
+
+    netdata_publish_dcstat_t publish;
+    memset(&publish, 0, sizeof(publish));
+    int apps = em->apps_charts;
+    while (!close_ebpf_plugin) {
+        pthread_mutex_lock(&collect_data_mutex);
+        pthread_cond_wait(&collect_data_cond_var, &collect_data_mutex);
+
+        if (apps)
+            read_apps_table();
+
+        pthread_mutex_lock(&lock);
+
+        dcstat_send_global(&publish);
+
+        if (apps)
+            ebpf_dcache_send_apps_data(apps_groups_root_target);
+
+        pthread_mutex_unlock(&lock);
+        pthread_mutex_unlock(&collect_data_mutex);
+    }
+}
+
+/*****************************************************************
+ *
+ *  INITIALIZE THREAD
+ *
+ *****************************************************************/
+
+/**
+ * Create filesystem charts
+ *
+ * Call ebpf_create_chart to create the charts for the collector.
+ */
+static void ebpf_create_filesystem_charts()
+{
+    ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY, NETDATA_DC_HIT_CHART,
+                      "Percentage of files listed inside directory cache",
+                      EBPF_COMMON_DIMENSION_PERCENTAGE, NETDATA_DIRECTORY_FILESYSTEM_SUBMENU,
+                      NULL,
+                      NETDATA_EBPF_CHART_TYPE_LINE,
+                      21200,
+                      ebpf_create_global_dimension,
+                      dcstat_counter_publish_aggregated, 1);
+
+    ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY, NETDATA_DC_REFERENCE_CHART,
+                      "Variables used to calculate hit ratio.",
+                      EBPF_COMMON_DIMENSION_FILES, NETDATA_DIRECTORY_FILESYSTEM_SUBMENU,
+                      NULL,
+                      NETDATA_EBPF_CHART_TYPE_LINE,
+                      21201,
+                      ebpf_create_global_dimension,
+                      &dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE], 3);
+
+    fflush(stdout);
+}
+
+/**
+ * Allocate vectors used with this thread.
+ *
+ * We are not testing the return, because callocz does this and shutdown the software
+ * case it was not possible to allocate.
+ *
+ * @param length is the length for the vectors used inside the collector.
+ */
+static void ebpf_dcstat_allocate_global_vectors(size_t length)
+{
+    dcstat_pid = callocz((size_t)pid_max, sizeof(netdata_publish_dcstat_t *));
+    dcstat_vector = callocz((size_t)ebpf_nprocs, sizeof(netdata_dcstat_pid_t));
+
+    memset(dcstat_counter_aggregated_data, 0, length*sizeof(netdata_syscall_stat_t));
+    memset(dcstat_counter_publish_aggregated, 0, length*sizeof(netdata_publish_syscall_t));
+}
+
+/*****************************************************************
+ *
+ *  MAIN THREAD
+ *
+ *****************************************************************/
+
+/**
+ * Directory Cache thread
+ *
+ * Thread used to make dcstat thread
+ *
+ * @param ptr a pointer to `struct ebpf_module`
+ *
+ * @return It always returns NULL
+ */
+void *ebpf_dcstat_thread(void *ptr)
+{
+    netdata_thread_cleanup_push(ebpf_dcstat_cleanup, ptr);
+
+    ebpf_module_t *em = (ebpf_module_t *)ptr;
+    em->maps = dcstat_maps;
+    fill_ebpf_data(&dcstat_data);
+
+    ebpf_update_module(em, &dcstat_config, NETDATA_DIRECTORY_DCSTAT_CONFIG_FILE);
+    ebpf_update_pid_table(&dcstat_maps[0], em);
+
+    ebpf_update_names(dc_optional_name, em);
+
+    if (!em->enabled)
+        goto enddcstat;
+
+    ebpf_dcstat_allocate_global_vectors(NETDATA_DCSTAT_IDX_END);
+
+    pthread_mutex_lock(&lock);
+
+    probe_links = ebpf_load_program(ebpf_plugin_dir, em, kernel_string, &objects, dcstat_data.map_fd);
+    if (!probe_links) {
+        pthread_mutex_unlock(&lock);
+        goto enddcstat;
+    }
+
+    int algorithms[NETDATA_DCSTAT_IDX_END] = {
+        NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX, NETDATA_EBPF_ABSOLUTE_IDX,
+        NETDATA_EBPF_ABSOLUTE_IDX
+    };
+
+    ebpf_global_labels(dcstat_counter_aggregated_data, dcstat_counter_publish_aggregated,
+                       dcstat_counter_dimension_name, dcstat_counter_dimension_name,
+                       algorithms, NETDATA_DCSTAT_IDX_END);
+
+    ebpf_create_filesystem_charts();
+    pthread_mutex_unlock(&lock);
+
+    dcstat_collector(em);
+
+enddcstat:
+    netdata_thread_cleanup_pop(1);
+    return NULL;
+}
diff --git a/collectors/ebpf.plugin/ebpf_dcstat.h b/collectors/ebpf.plugin/ebpf_dcstat.h
new file mode 100644
index 0000000000..ad4bd1992f
--- /dev/null
+++ b/collectors/ebpf.plugin/ebpf_dcstat.h
@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef NETDATA_EBPF_DCSTAT_H
+#define NETDATA_EBPF_DCSTAT_H 1
+
+
+// charts
+#define NETDATA_DC_HIT_CHART "dc_hit_ratio"
+#define NETDATA_DC_REFERENCE_CHART "dc_reference"
+#define NETDATA_DC_REQUEST_NOT_CACHE_CHART "dc_not_cache"
+#define NETDATA_DC_REQUEST_NOT_FOUND_CHART "dc_not_found"
+
+#define NETDATA_DIRECTORY_CACHE_SUBMENU "directory cache (eBPF)"
+#define NETDATA_DIRECTORY_FILESYSTEM_SUBMENU "Directory Cache (eBPF)"
+
+// configuration file
+#define NETDATA_DIRECTORY_DCSTAT_CONFIG_FILE "dcstat.conf"
+
+#define NETDATA_LATENCY_DCSTAT_SLEEP_MS 700000ULL
+
+enum directory_cache_indexes {
+    NETDATA_DCSTAT_IDX_RATIO,
+    NETDATA_DCSTAT_IDX_REFERENCE,
+    NETDATA_DCSTAT_IDX_SLOW,
+    NETDATA_DCSTAT_IDX_MISS,
+
+    // Keep this as last and don't skip numbers as it is used as element counter
+    NETDATA_DCSTAT_IDX_END
+};
+
+enum directory_cache_tables {
+    NETDATA_DCSTAT_GLOBAL_STATS,
+    NETDATA_DCSTAT_PID_STATS
+};
+