#ifdef HAVE_CONFIG_H

#include <config.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/time.h>

#include <sys/wait.h>

#include <sys/stat.h>

#include <sys/resource.h>

#include <sys/stat.h>

#include <errno.h>

#include <stdarg.h>

#include <locale.h>

#include <ctype.h>

#include <fcntl.h>

#include <malloc.h>

#include <dirent.h>

#include <arpa/inet.h>

#include <sys/types.h>

#include <pwd.h>

#include <grp.h>

#include "avl.h"

#include "common.h"

#include "log.h"

#include "procfile.h"

#include "../config.h"

#ifdef NETDATA_INTERNAL_CHECKS

#include <sys/prctl.h>

#define MAX_COMPARE_NAME 100

#define MAX_NAME 100

#define MAX_CMDLINE 1024

long processors = 1;

long pid_max = 32768;

int debug = 0;

int update_every = 1;

unsigned long long file_counter = 0;

int proc_pid_cmdline_is_needed = 0;

char *host_prefix = "";

char *config_dir = CONFIG_DIR;

#ifdef NETDATA_INTERNAL_CHECKS

struct allocations {

} allocations = { 0, 0, 0 };

#define MALLOC_MARK (uint32_t)(0x0BADCAFE)

#define MALLOC_PREFIX (sizeof(uint32_t) * 2)

#define MALLOC_SUFFIX (sizeof(uint32_t))

#define MALLOC_OVERHEAD (MALLOC_PREFIX + MALLOC_SUFFIX)

void *mark_allocation(void *allocated_ptr, size_t size_without_overheads) {

uint32_t *real_ptr = (uint32_t *)allocated_ptr;

real_ptr[0] = MALLOC_MARK;

real_ptr[1] = (uint32_t) size_without_overheads;

uint32_t *end_ptr = (uint32_t *)(allocated_ptr + MALLOC_PREFIX + size_without_overheads);

end_ptr[0] = MALLOC_MARK;

// fprintf(stderr, "MEMORY_POINTER: Allocated at %p, returning %p.\n", allocated_ptr, (void *)(allocated_ptr + MALLOC_PREFIX));

return allocated_ptr + MALLOC_PREFIX;

}

void *check_allocation(const char *file, int line, const char *function, void *marked_ptr, size_t *size_without_overheads_ptr) {

uint32_t *real_ptr = (uint32_t *)(marked_ptr - MALLOC_PREFIX);

// fprintf(stderr, "MEMORY_POINTER: Checking pointer at %p, real %p for %s/%u@%s.\n", marked_ptr, (void *)(marked_ptr - MALLOC_PREFIX), function, line, file);

if(real_ptr[0] != MALLOC_MARK) fatal("MEMORY: prefix MARK is not valid for %s/%u@%s.", function, line, file);

size_t size = real_ptr[1];

uint32_t *end_ptr = (uint32_t *)(marked_ptr + size);

if(end_ptr[0] != MALLOC_MARK) fatal("MEMORY: suffix MARK of allocation with size %zu is not valid for %s/%u@%s.", size, function, line, file);

if(size_without_overheads_ptr) *size_without_overheads_ptr = size;

return real_ptr;

}

void *malloc_debug(const char *file, int line, const char *function, size_t size) {

void *ptr = malloc(size + MALLOC_OVERHEAD);

if(!ptr) fatal("MEMORY: Cannot allocate %zu bytes for %s/%u@%s.", size, function, line, file);

allocations.allocated += size;

allocations.allocations++;

debug(D_MEMORY, "MEMORY: Allocated %zu bytes for %s/%u@%s."

" Status: allocated %zu in %zu allocs."

, size

, function, line, file

, allocations.allocated

, allocations.allocations

);

if(allocations.allocated > allocations.allocated_max) {

debug(D_MEMORY, "MEMORY: total allocation peak increased from %zu to %zu", allocations.allocated_max, allocations.allocated);

allocations.allocated_max = allocations.allocated;

}

size_t csize;

check_allocation(file, line, function, mark_allocation(ptr, size), &csize);

if(size != csize) {

fatal("Invalid size.");

}

return mark_allocation(ptr, size);

}

