X-Git-Url: https://arthur.barton.de/gitweb/?a=blobdiff_plain;f=src%2Fprocfile.c;h=3a89e83539c75371db0f7c8c77565463d746a772;hb=f5fef72a72cfc1c799b7a9b37ff2dfa25e731420;hp=aed26f9c981e4cfeb8a58d5e4fee957cb8baccc0;hpb=133d7abbb4caebd1fc0dfe3a47b099aff697dfa5;p=netdata.git diff --git a/src/procfile.c b/src/procfile.c old mode 100755 new mode 100644 index aed26f9c..3a89e835 --- a/src/procfile.c +++ b/src/procfile.c @@ -1,339 +1,473 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#include "log.h" +#include "common.h" #include "procfile.h" #define PF_PREFIX "PROCFILE" +#define PFWORDS_INCREASE_STEP 200 +#define PFLINES_INCREASE_STEP 10 +#define PROCFILE_INCREMENT_BUFFER 512 + +int procfile_adaptive_initial_allocation = 0; + +// if adaptive allocation is set, these store the +// max values we have seen so far +size_t procfile_max_lines = PFLINES_INCREASE_STEP; +size_t procfile_max_words = PFWORDS_INCREASE_STEP; +size_t procfile_max_allocation = PROCFILE_INCREMENT_BUFFER; + + // ---------------------------------------------------------------------------- -// An array of words -#define PFWORDS_INCREASE_STEP 200 +char *procfile_filename(procfile *ff) { + if(ff->filename[0]) return ff->filename; -pfwords *pfwords_add(pfwords *fw, char *str) { - // debug(D_PROCFILE, PF_PREFIX ": adding word No %d: '%s'", fw->len, str); + char buffer[FILENAME_MAX + 1]; + snprintfz(buffer, FILENAME_MAX, "/proc/self/fd/%d", ff->fd); - if(fw->len == fw->size) { - // debug(D_PROCFILE, PF_PREFIX ": expanding words"); + ssize_t l = readlink(buffer, ff->filename, FILENAME_MAX); + if(unlikely(l == -1)) + snprintfz(ff->filename, FILENAME_MAX, "unknown filename for fd %d", ff->fd); + else + ff->filename[l] = '\0'; - pfwords *new = realloc(fw, sizeof(pfwords) + (fw->size + PFWORDS_INCREASE_STEP) * sizeof(char *)); - if(!new) { - error(PF_PREFIX ": failed to expand words"); - free(fw); - return NULL; - } - fw = new; - fw->size += PFWORDS_INCREASE_STEP; - } + // on non-linux systems, something like this will be needed + // fcntl(ff->fd, F_GETPATH, ff->filename) - fw->words[fw->len++] = str; + return ff->filename; +} + +// ---------------------------------------------------------------------------- +// An array of words + +static inline pfwords *pfwords_add(pfwords *fw, char *str) NEVERNULL; +static inline pfwords *pfwords_add(pfwords *fw, char *str) { + // debug(D_PROCFILE, PF_PREFIX ": adding word No %d: '%s'", fw->len, str); - return fw; + if(unlikely(fw->len == fw->size)) { + // debug(D_PROCFILE, PF_PREFIX ": expanding words"); + + fw = reallocz(fw, sizeof(pfwords) + (fw->size + PFWORDS_INCREASE_STEP) * sizeof(char *)); + fw->size += PFWORDS_INCREASE_STEP; + } + + fw->words[fw->len++] = str; + + return fw; } -pfwords *pfwords_new(void) { - // debug(D_PROCFILE, PF_PREFIX ": initializing words"); +static inline pfwords *pfwords_new(void) NEVERNULL; +static inline pfwords *pfwords_new(void) { + // debug(D_PROCFILE, PF_PREFIX ": initializing words"); - pfwords *new = malloc(sizeof(pfwords) + PFWORDS_INCREASE_STEP * sizeof(char *)); - if(!new) return NULL; + size_t size = (procfile_adaptive_initial_allocation) ? procfile_max_words : PFWORDS_INCREASE_STEP; - new->len = 0; - new->size = PFWORDS_INCREASE_STEP; - return new; + pfwords *new = mallocz(sizeof(pfwords) + size * sizeof(char *)); + new->len = 0; + new->size = size; + return new; } -void pfwords_reset(pfwords *fw) { - // debug(D_PROCFILE, PF_PREFIX ": reseting words"); - fw->len = 0; +static inline void pfwords_reset(pfwords *fw) { + // debug(D_PROCFILE, PF_PREFIX ": reseting words"); + fw->len = 0; } -void pfwords_free(pfwords *fw) { - // debug(D_PROCFILE, PF_PREFIX ": freeing words"); +static inline void pfwords_free(pfwords *fw) { + // debug(D_PROCFILE, PF_PREFIX ": freeing words"); - free(fw); + freez(fw); } // ---------------------------------------------------------------------------- // An array of lines -#define PFLINES_INCREASE_STEP 10 - -pflines *pflines_add(pflines *fl, uint32_t first_word) { - // debug(D_PROCFILE, PF_PREFIX ": adding line %d at word %d", fl->len, first_word); +static inline pflines *pflines_add(pflines *fl, size_t first_word) NEVERNULL; +static inline pflines *pflines_add(pflines *fl, size_t first_word) { + // debug(D_PROCFILE, PF_PREFIX ": adding line %d at word %d", fl->len, first_word); - if(fl->len == fl->size) { - // debug(D_PROCFILE, PF_PREFIX ": expanding lines"); + if(unlikely(fl->len == fl->size)) { + // debug(D_PROCFILE, PF_PREFIX ": expanding lines"); - pflines *new = realloc(fl, sizeof(pflines) + (fl->size + PFLINES_INCREASE_STEP) * sizeof(ffline)); - if(!new) { - error(PF_PREFIX ": failed to expand lines"); - free(fl); - return NULL; - } - fl = new; - fl->size += PFLINES_INCREASE_STEP; - } + fl = reallocz(fl, sizeof(pflines) + (fl->size + PFLINES_INCREASE_STEP) * sizeof(ffline)); + fl->size += PFLINES_INCREASE_STEP; + } - fl->lines[fl->len].words = 0; - fl->lines[fl->len++].first = first_word; + fl->lines[fl->len].words = 0; + fl->lines[fl->len++].first = first_word; - return fl; + return fl; } -pflines *pflines_new(void) { - // debug(D_PROCFILE, PF_PREFIX ": initializing lines"); +static inline pflines *pflines_new(void) NEVERNULL; +static inline pflines *pflines_new(void) { + // debug(D_PROCFILE, PF_PREFIX ": initializing lines"); - pflines *new = malloc(sizeof(pflines) + PFLINES_INCREASE_STEP * sizeof(ffline)); - if(!new) return NULL; + size_t size = (unlikely(procfile_adaptive_initial_allocation)) ? procfile_max_words : PFLINES_INCREASE_STEP; - new->len = 0; - new->size = PFLINES_INCREASE_STEP; - return new; + pflines *new = mallocz(sizeof(pflines) + size * sizeof(ffline)); + new->len = 0; + new->size = size; + return new; } -void pflines_reset(pflines *fl) { - // debug(D_PROCFILE, PF_PREFIX ": reseting lines"); +static inline void pflines_reset(pflines *fl) { + // debug(D_PROCFILE, PF_PREFIX ": reseting lines"); - fl->len = 0; + fl->len = 0; } -void pflines_free(pflines *fl) { - // debug(D_PROCFILE, PF_PREFIX ": freeing lines"); +static inline void pflines_free(pflines *fl) { + // debug(D_PROCFILE, PF_PREFIX ": freeing lines"); - free(fl); + freez(fl); } // ---------------------------------------------------------------------------- // The procfile -#define PROCFILE_INITIAL_BUFFER 256 -#define PROCFILE_INCREMENT_BUFFER 512 +void procfile_close(procfile *ff) { + if(unlikely(!ff)) return; -#define PF_CHAR_IS_SEPARATOR 0 -#define PF_CHAR_IS_NEWLINE 1 -#define PF_CHAR_IS_WORD 2 + debug(D_PROCFILE, PF_PREFIX ": Closing file '%s'", procfile_filename(ff)); -void procfile_close(procfile *ff) { - debug(D_PROCFILE, PF_PREFIX ": Closing file '%s'. Reason: %s", ff->filename, strerror(errno)); + if(likely(ff->lines)) pflines_free(ff->lines); + if(likely(ff->words)) pfwords_free(ff->words); - if(ff->lines) pflines_free(ff->lines); - if(ff->words) pfwords_free(ff->words); + if(likely(ff->fd != -1)) close(ff->fd); + freez(ff); +} - if(ff->fd != -1) close(ff->fd); - free(ff); +static inline void procfile_parser(procfile *ff) { + // debug(D_PROCFILE, PF_PREFIX ": Parsing file '%s'", ff->filename); + + char *s = ff->data // our current position + , *e = &ff->data[ff->len] // the terminating null + , *t = ff->data; // the first character of a quoted or a parenthesized string + + // the look up array to find our type of character + PF_CHAR_TYPE *separators = ff->separators; + + char quote = 0; // the quote character - only when in quoted string + + size_t + l = 0 // counts the number of lines we added + , w = 0 // counts the number of words we added + , opened = 0; // counts the number of open parenthesis + + ff->lines = pflines_add(ff->lines, w); + + while(likely(s < e)) { + // we are not at the end + PF_CHAR_TYPE ct = separators[(unsigned char)(*s)]; + + // this is faster than a switch() + if(likely(ct == PF_CHAR_IS_WORD)) { + s++; + } + else if(likely(ct == PF_CHAR_IS_SEPARATOR)) { + if(unlikely(quote || opened)) { + // we are inside a quote + s++; + continue; + } + + if(unlikely(s == t)) { + // skip all leading white spaces + t = ++s; + continue; + } + + // end of word + *s = '\0'; + + ff->words = pfwords_add(ff->words, t); + ff->lines->lines[l].words++; + w++; + + t = ++s; + } + else if(likely(ct == PF_CHAR_IS_NEWLINE)) { + // end of line + *s = '\0'; + + ff->words = pfwords_add(ff->words, t); + ff->lines->lines[l].words++; + w++; + + // debug(D_PROCFILE, PF_PREFIX ": ended line %d with %d words", l, ff->lines->lines[l].words); + + ff->lines = pflines_add(ff->lines, w); + l++; + + t = ++s; + } + else if(likely(ct == PF_CHAR_IS_QUOTE)) { + if(unlikely(!quote && s == t)) { + // quote opened at the beginning + quote = *s; + t = ++s; + } + else if(unlikely(quote && quote == *s)) { + // quote closed + quote = 0; + + *s = '\0'; + ff->words = pfwords_add(ff->words, t); + ff->lines->lines[l].words++; + w++; + + t = ++s; + } + else + s++; + } + else if(likely(ct == PF_CHAR_IS_OPEN)) { + if(s == t) { + opened++; + t = ++s; + } + else if(opened) { + opened++; + s++; + } + else + s++; + } + else if(likely(ct == PF_CHAR_IS_CLOSE)) { + if(opened) { + opened--; + + if(!opened) { + *s = '\0'; + ff->words = pfwords_add(ff->words, t); + ff->lines->lines[l].words++; + w++; + + t = ++s; + } + else + s++; + } + else + s++; + } + else + fatal("Internal Error: procfile_readall() does not handle all the cases."); + } + + if(likely(s > t && t < e)) { + // the last word + if(likely(ff->len < ff->size)) + *s = '\0'; + else { + // we are going to loose the last byte + ff->data[ff->size - 1] = '\0'; + } + + ff->words = pfwords_add(ff->words, t); + ff->lines->lines[l].words++; + } } -procfile *procfile_parser(procfile *ff) { - debug(D_PROCFILE, PF_PREFIX ": Parsing file '%s'", ff->filename); +procfile *procfile_readall(procfile *ff) { + // debug(D_PROCFILE, PF_PREFIX ": Reading file '%s'.", ff->filename); + + ff->len = 0; // zero the used size + ssize_t r = 1; // read at least once + while(r > 0) { + ssize_t s = ff->len; + ssize_t x = ff->size - s; + + if(unlikely(!x)) { + debug(D_PROCFILE, PF_PREFIX ": Expanding data buffer for file '%s'.", procfile_filename(ff)); + ff = reallocz(ff, sizeof(procfile) + ff->size + PROCFILE_INCREMENT_BUFFER); + ff->size += PROCFILE_INCREMENT_BUFFER; + } + + debug(D_PROCFILE, "Reading file '%s', from position %zd with length %zd", procfile_filename(ff), s, (ssize_t)(ff->size - s)); + r = read(ff->fd, &ff->data[s], ff->size - s); + if(unlikely(r == -1)) { + if(unlikely(!(ff->flags & PROCFILE_FLAG_NO_ERROR_ON_FILE_IO))) error(PF_PREFIX ": Cannot read from file '%s'", procfile_filename(ff)); + procfile_close(ff); + return NULL; + } + + ff->len += r; + } + + // debug(D_PROCFILE, "Rewinding file '%s'", ff->filename); + if(unlikely(lseek(ff->fd, 0, SEEK_SET) == -1)) { + if(unlikely(!(ff->flags & PROCFILE_FLAG_NO_ERROR_ON_FILE_IO))) error(PF_PREFIX ": Cannot rewind on file '%s'.", procfile_filename(ff)); + procfile_close(ff); + return NULL; + } + + pflines_reset(ff->lines); + pfwords_reset(ff->words); + procfile_parser(ff); + + if(unlikely(procfile_adaptive_initial_allocation)) { + if(unlikely(ff->len > procfile_max_allocation)) procfile_max_allocation = ff->len; + if(unlikely(ff->lines->len > procfile_max_lines)) procfile_max_lines = ff->lines->len; + if(unlikely(ff->words->len > procfile_max_words)) procfile_max_words = ff->words->len; + } + + // debug(D_PROCFILE, "File '%s' updated.", ff->filename); + return ff; +} - char *s = ff->data, *e = ff->data, *t = ff->data; - uint32_t l = 0, w = 0; - e += ff->len; - - ff->lines = pflines_add(ff->lines, w); - if(!ff->lines) goto cleanup; +static inline void procfile_set_separators(procfile *ff, const char *separators) { + static PF_CHAR_TYPE def[256]; + static char initilized = 0; + + if(unlikely(!initilized)) { + // this is thread safe + // if initialized is zero, multiple threads may be executing + // this code at the same time, setting in def[] the exact same values + int i = 256; + while(i--) { + if(unlikely(i == '\n' || i == '\r')) + def[i] = PF_CHAR_IS_NEWLINE; + + else if(unlikely(isspace(i) || !isprint(i))) + def[i] = PF_CHAR_IS_SEPARATOR; + + else + def[i] = PF_CHAR_IS_WORD; + } + + initilized = 1; + } + + // copy the default + PF_CHAR_TYPE *ffs = ff->separators, *ffd = def, *ffe = &def[256]; + while(ffd != ffe) + *ffs++ = *ffd++; + + // set the separators + if(unlikely(!separators)) + separators = " \t=|"; + + ffs = ff->separators; + const char *s = separators; + while(*s) + ffs[(int)*s++] = PF_CHAR_IS_SEPARATOR; +} - while(s < e) { - switch(ff->separators[(int)(*s)]) { - case PF_CHAR_IS_SEPARATOR: - if(s == t) { - // skip all leading white spaces - t = ++s; - continue; - } +void procfile_set_quotes(procfile *ff, const char *quotes) { + PF_CHAR_TYPE *ffs = ff->separators; - // end of word - *s = '\0'; + // remove all quotes + int i = 256; + while(i--) + if(unlikely(ffs[i] == PF_CHAR_IS_QUOTE)) + ffs[i] = PF_CHAR_IS_WORD; - ff->words = pfwords_add(ff->words, t); - if(!ff->words) goto cleanup; + // if nothing given, return + if(unlikely(!quotes || !*quotes)) + return; - ff->lines->lines[l].words++; - w++; + // set the quotes + const char *s = quotes; + while(*s) + ffs[(int)*s++] = PF_CHAR_IS_QUOTE; +} - t = ++s; - continue; +void procfile_set_open_close(procfile *ff, const char *open, const char *close) { + PF_CHAR_TYPE *ffs = ff->separators; - case PF_CHAR_IS_NEWLINE: - // end of line - *s = '\0'; + // remove all open/close + int i = 256; + while(i--) + if(unlikely(ffs[i] == PF_CHAR_IS_OPEN || ffs[i] == PF_CHAR_IS_CLOSE)) + ffs[i] = PF_CHAR_IS_WORD; - ff->words = pfwords_add(ff->words, t); - if(!ff->words) goto cleanup; + // if nothing given, return + if(unlikely(!open || !*open || !close || !*close)) + return; - ff->lines->lines[l].words++; - w++; + // set the openings + const char *s = open; + while(*s) + ffs[(int)*s++] = PF_CHAR_IS_OPEN; - debug(D_PROCFILE, PF_PREFIX ": ended line %d with %d words", l, ff->lines->lines[l].words); + // set the closings + s = close; + while(*s) + ffs[(int)*s++] = PF_CHAR_IS_CLOSE; +} - ff->lines = pflines_add(ff->lines, w); - if(!ff->lines) goto cleanup; - l++; +procfile *procfile_open(const char *filename, const char *separators, uint32_t flags) { + debug(D_PROCFILE, PF_PREFIX ": Opening file '%s'", filename); - t = ++s; - continue; + int fd = open(filename, O_RDONLY, 0666); + if(unlikely(fd == -1)) { + if(unlikely(!(flags & PROCFILE_FLAG_NO_ERROR_ON_FILE_IO))) error(PF_PREFIX ": Cannot open file '%s'", filename); + return NULL; + } - default: - s++; - continue; - } - } + size_t size = (unlikely(procfile_adaptive_initial_allocation)) ? procfile_max_allocation : PROCFILE_INCREMENT_BUFFER; + procfile *ff = mallocz(sizeof(procfile) + size); - if(s != t) { - // the last word - if(ff->len < ff->size) *s = '\0'; - else { - // we are going to loose the last byte - ff->data[ff->size - 1] = '\0'; - } + //strncpyz(ff->filename, filename, FILENAME_MAX); + ff->filename[0] = '\0'; - ff->words = pfwords_add(ff->words, t); - if(!ff->words) goto cleanup; + ff->fd = fd; + ff->size = size; + ff->len = 0; + ff->flags = flags; - ff->lines->lines[l].words++; - w++; - } + ff->lines = pflines_new(); + ff->words = pfwords_new(); - return ff; + procfile_set_separators(ff, separators); -cleanup: - error(PF_PREFIX ": Failed to parse file '%s'. Reason: %s", ff->filename, strerror(errno)); - procfile_close(ff); - return NULL; + debug(D_PROCFILE, "File '%s' opened.", filename); + return ff; } -procfile *procfile_readall(procfile *ff) { - debug(D_PROCFILE, PF_PREFIX ": Reading file '%s'.", ff->filename); - - ssize_t s = 0, r = ff->size, x = ff->size; - ff->len = 0; - - while(r == x) { - if(s) { - debug(D_PROCFILE, PF_PREFIX ": Expanding data buffer for file '%s'.", ff->filename); - - procfile *new = realloc(ff, sizeof(procfile) + ff->size + PROCFILE_INCREMENT_BUFFER); - if(!new) { - error(PF_PREFIX ": Cannot allocate memory for file '%s'. Reason: %s", ff->filename, strerror(errno)); - procfile_close(ff); - return NULL; - } - ff = new; - ff->size += PROCFILE_INCREMENT_BUFFER; - x = PROCFILE_INCREMENT_BUFFER; - } - - debug(D_PROCFILE, "Reading file '%s', from position %ld with length %ld", ff->filename, s, ff->size - s); - r = read(ff->fd, &ff->data[s], ff->size - s); - if(r == -1) { - error(PF_PREFIX ": Cannot read from file '%s'. Reason: %s", ff->filename, strerror(errno)); - procfile_close(ff); - return NULL; - } - - ff->len += r; - s = ff->len; - } - - debug(D_PROCFILE, "Rewinding file '%s'", ff->filename); - if(lseek(ff->fd, 0, SEEK_SET) == -1) { - error(PF_PREFIX ": Cannot rewind on file '%s'.", ff->filename); - procfile_close(ff); - return NULL; - } - - pflines_reset(ff->lines); - pfwords_reset(ff->words); - - ff = procfile_parser(ff); - - debug(D_PROCFILE, "File '%s' updated.", ff->filename); - return ff; -} +procfile *procfile_reopen(procfile *ff, const char *filename, const char *separators, uint32_t flags) { + if(unlikely(!ff)) return procfile_open(filename, separators, flags); -procfile *procfile_open(const char *filename, const char *separators) { - debug(D_PROCFILE, PF_PREFIX ": Opening file '%s'", filename); - - int fd = open(filename, O_RDONLY, 0666); - if(fd == -1) { - error(PF_PREFIX ": Cannot open file '%s'. Reason: %s", filename, strerror(errno)); - return NULL; - } - - procfile *ff = malloc(sizeof(procfile) + PROCFILE_INITIAL_BUFFER); - if(!ff) { - error(PF_PREFIX ": Cannot allocate memory for file '%s'. Reason: %s", filename, strerror(errno)); - close(fd); - return NULL; - } - - strncpy(ff->filename, filename, FILENAME_MAX); - ff->filename[FILENAME_MAX] = '\0'; - - ff->fd = fd; - ff->size = PROCFILE_INITIAL_BUFFER; - ff->len = 0; - - ff->lines = pflines_new(); - ff->words = pfwords_new(); - - if(!ff->lines || !ff->words) { - error(PF_PREFIX ": Cannot initialize parser for file '%s'. Reason: %s", filename, strerror(errno)); - procfile_close(ff); - return NULL; - } - - int i; - for(i = 0; i < 256 ;i++) { - if(i == '\n' || i == '\r') ff->separators[i] = PF_CHAR_IS_NEWLINE; - else if(isspace(i) || !isprint(i)) ff->separators[i] = PF_CHAR_IS_SEPARATOR; - else ff->separators[i] = PF_CHAR_IS_WORD; - } - - if(!separators) separators = " \t=|"; - const char *s = separators; - while(*s) ff->separators[(int)*s++] = PF_CHAR_IS_SEPARATOR; - - debug(D_PROCFILE, "File '%s' opened.", filename); - return ff; -} + if(likely(ff->fd != -1)) close(ff->fd); + + ff->fd = open(filename, O_RDONLY, 0666); + if(unlikely(ff->fd == -1)) { + procfile_close(ff); + return NULL; + } + //strncpyz(ff->filename, filename, FILENAME_MAX); + ff->filename[0] = '\0'; + + ff->flags = flags; + + // do not do the separators again if NULL is given + if(likely(separators)) procfile_set_separators(ff, separators); + + return ff; +} // ---------------------------------------------------------------------------- // example parsing of procfile data void procfile_print(procfile *ff) { - uint32_t lines = procfile_lines(ff), l; - uint32_t words, w; - char *s; + size_t lines = procfile_lines(ff), l; + char *s; - debug(D_PROCFILE, "File '%s' with %d lines and %d words", ff->filename, ff->lines->len, ff->words->len); + debug(D_PROCFILE, "File '%s' with %zu lines and %zu words", procfile_filename(ff), ff->lines->len, ff->words->len); - for(l = 0; l < lines ;l++) { - words = procfile_linewords(ff, l); + for(l = 0; likely(l < lines) ;l++) { + size_t words = procfile_linewords(ff, l); - debug(D_PROCFILE, " line %d starts at word %d and has %d words", l, ff->lines->lines[l].first, ff->lines->lines[l].words); + debug(D_PROCFILE, " line %zu starts at word %zu and has %zu words", l, ff->lines->lines[l].first, ff->lines->lines[l].words); - for(w = 0; w < words ;w++) { - s = procfile_lineword(ff, l, w); - debug(D_PROCFILE, " [%d.%d] '%s'", l, w, s); - } - } + size_t w; + for(w = 0; likely(w < words) ;w++) { + s = procfile_lineword(ff, l, w); + debug(D_PROCFILE, " [%zu.%zu] '%s'", l, w, s); + } + } }