#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/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 "common.h"

#include "log.h"

#include "avl.h"

#include "procfile.h"

#define MAX_COMPARE_NAME 15

#define MAX_NAME 100

unsigned long long Hertz = 1;

long processors = 1;

long pid_max = 32768;

int debug = 0;

int update_every = 1;

unsigned long long file_counter = 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 /* ifdef NETDATA_INTERNAL_CHECKS */

procfile *ff = NULL;

long get_processors(void) {

int processors = 0;

char filename[FILENAME_MAX + 1];

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

ff = procfile_reopen(ff, filename, "", 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_pid_max(void) {

long mpid = 32768;

char filename[FILENAME_MAX + 1];

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

ff = procfile_reopen(ff, filename, "", 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;

}

unsigned long long get_hertz(void)

{

unsigned long long myhz = 1;

#ifdef _SC_CLK_TCK

if((myhz = (unsigned long long int) sysconf(_SC_CLK_TCK)) > 0) {

return myhz;

}

#ifdef HZ

myhz = HZ; /* <asm/param.h> */

/* If 32-bit or big-endian (not Alpha or ia64), assume HZ is 100. */

hz = (sizeof(long)==sizeof(int) || htons(999)==999) ? 100UL : 1024UL;

error("Unknown HZ value. Assuming %llu.", myhz);

return myhz;

}

struct target {

} *target_root = NULL, *default_target = NULL;

long targets = 0;

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

{

const char *nid = id;

if(nid[0] == '-') nid++;

struct target *w;

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

if(strncmp(nid, w->id, MAX_NAME) == 0) return w;

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

if(!w) {

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

return NULL;

}

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

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

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

if(id[0] == '-') w->hidden = 1;

w->target = target;

w->next = target_root;

target_root = w;

if(debug) fprintf(stderr, "apps.plugin: adding hook for process '%s', compare '%s' on target '%s'\n", w->id, w->compare, w->target?w->target->id:"");

return w;

}

int read_process_groups(const char *name)

{

char buffer[4096+1];

char filename[FILENAME_MAX + 1];

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

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

FILE *fp = fopen(filename, "r");

if(!fp) {

error("Cannot open file '%s'", filename);

return 1;

}

long line = 0;

while(fgets(buffer, 4096, fp) != NULL) {

int whidden = 0, wdebug = 0;

line++;

// if(debug) fprintf(stderr, "apps.plugin: \tread %s\n", buffer);

char *s = buffer, *t, *p;

s = trim(s);

if(!s || !*s || *s == '#') continue;

if(debug) fprintf(stderr, "apps.plugin: \tread %s\n", s);

// the target name

t = strsep(&s, ":");

if(t) t = trim(t);

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

while(t[0]) {

int stop = 1;

switch(t[0]) {

case '-':

stop = 0;

whidden = 1;

t++;

break;

case '+':

stop = 0;

wdebug = 1;

t++;

break;

}

if(stop) break;

}

if(debug) fprintf(stderr, "apps.plugin: \t\ttarget %s\n", t);

struct target *w = NULL;

long count = 0;

int blen = 0;

char buffer[4097] = "";

buffer[4096] = '\0';

// the process names

while((p = strsep(&s, " "))) {

p = trim(p);

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

strncpy(&buffer[blen], p, 4096 - blen);

blen = strlen(buffer);

while(buffer[blen - 1] == '\\') {

buffer[blen - 1] = ' ';

if((p = strsep(&s, " ")))

p = trim(p);

if(!p || !*p) p = " ";

strncpy(&buffer[blen], p, 4096 - blen);

blen = strlen(buffer);

}

struct target *n = get_target(buffer, w);

n->hidden = whidden;

n->debug = wdebug;

if(!w) w = n;

buffer[0] = '\0';

blen = 0;

count++;

}

if(w) strncpy(w->name, t, MAX_NAME);

if(!count) error("The line %ld on file '%s', for group '%s' does not state any process names.", line, filename, t);

}

fclose(fp);

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

strncpy(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_stat(struct pid_stat *p) {

char filename[FILENAME_MAX + 1];

snprintf(filename, FILENAME_MAX, "%s/proc/%d/stat", 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->comm[0] = '\0';

p->comm[MAX_COMPARE_NAME] = '\0';

size_t blen = 0;

char *s = procfile_lineword(ff, 0, 1);

if(*s == '(') s++;

size_t len = strlen(s);

unsigned int i = 0;

while(len && s[len - 1] != ')') {

if(blen < MAX_COMPARE_NAME) {

strncpy(&p->comm[blen], s, MAX_COMPARE_NAME - blen);

blen = strlen(p->comm);

}

i++;

s = procfile_lineword(ff, 0, 1+i);

len = strlen(s);

}

if(len && s[len - 1] == ')') s[len - 1] = '\0';

if(blen < MAX_COMPARE_NAME)

strncpy(&p->comm[blen], s, MAX_COMPARE_NAME - blen);

// 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: VALUES: %s utime=%llu, stime=%llu, cutime=%llu, cstime=%llu, minflt=%llu, majflt=%llu, cminflt=%llu, cmajflt=%llu, threads=%d\n", 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) {

char filename[FILENAME_MAX + 1];

snprintf(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) {

char filename[FILENAME_MAX + 1];

snprintf(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;

}

#ifdef INCLUDE_CHILDS

int walk_down(pid_t pid, int level) {

struct pid_stat *p = NULL;

char b[level+3];

int i, ret = 0;

for(i = 0; i < level; i++) b[i] = '\t';

b[level] = '|';

b[level+1] = '-';

b[level+2] = '\0';

for(p = root_of_pids; p ; p = p->next) {

if(p->ppid == pid) {

ret += walk_down(p->pid, level+1);

}

}

p = all_pids[pid];

if(p) {

if(!p->updated) ret += 1;

if(ret) fprintf(stderr, "%s %s %d [%s, %s] c=%d u=%llu+%llu, s=%llu+%llu, cu=%llu+%llu, cs=%llu+%llu, n=%llu+%llu, j=%llu+%llu, cn=%llu+%llu, cj=%llu+%llu\n"

, b, p->comm, p->pid, p->updated?"OK":"KILLED", p->target->name, p->children_count

, p->utime, p->utime - p->old_utime

, p->stime, p->stime - p->old_stime

, p->cutime, p->cutime - p->old_cutime

, p->cstime, p->cstime - p->old_cstime

, p->minflt, p->minflt - p->old_minflt

, p->majflt, p->majflt - p->old_majflt

, p->cminflt, p->cminflt - p->old_cminflt

, p->cmajflt, p->cmajflt - p->old_cmajflt

);

}

return ret;

}

#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) {

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

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

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; }

avl_tree all_files_index = {

NULL,

file_descriptor_compare,

#ifdef AVL_LOCK_WITH_MUTEX

PTHREAD_MUTEX_INITIALIZER

PTHREAD_RWLOCK_INITIALIZER

};

static struct file_descriptor *file_descriptor_find(const char *name, uint32_t hash) {

struct file_descriptor *result = NULL, tmp;

tmp.hash = (hash)?hash:simple_hash(name);

tmp.name = name;

tmp.count = 0;

tmp.pos = 0;

tmp.magic = 0x0BADCAFE;

avl_search(&all_files_index, (avl *)&tmp, file_descriptor_iterator, (avl **)&result);

return result;

}

#define file_descriptor_add(fd) avl_insert(&all_files_index, (avl *)(fd))

#define file_descriptor_remove(fd) avl_remove(&all_files_index, (avl *)(fd))

#define FILETYPE_OTHER 0

#define FILETYPE_FILE 1

#define FILETYPE_PIPE 2

#define FILETYPE_SOCKET 3

#define FILETYPE_INOTIFY 4

#define FILETYPE_EVENTFD 5

#define FILETYPE_EVENTPOLL 6

#define FILETYPE_TIMERFD 7

#define FILETYPE_SIGNALFD 8

void file_descriptor_not_used(int id)

{

if(id > 0 && id < all_files_size) {

if(all_files[id].magic != 0x0BADCAFE) {

error("Ignoring request to remove empty file id %d.", id);

return;

}

if(debug) fprintf(stderr, "apps.plugin: decreasing slot %d (count = %d).\n", id, all_files[id].count);

if(all_files[id].count > 0) {

all_files[id].count--;

if(!all_files[id].count) {

if(debug) fprintf(stderr, "apps.plugin: >> slot %d is empty.\n", id);

file_descriptor_remove(&all_files[id]);

all_files[id].magic = 0x00000000;

all_files_len--;

}

}

else

error("Request to decrease counter of fd %d (%s), while the use counter is 0", id, all_files[id].name);

}

else error("Request to decrease counter of fd %d, which is outside the array size (1 to %d)", id, all_files_size);

}

int file_descriptor_find_or_add(const char *name)

{

static int last_pos = 0;

uint32_t hash = simple_hash(name);

if(debug) fprintf(stderr, "apps.plugin: adding or finding name '%s' with hash %u\n", name, hash);

struct file_descriptor *fd = file_descriptor_find(name, hash);

if(fd) {

// found

if(debug) fprintf(stderr, "apps.plugin: >> found on slot %d\n", fd->pos);

fd->count++;

return fd->pos;

}

// not found

// check we have enough memory to add it

if(!all_files || all_files_len == all_files_size) {

void *old = all_files;

int i;

// there is no empty slot

if(debug) fprintf(stderr, "apps.plugin: extending fd array to %d entries\n", all_files_size + FILE_DESCRIPTORS_INCREASE_STEP);

all_files = realloc(all_files, (all_files_size + FILE_DESCRIPTORS_INCREASE_STEP) * sizeof(struct file_descriptor));

// if the address changed, we have to rebuild the index

// since all pointers are now invalid

if(old && old != (void *)all_files) {

if(debug) fprintf(stderr, "apps.plugin: >> re-indexing.\n");

all_files_index.root = NULL;

for(i = 0; i < all_files_size; i++) {

if(!all_files[i].count) continue;

file_descriptor_add(&all_files[i]);

}

if(debug) fprintf(stderr, "apps.plugin: >> re-indexing done.\n");

}

for(i = all_files_size; i < (all_files_size + FILE_DESCRIPTORS_INCREASE_STEP); i++) {

all_files[i].count = 0;

all_files[i].name = NULL;

all_files[i].magic = 0x00000000;

all_files[i].pos = i;

}

if(!all_files_size) all_files_len = 1;

all_files_size += FILE_DESCRIPTORS_INCREASE_STEP;

}

if(debug) fprintf(stderr, "apps.plugin: >> searching for empty slot.\n");

// search for an empty slot

int i, c;

for(i = 0, c = last_pos ; i < all_files_size ; i++, c++) {

if(c >= all_files_size) c = 0;

if(c == 0) continue;

if(!all_files[c].count) {

if(debug) fprintf(stderr, "apps.plugin: >> Examining slot %d.\n", c);

if(all_files[c].magic == 0x0BADCAFE && all_files[c].name && file_descriptor_find(all_files[c].name, all_files[c].hash))

error("fd on position %d is not cleared properly. It still has %s in it.\n", c, all_files[c].name);

if(debug) fprintf(stderr, "apps.plugin: >> %s fd position %d for %s (last name: %s)\n", all_files[c].name?"re-using":"using", c, name, all_files[c].name);

if(all_files[c].name) free((void *)all_files[c].name);

all_files[c].name = NULL;

last_pos = c;

break;

}

}

if(i == all_files_size) {

fatal("We should find an empty slot, but there isn't any");

exit(1);

}

if(debug) fprintf(stderr, "apps.plugin: >> updating slot %d.\n", c);

all_files_len++;

// else we have an empty slot in 'c'

int type;