void *calloc_debug(const char *file, int line, const char *function, size_t nmemb, size_t size) {

void *ptr = malloc_debug(file, line, function, (nmemb * size));

bzero(ptr, nmemb * size);

return ptr;

}

void free_debug(const char *file, int line, const char *function, void *ptr) {

size_t size;

void *real_ptr = check_allocation(file, line, function, ptr, &size);

bzero(real_ptr, size + MALLOC_OVERHEAD);

free(real_ptr);

allocations.allocated -= size;

allocations.allocations--;

debug(D_MEMORY, "MEMORY: freed %zu bytes for %s/%u@%s."

" Status: allocated %zu in %zu allocs."

, size

, function, line, file

, allocations.allocated

, allocations.allocations

);

}

void *realloc_debug(const char *file, int line, const char *function, void *ptr, size_t size) {

if(!ptr) return malloc_debug(file, line, function, size);

if(!size) { free_debug(file, line, function, ptr); return NULL; }

size_t old_size;

void *real_ptr = check_allocation(file, line, function, ptr, &old_size);

void *new_ptr = realloc(real_ptr, size + MALLOC_OVERHEAD);

if(!new_ptr) fatal("MEMORY: Cannot allocate %zu bytes for %s/%u@%s.", size, function, line, file);

allocations.allocated += size;

allocations.allocated -= old_size;

debug(D_MEMORY, "MEMORY: Re-allocated from %zu to %zu bytes for %s/%u@%s."

" Status: allocated %z in %zu allocs."

, old_size, size

, function, line, file

, allocations.allocated

, allocations.allocations

);

if(allocations.allocated > allocations.allocated_max) {

debug(D_MEMORY, "MEMORY: total allocation peak increased from %zu to %zu", allocations.allocated_max, allocations.allocated);

allocations.allocated_max = allocations.allocated;

}

return mark_allocation(new_ptr, size);

}

char *strdup_debug(const char *file, int line, const char *function, const char *ptr) {

size_t size = 0;

const char *s = ptr;

while(*s++) size++;

size++;

char *p = malloc_debug(file, line, function, size);

if(!p) fatal("Cannot allocate %zu bytes.", size);

memcpy(p, ptr, size);

return p;

}

#define malloc(size) malloc_debug(__FILE__, __LINE__, __FUNCTION__, (size))

#define calloc(nmemb, size) calloc_debug(__FILE__, __LINE__, __FUNCTION__, (nmemb), (size))

#define realloc(ptr, size) realloc_debug(__FILE__, __LINE__, __FUNCTION__, (ptr), (size))

#define free(ptr) free_debug(__FILE__, __LINE__, __FUNCTION__, (ptr))

#ifdef strdup

#undef strdup

#define strdup(ptr) strdup_debug(__FILE__, __LINE__, __FUNCTION__, (ptr))

#endif /* NETDATA_INTERNAL_CHECKS */

long get_system_cpus(void) {

procfile *ff = NULL;

int processors = 0;

char filename[FILENAME_MAX + 1];

snprintfz(filename, FILENAME_MAX, "%s/proc/stat", host_prefix);

ff = procfile_open(filename, NULL, PROCFILE_FLAG_DEFAULT);

if(!ff) return 1;

ff = procfile_readall(ff);

if(!ff) {

procfile_close(ff);

return 1;

}

unsigned int i;

for(i = 0; i < procfile_lines(ff); i++) {

if(!procfile_linewords(ff, i)) continue;

if(strncmp(procfile_lineword(ff, i, 0), "cpu", 3) == 0) processors++;

}

processors--;

if(processors < 1) processors = 1;

procfile_close(ff);

return processors;

}

long get_system_pid_max(void) {

procfile *ff = NULL;

long mpid = 32768;

char filename[FILENAME_MAX + 1];

snprintfz(filename, FILENAME_MAX, "%s/proc/sys/kernel/pid_max", host_prefix);

ff = procfile_open(filename, NULL, PROCFILE_FLAG_DEFAULT);

if(!ff) return mpid;

ff = procfile_readall(ff);

if(!ff) {

procfile_close(ff);

return mpid;

}

mpid = atol(procfile_lineword(ff, 0, 0));

if(!mpid) mpid = 32768;

procfile_close(ff);

return mpid;

}

struct target {

};

struct target *apps_groups_root_target = NULL;

struct target *apps_groups_default_target = NULL;

long apps_groups_targets = 0;

struct target *users_root_target = NULL;

struct target *groups_root_target = NULL;

struct target *get_users_target(uid_t uid)

{

struct target *w;

for(w = users_root_target ; w ; w = w->next)

if(w->uid == uid) return w;

w = calloc(sizeof(struct target), 1);

if(unlikely(!w)) {

error("Cannot allocate %lu bytes of memory", (unsigned long)sizeof(struct target));

return NULL;

}

snprintfz(w->compare, MAX_COMPARE_NAME, "%d", uid);

w->comparehash = simple_hash(w->compare);

w->comparelen = strlen(w->compare);

snprintfz(w->id, MAX_NAME, "%d", uid);

w->idhash = simple_hash(w->id);

struct passwd *pw = getpwuid(uid);

if(!pw)

snprintfz(w->name, MAX_NAME, "%d", uid);

else

snprintfz(w->name, MAX_NAME, "%s", pw->pw_name);

netdata_fix_chart_name(w->name);

w->uid = uid;

w->next = users_root_target;

users_root_target = w;

if(unlikely(debug))

fprintf(stderr, "apps.plugin: added uid %d ('%s') target\n", w->uid, w->name);

return w;

}

struct target *get_groups_target(gid_t gid)

{

struct target *w;

for(w = groups_root_target ; w ; w = w->next)

if(w->gid == gid) return w;

w = calloc(sizeof(struct target), 1);

if(unlikely(!w)) {

error("Cannot allocate %lu bytes of memory", (unsigned long)sizeof(struct target));

return NULL;

}

snprintfz(w->compare, MAX_COMPARE_NAME, "%d", gid);

w->comparehash = simple_hash(w->compare);

w->comparelen = strlen(w->compare);

snprintfz(w->id, MAX_NAME, "%d", gid);

w->idhash = simple_hash(w->id);

struct group *gr = getgrgid(gid);

if(!gr)

snprintfz(w->name, MAX_NAME, "%d", gid);

else

snprintfz(w->name, MAX_NAME, "%s", gr->gr_name);

netdata_fix_chart_name(w->name);

w->gid = gid;

w->next = groups_root_target;

groups_root_target = w;

if(unlikely(debug))

fprintf(stderr, "apps.plugin: added gid %d ('%s') target\n", w->gid, w->name);

return w;

}

struct target *get_apps_groups_target(const char *id, struct target *target)

{

int tdebug = 0, thidden = 0, ends_with = 0;

const char *nid = id;

while(nid[0] == '-' || nid[0] == '+' || nid[0] == '*') {

if(nid[0] == '-') thidden = 1;

if(nid[0] == '+') tdebug = 1;

if(nid[0] == '*') ends_with = 1;

nid++;

}

uint32_t hash = simple_hash(id);

struct target *w;

for(w = apps_groups_root_target ; w ; w = w->next) {

if(w->idhash == hash && strncmp(nid, w->id, MAX_NAME) == 0)

return w;

}

w = calloc(sizeof(struct target), 1);

if(unlikely(!w)) {

error("Cannot allocate %lu bytes of memory", (unsigned long)sizeof(struct target));

return NULL;

}

strncpyz(w->id, nid, MAX_NAME);

w->idhash = simple_hash(w->id);

strncpyz(w->name, nid, MAX_NAME);

strncpyz(w->compare, nid, MAX_COMPARE_NAME);

int len = strlen(w->compare);

if(w->compare[len - 1] == '*') {

w->compare[len - 1] = '\0';

w->starts_with = 1;

}

w->ends_with = ends_with;

if(w->starts_with && w->ends_with)

proc_pid_cmdline_is_needed = 1;

w->comparehash = simple_hash(w->compare);

w->comparelen = strlen(w->compare);

w->hidden = thidden;

w->debug = tdebug;

w->target = target;

w->next = apps_groups_root_target;

apps_groups_root_target = w;

if(unlikely(debug))

fprintf(stderr, "apps.plugin: ADDING TARGET ID '%s', process name '%s' (%s), aggregated on target '%s', options: %s %s\n"

, w->id

, w->compare, (w->starts_with && w->ends_with)?"substring":((w->starts_with)?"prefix":((w->ends_with)?"suffix":"exact"))

, w->target?w->target->id:w->id

, (w->hidden)?"hidden":"-"

, (w->debug)?"debug":"-"

);

return w;

}

int read_apps_groups_conf(const char *name)

{

char filename[FILENAME_MAX + 1];

snprintfz(filename, FILENAME_MAX, "%s/apps_%s.conf", config_dir, name);

if(unlikely(debug))

fprintf(stderr, "apps.plugin: process groups file: '%s'\n", filename);

// ----------------------------------------

procfile *ff = procfile_open(filename, " :\t", PROCFILE_FLAG_DEFAULT);

if(!ff) return 1;

procfile_set_quotes(ff, "'\"");

ff = procfile_readall(ff);

if(!ff) {

procfile_close(ff);

return 1;

}

unsigned long line, lines = procfile_lines(ff);

for(line = 0; line < lines ;line++) {

unsigned long word, words = procfile_linewords(ff, line);

struct target *w = NULL;

char *t = procfile_lineword(ff, line, 0);

if(!t || !*t) continue;

for(word = 0; word < words ;word++) {

char *s = procfile_lineword(ff, line, word);

if(!s || !*s) continue;

if(*s == '#') break;

if(t == s) continue;

struct target *n = get_apps_groups_target(s, w);

if(!n) {

error("Cannot create target '%s' (line %d, word %d)", s, line, word);

continue;

}

if(!w) w = n;

}

if(w) {

int tdebug = 0, thidden = 0;

while(t[0] == '-' || t[0] == '+') {

if(t[0] == '-') thidden = 1;

if(t[0] == '+') tdebug = 1;

t++;

}

strncpyz(w->name, t, MAX_NAME);

w->hidden = thidden;

w->debug = tdebug;

if(unlikely(debug))

fprintf(stderr, "apps.plugin: AGGREGATION TARGET NAME '%s' on ID '%s', process name '%s' (%s), aggregated on target '%s', options: %s %s\n"

, w->name

, w->id

, w->compare, (w->starts_with && w->ends_with)?"substring":((w->starts_with)?"prefix":((w->ends_with)?"suffix":"exact"))

, w->target?w->target->id:w->id

, (w->hidden)?"hidden":"-"

, (w->debug)?"debug":"-"

);

}

}

procfile_close(ff);

apps_groups_default_target = get_apps_groups_target("p+!o@w#e$i^r&7*5(-i)l-o_", NULL); // match nothing

if(!apps_groups_default_target)

error("Cannot create default target");

else

strncpyz(apps_groups_default_target->name, "other", MAX_NAME);

return 0;

}

struct pid_stat {

} *root_of_pids = NULL, **all_pids;

long all_pids_count = 0;

struct pid_stat *get_pid_entry(pid_t pid)

{

if(all_pids[pid]) {

all_pids[pid]->new_entry = 0;

return all_pids[pid];

}

all_pids[pid] = calloc(sizeof(struct pid_stat), 1);

if(!all_pids[pid]) {

error("Cannot allocate %lu bytes of memory", (unsigned long)sizeof(struct pid_stat));

return NULL;

}

all_pids[pid]->fds = calloc(sizeof(int), 100);

if(!all_pids[pid]->fds)

error("Cannot allocate %ld bytes of memory", (unsigned long)(sizeof(int) * 100));

else all_pids[pid]->fds_size = 100;

if(root_of_pids) root_of_pids->prev = all_pids[pid];

all_pids[pid]->next = root_of_pids;

root_of_pids = all_pids[pid];

all_pids[pid]->pid = pid;

all_pids[pid]->new_entry = 1;

return all_pids[pid];

}

void del_pid_entry(pid_t pid)

{

if(!all_pids[pid]) return;

if(debug) fprintf(stderr, "apps.plugin: process %d %s exited, deleting it.\n", pid, all_pids[pid]->comm);

if(root_of_pids == all_pids[pid]) root_of_pids = all_pids[pid]->next;

if(all_pids[pid]->next) all_pids[pid]->next->prev = all_pids[pid]->prev;

if(all_pids[pid]->prev) all_pids[pid]->prev->next = all_pids[pid]->next;

if(all_pids[pid]->fds) free(all_pids[pid]->fds);

free(all_pids[pid]);

all_pids[pid] = NULL;

}

int read_proc_pid_cmdline(struct pid_stat *p) {

char filename[FILENAME_MAX + 1];

snprintfz(filename, FILENAME_MAX, "%s/proc/%d/cmdline", host_prefix, p->pid);

int fd = open(filename, O_RDONLY, 0666);

if(unlikely(fd == -1)) return 1;

int i, bytes = read(fd, p->cmdline, MAX_CMDLINE);

close(fd);

if(bytes <= 0) {

// copy the command to the command line

strncpyz(p->cmdline, p->comm, MAX_CMDLINE);

return 0;

}

p->cmdline[bytes] = '\0';

for(i = 0; i < bytes ; i++)

if(!p->cmdline[i]) p->cmdline[i] = ' ';

if(unlikely(debug))

fprintf(stderr, "Read file '%s' contents: %s\n", filename, p->cmdline);

return 0;

}

int read_proc_pid_ownership(struct pid_stat *p) {

char filename[FILENAME_MAX + 1];

snprintfz(filename, FILENAME_MAX, "%s/proc/%d", host_prefix, p->pid);

// ----------------------------------------

// read uid and gid

struct stat st;

if(stat(filename, &st) != 0)

return 1;

p->uid = st.st_uid;

p->gid = st.st_gid;

return 0;

}

int read_proc_pid_stat(struct pid_stat *p) {

static procfile *ff = NULL;

char filename[FILENAME_MAX + 1];

snprintfz(filename, FILENAME_MAX, "%s/proc/%d/stat", host_prefix, p->pid);

// ----------------------------------------

int set_quotes = (!ff)?1:0;

ff = procfile_reopen(ff, filename, NULL, PROCFILE_FLAG_NO_ERROR_ON_FILE_IO);

if(!ff) return 1;

// if(set_quotes) procfile_set_quotes(ff, "()");

if(set_quotes) procfile_set_open_close(ff, "(", ")");

ff = procfile_readall(ff);

if(!ff) {

// procfile_close(ff);

return 1;

}

file_counter++;

// parse the process name

unsigned int i = 0;

strncpyz(p->comm, procfile_lineword(ff, 0, 1), MAX_COMPARE_NAME);

// p->pid = atol(procfile_lineword(ff, 0, 0+i));

// comm is at 1

// p->state = *(procfile_lineword(ff, 0, 2+i));

p->ppid = (int32_t) atol(procfile_lineword(ff, 0, 3 + i));

// p->pgrp = atol(procfile_lineword(ff, 0, 4+i));

// p->session = atol(procfile_lineword(ff, 0, 5+i));

// p->tty_nr = atol(procfile_lineword(ff, 0, 6+i));

// p->tpgid = atol(procfile_lineword(ff, 0, 7+i));

// p->flags = strtoull(procfile_lineword(ff, 0, 8+i), NULL, 10);

p->minflt = strtoull(procfile_lineword(ff, 0, 9+i), NULL, 10);

p->cminflt = strtoull(procfile_lineword(ff, 0, 10+i), NULL, 10);

p->majflt = strtoull(procfile_lineword(ff, 0, 11+i), NULL, 10);

p->cmajflt = strtoull(procfile_lineword(ff, 0, 12+i), NULL, 10);

p->utime = strtoull(procfile_lineword(ff, 0, 13+i), NULL, 10);

p->stime = strtoull(procfile_lineword(ff, 0, 14+i), NULL, 10);

p->cutime = strtoull(procfile_lineword(ff, 0, 15+i), NULL, 10);

p->cstime = strtoull(procfile_lineword(ff, 0, 16+i), NULL, 10);

// p->priority = strtoull(procfile_lineword(ff, 0, 17+i), NULL, 10);

// p->nice = strtoull(procfile_lineword(ff, 0, 18+i), NULL, 10);

p->num_threads = (int32_t) atol(procfile_lineword(ff, 0, 19 + i));

// p->itrealvalue = strtoull(procfile_lineword(ff, 0, 20+i), NULL, 10);

// p->starttime = strtoull(procfile_lineword(ff, 0, 21+i), NULL, 10);

// p->vsize = strtoull(procfile_lineword(ff, 0, 22+i), NULL, 10);

p->rss = strtoull(procfile_lineword(ff, 0, 23+i), NULL, 10);

// p->rsslim = strtoull(procfile_lineword(ff, 0, 24+i), NULL, 10);

// p->starcode = strtoull(procfile_lineword(ff, 0, 25+i), NULL, 10);

// p->endcode = strtoull(procfile_lineword(ff, 0, 26+i), NULL, 10);

// p->startstack = strtoull(procfile_lineword(ff, 0, 27+i), NULL, 10);

// p->kstkesp = strtoull(procfile_lineword(ff, 0, 28+i), NULL, 10);

// p->kstkeip = strtoull(procfile_lineword(ff, 0, 29+i), NULL, 10);

// p->signal = strtoull(procfile_lineword(ff, 0, 30+i), NULL, 10);

// p->blocked = strtoull(procfile_lineword(ff, 0, 31+i), NULL, 10);

// p->sigignore = strtoull(procfile_lineword(ff, 0, 32+i), NULL, 10);

// p->sigcatch = strtoull(procfile_lineword(ff, 0, 33+i), NULL, 10);

// p->wchan = strtoull(procfile_lineword(ff, 0, 34+i), NULL, 10);

// p->nswap = strtoull(procfile_lineword(ff, 0, 35+i), NULL, 10);

// p->cnswap = strtoull(procfile_lineword(ff, 0, 36+i), NULL, 10);

// p->exit_signal = atol(procfile_lineword(ff, 0, 37+i));

// p->processor = atol(procfile_lineword(ff, 0, 38+i));

// p->rt_priority = strtoul(procfile_lineword(ff, 0, 39+i), NULL, 10);

// p->policy = strtoul(procfile_lineword(ff, 0, 40+i), NULL, 10);

// p->delayacct_blkio_ticks = strtoull(procfile_lineword(ff, 0, 41+i), NULL, 10);

// p->guest_time = strtoull(procfile_lineword(ff, 0, 42+i), NULL, 10);

// p->cguest_time = strtoull(procfile_lineword(ff, 0, 43), NULL, 10);

if(debug || (p->target && p->target->debug))

fprintf(stderr, "apps.plugin: READ PROC/PID/STAT: %s/proc/%d/stat, process: '%s' VALUES: utime=%llu, stime=%llu, cutime=%llu, cstime=%llu, minflt=%llu, majflt=%llu, cminflt=%llu, cmajflt=%llu, threads=%d\n", host_prefix, p->pid, p->comm, p->utime, p->stime, p->cutime, p->cstime, p->minflt, p->majflt, p->cminflt, p->cmajflt, p->num_threads);

// procfile_close(ff);

return 0;

}

int read_proc_pid_statm(struct pid_stat *p) {

static procfile *ff = NULL;

char filename[FILENAME_MAX + 1];

snprintfz(filename, FILENAME_MAX, "%s/proc/%d/statm", host_prefix, p->pid);

ff = procfile_reopen(ff, filename, NULL, PROCFILE_FLAG_NO_ERROR_ON_FILE_IO);

if(!ff) return 1;

ff = procfile_readall(ff);

if(!ff) {

// procfile_close(ff);

return 1;

}

file_counter++;

p->statm_size = strtoull(procfile_lineword(ff, 0, 0), NULL, 10);

p->statm_resident = strtoull(procfile_lineword(ff, 0, 1), NULL, 10);

p->statm_share = strtoull(procfile_lineword(ff, 0, 2), NULL, 10);

p->statm_text = strtoull(procfile_lineword(ff, 0, 3), NULL, 10);

p->statm_lib = strtoull(procfile_lineword(ff, 0, 4), NULL, 10);

p->statm_data = strtoull(procfile_lineword(ff, 0, 5), NULL, 10);

p->statm_dirty = strtoull(procfile_lineword(ff, 0, 6), NULL, 10);

// procfile_close(ff);

return 0;

}

int read_proc_pid_io(struct pid_stat *p) {

static procfile *ff = NULL;

char filename[FILENAME_MAX + 1];

snprintfz(filename, FILENAME_MAX, "%s/proc/%d/io", host_prefix, p->pid);

ff = procfile_reopen(ff, filename, NULL, PROCFILE_FLAG_NO_ERROR_ON_FILE_IO);

if(!ff) return 1;

ff = procfile_readall(ff);

if(!ff) {

// procfile_close(ff);

return 1;

}

file_counter++;

p->io_logical_bytes_read = strtoull(procfile_lineword(ff, 0, 1), NULL, 10);

p->io_logical_bytes_written = strtoull(procfile_lineword(ff, 1, 1), NULL, 10);

p->io_read_calls = strtoull(procfile_lineword(ff, 2, 1), NULL, 10);

p->io_write_calls = strtoull(procfile_lineword(ff, 3, 1), NULL, 10);

p->io_storage_bytes_read = strtoull(procfile_lineword(ff, 4, 1), NULL, 10);

p->io_storage_bytes_written = strtoull(procfile_lineword(ff, 5, 1), NULL, 10);

p->io_cancelled_write_bytes = strtoull(procfile_lineword(ff, 6, 1), NULL, 10);

// procfile_close(ff);

return 0;

}

#define FILE_DESCRIPTORS_INCREASE_STEP 100

struct file_descriptor {

} *all_files = NULL;

int all_files_len = 0;

int all_files_size = 0;

int file_descriptor_compare(void* a, void* b) {

#ifdef NETDATA_INTERNAL_CHECKS

if(((struct file_descriptor *)a)->magic != 0x0BADCAFE || ((struct file_descriptor *)b)->magic != 0x0BADCAFE)

error("Corrupted index data detected. Please report this.");

#endif /* NETDATA_INTERNAL_CHECKS */

if(((struct file_descriptor *)a)->hash < ((struct file_descriptor *)b)->hash)

return -1;

else if(((struct file_descriptor *)a)->hash > ((struct file_descriptor *)b)->hash)

return 1;

else

return strcmp(((struct file_descriptor *)a)->name, ((struct file_descriptor *)b)->name);

}

int file_descriptor_iterator(avl *a) { if(a) {}; return 0; }