diff options
Diffstat (limited to 'library')
39 files changed, 13437 insertions, 0 deletions
diff --git a/library/devname.c b/library/devname.c new file mode 100644 index 0000000..6a23653 --- /dev/null +++ b/library/devname.c @@ -0,0 +1,364 @@ +/* + * devname - device name functions + * + * Copyright © 2011-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2017-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 1998-2009 Albert Cahalan + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include "misc.h" +#include "devname.h" + +// This is the buffer size for a tty name. Any path is legal, +// which makes PAGE_SIZE appropriate (see kernel source), but +// that is only 99% portable and utmp only holds 32 anyway. +// We need at least 20 for guess_name(). +#define TTY_NAME_SIZE 128 + +/* Who uses what: + * + * dev_to_tty top, ps + */ + +#ifdef MAJOR_IN_MKDEV +#include <sys/mkdev.h> +#elif defined MAJOR_IN_SYSMACROS +#include <sys/sysmacros.h> +#else +#define major(d) ( ((unsigned)(d)>>8u) & 0xfffu ) +#define minor(d) ( ((unsigned)(d)&0xffu) | (((unsigned)(d)&0xfff00000u)>>12u) ) +#endif + +typedef struct tty_map_node { + struct tty_map_node *next; + unsigned short devfs_type; // bool + unsigned short major_number; + unsigned minor_first; + unsigned minor_last; + char name[16]; +} tty_map_node; + +static __thread tty_map_node *tty_map = NULL; + +/* Load /proc/tty/drivers for device name mapping use. */ +static void load_drivers(void){ + char buf[10000]; + char *p; + int fd; + int bytes; + fd = open("/proc/tty/drivers",O_RDONLY); + if(fd == -1) goto fail; + bytes = read(fd, buf, sizeof(buf) - 1); + if(bytes == -1) goto fail; + buf[bytes] = '\0'; + p = buf; + while(( p = strstr(p, " /dev/") )){ // " /dev/" is the second column + tty_map_node *tmn; + size_t len; + char *end; + p += 6; + end = strchr(p, ' '); + if(!end) continue; + len = end - p; + if (!(tmn = calloc(1, sizeof(tty_map_node)))) + goto fail; + tmn->next = tty_map; + tty_map = tmn; + /* if we have a devfs type name such as /dev/tts/%d then strip the %d but + keep a flag. */ + if(len >= 3 && !strncmp(end - 2, "%d", 2)){ + len -= 2; + tmn->devfs_type = 1; + } + if(len >= sizeof tmn->name) + len = sizeof tmn->name - 1; // mangle it to avoid overflow + memcpy(tmn->name, p, len); + p = end; /* set p to point past the %d as well if there is one */ + while(*p == ' ') p++; + tmn->major_number = atoi(p); + p += strspn(p, "0123456789"); + while(*p == ' ') p++; + switch(sscanf(p, "%u-%u", &tmn->minor_first, &tmn->minor_last)){ + default: + /* Can't finish parsing this line so we remove it from the list */ + tty_map = tty_map->next; + free(tmn); + break; + case 1: + tmn->minor_last = tmn->minor_first; + break; + case 2: + break; + } + } +fail: + if(fd != -1) close(fd); + if(!tty_map) tty_map = (tty_map_node *)-1; +} + +/* Try to guess the device name from /proc/tty/drivers info. */ +static int driver_name(char *restrict const buf, unsigned maj, unsigned min){ + struct stat sbuf; + tty_map_node *tmn; + if(!tty_map) load_drivers(); + if(tty_map == (tty_map_node *)-1) return 0; + tmn = tty_map; + for(;;){ + if(!tmn) return 0; + if(tmn->major_number == maj && tmn->minor_first <= min && tmn->minor_last >= min) break; + tmn = tmn->next; + } + sprintf(buf, "/dev/%s%d", tmn->name, min); /* like "/dev/ttyZZ255" */ + if(stat(buf, &sbuf) < 0){ + sprintf(buf, "/dev/%s/%d", tmn->name, min); /* like "/dev/pts/255" */ + if(stat(buf, &sbuf) < 0){ + if(tmn->devfs_type) return 0; + sprintf(buf, "/dev/%s", tmn->name); /* like "/dev/ttyZZ255" */ + if(stat(buf, &sbuf) < 0) return 0; + } + } + if(min != minor(sbuf.st_rdev)) return 0; + if(maj != major(sbuf.st_rdev)) return 0; + return 1; +} + +// major 204 is a mess -- "Low-density serial ports" +static const char low_density_names[][6] = { +"LU0", "LU1", "LU2", "LU3", +"FB0", +"SA0", "SA1", "SA2", +"SC0", "SC1", "SC2", "SC3", +"FW0", "FW1", "FW2", "FW3", +"AM0", "AM1", "AM2", "AM3", "AM4", "AM5", "AM6", "AM7", +"AM8", "AM9", "AM10", "AM11", "AM12", "AM13", "AM14", "AM15", +"DB0", "DB1", "DB2", "DB3", "DB4", "DB5", "DB6", "DB7", +"SG0", +"SMX0", "SMX1", "SMX2", +"MM0", "MM1", +"CPM0", "CPM1", "CPM2", "CPM3", /* "CPM4", "CPM5", */ // bad allocation? +"IOC0", "IOC1", "IOC2", "IOC3", "IOC4", "IOC5", "IOC6", "IOC7", +"IOC8", "IOC9", "IOC10", "IOC11", "IOC12", "IOC13", "IOC14", "IOC15", +"IOC16", "IOC17", "IOC18", "IOC19", "IOC20", "IOC21", "IOC22", "IOC23", +"IOC24", "IOC25", "IOC26", "IOC27", "IOC28", "IOC29", "IOC30", "IOC31", +"VR0", "VR1", +"IOC84", "IOC85", "IOC86", "IOC87", "IOC88", "IOC89", "IOC90", "IOC91", +"IOC92", "IOC93", "IOC94", "IOC95", "IOC96", "IOC97", "IOC98", "IOC99", +"IOC100", "IOC101", "IOC102", "IOC103", "IOC104", "IOC105", "IOC106", "IOC107", +"IOC108", "IOC109", "IOC110", "IOC111", "IOC112", "IOC113", "IOC114", "IOC115", +"SIOC0", "SIOC1", "SIOC2", "SIOC3", "SIOC4", "SIOC5", "SIOC6", "SIOC7", +"SIOC8", "SIOC9", "SIOC10", "SIOC11", "SIOC12", "SIOC13", "SIOC14", "SIOC15", +"SIOC16", "SIOC17", "SIOC18", "SIOC19", "SIOC20", "SIOC21", "SIOC22", "SIOC23", +"SIOC24", "SIOC25", "SIOC26", "SIOC27", "SIOC28", "SIOC29", "SIOC30", "SIOC31", +"PSC0", "PSC1", "PSC2", "PSC3", "PSC4", "PSC5", +"AT0", "AT1", "AT2", "AT3", "AT4", "AT5", "AT6", "AT7", +"AT8", "AT9", "AT10", "AT11", "AT12", "AT13", "AT14", "AT15", +"NX0", "NX1", "NX2", "NX3", "NX4", "NX5", "NX6", "NX7", +"NX8", "NX9", "NX10", "NX11", "NX12", "NX13", "NX14", "NX15", +"J0", // minor is 186 +"UL0","UL1","UL2","UL3", +"xvc0", // FAIL -- "/dev/xvc0" lacks "tty" prefix +"PZ0","PZ1","PZ2","PZ3", +"TX0","TX1","TX2","TX3","TX4","TX5","TX6","TX7", +"SC0","SC1","SC2","SC3", +"MAX0","MAX1","MAX2","MAX3", +}; + +#if 0 +// test code +#include <stdio.h> +#define AS(x) (sizeof(x)/sizeof((x)[0])) +int main(int argc, char *argv[]){ + int i = 0; + while(i<AS(low_density_names)){ + printf("%3d = /dev/tty%.*s\n",i,sizeof low_density_names[i],low_density_names[i]); + i++; + } + return 0; +} +#endif + +/* Try to guess the device name (useful until /proc/PID/tty is added) */ +static int guess_name(char *restrict const buf, unsigned maj, unsigned min){ + struct stat sbuf; +#ifndef __CYGWIN__ + int t0, t1; +#endif + unsigned tmpmin = min; + + switch(maj){ + case 3: /* /dev/[pt]ty[p-za-o][0-9a-z] is 936 */ + if(tmpmin > 255) return 0; // should never happen; array index protection +#ifdef __CYGWIN__ + sprintf(buf, "cons%d", tmpmin); + /* Skip stat call. The reason is that cons devices are local to + * the processes running in that console. Calling stat from another + * console or pty will return -1. */ + return 1; +#else + t0 = "pqrstuvwxyzabcde"[tmpmin>>4]; + t1 = "0123456789abcdef"[tmpmin&0x0f]; + sprintf(buf, "/dev/tty%c%c", t0, t1); +#endif + break; + case 4: + if(min<64){ + sprintf(buf, "/dev/tty%d", min); + break; + } + sprintf(buf, "/dev/ttyS%d", min-64); + break; + case 11: sprintf(buf, "/dev/ttyB%d", min); break; + case 17: sprintf(buf, "/dev/ttyH%d", min); break; + case 19: sprintf(buf, "/dev/ttyC%d", min); break; + case 22: sprintf(buf, "/dev/ttyD%d", min); break; /* devices.txt */ + case 23: sprintf(buf, "/dev/ttyD%d", min); break; /* driver code */ + case 24: sprintf(buf, "/dev/ttyE%d", min); break; + case 32: sprintf(buf, "/dev/ttyX%d", min); break; + case 43: sprintf(buf, "/dev/ttyI%d", min); break; + case 46: sprintf(buf, "/dev/ttyR%d", min); break; + case 48: sprintf(buf, "/dev/ttyL%d", min); break; + case 57: sprintf(buf, "/dev/ttyP%d", min); break; + case 71: sprintf(buf, "/dev/ttyF%d", min); break; + case 75: sprintf(buf, "/dev/ttyW%d", min); break; + case 78: sprintf(buf, "/dev/ttyM%d", min); break; /* conflict */ + case 105: sprintf(buf, "/dev/ttyV%d", min); break; + case 112: sprintf(buf, "/dev/ttyM%d", min); break; /* conflict */ +#ifdef __CYGWIN__ + case 136: sprintf(buf, "/dev/pty%d", min); break; +#else + /* 136 ... 143 are /dev/pts/0, /dev/pts/1, /dev/pts/2 ... */ + case 136 ... 143: sprintf(buf, "/dev/pts/%d", min+(maj-136)*256); break; +#endif + case 148: sprintf(buf, "/dev/ttyT%d", min); break; + case 154: sprintf(buf, "/dev/ttySR%d", min); break; + case 156: sprintf(buf, "/dev/ttySR%d", min+256); break; + case 164: sprintf(buf, "/dev/ttyCH%d", min); break; + case 166: sprintf(buf, "/dev/ttyACM%d", min); break; /* bummer, 9-char */ + case 172: sprintf(buf, "/dev/ttyMX%d", min); break; + case 174: sprintf(buf, "/dev/ttySI%d", min); break; + case 188: sprintf(buf, "/dev/ttyUSB%d", min); break; /* bummer, 9-char */ + case 204: + if(min >= sizeof low_density_names / sizeof low_density_names[0]) return 0; + memcpy(buf,"/dev/tty",8); + memcpy(buf+8, low_density_names[min], sizeof low_density_names[0]); + buf[8 + sizeof low_density_names[0]] = '\0'; +// snprintf(buf, 9 + sizeof low_density_names[0], "/dev/tty%.*s", sizeof low_density_names[0], low_density_names[min]); + break; + case 208: sprintf(buf, "/dev/ttyU%d", min); break; + case 216: sprintf(buf, "/dev/ttyUB%d", min); break; // "/dev/rfcomm%d" now? + case 224: sprintf(buf, "/dev/ttyY%d", min); break; + case 227: sprintf(buf, "/dev/3270/tty%d", min); break; /* bummer, HUGE */ + case 229: sprintf(buf, "/dev/iseries/vtty%d", min); break; /* bummer, HUGE */ + case 256: sprintf(buf, "/dev/ttyEQ%d", min); break; + default: return 0; + } + if(stat(buf, &sbuf) < 0) return 0; + if(min != minor(sbuf.st_rdev)) return 0; + if(maj != major(sbuf.st_rdev)) return 0; + return 1; +} + +/* Linux 2.2 can give us filenames that might be correct. + * Useful names could be in /proc/PID/fd/2 (stderr, seldom redirected) + * and in /proc/PID/fd/255 (used by bash to remember the tty). + */ +static int link_name(char *restrict const buf, unsigned maj, unsigned min, int pid, const char *restrict name){ + struct stat sbuf; + char path[32]; + ssize_t count; + const int len = snprintf(path, sizeof path, "/proc/%d/%s", pid, name); /* often permission denied */ + if(len <= 0 || (size_t)len >= sizeof path) return 0; + count = readlink(path,buf,TTY_NAME_SIZE-1); + if(count <= 0 || count >= TTY_NAME_SIZE-1) return 0; + buf[count] = '\0'; + if(stat(buf, &sbuf) < 0) return 0; + if(min != minor(sbuf.st_rdev)) return 0; + if(maj != major(sbuf.st_rdev)) return 0; + return 1; +} + +#ifdef USE_PROC_CTTY +/* Cygwin keeps the name to the controlling tty in a virtual file called + /proc/PID/ctty, including a trailing LF (sigh). */ +static int ctty_name(char *restrict const buf, int pid) { + char path[32]; + FILE *fp; + char *lf; + sprintf (path, "/proc/%d/ctty", pid); /* often permission denied */ + fp = fopen (path, "r"); + if (!fp) + return 0; + if (!fgets (buf,TTY_NAME_SIZE,fp)) + { + fclose (fp); + return 0; + } + fclose (fp); + lf = strchr (buf, '\n'); + if (lf) + *lf = (lf == buf ? '?' : '\0'); + return 1; +} +#endif + +/* number --> name */ +unsigned dev_to_tty(char *restrict ret, unsigned chop, dev_t dev_t_dev, int pid, unsigned int flags) { + static __thread char buf[TTY_NAME_SIZE]; + char *restrict tmp = buf; + unsigned dev = dev_t_dev; + unsigned i = 0; + int c; +#ifdef USE_PROC_CTTY + if( ctty_name(tmp, pid )) goto abbrev; +#endif + if(dev == 0u) goto no_tty; + if(driver_name(tmp, major(dev), minor(dev) )) goto abbrev; + if( link_name(tmp, major(dev), minor(dev), pid, "fd/2" )) goto abbrev; + if( guess_name(tmp, major(dev), minor(dev) )) goto abbrev; + if( link_name(tmp, major(dev), minor(dev), pid, "fd/255")) goto abbrev; + // fall through if unable to find a device file +no_tty: + strcpy(ret, chop >= 1 ? "?" : ""); + return 1; +abbrev: + if((flags&ABBREV_DEV) && !strncmp(tmp,"/dev/",5) && tmp[5]) tmp += 5; + if((flags&ABBREV_TTY) && !strncmp(tmp,"tty", 3) && tmp[3]) tmp += 3; + if((flags&ABBREV_PTS) && !strncmp(tmp,"pts/", 4) && tmp[4]) tmp += 4; + /* gotta check before we chop or we may chop someone else's memory */ + if(chop + (unsigned long)(tmp-buf) < sizeof buf) + tmp[chop] = '\0'; + /* replace non-ASCII characters with '?' and return the number of chars */ + while(i < chop){ + c = *tmp; + tmp++; + if(!c) break; + i++; + if(c<=' ') c = '?'; + if(c>126) c = '?'; + *ret = c; + ret++; + } + *ret = '\0'; + return i; +} diff --git a/library/diskstats.c b/library/diskstats.c new file mode 100644 index 0000000..b4e41f3 --- /dev/null +++ b/library/diskstats.c @@ -0,0 +1,1027 @@ +/* + * diskstats.c - disk I/O related definitions for libproc2 + * + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2003 Albert Cahalan + * Copyright © 2003 Fabian Frederick + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <errno.h> +#include <fcntl.h> +#include <dirent.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> + +#include <sys/stat.h> +#include <sys/types.h> + +#include "procps-private.h" +#include "diskstats.h" + +/* The following define will cause the 'node_add' function to maintain our | + nodes list in ascending alphabetical order which could be used to avoid | + a sort on name. Without it, we default to a 'pull-up' stack at slightly | + more effort than a simple 'push-down' list to duplicate prior behavior. | */ +//#define ALPHABETIC_NODES + +#define DISKSTATS_LINE_LEN 1024 +#define DISKSTATS_NAME_LEN 34 +#define DISKSTATS_FILE "/proc/diskstats" +#define SYSBLOCK_DIR "/sys/block" + +#define STACKS_INCR 64 // amount reap stack allocations grow +#define STR_COMPARE strverscmp + +/* ----------------------------------------------------------------------- + + this provision can help ensure that our Item_table remains synchronized | + with the enumerators found in the associated header file. It's intended | + to only be used locally (& temporarily) at some point before a release! | */ +// #define ITEMTABLE_DEBUG //--------------------------------------------- | +// ----------------------------------------------------------------------- + + + +struct dev_data { + unsigned long reads; + unsigned long reads_merged; + unsigned long read_sectors; + unsigned long read_time; + unsigned long writes; + unsigned long writes_merged; + unsigned long write_sectors; + unsigned long write_time; + unsigned long io_inprogress; + unsigned long io_time; + unsigned long io_wtime; +}; + +struct dev_node { + char name[DISKSTATS_NAME_LEN+1]; + int type; + int major; + int minor; + time_t stamped; + struct dev_data new; + struct dev_data old; + struct dev_node *next; +}; + +struct stacks_extent { + int ext_numstacks; + struct stacks_extent *next; + struct diskstats_stack **stacks; +}; + +struct ext_support { + int numitems; // includes 'logical_end' delimiter + enum diskstats_item *items; // includes 'logical_end' delimiter + struct stacks_extent *extents; // anchor for these extents +}; + +struct fetch_support { + struct diskstats_stack **anchor; // fetch consolidated extents + int n_alloc; // number of above pointers allocated + int n_inuse; // number of above pointers occupied + int n_alloc_save; // last known reap.stacks allocation + struct diskstats_reaped results; // count + stacks for return to caller +}; + +struct diskstats_info { + int refcount; + FILE *diskstats_fp; + time_t old_stamp; // previous read seconds + time_t new_stamp; // current read seconds + struct dev_node *nodes; // dev nodes anchor + struct ext_support select_ext; // supports concurrent select/reap + struct ext_support fetch_ext; // supports concurrent select/reap + struct fetch_support fetch; // support for procps_diskstats_reap + struct diskstats_result get_this; // used by procps_diskstats_get +}; + + +// ___ Results 'Set' Support |||||||||||||||||||||||||||||||||||||||||||||||||| + +#define setNAME(e) set_diskstats_ ## e +#define setDECL(e) static void setNAME(e) \ + (struct diskstats_result *R, struct dev_node *N) + +// regular assignment +#define DEV_set(e,t,x) setDECL(e) { R->result. t = N-> x; } +#define REG_set(e,t,x) setDECL(e) { R->result. t = N->new. x; } +// delta assignment +#define HST_set(e,t,x) setDECL(e) { R->result. t = ( N->new. x - N->old. x ); } + +setDECL(noop) { (void)R; (void)N; } +setDECL(extra) { (void)N; R->result.ul_int = 0; } + +DEV_set(NAME, str, name) +DEV_set(TYPE, s_int, type) +DEV_set(MAJOR, s_int, major) +DEV_set(MINOR, s_int, minor) + +REG_set(READS, ul_int, reads) +REG_set(READS_MERGED, ul_int, reads_merged) +REG_set(READ_SECTORS, ul_int, read_sectors) +REG_set(READ_TIME, ul_int, read_time) +REG_set(WRITES, ul_int, writes) +REG_set(WRITES_MERGED, ul_int, writes_merged) +REG_set(WRITE_SECTORS, ul_int, write_sectors) +REG_set(WRITE_TIME, ul_int, write_time) +REG_set(IO_TIME, ul_int, io_time) +REG_set(WEIGHTED_TIME, ul_int, io_wtime) + +REG_set(IO_INPROGRESS, s_int, io_inprogress) + +HST_set(DELTA_READS, s_int, reads) +HST_set(DELTA_READS_MERGED, s_int, reads_merged) +HST_set(DELTA_READ_SECTORS, s_int, read_sectors) +HST_set(DELTA_READ_TIME, s_int, read_time) +HST_set(DELTA_WRITES, s_int, writes) +HST_set(DELTA_WRITES_MERGED, s_int, writes_merged) +HST_set(DELTA_WRITE_SECTORS, s_int, write_sectors) +HST_set(DELTA_WRITE_TIME, s_int, write_time) +HST_set(DELTA_IO_TIME, s_int, io_time) +HST_set(DELTA_WEIGHTED_TIME, s_int, io_wtime) + +#undef setDECL +#undef DEV_set +#undef REG_set +#undef HST_set + + +// ___ Sorting Support |||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +struct sort_parms { + int offset; + enum diskstats_sort_order order; +}; + +#define srtNAME(t) sort_diskstats_ ## t +#define srtDECL(t) static int srtNAME(t) \ + (const struct diskstats_stack **A, const struct diskstats_stack **B, struct sort_parms *P) + +srtDECL(s_int) { + const struct diskstats_result *a = (*A)->head + P->offset; \ + const struct diskstats_result *b = (*B)->head + P->offset; \ + return P->order * (a->result.s_int - b->result.s_int); +} + +srtDECL(ul_int) { + const struct diskstats_result *a = (*A)->head + P->offset; \ + const struct diskstats_result *b = (*B)->head + P->offset; \ + if ( a->result.ul_int > b->result.ul_int ) return P->order > 0 ? 1 : -1; \ + if ( a->result.ul_int < b->result.ul_int ) return P->order > 0 ? -1 : 1; \ + return 0; +} + +srtDECL(str) { + const struct diskstats_result *a = (*A)->head + P->offset; + const struct diskstats_result *b = (*B)->head + P->offset; + return P->order * STR_COMPARE(a->result.str, b->result.str); +} + +srtDECL(noop) { \ + (void)A; (void)B; (void)P; \ + return 0; +} + +#undef srtDECL + + +// ___ Controlling Table |||||||||||||||||||||||||||||||||||||||||||||||||||||| + +typedef void (*SET_t)(struct diskstats_result *, struct dev_node *); +#ifdef ITEMTABLE_DEBUG +#define RS(e) (SET_t)setNAME(e), DISKSTATS_ ## e, STRINGIFY(DISKSTATS_ ## e) +#else +#define RS(e) (SET_t)setNAME(e) +#endif + +typedef int (*QSR_t)(const void *, const void *, void *); +#define QS(t) (QSR_t)srtNAME(t) + +#define TS(t) STRINGIFY(t) +#define TS_noop "" + + /* + * Need it be said? + * This table must be kept in the exact same order as + * those *enum diskstats_item* guys ! */ +static struct { + SET_t setsfunc; // the actual result setting routine +#ifdef ITEMTABLE_DEBUG + int enumnumb; // enumerator (must match position!) + char *enum2str; // enumerator name as a char* string +#endif + QSR_t sortfunc; // sort cmp func for a specific type + char *type2str; // the result type as a string value +} Item_table[] = { +/* setsfunc sortfunc type2str + ------------------------ ----------- ---------- */ + { RS(noop), QS(noop), TS_noop }, + { RS(extra), QS(ul_int), TS_noop }, + + { RS(NAME), QS(str), TS(str) }, + { RS(TYPE), QS(s_int), TS(s_int) }, + { RS(MAJOR), QS(s_int), TS(s_int) }, + { RS(MINOR), QS(s_int), TS(s_int) }, + + { RS(READS), QS(ul_int), TS(ul_int) }, + { RS(READS_MERGED), QS(ul_int), TS(ul_int) }, + { RS(READ_SECTORS), QS(ul_int), TS(ul_int) }, + { RS(READ_TIME), QS(ul_int), TS(ul_int) }, + { RS(WRITES), QS(ul_int), TS(ul_int) }, + { RS(WRITES_MERGED), QS(ul_int), TS(ul_int) }, + { RS(WRITE_SECTORS), QS(ul_int), TS(ul_int) }, + { RS(WRITE_TIME), QS(ul_int), TS(ul_int) }, + { RS(IO_TIME), QS(ul_int), TS(ul_int) }, + { RS(WEIGHTED_TIME), QS(ul_int), TS(ul_int) }, + + { RS(IO_INPROGRESS), QS(s_int), TS(s_int) }, + + { RS(DELTA_READS), QS(s_int), TS(s_int) }, + { RS(DELTA_READS_MERGED), QS(s_int), TS(s_int) }, + { RS(DELTA_READ_SECTORS), QS(s_int), TS(s_int) }, + { RS(DELTA_READ_TIME), QS(s_int), TS(s_int) }, + { RS(DELTA_WRITES), QS(s_int), TS(s_int) }, + { RS(DELTA_WRITES_MERGED), QS(s_int), TS(s_int) }, + { RS(DELTA_WRITE_SECTORS), QS(s_int), TS(s_int) }, + { RS(DELTA_WRITE_TIME), QS(s_int), TS(s_int) }, + { RS(DELTA_IO_TIME), QS(s_int), TS(s_int) }, + { RS(DELTA_WEIGHTED_TIME), QS(s_int), TS(s_int) }, +}; + + /* please note, + * this enum MUST be 1 greater than the highest value of any enum */ +enum diskstats_item DISKSTATS_logical_end = MAXTABLE(Item_table); + +#undef setNAME +#undef srtNAME +#undef RS +#undef QS + + +// ___ Private Functions |||||||||||||||||||||||||||||||||||||||||||||||||||||| +// --- dev_node specific support ---------------------------------------------- + +static struct dev_node *node_add ( + struct diskstats_info *info, + struct dev_node *this) +{ + struct dev_node *prev, *walk; + +#ifdef ALPHABETIC_NODES + if (!info->nodes + || (STR_COMPARE(this->name, info->nodes->name) < 0)) { + this->next = info->nodes; + info->nodes = this; + return this; + } + prev = info->nodes; + walk = info->nodes->next; + while (walk) { + if (STR_COMPARE(this->name, walk->name) < 0) + break; + prev = walk; + walk = walk->next; + } + prev->next = this; + this->next = walk; +#else + if (!info->nodes) + info->nodes = this; + else { + walk = info->nodes; + do { + prev = walk; + walk = walk->next; + } while (walk); + prev->next = this; + } +#endif + return this; +} // end: node_add + + +static void node_classify ( + struct dev_node *this) +{ + DIR *dirp; + struct dirent *dent; + + /* all disks start off as partitions. this function + checks /sys/block and changes a device found there + into a disk. if /sys/block cannot have the directory + read, all devices are then treated as disks. */ + this->type = DISKSTATS_TYPE_PARTITION; + + if (!(dirp = opendir(SYSBLOCK_DIR))) { + this->type = DISKSTATS_TYPE_DISK; + return; + } + while ((dent = readdir(dirp))) { + if (strcmp(this->name, dent->d_name) == 0) { + this->type = DISKSTATS_TYPE_DISK; + break; + } + } + closedir(dirp); +} // end: node_classify + + +static struct dev_node *node_cut ( + struct diskstats_info *info, + struct dev_node *this) +{ + struct dev_node *node = info->nodes; + + if (this) { + if (this == node) { + info->nodes = node->next; + return this; + } + do { + if (this == node->next) { + node->next = node->next->next; + return this; + } + node = node->next; + } while (node); + } + return NULL; +} // end: node_cut + + +static struct dev_node *node_get ( + struct diskstats_info *info, + const char *name) +{ + struct dev_node *node = info->nodes; + + while (node) { + if (strcmp(name, node->name) == 0) + break; + node = node->next; + } + if (node) { + /* if this disk or partition has somehow gotten stale, we'll lose + it and then pretend it was never actually found ... + [ we test against both stamps in case a 'read' was avoided ] */ + if (node->stamped != info->old_stamp + && (node->stamped != info->new_stamp)) { + free(node_cut(info, node)); + node = NULL; + } + } + return node; +} // end: node_get + + +static int node_update ( + struct diskstats_info *info, + struct dev_node *source) +{ + struct dev_node *target = node_get(info, source->name); + + if (!target) { + if (!(target = malloc(sizeof(struct dev_node)))) + return 0; + memcpy(target, source, sizeof(struct dev_node)); + // let's not distort the deltas when a new node is created ... + memcpy(&target->old, &target->new, sizeof(struct dev_data)); + node_classify(target); + node_add(info, target); + return 1; + } + // remember history from last time around ... + memcpy(&source->old, &target->new, sizeof(struct dev_data)); + // preserve some stuff from the existing node struct ... + source->type = target->type; + source->next = target->next; + // finally 'update' the existing node struct ... + memcpy(target, source, sizeof(struct dev_node)); + return 1; +} // end: node_update + + +// ___ Private Functions |||||||||||||||||||||||||||||||||||||||||||||||||||||| +// --- generalized support ---------------------------------------------------- + +static inline void diskstats_assign_results ( + struct diskstats_stack *stack, + struct dev_node *node) +{ + struct diskstats_result *this = stack->head; + + for (;;) { + enum diskstats_item item = this->item; + if (item >= DISKSTATS_logical_end) + break; + Item_table[item].setsfunc(this, node); + ++this; + } + return; +} // end: diskstats_assign_results + + +static void diskstats_extents_free_all ( + struct ext_support *this) +{ + while (this->extents) { + struct stacks_extent *p = this->extents; + this->extents = this->extents->next; + free(p); + }; +} // end: diskstats_extents_free_all + + +static inline struct diskstats_result *diskstats_itemize_stack ( + struct diskstats_result *p, + int depth, + enum diskstats_item *items) +{ + struct diskstats_result *p_sav = p; + int i; + + for (i = 0; i < depth; i++) { + p->item = items[i]; + ++p; + } + return p_sav; +} // end: diskstats_itemize_stack + + +static inline int diskstats_items_check_failed ( + enum diskstats_item *items, + int numitems) +{ + int i; + + /* if an enum is passed instead of an address of one or more enums, ol' gcc + * will silently convert it to an address (possibly NULL). only clang will + * offer any sort of warning like the following: + * + * warning: incompatible integer to pointer conversion passing 'int' to parameter of type 'enum diskstats_item *' + * my_stack = procps_diskstats_select(info, DISKSTATS_noop, num); + * ^~~~~~~~~~~~~~~~ + */ + if (numitems < 1 + || (void *)items < (void *)(unsigned long)(2 * DISKSTATS_logical_end)) + return 1; + + for (i = 0; i < numitems; i++) { + // a diskstats_item is currently unsigned, but we'll protect our future + if (items[i] < 0) + return 1; + if (items[i] >= DISKSTATS_logical_end) + return 1; + } + + return 0; +} // end: diskstats_items_check_failed + + +/* + * diskstats_read_failed: + * + * @info: info structure created at procps_diskstats_new + * + * Read the data out of /proc/diskstats putting the information + * into the supplied info structure + * + * Returns: 0 on success, 1 on error + */ +static int diskstats_read_failed ( + struct diskstats_info *info) +{ + static const char *fmtstr = "%d %d %" STRINGIFY(DISKSTATS_NAME_LEN) \ + "s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu"; + char buf[DISKSTATS_LINE_LEN]; + struct dev_node node; + int rc; + + if (!info->diskstats_fp + && (!(info->diskstats_fp = fopen(DISKSTATS_FILE, "r")))) + return 1; + + if (fseek(info->diskstats_fp, 0L, SEEK_SET) == -1) + return 1; + + info->old_stamp = info->new_stamp; + info->new_stamp = time(NULL); + + while (fgets(buf, DISKSTATS_LINE_LEN, info->diskstats_fp)) { + // clear out the soon to be 'current'values + memset(&node, 0, sizeof(struct dev_node)); + + rc = sscanf(buf, fmtstr + , &node.major + , &node.minor + , &node.name[0] + , &node.new.reads + , &node.new.reads_merged + , &node.new.read_sectors + , &node.new.read_time + , &node.new.writes + , &node.new.writes_merged + , &node.new.write_sectors + , &node.new.write_time + , &node.new.io_inprogress + , &node.new.io_time + , &node.new.io_wtime); + + if (rc != 14) { + errno = ERANGE; + return 1; + } + node.stamped = info->new_stamp; + if (!node_update(info, &node)) + return 1; // here, errno was set to ENOMEM + } + + return 0; +} // end: diskstats_read_failed + + +/* + * diskstats_stacks_alloc(): + * + * Allocate and initialize one or more stacks each of which is anchored in an + * associated context structure. + * + * All such stacks will have their result structures properly primed with + * 'items', while the result itself will be zeroed. + * + * Returns a stacks_extent struct anchoring the 'heads' of each new stack. + */ +static struct stacks_extent *diskstats_stacks_alloc ( + struct ext_support *this, + int maxstacks) +{ + struct stacks_extent *p_blob; + struct diskstats_stack **p_vect; + struct diskstats_stack *p_head; + size_t vect_size, head_size, list_size, blob_size; + void *v_head, *v_list; + int i; + + vect_size = sizeof(void *) * maxstacks; // size of the addr vectors | + vect_size += sizeof(void *); // plus NULL addr delimiter | + head_size = sizeof(struct diskstats_stack); // size of that head struct | + list_size = sizeof(struct diskstats_result) * this->numitems; // any single results stack | + blob_size = sizeof(struct stacks_extent); // the extent anchor itself | + blob_size += vect_size; // plus room for addr vects | + blob_size += head_size * maxstacks; // plus room for head thing | + blob_size += list_size * maxstacks; // plus room for our stacks | + + /* note: all of our memory is allocated in one single blob, facilitating some later free(). | + as a minimum, it's important that all of those result structs themselves always be | + contiguous within every stack since they will be accessed via a relative position. | */ + if (NULL == (p_blob = calloc(1, blob_size))) + return NULL; + + p_blob->next = this->extents; // push this extent onto... | + this->extents = p_blob; // ...some existing extents | + p_vect = (void *)p_blob + sizeof(struct stacks_extent); // prime our vector pointer | + p_blob->stacks = p_vect; // set actual vectors start | + v_head = (void *)p_vect + vect_size; // prime head pointer start | + v_list = v_head + (head_size * maxstacks); // prime our stacks pointer | + + for (i = 0; i < maxstacks; i++) { + p_head = (struct diskstats_stack *)v_head; + p_head->head = diskstats_itemize_stack((struct diskstats_result *)v_list, this->numitems, this->items); + p_blob->stacks[i] = p_head; + v_list += list_size; + v_head += head_size; + } + p_blob->ext_numstacks = maxstacks; + return p_blob; +} // end: diskstats_stacks_alloc + + +static int diskstats_stacks_fetch ( + struct diskstats_info *info) +{ + #define n_alloc info->fetch.n_alloc + #define n_inuse info->fetch.n_inuse + #define n_saved info->fetch.n_alloc_save + struct stacks_extent *ext; + struct dev_node *node; + + // initialize stuff ----------------------------------- + if (!info->fetch.anchor) { + if (!(info->fetch.anchor = calloc(sizeof(void *), STACKS_INCR))) + return -ENOMEM; + n_alloc = STACKS_INCR; + } + if (!info->fetch_ext.extents) { + if (!(ext = diskstats_stacks_alloc(&info->fetch_ext, n_alloc))) + return -1; // here, errno was set to ENOMEM + memcpy(info->fetch.anchor, ext->stacks, sizeof(void *) * n_alloc); + } + + // iterate stuff -------------------------------------- + n_inuse = 0; + node = info->nodes; + while (node) { + if (!(n_inuse < n_alloc)) { + n_alloc += STACKS_INCR; + if ((!(info->fetch.anchor = realloc(info->fetch.anchor, sizeof(void *) * n_alloc))) + || (!(ext = diskstats_stacks_alloc(&info->fetch_ext, STACKS_INCR)))) + return -1; // here, errno was set to ENOMEM + memcpy(info->fetch.anchor + n_inuse, ext->stacks, sizeof(void *) * STACKS_INCR); + } + diskstats_assign_results(info->fetch.anchor[n_inuse], node); + ++n_inuse; + node = node->next; + } + + // finalize stuff ------------------------------------- + /* note: we go to this trouble of maintaining a duplicate of the consolidated | + extent stacks addresses represented as our 'anchor' since these ptrs | + are exposed to a user (um, not that we don't trust 'em or anything). | + plus, we can NULL delimit these ptrs which we couldn't do otherwise. | */ + if (n_saved < n_inuse + 1) { + n_saved = n_inuse + 1; + if (!(info->fetch.results.stacks = realloc(info->fetch.results.stacks, sizeof(void *) * n_saved))) + return -1; + } + memcpy(info->fetch.results.stacks, info->fetch.anchor, sizeof(void *) * n_inuse); + info->fetch.results.stacks[n_inuse] = NULL; + info->fetch.results.total = n_inuse; + + return n_inuse; + #undef n_alloc + #undef n_inuse + #undef n_saved +} // end: diskstats_stacks_fetch + + +static int diskstats_stacks_reconfig_maybe ( + struct ext_support *this, + enum diskstats_item *items, + int numitems) +{ + if (diskstats_items_check_failed(items, numitems)) + return -1; + /* is this the first time or have things changed since we were last called? + if so, gotta' redo all of our stacks stuff ... */ + if (this->numitems != numitems + 1 + || memcmp(this->items, items, sizeof(enum diskstats_item) * numitems)) { + // allow for our DISKSTATS_logical_end + if (!(this->items = realloc(this->items, sizeof(enum diskstats_item) * (numitems + 1)))) + return -1; // here, errno was set to ENOMEM + memcpy(this->items, items, sizeof(enum diskstats_item) * numitems); + this->items[numitems] = DISKSTATS_logical_end; + this->numitems = numitems + 1; + diskstats_extents_free_all(this); + return 1; + } + return 0; +} // end: diskstats_stacks_reconfig_maybe + + +// ___ Public Functions ||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +// --- standard required functions -------------------------------------------- + +/* + * procps_diskstats_new(): + * + * @info: location of returned new structure + * + * Returns: < 0 on failure, 0 on success along with + * a pointer to a new context struct + */ +PROCPS_EXPORT int procps_diskstats_new ( + struct diskstats_info **info) +{ + struct diskstats_info *p; + +#ifdef ITEMTABLE_DEBUG + int i, failed = 0; + for (i = 0; i < MAXTABLE(Item_table); i++) { + if (i != Item_table[i].enumnumb) { + fprintf(stderr, "%s: enum/table error: Item_table[%d] was %s, but its value is %d\n" + , __FILE__, i, Item_table[i].enum2str, Item_table[i].enumnumb); + failed = 1; + } + } + if (failed) _Exit(EXIT_FAILURE); +#endif + + if (info == NULL || *info != NULL) + return -EINVAL; + if (!(p = calloc(1, sizeof(struct diskstats_info)))) + return -ENOMEM; + + p->refcount = 1; + + /* do a priming read here for the following potential benefits: | + 1) ensure there will be no problems with subsequent access | + 2) make delta results potentially useful, even if 1st time | + 3) elimnate need for history distortions 1st time 'switch' | */ + if (diskstats_read_failed(p)) { + procps_diskstats_unref(&p); + return -errno; + } + + *info = p; + return 0; +} // end: procps_diskstats_new + + +PROCPS_EXPORT int procps_diskstats_ref ( + struct diskstats_info *info) +{ + if (info == NULL) + return -EINVAL; + + info->refcount++; + return info->refcount; +} // end: procps_diskstats_ref + + +PROCPS_EXPORT int procps_diskstats_unref ( + struct diskstats_info **info) +{ + struct dev_node *node; + + if (info == NULL || *info == NULL) + return -EINVAL; + + (*info)->refcount--; + + if ((*info)->refcount < 1) { + int errno_sav = errno; + + if ((*info)->diskstats_fp) { + fclose((*info)->diskstats_fp); + (*info)->diskstats_fp = NULL; + } + node = (*info)->nodes; + while (node) { + struct dev_node *p = node; + node = p->next; + free(p); + } + if ((*info)->select_ext.extents) + diskstats_extents_free_all((&(*info)->select_ext)); + if ((*info)->select_ext.items) + free((*info)->select_ext.items); + + if ((*info)->fetch.anchor) + free((*info)->fetch.anchor); + if ((*info)->fetch.results.stacks) + free((*info)->fetch.results.stacks); + + if ((*info)->fetch_ext.extents) + diskstats_extents_free_all(&(*info)->fetch_ext); + if ((*info)->fetch_ext.items) + free((*info)->fetch_ext.items); + + free(*info); + *info = NULL; + + errno = errno_sav; + return 0; + } + return (*info)->refcount; +} // end: procps_diskstats_unref + + +// --- variable interface functions ------------------------------------------- + +PROCPS_EXPORT struct diskstats_result *procps_diskstats_get ( + struct diskstats_info *info, + const char *name, + enum diskstats_item item) +{ + struct dev_node *node; + time_t cur_secs; + + errno = EINVAL; + if (info == NULL) + return NULL; + if (item < 0 || item >= DISKSTATS_logical_end) + return NULL; + errno = 0; + + /* we will NOT read the diskstat file with every call - rather, we'll offer + a granularity of 1 second between reads ... */ + cur_secs = time(NULL); + if (1 <= cur_secs - info->new_stamp) { + if (diskstats_read_failed(info)) + return NULL; + } + + info->get_this.item = item; + // with 'get', we must NOT honor the usual 'noop' guarantee + info->get_this.result.ul_int = 0; + + if (!(node = node_get(info, name))) { + errno = ENXIO; + return NULL; + } + Item_table[item].setsfunc(&info->get_this, node); + + return &info->get_this; +} // end: procps_diskstats_get + + +/* procps_diskstats_reap(): + * + * Harvest all the requested disks information providing + * the result stacks along with the total number of harvested. + * + * Returns: pointer to a diskstats_reaped struct on success, NULL on error. + */ +PROCPS_EXPORT struct diskstats_reaped *procps_diskstats_reap ( + struct diskstats_info *info, + enum diskstats_item *items, + int numitems) +{ + errno = EINVAL; + if (info == NULL || items == NULL) + return NULL; + if (0 > diskstats_stacks_reconfig_maybe(&info->fetch_ext, items, numitems)) + return NULL; // here, errno may be overridden with ENOMEM + errno = 0; + + if (diskstats_read_failed(info)) + return NULL; + if (0 > diskstats_stacks_fetch(info)) + return NULL; + + return &info->fetch.results; +} // end: procps_diskstats_reap + + +/* procps_diskstats_select(): + * + * Obtain all the requested disk/partition information then return + * it in a single library provided results stack. + * + * Returns: pointer to a diskstats_stack struct on success, NULL on error. + */ +PROCPS_EXPORT struct diskstats_stack *procps_diskstats_select ( + struct diskstats_info *info, + const char *name, + enum diskstats_item *items, + int numitems) +{ + struct dev_node *node; + + errno = EINVAL; + if (info == NULL || items == NULL) + return NULL; + if (0 > diskstats_stacks_reconfig_maybe(&info->select_ext, items, numitems)) + return NULL; // here, errno may be overridden with ENOMEM + errno = 0; + + if (!info->select_ext.extents + && (!diskstats_stacks_alloc(&info->select_ext, 1))) + return NULL; + + if (diskstats_read_failed(info)) + return NULL; + if (!(node = node_get(info, name))) { + errno = ENXIO; + return NULL; + } + + diskstats_assign_results(info->select_ext.extents->stacks[0], node); + + return info->select_ext.extents->stacks[0]; +} // end: procps_diskstats_select + + +/* + * procps_diskstats_sort(): + * + * Sort stacks anchored in the passed stack pointers array + * based on the designated sort enumerator and specified order. + * + * Returns those same addresses sorted. + * + * Note: all of the stacks must be homogeneous (of equal length and content). + */ +PROCPS_EXPORT struct diskstats_stack **procps_diskstats_sort ( + struct diskstats_info *info, + struct diskstats_stack *stacks[], + int numstacked, + enum diskstats_item sortitem, + enum diskstats_sort_order order) +{ + struct diskstats_result *p; + struct sort_parms parms; + int offset; + + errno = EINVAL; + if (info == NULL || stacks == NULL) + return NULL; + // a diskstats_item is currently unsigned, but we'll protect our future + if (sortitem < 0 || sortitem >= DISKSTATS_logical_end) + return NULL; + if (order != DISKSTATS_SORT_ASCEND && order != DISKSTATS_SORT_DESCEND) + return NULL; + if (numstacked < 2) + return stacks; + + offset = 0; + p = stacks[0]->head; + for (;;) { + if (p->item == sortitem) + break; + ++offset; + if (p->item >= DISKSTATS_logical_end) + return NULL; + ++p; + } + errno = 0; + + parms.offset = offset; + parms.order = order; + + qsort_r(stacks, numstacked, sizeof(void *), (QSR_t)Item_table[p->item].sortfunc, &parms); + return stacks; +} // end: procps_diskstats_sort + + +// --- special debugging function(s) ------------------------------------------ +/* + * The following isn't part of the normal programming interface. Rather, + * it exists to validate result types referenced in application programs. + * + * It's used only when: + * 1) the 'XTRA_PROCPS_DEBUG' has been defined, or + * 2) an #include of 'xtra-procps-debug.h' is used + */ + +PROCPS_EXPORT struct diskstats_result *xtra_diskstats_get ( + struct diskstats_info *info, + const char *name, + enum diskstats_item actual_enum, + const char *typestr, + const char *file, + int lineno) +{ + struct diskstats_result *r = procps_diskstats_get(info, name, actual_enum); + + if (actual_enum < 0 || actual_enum >= DISKSTATS_logical_end) { + fprintf(stderr, "%s line %d: invalid item = %d, type = %s\n" + , file, lineno, actual_enum, typestr); + } + if (r) { + char *str = Item_table[r->item].type2str; + if (str[0] + && (strcmp(typestr, str))) + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return r; +} // end: xtra_diskstats_get_ + + +PROCPS_EXPORT struct diskstats_result *xtra_diskstats_val ( + int relative_enum, + const char *typestr, + const struct diskstats_stack *stack, + struct diskstats_info *info, + const char *file, + int lineno) +{ + char *str; + int i; + + for (i = 0; stack->head[i].item < DISKSTATS_logical_end; i++) + ; + if (relative_enum < 0 || relative_enum >= i) { + fprintf(stderr, "%s line %d: invalid relative_enum = %d, valid range = 0-%d\n" + , file, lineno, relative_enum, i-1); + return NULL; + } + str = Item_table[stack->head[relative_enum].item].type2str; + if (str[0] + && (strcmp(typestr, str))) { + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return &stack->head[relative_enum]; + (void)info; +} // end: xtra_diskstats_val diff --git a/library/escape.c b/library/escape.c new file mode 100644 index 0000000..f988672 --- /dev/null +++ b/library/escape.c @@ -0,0 +1,157 @@ +/* + * escape.c - printing handling + * + * Copyright © 2011-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2016-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 1998-2005 Albert Cahalan + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <limits.h> +#include <stdio.h> +#include <string.h> + +#include "escape.h" +#include "readproc.h" +#include "nls.h" + +#define SECURE_ESCAPE_ARGS(dst, bytes) do { \ + if ((bytes) <= 0) return 0; \ + *(dst) = '\0'; \ + if ((bytes) >= INT_MAX) return 0; \ +} while (0) + +static const char UTF_tab[] = { + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x00 - 0x0F + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x10 - 0x1F + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x20 - 0x2F + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x30 - 0x3F + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 - 0x4F + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x50 - 0x5F + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 - 0x6F + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x70 - 0x7F + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 0x80 - 0x8F + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 0x90 - 0x9F + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 0xA0 - 0xAF + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 0xB0 - 0xBF + -1,-1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xC0 - 0xCF + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xD0 - 0xDF + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xE0 - 0xEF + 4, 4, 4, 4, 4,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 0xF0 - 0xFF +}; + +static const unsigned char ESC_tab[] = { + "@..............................." // 0x00 - 0x1F + "||||||||||||||||||||||||||||||||" // 0x20 - 0x3F + "||||||||||||||||||||||||||||||||" // 0x40 - 0x5f + "|||||||||||||||||||||||||||||||." // 0x60 - 0x7F + "????????????????????????????????" // 0x80 - 0x9F + "????????????????????????????????" // 0xA0 - 0xBF + "????????????????????????????????" // 0xC0 - 0xDF + "????????????????????????????????" // 0xE0 - 0xFF +}; + +static inline void esc_all (unsigned char *str) { + unsigned char c; + + // if bad locale/corrupt str, replace non-printing stuff + while (*str) { + if ((c = ESC_tab[*str]) != '|') + *str = c; + ++str; + } +} + +static inline void esc_ctl (unsigned char *str, int len) { + #define setQ { *str = '?'; n = 1; goto next_up; } + int i, n, x; + + for (i = 0; i < len; ) { + n = UTF_tab[*str]; + /* even with a proper locale, strings might be corrupt or we + might encounter one of those 32 unicode multibyte control + characters which begin at U+0080 (0xc280) */ + if (n < 0 || i + n > len + || (*str == 0xc2 && str[1] >= 0x80 && str[1] <= 0x9f)) { + setQ + } + /* let's validate those utf-8 continuation bytes too, all of + which must take the binary form of 10xxxxxx */ + for (x = 1; x < n; x++) { + if (str[x] < 0x80 || str[x] > 0xbf) { + setQ + } + } + // and eliminate those non-printing control characters + if (*str < 0x20 || *str == 0x7f) + *str = '?'; +next_up: + str += n; + i += n; + } + #undef setQ +} + +int escape_str (char *dst, const char *src, int bufsize) { + static __thread int utf_sw = 0; + int n; + + if (utf_sw == 0) { + char *enc = nl_langinfo(CODESET); + utf_sw = enc && strcasecmp(enc, "UTF-8") == 0 ? 1 : -1; + } + SECURE_ESCAPE_ARGS(dst, bufsize); + n = snprintf(dst, bufsize, "%s", src); + if (n < 0) { + *dst = '\0'; + return 0; + } + if (n >= bufsize) n = bufsize-1; + if (utf_sw < 0) + esc_all((unsigned char *)dst); + else + esc_ctl((unsigned char *)dst, n); + return n; +} + +int escape_command (char *outbuf, const proc_t *pp, int bytes, unsigned flags) { + int overhead = 0; + int end = 0; + + if (flags & ESC_BRACKETS) + overhead += 2; + if (flags & ESC_DEFUNCT) { + if (pp->state == 'Z') overhead += 10; // chars in " <defunct>" + else flags &= ~ESC_DEFUNCT; + } + if (overhead + 1 >= bytes) { + // if no room for even one byte of the command name + outbuf[0] = '\0'; + return 0; + } + if (flags & ESC_BRACKETS) + outbuf[end++] = '['; + end += escape_str(outbuf+end, pp->cmd, bytes-overhead); + // we want "[foo] <defunct>", not "[foo <defunct>]" + if (flags & ESC_BRACKETS) + outbuf[end++] = ']'; + if (flags & ESC_DEFUNCT) { + memcpy(outbuf+end, " <defunct>", 10); + end += 10; + } + outbuf[end] = '\0'; + return end; // bytes, not including the NUL +} diff --git a/library/include/devname.h b/library/include/devname.h new file mode 100644 index 0000000..467cd29 --- /dev/null +++ b/library/include/devname.h @@ -0,0 +1,10 @@ +#ifndef PROC_DEVNAME_H +#define PROC_DEVNAME_H + +#define ABBREV_DEV 1 /* remove /dev/ */ +#define ABBREV_TTY 2 /* remove tty */ +#define ABBREV_PTS 4 /* remove pts/ */ + +unsigned dev_to_tty(char *__restrict ret, unsigned chop, dev_t dev_t_dev, int pid, unsigned int flags); + +#endif diff --git a/library/include/diskstats.h b/library/include/diskstats.h new file mode 100644 index 0000000..d5a4b1f --- /dev/null +++ b/library/include/diskstats.h @@ -0,0 +1,135 @@ +/* + * diskstats.h - disk I/O related declarations for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef PROCPS_DISKSTATS_H +#define PROCPS_DISKSTATS_H + +#ifdef __cplusplus +extern "C" { +#endif + +enum diskstats_item { + DISKSTATS_noop, // ( never altered ) + DISKSTATS_extra, // ( reset to zero ) + // returns origin, see proc(5) + // ------- ------------------- + DISKSTATS_NAME, // str /proc/diskstats + DISKSTATS_TYPE, // s_int " + DISKSTATS_MAJOR, // s_int " + DISKSTATS_MINOR, // s_int " + + DISKSTATS_READS, // ul_int " + DISKSTATS_READS_MERGED, // ul_int " + DISKSTATS_READ_SECTORS, // ul_int " + DISKSTATS_READ_TIME, // ul_int " + DISKSTATS_WRITES, // ul_int " + DISKSTATS_WRITES_MERGED, // ul_int " + DISKSTATS_WRITE_SECTORS, // ul_int " + DISKSTATS_WRITE_TIME, // ul_int " + DISKSTATS_IO_TIME, // ul_int " + DISKSTATS_WEIGHTED_TIME, // ul_int " + + DISKSTATS_IO_INPROGRESS, // s_int " + + DISKSTATS_DELTA_READS, // s_int derived from above + DISKSTATS_DELTA_READS_MERGED, // s_int " + DISKSTATS_DELTA_READ_SECTORS, // s_int " + DISKSTATS_DELTA_READ_TIME, // s_int " + DISKSTATS_DELTA_WRITES, // s_int " + DISKSTATS_DELTA_WRITES_MERGED, // s_int " + DISKSTATS_DELTA_WRITE_SECTORS, // s_int " + DISKSTATS_DELTA_WRITE_TIME, // s_int " + DISKSTATS_DELTA_IO_TIME, // s_int " + DISKSTATS_DELTA_WEIGHTED_TIME // s_int " +}; + +enum diskstats_sort_order { + DISKSTATS_SORT_ASCEND = +1, + DISKSTATS_SORT_DESCEND = -1 +}; + + +struct diskstats_result { + enum diskstats_item item; + union { + signed int s_int; + unsigned long ul_int; + char *str; + } result; +}; + +struct diskstats_stack { + struct diskstats_result *head; +}; + +struct diskstats_reaped { + int total; + struct diskstats_stack **stacks; +}; + +struct diskstats_info; + + +#define DISKSTATS_TYPE_DISK -11111 +#define DISKSTATS_TYPE_PARTITION -22222 + +#define DISKSTATS_GET( info, name, actual_enum, type ) ( { \ + struct diskstats_result *r = procps_diskstats_get( info, name, actual_enum ); \ + r ? r->result . type : 0; } ) + +#define DISKSTATS_VAL( relative_enum, type, stack, info ) \ + stack -> head [ relative_enum ] . result . type + + +int procps_diskstats_new (struct diskstats_info **info); +int procps_diskstats_ref (struct diskstats_info *info); +int procps_diskstats_unref (struct diskstats_info **info); + +struct diskstats_result *procps_diskstats_get ( + struct diskstats_info *info, + const char *name, + enum diskstats_item item); + +struct diskstats_reaped *procps_diskstats_reap ( + struct diskstats_info *info, + enum diskstats_item *items, + int numitems); + +struct diskstats_stack *procps_diskstats_select ( + struct diskstats_info *info, + const char *name, + enum diskstats_item *items, + int numitems); + +struct diskstats_stack **procps_diskstats_sort ( + struct diskstats_info *info, + struct diskstats_stack *stacks[], + int numstacked, + enum diskstats_item sortitem, + enum diskstats_sort_order order); + + +#ifdef XTRA_PROCPS_DEBUG +# include "xtra-procps-debug.h" +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/library/include/escape.h b/library/include/escape.h new file mode 100644 index 0000000..1f0b0f9 --- /dev/null +++ b/library/include/escape.h @@ -0,0 +1,35 @@ +/* + * escape.h - printing handling + * + * Copyright © 2011-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2016-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 1998-2005 Albert Cahalan + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PROCPS_PROC_ESCAPE_H +#define PROCPS_PROC_ESCAPE_H + +#include "readproc.h" + +#define ESC_BRACKETS 0x2 // if using cmd, put '[' and ']' around it +#define ESC_DEFUNCT 0x4 // mark zombies with " <defunct>" + +int escape_command (char *outbuf, const proc_t *pp, int bytes, unsigned flags); + +int escape_str (char *dst, const char *src, int bufsize); + +#endif diff --git a/library/include/meminfo.h b/library/include/meminfo.h new file mode 100644 index 0000000..edca8d2 --- /dev/null +++ b/library/include/meminfo.h @@ -0,0 +1,216 @@ +/* + * meminfo.h - memory related declarations for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PROCPS_MEMINFO_H +#define PROCPS_MEMINFO_H + +#ifdef __cplusplus +extern "C" { +#endif + +enum meminfo_item { + MEMINFO_noop, // ( never altered ) + MEMINFO_extra, // ( reset to zero ) + /* + note: all of the following values are expressed as KiB + */ + // returns origin, see proc(5) + // ------- ------------------- + MEMINFO_MEM_ACTIVE, // ul_int /proc/meminfo + MEMINFO_MEM_ACTIVE_ANON, // ul_int " + MEMINFO_MEM_ACTIVE_FILE, // ul_int " + MEMINFO_MEM_ANON, // ul_int " + MEMINFO_MEM_AVAILABLE, // ul_int " + MEMINFO_MEM_BOUNCE, // ul_int " + MEMINFO_MEM_BUFFERS, // ul_int " + MEMINFO_MEM_CACHED, // ul_int " + MEMINFO_MEM_CACHED_ALL, // ul_int derived from MEM_CACHED + MEM_SLAB_RECLAIM + MEMINFO_MEM_CMA_FREE, // ul_int /proc/meminfo + MEMINFO_MEM_CMA_TOTAL, // ul_int " + MEMINFO_MEM_COMMITTED_AS, // ul_int " + MEMINFO_MEM_COMMIT_LIMIT, // ul_int " + MEMINFO_MEM_DIRECTMAP_1G, // ul_int " + MEMINFO_MEM_DIRECTMAP_2M, // ul_int " + MEMINFO_MEM_DIRECTMAP_4K, // ul_int " + MEMINFO_MEM_DIRECTMAP_4M, // ul_int " + MEMINFO_MEM_DIRTY, // ul_int " + MEMINFO_MEM_FILE_HUGEPAGES, // ul_int " + MEMINFO_MEM_FILE_PMDMAPPED, // ul_int " + MEMINFO_MEM_FREE, // ul_int " + MEMINFO_MEM_HARD_CORRUPTED, // ul_int " + MEMINFO_MEM_HIGH_FREE, // ul_int " + MEMINFO_MEM_HIGH_TOTAL, // ul_int " + MEMINFO_MEM_HIGH_USED, // ul_int derived from MEM_HIGH_TOTAL - MEM_HIGH_FREE + MEMINFO_MEM_HUGETBL, // ul_int /proc/meminfo + MEMINFO_MEM_HUGE_ANON, // ul_int " + MEMINFO_MEM_HUGE_FREE, // ul_int " + MEMINFO_MEM_HUGE_RSVD, // ul_int " + MEMINFO_MEM_HUGE_SIZE, // ul_int " + MEMINFO_MEM_HUGE_SURPLUS, // ul_int " + MEMINFO_MEM_HUGE_TOTAL, // ul_int " + MEMINFO_MEM_INACTIVE, // ul_int " + MEMINFO_MEM_INACTIVE_ANON, // ul_int " + MEMINFO_MEM_INACTIVE_FILE, // ul_int " + MEMINFO_MEM_KERNEL_RECLAIM, // ul_int " + MEMINFO_MEM_KERNEL_STACK, // ul_int " + MEMINFO_MEM_LOCKED, // ul_int " + MEMINFO_MEM_LOW_FREE, // ul_int " + MEMINFO_MEM_LOW_TOTAL, // ul_int " + MEMINFO_MEM_LOW_USED, // ul_int derived from MEM_LOW_TOTAL - MEM_LOW_FREE + MEMINFO_MEM_MAPPED, // ul_int /proc/meminfo + MEMINFO_MEM_MAP_COPY, // ul_int " + MEMINFO_MEM_NFS_UNSTABLE, // ul_int " + MEMINFO_MEM_PAGE_TABLES, // ul_int " + MEMINFO_MEM_PER_CPU, // ul_int " + MEMINFO_MEM_SHADOWCALLSTACK, // ul_int " + MEMINFO_MEM_SHARED, // ul_int " + MEMINFO_MEM_SHMEM_HUGE, // ul_int " + MEMINFO_MEM_SHMEM_HUGE_MAP, // ul_int " + MEMINFO_MEM_SLAB, // ul_int " + MEMINFO_MEM_SLAB_RECLAIM, // ul_int " + MEMINFO_MEM_SLAB_UNRECLAIM, // ul_int " + MEMINFO_MEM_TOTAL, // ul_int " + MEMINFO_MEM_UNEVICTABLE, // ul_int " + MEMINFO_MEM_USED, // ul_int derived from MEM_TOTAL - MEM_AVAILABLE + MEMINFO_MEM_VM_ALLOC_CHUNK, // ul_int /proc/meminfo + MEMINFO_MEM_VM_ALLOC_TOTAL, // ul_int " + MEMINFO_MEM_VM_ALLOC_USED, // ul_int " + MEMINFO_MEM_WRITEBACK, // ul_int " + MEMINFO_MEM_WRITEBACK_TMP, // ul_int " + + MEMINFO_DELTA_ACTIVE, // s_int derived from above + MEMINFO_DELTA_ACTIVE_ANON, // s_int " + MEMINFO_DELTA_ACTIVE_FILE, // s_int " + MEMINFO_DELTA_ANON, // s_int " + MEMINFO_DELTA_AVAILABLE, // s_int " + MEMINFO_DELTA_BOUNCE, // s_int " + MEMINFO_DELTA_BUFFERS, // s_int " + MEMINFO_DELTA_CACHED, // s_int " + MEMINFO_DELTA_CACHED_ALL, // s_int " + MEMINFO_DELTA_CMA_FREE, // s_int " + MEMINFO_DELTA_CMA_TOTAL, // s_int " + MEMINFO_DELTA_COMMITTED_AS, // s_int " + MEMINFO_DELTA_COMMIT_LIMIT, // s_int " + MEMINFO_DELTA_DIRECTMAP_1G, // s_int " + MEMINFO_DELTA_DIRECTMAP_2M, // s_int " + MEMINFO_DELTA_DIRECTMAP_4K, // s_int " + MEMINFO_DELTA_DIRECTMAP_4M, // s_int " + MEMINFO_DELTA_DIRTY, // s_int " + MEMINFO_DELTA_FILE_HUGEPAGES, // s_int " + MEMINFO_DELTA_FILE_PMDMAPPED, // s_int " + MEMINFO_DELTA_FREE, // s_int " + MEMINFO_DELTA_HARD_CORRUPTED, // s_int " + MEMINFO_DELTA_HIGH_FREE, // s_int " + MEMINFO_DELTA_HIGH_TOTAL, // s_int " + MEMINFO_DELTA_HIGH_USED, // s_int " + MEMINFO_DELTA_HUGETBL, // s_int " + MEMINFO_DELTA_HUGE_ANON, // s_int " + MEMINFO_DELTA_HUGE_FREE, // s_int " + MEMINFO_DELTA_HUGE_RSVD, // s_int " + MEMINFO_DELTA_HUGE_SIZE, // s_int " + MEMINFO_DELTA_HUGE_SURPLUS, // s_int " + MEMINFO_DELTA_HUGE_TOTAL, // s_int " + MEMINFO_DELTA_INACTIVE, // s_int " + MEMINFO_DELTA_INACTIVE_ANON, // s_int " + MEMINFO_DELTA_INACTIVE_FILE, // s_int " + MEMINFO_DELTA_KERNEL_RECLAIM, // s_int " + MEMINFO_DELTA_KERNEL_STACK, // s_int " + MEMINFO_DELTA_LOCKED, // s_int " + MEMINFO_DELTA_LOW_FREE, // s_int " + MEMINFO_DELTA_LOW_TOTAL, // s_int " + MEMINFO_DELTA_LOW_USED, // s_int " + MEMINFO_DELTA_MAPPED, // s_int " + MEMINFO_DELTA_MAP_COPY, // s_int " + MEMINFO_DELTA_NFS_UNSTABLE, // s_int " + MEMINFO_DELTA_PAGE_TABLES, // s_int " + MEMINFO_DELTA_PER_CPU, // s_int " + MEMINFO_DELTA_SHADOWCALLSTACK, // s_int " + MEMINFO_DELTA_SHARED, // s_int " + MEMINFO_DELTA_SHMEM_HUGE, // s_int " + MEMINFO_DELTA_SHMEM_HUGE_MAP, // s_int " + MEMINFO_DELTA_SLAB, // s_int " + MEMINFO_DELTA_SLAB_RECLAIM, // s_int " + MEMINFO_DELTA_SLAB_UNRECLAIM, // s_int " + MEMINFO_DELTA_TOTAL, // s_int " + MEMINFO_DELTA_UNEVICTABLE, // s_int " + MEMINFO_DELTA_USED, // s_int " + MEMINFO_DELTA_VM_ALLOC_CHUNK, // s_int " + MEMINFO_DELTA_VM_ALLOC_TOTAL, // s_int " + MEMINFO_DELTA_VM_ALLOC_USED, // s_int " + MEMINFO_DELTA_WRITEBACK, // s_int " + MEMINFO_DELTA_WRITEBACK_TMP, // s_int " + + MEMINFO_SWAP_CACHED, // ul_int /proc/meminfo + MEMINFO_SWAP_FREE, // ul_int " + MEMINFO_SWAP_TOTAL, // ul_int " + MEMINFO_SWAP_USED, // ul_int derived from SWAP_TOTAL - SWAP_FREE + + MEMINFO_SWAP_DELTA_CACHED, // s_int derived from above + MEMINFO_SWAP_DELTA_FREE, // s_int " + MEMINFO_SWAP_DELTA_TOTAL, // s_int " + MEMINFO_SWAP_DELTA_USED // s_int " +}; + + +struct meminfo_result { + enum meminfo_item item; + union { + signed int s_int; + unsigned long ul_int; + } result; +}; + +struct meminfo_stack { + struct meminfo_result *head; +}; + +struct meminfo_info; + + +#define MEMINFO_GET( info, actual_enum, type ) ( { \ + struct meminfo_result *r = procps_meminfo_get( info, actual_enum ); \ + r ? r->result . type : 0; } ) + +#define MEMINFO_VAL( relative_enum, type, stack, info ) \ + stack -> head [ relative_enum ] . result . type + + +int procps_meminfo_new (struct meminfo_info **info); +int procps_meminfo_ref (struct meminfo_info *info); +int procps_meminfo_unref (struct meminfo_info **info); + +struct meminfo_result *procps_meminfo_get ( + struct meminfo_info *info, + enum meminfo_item item); + +struct meminfo_stack *procps_meminfo_select ( + struct meminfo_info *info, + enum meminfo_item *items, + int numitems); + + +#ifdef XTRA_PROCPS_DEBUG +# include "xtra-procps-debug.h" +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/library/include/misc.h b/library/include/misc.h new file mode 100644 index 0000000..bbfa5e2 --- /dev/null +++ b/library/include/misc.h @@ -0,0 +1,90 @@ +/* + * misc.h - miscellaneous declarations for libproc2 + * + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2021-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 1998-2003 Albert Cahalan + * Copyright © 1992-1998 Michael K. Johnson <johnsonm@redhat.com> + * Copyright © 1996 Charles Blake <cblake@bbn.com> + * Copyright © 1993 J. Cowley + * Copyright © 1995 Martin Schulze <joey@infodrom.north.de> + * Copyright © ???? Larry Greenfield <greenfie@gauss.rutgers.edu> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PROC_MISC_H +#define PROC_MISC_H +#include <sys/types.h> +#include <dirent.h> + +#ifdef __cplusplus +extern "C" { +#endif + + +// ////////////////////////////////////////////////////////////////// +// Platform Particulars ///////////////////////////////////////////// + +long procps_cpu_count (void); +long procps_hertz_get (void); +unsigned int procps_pid_length (void); + + // Convenience macros for composing/decomposing version codes +#define LINUX_VERSION(x,y,z) (0x10000*((x)&0x7fff) + 0x100*((y)&0xff) + ((z)&0xff)) +#define LINUX_VERSION_MAJOR(x) (((x)>>16) & 0xFF) +#define LINUX_VERSION_MINOR(x) (((x)>> 8) & 0xFF) +#define LINUX_VERSION_PATCH(x) ( (x) & 0xFF) + +int procps_linux_version(void); + + +// ////////////////////////////////////////////////////////////////// +// Runtime Particulars ////////////////////////////////////////////// + +int procps_loadavg (double *av1, double *av5, double *av15); +int procps_uptime (double *uptime_secs, double *idle_secs); +char *procps_uptime_sprint (void); +char *procps_uptime_sprint_short (void); + + +// ////////////////////////////////////////////////////////////////// +// Namespace Particulars //////////////////////////////////////////// + +enum namespace_type { + PROCPS_NS_CGROUP, + PROCPS_NS_IPC, + PROCPS_NS_MNT, + PROCPS_NS_NET, + PROCPS_NS_PID, + PROCPS_NS_TIME, + PROCPS_NS_USER, + PROCPS_NS_UTS, + PROCPS_NS_COUNT // total namespaces (fencepost) +}; + +struct procps_ns { + unsigned long ns[PROCPS_NS_COUNT]; +}; + +const char *procps_ns_get_name (const int id); +int procps_ns_get_id (const char *name); +int procps_ns_read_pid (const int pid, struct procps_ns *nsp); + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/library/include/numa.h b/library/include/numa.h new file mode 100644 index 0000000..5a4368b --- /dev/null +++ b/library/include/numa.h @@ -0,0 +1,30 @@ +/* + * NUMA node support for <PIDS> & <STAT> interfaces + * + * Copyright © 2017-2023 Jim Warner <james.warner@comcast.net> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PROCPS_NUMA_H +#define PROCPS_NUMA_H + +void numa_init (void); +void numa_uninit (void); + +extern int (*numa_max_node) (void); +extern int (*numa_node_of_cpu) (int); + +#endif diff --git a/library/include/pids.h b/library/include/pids.h new file mode 100644 index 0000000..8245e36 --- /dev/null +++ b/library/include/pids.h @@ -0,0 +1,287 @@ +/* + * pids.h - process related declarations for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PROCPS_PIDS_H +#define PROCPS_PIDS_H + +#ifdef __cplusplus +extern "C" { +#endif + +enum pids_item { + PIDS_noop, // ( never altered ) + PIDS_extra, // ( reset to zero ) + // returns origin, see proc(5) + // ------- ------------------- + PIDS_ADDR_CODE_END, // ul_int stat: end_code + PIDS_ADDR_CODE_START, // ul_int stat: start_code + PIDS_ADDR_CURR_EIP, // ul_int stat: eip + PIDS_ADDR_CURR_ESP, // ul_int stat: esp + PIDS_ADDR_STACK_START, // ul_int stat: start_stack + PIDS_AUTOGRP_ID, // s_int autogroup + PIDS_AUTOGRP_NICE, // s_int autogroup + PIDS_CGNAME, // str derived from CGROUP ':name=' + PIDS_CGROUP, // str cgroup + PIDS_CGROUP_V, // strv cgroup, as *str[] + PIDS_CMD, // str stat: comm or status: Name + PIDS_CMDLINE, // str cmdline + PIDS_CMDLINE_V, // strv cmdline, as *str[] + PIDS_ENVIRON, // str environ + PIDS_ENVIRON_V, // strv environ, as *str[] + PIDS_EXE, // str exe + PIDS_EXIT_SIGNAL, // s_int stat: exit_signal + PIDS_FLAGS, // ul_int stat: flags + PIDS_FLT_MAJ, // ul_int stat: maj_flt + PIDS_FLT_MAJ_C, // ul_int derived from stat: maj_flt + cmaj_flt + PIDS_FLT_MAJ_DELTA, // s_int derived from FLT_MAJ + PIDS_FLT_MIN, // ul_int stat: min_flt + PIDS_FLT_MIN_C, // ul_int derived from stat: min_flt + cmin_flt + PIDS_FLT_MIN_DELTA, // s_int derived from FLT_MIN + PIDS_ID_EGID, // u_int status: Gid + PIDS_ID_EGROUP, // str derived from EGID, see getgrgid(3) + PIDS_ID_EUID, // u_int status: Uid + PIDS_ID_EUSER, // str derived from EUID, see getpwuid(3) + PIDS_ID_FGID, // u_int status: Gid + PIDS_ID_FGROUP, // str derived from FGID, see getgrgid(3) + PIDS_ID_FUID, // u_int status: Uid + PIDS_ID_FUSER, // str derived from FUID, see getpwuid(3) + PIDS_ID_LOGIN, // s_int loginuid + PIDS_ID_PGRP, // s_int stat: pgrp + PIDS_ID_PID, // s_int from /proc/<pid> + PIDS_ID_PPID, // s_int stat: ppid or status: PPid + PIDS_ID_RGID, // u_int status: Gid + PIDS_ID_RGROUP, // str derived from RGID, see getgrgid(3) + PIDS_ID_RUID, // u_int status: Uid + PIDS_ID_RUSER, // str derived from RUID, see getpwuid(3) + PIDS_ID_SESSION, // s_int stat: sid + PIDS_ID_SGID, // u_int status: Gid + PIDS_ID_SGROUP, // str derived from SGID, see getgrgid(3) + PIDS_ID_SUID, // u_int status: Uid + PIDS_ID_SUSER, // str derived from SUID, see getpwuid(3) + PIDS_ID_TGID, // s_int status: Tgid + PIDS_ID_TID, // s_int from /proc/<pid>/task/<tid> + PIDS_ID_TPGID, // s_int stat: tty_pgrp + PIDS_IO_READ_BYTES, // ul_int io: read_bytes + PIDS_IO_READ_CHARS, // ul_int io: rchar + PIDS_IO_READ_OPS, // ul_int io: syscr + PIDS_IO_WRITE_BYTES, // ul_int io: write_bytes + PIDS_IO_WRITE_CBYTES, // ul_int io: cancelled_write_bytes + PIDS_IO_WRITE_CHARS, // ul_int io: wchar + PIDS_IO_WRITE_OPS, // ul_int io: syscw + PIDS_LXCNAME, // str derived from CGROUP 'lxc.payload' + PIDS_MEM_CODE, // ul_int derived from MEM_CODE_PGS, as KiB + PIDS_MEM_CODE_PGS, // ul_int statm: trs + PIDS_MEM_DATA, // ul_int derived from MEM_DATA_PGS, as KiB + PIDS_MEM_DATA_PGS, // ul_int statm: drs + PIDS_MEM_RES, // ul_int derived from MEM_RES_PGS, as KiB + PIDS_MEM_RES_PGS, // ul_int statm: resident + PIDS_MEM_SHR, // ul_int derived from MEM_SHR_PGS, as KiB + PIDS_MEM_SHR_PGS, // ul_int statm: shared + PIDS_MEM_VIRT, // ul_int derived from MEM_VIRT_PGS, as KiB + PIDS_MEM_VIRT_PGS, // ul_int statm: size + PIDS_NICE, // s_int stat: nice + PIDS_NLWP, // s_int stat: num_threads or status: Threads + PIDS_NS_CGROUP, // ul_int ns/ + PIDS_NS_IPC, // ul_int " + PIDS_NS_MNT, // ul_int " + PIDS_NS_NET, // ul_int " + PIDS_NS_PID, // ul_int " + PIDS_NS_TIME, // ul_int " + PIDS_NS_USER, // ul_int " + PIDS_NS_UTS, // ul_int " + PIDS_OOM_ADJ, // s_int oom_score_adj + PIDS_OOM_SCORE, // s_int oom_score + PIDS_PRIORITY, // s_int stat: priority + PIDS_PRIORITY_RT, // s_int stat: rt_priority + PIDS_PROCESSOR, // s_int stat: task_cpu + PIDS_PROCESSOR_NODE, // s_int derived from PROCESSOR, see numa(3) + PIDS_RSS, // ul_int stat: rss + PIDS_RSS_RLIM, // ul_int stat: rsslim + PIDS_SCHED_CLASS, // s_int stat: policy + PIDS_SD_MACH, // str derived from PID/TID, see sd-login(3) + PIDS_SD_OUID, // str " + PIDS_SD_SEAT, // str " + PIDS_SD_SESS, // str " + PIDS_SD_SLICE, // str " + PIDS_SD_UNIT, // str " + PIDS_SD_UUNIT, // str " + PIDS_SIGBLOCKED, // str status: SigBlk + PIDS_SIGCATCH, // str status: SigCgt + PIDS_SIGIGNORE, // str status: SigIgn + PIDS_SIGNALS, // str status: ShdPnd + PIDS_SIGPENDING, // str status: SigPnd + PIDS_SMAP_ANONYMOUS, // ul_int smaps_rollup: Anonymous + PIDS_SMAP_HUGE_ANON, // ul_int smaps_rollup: AnonHugePages + PIDS_SMAP_HUGE_FILE, // ul_int smaps_rollup: FilePmdMapped + PIDS_SMAP_HUGE_SHMEM, // ul_int smaps_rollup: ShmemPmdMapped + PIDS_SMAP_HUGE_TLBPRV, // ul_int smaps_rollup: Private_Hugetlb + PIDS_SMAP_HUGE_TLBSHR, // ul_int smaps_rollup: Shared_Hugetlb + PIDS_SMAP_LAZY_FREE, // ul_int smaps_rollup: LazyFree + PIDS_SMAP_LOCKED, // ul_int smaps_rollup: Locked + PIDS_SMAP_PRV_CLEAN, // ul_int smaps_rollup: Private_Clean + PIDS_SMAP_PRV_DIRTY, // ul_int smaps_rollup: Private_Dirty + PIDS_SMAP_PRV_TOTAL, // ul_int derived from SMAP_PRV_CLEAN + SMAP_PRV_DIRTY + PIDS_SMAP_PSS, // ul_int smaps_rollup: Pss + PIDS_SMAP_PSS_ANON, // ul_int smaps_rollup: Pss_Anon + PIDS_SMAP_PSS_FILE, // ul_int smaps_rollup: Pss_File + PIDS_SMAP_PSS_SHMEM, // ul_int smaps_rollup: Pss_Shmem + PIDS_SMAP_REFERENCED, // ul_int smaps_rollup: Referenced + PIDS_SMAP_RSS, // ul_int smaps_rollup: Rss + PIDS_SMAP_SHR_CLEAN, // ul_int smaps_rollup: Shared_Clean + PIDS_SMAP_SHR_DIRTY, // ul_int smaps_rollup: Shared_Dirty + PIDS_SMAP_SWAP, // ul_int smaps_rollup: Swap + PIDS_SMAP_SWAP_PSS, // ul_int smaps_rollup: SwapPss + PIDS_STATE, // s_ch stat: state or status: State + PIDS_SUPGIDS, // str status: Groups + PIDS_SUPGROUPS, // str derived from SUPGIDS, see getgrgid(3) + PIDS_TICS_ALL, // ull_int derived from stat: stime + utime + PIDS_TICS_ALL_C, // ull_int derived from stat: stime + utime + cstime + cutime + PIDS_TICS_ALL_DELTA, // u_int derived from TICS_ALL + PIDS_TICS_BEGAN, // ull_int stat: start_time + PIDS_TICS_BLKIO, // ull_int stat: blkio_ticks + PIDS_TICS_GUEST, // ull_int stat: gtime + PIDS_TICS_GUEST_C, // ull_int derived from stat: gtime + cgtime + PIDS_TICS_SYSTEM, // ull_int stat: stime + PIDS_TICS_SYSTEM_C, // ull_int derived from stat: stime + cstime + PIDS_TICS_USER, // ull_int stat: utime + PIDS_TICS_USER_C, // ull_int derived from stat: utime + cutime + PIDS_TIME_ALL, // real * derived from stat: (utime + stime) / hertz + PIDS_TIME_ALL_C, // real * derived from stat: (utime + stime + cutime + cstime) / hertz + PIDS_TIME_ELAPSED, // real * derived from stat: (/proc/uptime - start_time) / hertz + PIDS_TIME_START, // real * derived from stat: start_time / hertz + PIDS_TTY, // s_int stat: tty_nr + PIDS_TTY_NAME, // str derived from TTY + PIDS_TTY_NUMBER, // str derived from TTY as str + PIDS_UTILIZATION, // real derived from TIME_ALL / TIME_ELAPSED, as percentage + PIDS_UTILIZATION_C, // real derived from TIME_ALL_C / TIME_ELAPSED, as percentage + PIDS_VM_DATA, // ul_int status: VmData + PIDS_VM_EXE, // ul_int status: VmExe + PIDS_VM_LIB, // ul_int status: VmLib + PIDS_VM_RSS, // ul_int status: VmRSS + PIDS_VM_RSS_ANON, // ul_int status: RssAnon + PIDS_VM_RSS_FILE, // ul_int status: RssFile + PIDS_VM_RSS_LOCKED, // ul_int status: VmLck + PIDS_VM_RSS_SHARED, // ul_int status: RssShmem + PIDS_VM_SIZE, // ul_int status: VmSize + PIDS_VM_STACK, // ul_int status: VmStk + PIDS_VM_SWAP, // ul_int status: VmSwap + PIDS_VM_USED, // ul_int derived from status: VmRSS + VmSwap + PIDS_VSIZE_BYTES, // ul_int stat: vsize + PIDS_WCHAN_NAME // str wchan +}; + // * while these are all expressed as seconds, each can be + // converted into tics/jiffies with no loss of precision + // when multiplied by hertz obtained via procps_misc(3). +enum pids_fetch_type { + PIDS_FETCH_TASKS_ONLY, + PIDS_FETCH_THREADS_TOO +}; + +enum pids_select_type { + PIDS_SELECT_PID = 0x10000, + PIDS_SELECT_PID_THREADS = 0x10001, + PIDS_SELECT_UID = 0x20000, + PIDS_SELECT_UID_THREADS = 0x20001 +}; + +enum pids_sort_order { + PIDS_SORT_ASCEND = +1, + PIDS_SORT_DESCEND = -1 +}; + + +struct pids_result { + enum pids_item item; + union { + signed char s_ch; + signed int s_int; + unsigned int u_int; + unsigned long ul_int; + unsigned long long ull_int; + char *str; + char **strv; + double real; + } result; +}; + +struct pids_stack { + struct pids_result *head; +}; + +struct pids_counts { + int total; + int running, sleeping, stopped, zombied, other; +}; + +struct pids_fetch { + struct pids_counts *counts; + struct pids_stack **stacks; +}; + +struct pids_info; + + +#define PIDS_VAL( relative_enum, type, stack, info ) \ + stack -> head [ relative_enum ] . result . type + + +int procps_pids_new (struct pids_info **info, enum pids_item *items, int numitems); +int procps_pids_ref (struct pids_info *info); +int procps_pids_unref (struct pids_info **info); + +struct pids_stack *fatal_proc_unmounted ( + struct pids_info *info, + int return_self); + +struct pids_stack *procps_pids_get ( + struct pids_info *info, + enum pids_fetch_type which); + +struct pids_fetch *procps_pids_reap ( + struct pids_info *info, + enum pids_fetch_type which); + +int procps_pids_reset ( + struct pids_info *info, + enum pids_item *newitems, + int newnumitems); + +struct pids_fetch *procps_pids_select ( + struct pids_info *info, + unsigned *these, + int numthese, + enum pids_select_type which); + +struct pids_stack **procps_pids_sort ( + struct pids_info *info, + struct pids_stack *stacks[], + int numstacked, + enum pids_item sortitem, + enum pids_sort_order order); + + +#ifdef XTRA_PROCPS_DEBUG +# include "xtra-procps-debug.h" +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/library/include/procps-private.h b/library/include/procps-private.h new file mode 100644 index 0000000..835ea21 --- /dev/null +++ b/library/include/procps-private.h @@ -0,0 +1,28 @@ +/* + * libprocps - Library to read proc filesystem + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef PROCPS_PRIVATE_H +#define PROCPS_PRIVATE_H + +#define PROCPS_EXPORT __attribute__ ((visibility("default"))) + +#define STRINGIFY_ARG(a) #a +#define STRINGIFY(a) STRINGIFY_ARG(a) + +#define MAXTABLE(t) (int)(sizeof(t) / sizeof(t[0])) + +#endif diff --git a/library/include/pwcache.h b/library/include/pwcache.h new file mode 100644 index 0000000..524a2af --- /dev/null +++ b/library/include/pwcache.h @@ -0,0 +1,38 @@ +/* + * pwcache.c - memory cache passwd file handling + * + * Copyright © 2011-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2002 Albert Cahalan + * + * Older version: + * Copyright © 1992-1998 Michael K. Johnson <johnsonm@redhat.com> + * Note: most likely none of his code remains + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PROCPS_PROC_PWCACHE_H +#define PROCPS_PROC_PWCACHE_H + +#include <sys/types.h> + +// used in pwcache and in readproc to set size of username or groupname +#define P_G_SZ 33 + +char *pwcache_get_user(uid_t uid); +char *pwcache_get_group(gid_t gid); + +#endif diff --git a/library/include/readproc.h b/library/include/readproc.h new file mode 100644 index 0000000..33c630e --- /dev/null +++ b/library/include/readproc.h @@ -0,0 +1,303 @@ +/* + * readproc - interface to process table + * + * Copyright © 2002-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2011-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 1998-2010 Albert Cahalan + * Copyright © 1998 Michael K. Johnson + * Copyright © 1996 Charles L. Blake. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PROCPS_PROC_READPROC_H +#define PROCPS_PROC_READPROC_H + +#include <sys/types.h> +#include <dirent.h> +#include <unistd.h> +#include "misc.h" + +// the following is development only, forcing display of "[ duplicate ENUM ]" strings +// #define FALSE_THREADS /* set most child string fields to NULL */ + + +// This is to help document a transition from pid to tgid/tid caused +// by the introduction of thread support. It is used in cases where +// neither tgid nor tid seemed correct. (in other words, FIXME) +#define XXXID tid + +// Basic data structure which holds all information we can get about a process. +// (unless otherwise specified, fields are read from /proc/#/stat) +// +// Most of it comes from task_struct in linux/sched.h +// +typedef struct proc_t { + int + tid, // (special) task id, the POSIX thread ID (see also: tgid) + ppid; // stat,status pid of parent process + char + state, // stat,status single-char code for process state (S=sleeping) + pad_1, // n/a padding + pad_2, // n/a padding + pad_3; // n/a padding + unsigned long long + utime, // stat user-mode CPU time accumulated by process + stime, // stat kernel-mode CPU time accumulated by process + cutime, // stat cumulative utime of process and reaped children + cstime, // stat cumulative stime of process and reaped children + start_time, // stat start time of process -- seconds since system boot + blkio_tics, // stat time spent waiting for block IO + gtime, // stat guest time of the task in jiffies + cgtime; // stat guest time of the task children in jiffies + int // next 3 fields are NOT filled in by readproc + pcpu, // stat (special) elapsed tics for %CPU usage calculation + maj_delta, // stat (special) major page faults since last update + min_delta; // stat (special) minor page faults since last update + char + // Linux 2.1.7x and up have 64 signals. Allow 64, plus '\0' and padding. + signal[18], // status mask of pending signals + blocked[18], // status mask of blocked signals + sigignore[18], // status mask of ignored signals + sigcatch[18], // status mask of caught signals + _sigpnd[18]; // status mask of PER TASK pending signals + unsigned long + start_code, // stat address of beginning of code segment + end_code, // stat address of end of code segment + start_stack, // stat address of the bottom of stack for the process + kstk_esp, // stat kernel stack pointer + kstk_eip, // stat kernel instruction pointer + wchan, // stat (special) address of kernel wait channel proc is sleeping in + rss, // stat identical to 'resident' + alarm; // stat ? + int + priority, // stat kernel scheduling priority + nice; // stat standard unix nice level of process + unsigned long + // the next 7 members come from /proc/#/statm + size, // statm total virtual memory (as # pages) + resident, // statm resident non-swapped memory (as # pages) + share, // statm shared (mmap'd) memory (as # pages) + trs, // statm text (exe) resident set (as # pages) + lrs, // statm library resident set (always 0 w/ 2.6) + drs, // statm data+stack resident set (as # pages) + dt; // statm dirty pages (always 0 w/ 2.6) + unsigned long + vm_size, // status equals 'size' (as kb) + vm_lock, // status locked pages (as kb) + vm_rss, // status equals 'rss' and/or 'resident' (as kb) + vm_rss_anon, // status the 'anonymous' portion of vm_rss (as kb) + vm_rss_file, // status the 'file-backed' portion of vm_rss (as kb) + vm_rss_shared, // status the 'shared' portion of vm_rss (as kb) + vm_data, // status data only size (as kb) + vm_stack, // status stack only size (as kb) + vm_swap, // status based on linux-2.6.34 "swap ents" (as kb) + vm_exe, // status equals 'trs' (as kb) + vm_lib, // status total, not just used, library pages (as kb) + vsize, // stat number of pages of virtual memory ... + rss_rlim, // stat resident set size limit? + flags, // stat kernel flags for the process + min_flt, // stat number of minor page faults since process start + maj_flt, // stat number of major page faults since process start + cmin_flt, // stat cumulative min_flt of process and child processes + cmaj_flt, // stat cumulative maj_flt of process and child processes + rchar, // io characters read + wchar, // io characters written + syscr, // io number of read I/O operations + syscw, // io number of write I/O operations + read_bytes, // io number of bytes fetched from the storage layer + write_bytes, // io number of bytes sent to the storage layer + cancelled_write_bytes, // io number of bytes truncating pagecache + smap_Rss, // smaps_rollup mapping currently resident in RAM + smap_Pss, // " Rss divided by total processes sharing it + smap_Pss_Anon, // " proportional share of 'anonymous' memory + smap_Pss_File, // " proportional share of 'file' memory + smap_Pss_Shmem, // " proportional share of 'shmem' memory + smap_Shared_Clean, // " unmodified shared memory + smap_Shared_Dirty, // " altered shared memory + smap_Private_Clean, // " unmodified private memory + smap_Private_Dirty, // " altered private memory + smap_Referenced, // " memory marked as referenced/accessed + smap_Anonymous, // " memory not belonging to any file + smap_LazyFree, // " memory marked by madvise(MADV_FREE) + smap_AnonHugePages, // " memory backed by transparent huge pages + smap_ShmemPmdMapped, // " shmem/tmpfs memory backed by huge pages + smap_FilePmdMapped, // " file memory backed by huge pages + smap_Shared_Hugetlb, // " hugetlbfs backed memory *not* counted in Rss/Pss + smap_Private_Hugetlb, // " hugetlbfs backed memory *not* counted in Rss/Pss + smap_Swap, // " swapped would-be-anonymous memory (includes swapped out shmem) + smap_SwapPss, // " the proportional share of 'Swap' (excludes swapped out shmem) + smap_Locked; // " memory amount locked to RAM + char + *environ, // (special) environment as string (/proc/#/environ) + *cmdline, // (special) command line as string (/proc/#/cmdline) + *cgroup, // (special) cgroup as string (/proc/#/cgroup) + *cgname, // (special) name portion of above (if possible) + *supgid, // status supplementary gids as comma delimited str + *supgrp, // supp grp names as comma delimited str, derived from supgid + **environ_v, // (special) environment string vectors (/proc/#/environ) + **cmdline_v, // (special) command line string vectors (/proc/#/cmdline) + **cgroup_v; // (special) cgroup string vectors (/proc/#/cgroup) + char + *euser, // stat(),status effective user name + *ruser, // status real user name + *suser, // status saved user name + *fuser, // status filesystem user name + *rgroup, // status real group name + *egroup, // status effective group name + *sgroup, // status saved group name + *fgroup, // status filesystem group name + *cmd; // stat,status basename of executable file in call to exec(2) + int + rtprio, // stat real-time priority + sched, // stat scheduling class + pgrp, // stat process group id + session, // stat session id + nlwp, // stat,status number of threads, or 0 if no clue + tgid, // (special) thread group ID, the POSIX PID (see also: tid) + tty; // stat full device number of controlling terminal + /* FIXME: int uids & gids should be uid_t or gid_t from pwd.h */ + uid_t euid; gid_t egid; // stat(),status effective + uid_t ruid; gid_t rgid; // status real + uid_t suid; gid_t sgid; // status saved + uid_t fuid; gid_t fgid; // status fs (used for file access only) + int + tpgid, // stat terminal process group id + exit_signal, // stat might not be SIGCHLD + processor; // stat current (or most recent?) CPU + int + oom_score, // oom_score (badness for OOM killer) + oom_adj; // oom_adj (adjustment to OOM score) + struct procps_ns ns; // (ns subdir) inode number of namespaces + char + *sd_mach, // n/a systemd vm/container name + *sd_ouid, // n/a systemd session owner uid + *sd_seat, // n/a systemd login session seat + *sd_sess, // n/a systemd login session id + *sd_slice, // n/a systemd slice unit + *sd_unit, // n/a systemd system unit id + *sd_uunit; // n/a systemd user unit id + char + *lxcname, // n/a lxc container name + *exe; // exe executable path + name + int + luid, // loginuid user id at login + autogrp_id, // autogroup autogroup number (id) + autogrp_nice; // autogroup autogroup nice value +} proc_t; + +// PROCTAB: data structure holding the persistent information readproc needs +// from openproc(). The setup is intentionally similar to the dirent interface +// and other system table interfaces (utmp+wtmp come to mind). + +#define PROCPATHLEN 64 // must hold /proc/2000222000/task/2000222000/cmdline + +typedef struct PROCTAB { + DIR *procfs; +// char deBug0[64]; + DIR *taskdir; // for threads +// char deBug1[64]; + pid_t taskdir_user; // for threads + int(*finder)(struct PROCTAB *__restrict const, proc_t *__restrict const); + proc_t*(*reader)(struct PROCTAB *__restrict const, proc_t *__restrict const); + int(*taskfinder)(struct PROCTAB *__restrict const, const proc_t *__restrict const, proc_t *__restrict const, char *__restrict const); + proc_t*(*taskreader)(struct PROCTAB *__restrict const, proc_t *__restrict const, char *__restrict const); + pid_t *pids; // pids of the procs + uid_t *uids; // uids of procs + int nuid; // cannot really sentinel-terminate unsigned short[] + int i; // generic + int hide_kernel; // getenv LIBPROC_HIDE_KERNEL was set + unsigned flags; + unsigned u; // generic + void * vp; // generic + char path[PROCPATHLEN]; // must hold /proc/2000222000/task/2000222000/cmdline + unsigned pathlen; // length of string in the above (w/o '\0') +} PROCTAB; + + +// openproc/readproctab: +// +// Return PROCTAB* / *proc_t[] or NULL on error ((probably) "/proc" cannot be +// opened.) By default readproc will consider all processes as valid to parse +// and return, but not actually fill in the cmdline, environ, and /proc/#/statm +// derived memory fields. +// +// `flags' (a bitwise-or of PROC_* below) modifies the default behavior. The +// "fill" options will cause more of the proc_t to be filled in. The "filter" +// options all use the second argument as the pointer to a list of objects: +// process status', process id's, user id's. The third +// argument is the length of the list (currently only used for lists of user +// id's since uid_t supports no convenient termination sentinel.) + +#define PROC_FILLMEM 0x00000001 // read statm +#define PROC_FILLARG 0x00000002 // alloc and fill in `cmdline' vectors +#define PROC_FILLENV 0x00000004 // alloc and fill in `environ' vectors +#define PROC_FILLUSR 0x00000008 // resolve user id number -> user name +#define PROC_FILLGRP 0x00000010 // resolve group id number -> group name +#define PROC_FILLSTATUS 0x00000020 // read status +#define PROC_FILLSTAT 0x00000040 // read stat +#define PROC_FILLCGROUP 0x00000080 // alloc and fill in `cgroup` vectors +#define PROC_FILLOOM 0x00000100 // fill in proc_t oom_score and oom_adj +#define PROC_FILLNS 0x00000200 // fill in proc_t namespace information +#define PROC_FILLSYSTEMD 0x00000400 // fill in proc_t systemd information +#define PROC_FILL_LXC 0x00000800 // fill in proc_t lxcname, if possible +#define PROC_FILL_LUID 0x00001000 // fill in proc_t luid (login user id) +#define PROC_FILL_EXE 0x00002000 // fill in proc_t exe path + pgm name +#define PROC_FILLIO 0x00004000 // fill in proc_t io information +#define PROC_FILLSMAPS 0x00008000 // fill in proc_t smaps_rollup stuff + +// consider only processes with one of the passed: +#define PROC_PID 0x00010000 // process id numbers ( 0 terminated ) +#define PROC_UID 0x00020000 // user id numbers ( length needed ) +// Note: the above 2 values must NOT change without also changing pids.h !!! + +#define PROC_EDITCGRPCVT 0x00040000 // edit `cgroup' as regular string +#define PROC_EDITCMDLCVT 0x00080000 // edit `cmdline' as regular string +#define PROC_EDITENVRCVT 0x00100000 // edit `environ' as regular string + +// these three also require the PROC_FILLSTATUS flage +#define PROC_FILL_OUSERS ( 0x00200000 | PROC_FILLSTATUS ) // obtain other user names +#define PROC_FILL_OGROUPS ( 0x00400000 | PROC_FILLSTATUS ) // obtain other group names +#define PROC_FILL_SUPGRP ( 0x00800000 | PROC_FILLSTATUS ) // obtain supplementary group names + +// and let's put new flags here ... +#define PROC_FILLAUTOGRP 0x01000000 // fill in proc_t autogroup stuff + +// it helps to give app code a few spare bits +#define PROC_SPARE_1 0x10000000 +#define PROC_SPARE_2 0x20000000 +#define PROC_SPARE_3 0x40000000 +#define PROC_SPARE_4 0x80000000 + +// Function definitions +// Initialize a PROCTAB structure holding needed call-to-call persistent data +PROCTAB *openproc(unsigned flags, ... /* pid_t *| uid_t *| dev_t *| char *[, int n] */ ); +// Retrieve the next process or task matching the criteria set by the openproc(). +// +// Note: When NULL is used as the readproc 'p' or readeither 'x' +// parameter, the library will allocate the necessary proc_t storage. +// +// Alternatively, you may provide your own reuseable buffer address +// in which case that buffer *MUST* be initialized to zero one time +// only before first use. Thereafter, the library will manage such +// a passed proc_t, freeing any additional acquired memory associated +// with the previous process or thread. +proc_t *readproc(PROCTAB *__restrict const PT, proc_t *__restrict p); +proc_t *readeither(PROCTAB *__restrict const PT, proc_t *__restrict x); +int look_up_our_self(void); +void closeproc(PROCTAB *PT); +char **vectorize_this_str(const char *src); + +#endif diff --git a/library/include/slabinfo.h b/library/include/slabinfo.h new file mode 100644 index 0000000..f63ca79 --- /dev/null +++ b/library/include/slabinfo.h @@ -0,0 +1,140 @@ +/* + * slabinfo.h - slab pools related declarations for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PROCPS_SLABINFO_H +#define PROCPS_SLABINFO_H + +#ifdef __cplusplus +extern "C "{ +#endif + +enum slabinfo_item { + SLABINFO_noop, // ( never altered ) + SLABINFO_extra, // ( reset to zero ) + // returns origin, see proc(5) + // ------- ------------------- + SLAB_NAME, // str /proc/slabinfo + SLAB_NUM_OBJS, // u_int " + SLAB_ACTIVE_OBJS, // u_int " + SLAB_OBJ_SIZE, // u_int " + SLAB_OBJ_PER_SLAB, // u_int " + SLAB_NUMS_SLABS, // u_int " + SLAB_ACTIVE_SLABS, // u_int " + SLAB_PAGES_PER_SLAB, // u_int " + SLAB_PERCENT_USED, // u_int derived from ACTIVE_OBJS / NUM_OBJS + SLAB_SIZE_TOTAL, // ul_int derived from page size * NUMS_SLABS * PAGES_PER_SLAB + + SLABS_CACHES_TOTAL, // u_int derived from all caches + SLABS_CACHES_ACTIVE, // u_int " + SLABS_NUM_OBJS, // u_int " + SLABS_ACTIVE_OBJS, // u_int " + SLABS_OBJ_SIZE_AVG, // u_int " + SLABS_OBJ_SIZE_MIN, // u_int " + SLABS_OBJ_SIZE_MAX, // u_int " + SLABS_NUMS_SLABS, // u_int " + SLABS_ACTIVE_SLABS, // u_int " + SLABS_PAGES_TOTAL, // u_int " + SLABS_SIZE_ACTIVE, // ul_int " + SLABS_SIZE_TOTAL, // ul_int " + + SLABS_DELTA_CACHES_TOTAL, // s_int derived from above + SLABS_DELTA_CACHES_ACTIVE, // s_int " + SLABS_DELTA_NUM_OBJS, // s_int " + SLABS_DELTA_ACTIVE_OBJS, // s_int " + SLABS_DELTA_OBJ_SIZE_AVG, // s_int " + SLABS_DELTA_OBJ_SIZE_MIN, // s_int " + SLABS_DELTA_OBJ_SIZE_MAX, // s_int " + SLABS_DELTA_NUMS_SLABS, // s_int " + SLABS_DELTA_ACTIVE_SLABS, // s_int " + SLABS_DELTA_PAGES_TOTAL, // s_int " + SLABS_DELTA_SIZE_ACTIVE, // s_int " + SLABS_DELTA_SIZE_TOTAL // s_int " +}; + +enum slabinfo_sort_order { + SLABINFO_SORT_ASCEND = +1, + SLABINFO_SORT_DESCEND = -1 +}; + + +struct slabinfo_result { + enum slabinfo_item item; + union { + signed int s_int; + unsigned int u_int; + unsigned long ul_int; + char *str; + } result; +}; + +struct slabinfo_stack { + struct slabinfo_result *head; +}; + +struct slabinfo_reaped { + int total; + struct slabinfo_stack **stacks; +}; + +struct slabinfo_info; + + +#define SLABINFO_GET( info, actual_enum, type ) ( { \ + struct slabinfo_result *r = procps_slabinfo_get( info, actual_enum ); \ + r ? r->result . type : 0; } ) + +#define SLABINFO_VAL( relative_enum, type, stack, info ) \ + stack -> head [ relative_enum ] . result . type + + +int procps_slabinfo_new (struct slabinfo_info **info); +int procps_slabinfo_ref (struct slabinfo_info *info); +int procps_slabinfo_unref (struct slabinfo_info **info); + +struct slabinfo_result *procps_slabinfo_get ( + struct slabinfo_info *info, + enum slabinfo_item item); + +struct slabinfo_reaped *procps_slabinfo_reap ( + struct slabinfo_info *info, + enum slabinfo_item *items, + int numitems); + +struct slabinfo_stack *procps_slabinfo_select ( + struct slabinfo_info *info, + enum slabinfo_item *items, + int numitems); + +struct slabinfo_stack **procps_slabinfo_sort ( + struct slabinfo_info *info, + struct slabinfo_stack *stacks[], + int numstacked, + enum slabinfo_item sortitem, + enum slabinfo_sort_order order); + + +#ifdef XTRA_PROCPS_DEBUG +# include "xtra-procps-debug.h" +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/library/include/stat.h b/library/include/stat.h new file mode 100644 index 0000000..7adefa6 --- /dev/null +++ b/library/include/stat.h @@ -0,0 +1,175 @@ +/* + * stat.h - cpu/numa related declarations for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PROCPS_STAT_H +#define PROCPS_STAT_H + +#ifdef __cplusplus +extern "C" { +#endif + +enum stat_item { + STAT_noop, // ( never altered ) + STAT_extra, // ( reset to zero ) + // returns origin, see proc(5) + // ------- ------------------- + STAT_TIC_ID, // s_int /proc/stat, cpu or numa node id + STAT_TIC_ID_CORE, // s_int /proc/cpuinfo: 'core id', -1 = n/a + STAT_TIC_NUMA_NODE, // s_int [ CPU ID based, see: numa(3) ] + STAT_TIC_NUM_CONTRIBUTORS, // s_int [ total CPUs contributing to TIC counts ] + STAT_TIC_TYPE_CORE, // s_int [ 2 = P-core, 1 = E-core, 0 = n/a ] + + STAT_TIC_USER, // ull_int /proc/stat + STAT_TIC_NICE, // ull_int " + STAT_TIC_SYSTEM, // ull_int " + STAT_TIC_IDLE, // ull_int " + STAT_TIC_IOWAIT, // ull_int " + STAT_TIC_IRQ, // ull_int " + STAT_TIC_SOFTIRQ, // ull_int " + STAT_TIC_STOLEN, // ull_int " + STAT_TIC_GUEST, // ull_int " + STAT_TIC_GUEST_NICE, // ull_int " + + STAT_TIC_DELTA_USER, // sl_int derived from above + STAT_TIC_DELTA_NICE, // sl_int " + STAT_TIC_DELTA_SYSTEM, // sl_int " + STAT_TIC_DELTA_IDLE, // sl_int " + STAT_TIC_DELTA_IOWAIT, // sl_int " + STAT_TIC_DELTA_IRQ, // sl_int " + STAT_TIC_DELTA_SOFTIRQ, // sl_int " + STAT_TIC_DELTA_STOLEN, // sl_int " + STAT_TIC_DELTA_GUEST, // sl_int " + STAT_TIC_DELTA_GUEST_NICE, // sl_int " + + STAT_TIC_SUM_USER, // ull_int derived from USER + NICE tics + STAT_TIC_SUM_SYSTEM, // ull_int derived from SYSTEM + IRQ + SOFTIRQ tics + STAT_TIC_SUM_IDLE, // ull_int derived from IDLE + IOWAIT tics + STAT_TIC_SUM_BUSY, // ull_int derived from SUM_TOTAL - SUM_IDLE tics + STAT_TIC_SUM_TOTAL, // ull_int derived from sum of all 10 tics + + STAT_TIC_SUM_DELTA_USER, // sl_int derived from above + STAT_TIC_SUM_DELTA_SYSTEM, // sl_int " + STAT_TIC_SUM_DELTA_IDLE, // sl_int " + STAT_TIC_SUM_DELTA_BUSY, // sl_int " + STAT_TIC_SUM_DELTA_TOTAL, // sl_int " + + STAT_SYS_CTX_SWITCHES, // ul_int /proc/stat + STAT_SYS_INTERRUPTS, // ul_int " + STAT_SYS_PROC_BLOCKED, // ul_int " + STAT_SYS_PROC_CREATED, // ul_int " + STAT_SYS_PROC_RUNNING, // ul_int " + STAT_SYS_TIME_OF_BOOT, // ul_int " + + STAT_SYS_DELTA_CTX_SWITCHES, // s_int derived from above + STAT_SYS_DELTA_INTERRUPTS, // s_int " + STAT_SYS_DELTA_PROC_BLOCKED, // s_int " + STAT_SYS_DELTA_PROC_CREATED, // s_int " + STAT_SYS_DELTA_PROC_RUNNING // s_int " +}; + +enum stat_reap_type { + STAT_REAP_CPUS_ONLY, + STAT_REAP_NUMA_NODES_TOO +}; + +enum stat_sort_order { + STAT_SORT_ASCEND = +1, + STAT_SORT_DESCEND = -1 +}; + + +struct stat_result { + enum stat_item item; + union { + signed int s_int; + signed long sl_int; + unsigned long ul_int; + unsigned long long ull_int; + } result; +}; + +struct stat_stack { + struct stat_result *head; +}; + +struct stat_reap { + int total; + struct stat_stack **stacks; +}; + +struct stat_reaped { + struct stat_stack *summary; + struct stat_reap *cpus; + struct stat_reap *numa; +}; + +struct stat_info; + + + // STAT_TIC_ID value for /proc/stat cpu summary +#define STAT_SUMMARY_ID -11111 + // STAT_TIC_NUMA_NODE value for STAT_REAP_CPUS_ONLY or + // for STAT_REAP_NUMA_NODES_TOO when node was inactive +#define STAT_NODE_INVALID -22222 + + +#define STAT_GET( info, actual_enum, type ) ( { \ + struct stat_result *r = procps_stat_get( info, actual_enum ); \ + r ? r->result . type : 0; } ) + +#define STAT_VAL( relative_enum, type, stack, info ) \ + stack -> head [ relative_enum ] . result . type + + +int procps_stat_new (struct stat_info **info); +int procps_stat_ref (struct stat_info *info); +int procps_stat_unref (struct stat_info **info); + +struct stat_result *procps_stat_get ( + struct stat_info *info, + enum stat_item item); + +struct stat_reaped *procps_stat_reap ( + struct stat_info *info, + enum stat_reap_type what, + enum stat_item *items, + int numitems); + +struct stat_stack *procps_stat_select ( + struct stat_info *info, + enum stat_item *items, + int numitems); + +struct stat_stack **procps_stat_sort ( + struct stat_info *info, + struct stat_stack *stacks[], + int numstacked, + enum stat_item sortitem, + enum stat_sort_order order); + + +#ifdef XTRA_PROCPS_DEBUG +# include "xtra-procps-debug.h" +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/library/include/vmstat.h b/library/include/vmstat.h new file mode 100644 index 0000000..9b94931 --- /dev/null +++ b/library/include/vmstat.h @@ -0,0 +1,382 @@ +/* + * vmstat.h - virtual memory related declarations for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef PROCPS_VMSTAT_H +#define PROCPS_VMSTAT_H + +#ifdef __cplusplus +extern "C" { +#endif + +enum vmstat_item { + VMSTAT_noop, // ( never altered ) + VMSTAT_extra, // ( reset to zero ) + // returns origin, see proc(5) + // ------- ------------------- + VMSTAT_ALLOCSTALL_DMA, // ul_int /proc/vmstat + VMSTAT_ALLOCSTALL_DMA32, // ul_int " + VMSTAT_ALLOCSTALL_HIGH, // ul_int " + VMSTAT_ALLOCSTALL_MOVABLE, // ul_int " + VMSTAT_ALLOCSTALL_NORMAL, // ul_int " + VMSTAT_BALLOON_DEFLATE, // ul_int " + VMSTAT_BALLOON_INFLATE, // ul_int " + VMSTAT_BALLOON_MIGRATE, // ul_int " + VMSTAT_COMPACT_DAEMON_FREE_SCANNED, // ul_int " + VMSTAT_COMPACT_DAEMON_MIGRATE_SCANNED, // ul_int " + VMSTAT_COMPACT_DAEMON_WAKE, // ul_int " + VMSTAT_COMPACT_FAIL, // ul_int " + VMSTAT_COMPACT_FREE_SCANNED, // ul_int " + VMSTAT_COMPACT_ISOLATED, // ul_int " + VMSTAT_COMPACT_MIGRATE_SCANNED, // ul_int " + VMSTAT_COMPACT_STALL, // ul_int " + VMSTAT_COMPACT_SUCCESS, // ul_int " + VMSTAT_DROP_PAGECACHE, // ul_int " + VMSTAT_DROP_SLAB, // ul_int " + VMSTAT_HTLB_BUDDY_ALLOC_FAIL, // ul_int " + VMSTAT_HTLB_BUDDY_ALLOC_SUCCESS, // ul_int " + VMSTAT_KSWAPD_HIGH_WMARK_HIT_QUICKLY, // ul_int " + VMSTAT_KSWAPD_INODESTEAL, // ul_int " + VMSTAT_KSWAPD_LOW_WMARK_HIT_QUICKLY, // ul_int " + VMSTAT_NR_ACTIVE_ANON, // ul_int " + VMSTAT_NR_ACTIVE_FILE, // ul_int " + VMSTAT_NR_ANON_PAGES, // ul_int " + VMSTAT_NR_ANON_TRANSPARENT_HUGEPAGES, // ul_int " + VMSTAT_NR_BOUNCE, // ul_int " + VMSTAT_NR_DIRTIED, // ul_int " + VMSTAT_NR_DIRTY, // ul_int " + VMSTAT_NR_DIRTY_BACKGROUND_THRESHOLD, // ul_int " + VMSTAT_NR_DIRTY_THRESHOLD, // ul_int " + VMSTAT_NR_FILE_HUGEPAGES, // ul_int " + VMSTAT_NR_FILE_PAGES, // ul_int " + VMSTAT_NR_FILE_PMDMAPPED, // ul_int " + VMSTAT_NR_FOLL_PIN_ACQUIRED, // ul_int " + VMSTAT_NR_FOLL_PIN_RELEASED, // ul_int " + VMSTAT_NR_FREE_CMA, // ul_int " + VMSTAT_NR_FREE_PAGES, // ul_int " + VMSTAT_NR_INACTIVE_ANON, // ul_int " + VMSTAT_NR_INACTIVE_FILE, // ul_int " + VMSTAT_NR_ISOLATED_ANON, // ul_int " + VMSTAT_NR_ISOLATED_FILE, // ul_int " + VMSTAT_NR_KERNEL_MISC_RECLAIMABLE, // ul_int " + VMSTAT_NR_KERNEL_STACK, // ul_int " + VMSTAT_NR_MAPPED, // ul_int " + VMSTAT_NR_MLOCK, // ul_int " + VMSTAT_NR_PAGE_TABLE_PAGES, // ul_int " + VMSTAT_NR_SHADOW_CALL_STACK, // ul_int " + VMSTAT_NR_SHMEM, // ul_int " + VMSTAT_NR_SHMEM_HUGEPAGES, // ul_int " + VMSTAT_NR_SHMEM_PMDMAPPED, // ul_int " + VMSTAT_NR_SLAB_RECLAIMABLE, // ul_int " + VMSTAT_NR_SLAB_UNRECLAIMABLE, // ul_int " + VMSTAT_NR_UNEVICTABLE, // ul_int " + VMSTAT_NR_UNSTABLE, // ul_int " + VMSTAT_NR_VMSCAN_IMMEDIATE_RECLAIM, // ul_int " + VMSTAT_NR_VMSCAN_WRITE, // ul_int " + VMSTAT_NR_WRITEBACK, // ul_int " + VMSTAT_NR_WRITEBACK_TEMP, // ul_int " + VMSTAT_NR_WRITTEN, // ul_int " + VMSTAT_NR_ZONE_ACTIVE_ANON, // ul_int " + VMSTAT_NR_ZONE_ACTIVE_FILE, // ul_int " + VMSTAT_NR_ZONE_INACTIVE_ANON, // ul_int " + VMSTAT_NR_ZONE_INACTIVE_FILE, // ul_int " + VMSTAT_NR_ZONE_UNEVICTABLE, // ul_int " + VMSTAT_NR_ZONE_WRITE_PENDING, // ul_int " + VMSTAT_NR_ZSPAGES, // ul_int " + VMSTAT_NUMA_FOREIGN, // ul_int " + VMSTAT_NUMA_HINT_FAULTS, // ul_int " + VMSTAT_NUMA_HINT_FAULTS_LOCAL, // ul_int " + VMSTAT_NUMA_HIT, // ul_int " + VMSTAT_NUMA_HUGE_PTE_UPDATES, // ul_int " + VMSTAT_NUMA_INTERLEAVE, // ul_int " + VMSTAT_NUMA_LOCAL, // ul_int " + VMSTAT_NUMA_MISS, // ul_int " + VMSTAT_NUMA_OTHER, // ul_int " + VMSTAT_NUMA_PAGES_MIGRATED, // ul_int " + VMSTAT_NUMA_PTE_UPDATES, // ul_int " + VMSTAT_OOM_KILL, // ul_int " + VMSTAT_PAGEOUTRUN, // ul_int " + VMSTAT_PGACTIVATE, // ul_int " + VMSTAT_PGALLOC_DMA, // ul_int " + VMSTAT_PGALLOC_DMA32, // ul_int " + VMSTAT_PGALLOC_HIGH, // ul_int " + VMSTAT_PGALLOC_MOVABLE, // ul_int " + VMSTAT_PGALLOC_NORMAL, // ul_int " + VMSTAT_PGDEACTIVATE, // ul_int " + VMSTAT_PGFAULT, // ul_int " + VMSTAT_PGFREE, // ul_int " + VMSTAT_PGINODESTEAL, // ul_int " + VMSTAT_PGLAZYFREE, // ul_int " + VMSTAT_PGLAZYFREED, // ul_int " + VMSTAT_PGMAJFAULT, // ul_int " + VMSTAT_PGMIGRATE_FAIL, // ul_int " + VMSTAT_PGMIGRATE_SUCCESS, // ul_int " + VMSTAT_PGPGIN, // ul_int " + VMSTAT_PGPGOUT, // ul_int " + VMSTAT_PGREFILL, // ul_int " + VMSTAT_PGROTATED, // ul_int " + VMSTAT_PGSCAN_ANON, // ul_int " + VMSTAT_PGSCAN_DIRECT, // ul_int " + VMSTAT_PGSCAN_DIRECT_THROTTLE, // ul_int " + VMSTAT_PGSCAN_FILE, // ul_int " + VMSTAT_PGSCAN_KSWAPD, // ul_int " + VMSTAT_PGSKIP_DMA, // ul_int " + VMSTAT_PGSKIP_DMA32, // ul_int " + VMSTAT_PGSKIP_HIGH, // ul_int " + VMSTAT_PGSKIP_MOVABLE, // ul_int " + VMSTAT_PGSKIP_NORMAL, // ul_int " + VMSTAT_PGSTEAL_ANON, // ul_int " + VMSTAT_PGSTEAL_DIRECT, // ul_int " + VMSTAT_PGSTEAL_FILE, // ul_int " + VMSTAT_PGSTEAL_KSWAPD, // ul_int " + VMSTAT_PSWPIN, // ul_int " + VMSTAT_PSWPOUT, // ul_int " + VMSTAT_SLABS_SCANNED, // ul_int " + VMSTAT_SWAP_RA, // ul_int " + VMSTAT_SWAP_RA_HIT, // ul_int " + VMSTAT_THP_COLLAPSE_ALLOC, // ul_int " + VMSTAT_THP_COLLAPSE_ALLOC_FAILED, // ul_int " + VMSTAT_THP_DEFERRED_SPLIT_PAGE, // ul_int " + VMSTAT_THP_FAULT_ALLOC, // ul_int " + VMSTAT_THP_FAULT_FALLBACK, // ul_int " + VMSTAT_THP_FAULT_FALLBACK_CHARGE, // ul_int " + VMSTAT_THP_FILE_ALLOC, // ul_int " + VMSTAT_THP_FILE_FALLBACK, // ul_int " + VMSTAT_THP_FILE_FALLBACK_CHARGE, // ul_int " + VMSTAT_THP_FILE_MAPPED, // ul_int " + VMSTAT_THP_SPLIT_PAGE, // ul_int " + VMSTAT_THP_SPLIT_PAGE_FAILED, // ul_int " + VMSTAT_THP_SPLIT_PMD, // ul_int " + VMSTAT_THP_SPLIT_PUD, // ul_int " + VMSTAT_THP_SWPOUT, // ul_int " + VMSTAT_THP_SWPOUT_FALLBACK, // ul_int " + VMSTAT_THP_ZERO_PAGE_ALLOC, // ul_int " + VMSTAT_THP_ZERO_PAGE_ALLOC_FAILED, // ul_int " + VMSTAT_UNEVICTABLE_PGS_CLEARED, // ul_int " + VMSTAT_UNEVICTABLE_PGS_CULLED, // ul_int " + VMSTAT_UNEVICTABLE_PGS_MLOCKED, // ul_int " + VMSTAT_UNEVICTABLE_PGS_MUNLOCKED, // ul_int " + VMSTAT_UNEVICTABLE_PGS_RESCUED, // ul_int " + VMSTAT_UNEVICTABLE_PGS_SCANNED, // ul_int " + VMSTAT_UNEVICTABLE_PGS_STRANDED, // ul_int " + VMSTAT_WORKINGSET_ACTIVATE, // ul_int " + VMSTAT_WORKINGSET_NODERECLAIM, // ul_int " + VMSTAT_WORKINGSET_NODES, // ul_int " + VMSTAT_WORKINGSET_REFAULT, // ul_int " + VMSTAT_WORKINGSET_RESTORE, // ul_int " + VMSTAT_ZONE_RECLAIM_FAILED, // ul_int " + + VMSTAT_DELTA_ALLOCSTALL_DMA, // sl_int derived from above + VMSTAT_DELTA_ALLOCSTALL_DMA32, // sl_int " + VMSTAT_DELTA_ALLOCSTALL_HIGH, // sl_int " + VMSTAT_DELTA_ALLOCSTALL_MOVABLE, // sl_int " + VMSTAT_DELTA_ALLOCSTALL_NORMAL, // sl_int " + VMSTAT_DELTA_BALLOON_DEFLATE, // sl_int " + VMSTAT_DELTA_BALLOON_INFLATE, // sl_int " + VMSTAT_DELTA_BALLOON_MIGRATE, // sl_int " + VMSTAT_DELTA_COMPACT_DAEMON_FREE_SCANNED, // sl_int " + VMSTAT_DELTA_COMPACT_DAEMON_MIGRATE_SCANNED, // sl_int " + VMSTAT_DELTA_COMPACT_DAEMON_WAKE, // sl_int " + VMSTAT_DELTA_COMPACT_FAIL, // sl_int " + VMSTAT_DELTA_COMPACT_FREE_SCANNED, // sl_int " + VMSTAT_DELTA_COMPACT_ISOLATED, // sl_int " + VMSTAT_DELTA_COMPACT_MIGRATE_SCANNED, // sl_int " + VMSTAT_DELTA_COMPACT_STALL, // sl_int " + VMSTAT_DELTA_COMPACT_SUCCESS, // sl_int " + VMSTAT_DELTA_DROP_PAGECACHE, // sl_int " + VMSTAT_DELTA_DROP_SLAB, // sl_int " + VMSTAT_DELTA_HTLB_BUDDY_ALLOC_FAIL, // sl_int " + VMSTAT_DELTA_HTLB_BUDDY_ALLOC_SUCCESS, // sl_int " + VMSTAT_DELTA_KSWAPD_HIGH_WMARK_HIT_QUICKLY, // sl_int " + VMSTAT_DELTA_KSWAPD_INODESTEAL, // sl_int " + VMSTAT_DELTA_KSWAPD_LOW_WMARK_HIT_QUICKLY, // sl_int " + VMSTAT_DELTA_NR_ACTIVE_ANON, // sl_int " + VMSTAT_DELTA_NR_ACTIVE_FILE, // sl_int " + VMSTAT_DELTA_NR_ANON_PAGES, // sl_int " + VMSTAT_DELTA_NR_ANON_TRANSPARENT_HUGEPAGES, // sl_int " + VMSTAT_DELTA_NR_BOUNCE, // sl_int " + VMSTAT_DELTA_NR_DIRTIED, // sl_int " + VMSTAT_DELTA_NR_DIRTY, // sl_int " + VMSTAT_DELTA_NR_DIRTY_BACKGROUND_THRESHOLD, // sl_int " + VMSTAT_DELTA_NR_DIRTY_THRESHOLD, // sl_int " + VMSTAT_DELTA_NR_FILE_HUGEPAGES, // sl_int " + VMSTAT_DELTA_NR_FILE_PAGES, // sl_int " + VMSTAT_DELTA_NR_FILE_PMDMAPPED, // sl_int " + VMSTAT_DELTA_NR_FOLL_PIN_ACQUIRED, // sl_int " + VMSTAT_DELTA_NR_FOLL_PIN_RELEASED, // sl_int " + VMSTAT_DELTA_NR_FREE_CMA, // sl_int " + VMSTAT_DELTA_NR_FREE_PAGES, // sl_int " + VMSTAT_DELTA_NR_INACTIVE_ANON, // sl_int " + VMSTAT_DELTA_NR_INACTIVE_FILE, // sl_int " + VMSTAT_DELTA_NR_ISOLATED_ANON, // sl_int " + VMSTAT_DELTA_NR_ISOLATED_FILE, // sl_int " + VMSTAT_DELTA_NR_KERNEL_MISC_RECLAIMABLE, // sl_int " + VMSTAT_DELTA_NR_KERNEL_STACK, // sl_int " + VMSTAT_DELTA_NR_MAPPED, // sl_int " + VMSTAT_DELTA_NR_MLOCK, // sl_int " + VMSTAT_DELTA_NR_PAGE_TABLE_PAGES, // sl_int " + VMSTAT_DELTA_NR_SHADOW_CALL_STACK, // sl_int " + VMSTAT_DELTA_NR_SHMEM, // sl_int " + VMSTAT_DELTA_NR_SHMEM_HUGEPAGES, // sl_int " + VMSTAT_DELTA_NR_SHMEM_PMDMAPPED, // sl_int " + VMSTAT_DELTA_NR_SLAB_RECLAIMABLE, // sl_int " + VMSTAT_DELTA_NR_SLAB_UNRECLAIMABLE, // sl_int " + VMSTAT_DELTA_NR_UNEVICTABLE, // sl_int " + VMSTAT_DELTA_NR_UNSTABLE, // sl_int " + VMSTAT_DELTA_NR_VMSCAN_IMMEDIATE_RECLAIM, // sl_int " + VMSTAT_DELTA_NR_VMSCAN_WRITE, // sl_int " + VMSTAT_DELTA_NR_WRITEBACK, // sl_int " + VMSTAT_DELTA_NR_WRITEBACK_TEMP, // sl_int " + VMSTAT_DELTA_NR_WRITTEN, // sl_int " + VMSTAT_DELTA_NR_ZONE_ACTIVE_ANON, // sl_int " + VMSTAT_DELTA_NR_ZONE_ACTIVE_FILE, // sl_int " + VMSTAT_DELTA_NR_ZONE_INACTIVE_ANON, // sl_int " + VMSTAT_DELTA_NR_ZONE_INACTIVE_FILE, // sl_int " + VMSTAT_DELTA_NR_ZONE_UNEVICTABLE, // sl_int " + VMSTAT_DELTA_NR_ZONE_WRITE_PENDING, // sl_int " + VMSTAT_DELTA_NR_ZSPAGES, // sl_int " + VMSTAT_DELTA_NUMA_FOREIGN, // sl_int " + VMSTAT_DELTA_NUMA_HINT_FAULTS, // sl_int " + VMSTAT_DELTA_NUMA_HINT_FAULTS_LOCAL, // sl_int " + VMSTAT_DELTA_NUMA_HIT, // sl_int " + VMSTAT_DELTA_NUMA_HUGE_PTE_UPDATES, // sl_int " + VMSTAT_DELTA_NUMA_INTERLEAVE, // sl_int " + VMSTAT_DELTA_NUMA_LOCAL, // sl_int " + VMSTAT_DELTA_NUMA_MISS, // sl_int " + VMSTAT_DELTA_NUMA_OTHER, // sl_int " + VMSTAT_DELTA_NUMA_PAGES_MIGRATED, // sl_int " + VMSTAT_DELTA_NUMA_PTE_UPDATES, // sl_int " + VMSTAT_DELTA_OOM_KILL, // sl_int " + VMSTAT_DELTA_PAGEOUTRUN, // sl_int " + VMSTAT_DELTA_PGACTIVATE, // sl_int " + VMSTAT_DELTA_PGALLOC_DMA, // sl_int " + VMSTAT_DELTA_PGALLOC_DMA32, // sl_int " + VMSTAT_DELTA_PGALLOC_HIGH, // sl_int " + VMSTAT_DELTA_PGALLOC_MOVABLE, // sl_int " + VMSTAT_DELTA_PGALLOC_NORMAL, // sl_int " + VMSTAT_DELTA_PGDEACTIVATE, // sl_int " + VMSTAT_DELTA_PGFAULT, // sl_int " + VMSTAT_DELTA_PGFREE, // sl_int " + VMSTAT_DELTA_PGINODESTEAL, // sl_int " + VMSTAT_DELTA_PGLAZYFREE, // sl_int " + VMSTAT_DELTA_PGLAZYFREED, // sl_int " + VMSTAT_DELTA_PGMAJFAULT, // sl_int " + VMSTAT_DELTA_PGMIGRATE_FAIL, // sl_int " + VMSTAT_DELTA_PGMIGRATE_SUCCESS, // sl_int " + VMSTAT_DELTA_PGPGIN, // sl_int " + VMSTAT_DELTA_PGPGOUT, // sl_int " + VMSTAT_DELTA_PGREFILL, // sl_int " + VMSTAT_DELTA_PGROTATED, // sl_int " + VMSTAT_DELTA_PGSCAN_ANON, // sl_int " + VMSTAT_DELTA_PGSCAN_DIRECT, // sl_int " + VMSTAT_DELTA_PGSCAN_DIRECT_THROTTLE, // sl_int " + VMSTAT_DELTA_PGSCAN_FILE, // sl_int " + VMSTAT_DELTA_PGSCAN_KSWAPD, // sl_int " + VMSTAT_DELTA_PGSKIP_DMA, // sl_int " + VMSTAT_DELTA_PGSKIP_DMA32, // sl_int " + VMSTAT_DELTA_PGSKIP_HIGH, // sl_int " + VMSTAT_DELTA_PGSKIP_MOVABLE, // sl_int " + VMSTAT_DELTA_PGSKIP_NORMAL, // sl_int " + VMSTAT_DELTA_PGSTEAL_ANON, // sl_int " + VMSTAT_DELTA_PGSTEAL_DIRECT, // sl_int " + VMSTAT_DELTA_PGSTEAL_FILE, // sl_int " + VMSTAT_DELTA_PGSTEAL_KSWAPD, // sl_int " + VMSTAT_DELTA_PSWPIN, // sl_int " + VMSTAT_DELTA_PSWPOUT, // sl_int " + VMSTAT_DELTA_SLABS_SCANNED, // sl_int " + VMSTAT_DELTA_SWAP_RA, // sl_int " + VMSTAT_DELTA_SWAP_RA_HIT, // sl_int " + VMSTAT_DELTA_THP_COLLAPSE_ALLOC, // sl_int " + VMSTAT_DELTA_THP_COLLAPSE_ALLOC_FAILED, // sl_int " + VMSTAT_DELTA_THP_DEFERRED_SPLIT_PAGE, // sl_int " + VMSTAT_DELTA_THP_FAULT_ALLOC, // sl_int " + VMSTAT_DELTA_THP_FAULT_FALLBACK, // sl_int " + VMSTAT_DELTA_THP_FAULT_FALLBACK_CHARGE, // sl_int " + VMSTAT_DELTA_THP_FILE_ALLOC, // sl_int " + VMSTAT_DELTA_THP_FILE_FALLBACK, // sl_int " + VMSTAT_DELTA_THP_FILE_FALLBACK_CHARGE, // sl_int " + VMSTAT_DELTA_THP_FILE_MAPPED, // sl_int " + VMSTAT_DELTA_THP_SPLIT_PAGE, // sl_int " + VMSTAT_DELTA_THP_SPLIT_PAGE_FAILED, // sl_int " + VMSTAT_DELTA_THP_SPLIT_PMD, // sl_int " + VMSTAT_DELTA_THP_SPLIT_PUD, // sl_int " + VMSTAT_DELTA_THP_SWPOUT, // sl_int " + VMSTAT_DELTA_THP_SWPOUT_FALLBACK, // sl_int " + VMSTAT_DELTA_THP_ZERO_PAGE_ALLOC, // sl_int " + VMSTAT_DELTA_THP_ZERO_PAGE_ALLOC_FAILED, // sl_int " + VMSTAT_DELTA_UNEVICTABLE_PGS_CLEARED, // sl_int " + VMSTAT_DELTA_UNEVICTABLE_PGS_CULLED, // sl_int " + VMSTAT_DELTA_UNEVICTABLE_PGS_MLOCKED, // sl_int " + VMSTAT_DELTA_UNEVICTABLE_PGS_MUNLOCKED, // sl_int " + VMSTAT_DELTA_UNEVICTABLE_PGS_RESCUED, // sl_int " + VMSTAT_DELTA_UNEVICTABLE_PGS_SCANNED, // sl_int " + VMSTAT_DELTA_UNEVICTABLE_PGS_STRANDED, // sl_int " + VMSTAT_DELTA_WORKINGSET_ACTIVATE, // sl_int " + VMSTAT_DELTA_WORKINGSET_NODERECLAIM, // sl_int " + VMSTAT_DELTA_WORKINGSET_NODES, // sl_int " + VMSTAT_DELTA_WORKINGSET_REFAULT, // sl_int " + VMSTAT_DELTA_WORKINGSET_RESTORE, // sl_int " + VMSTAT_DELTA_ZONE_RECLAIM_FAILED // sl_int " +}; + + +struct vmstat_result { + enum vmstat_item item; + union { + signed long sl_int; + unsigned long ul_int; + } result; +}; + +struct vmstat_stack { + struct vmstat_result *head; +}; + +struct vmstat_info; + + +#define VMSTAT_GET( info, actual_enum, type ) ( { \ + struct vmstat_result *r = procps_vmstat_get( info, actual_enum ); \ + r ? r->result . type : 0; } ) + +#define VMSTAT_VAL( relative_enum, type, stack, info ) \ + stack -> head [ relative_enum ] . result . type + + +int procps_vmstat_new (struct vmstat_info **info); +int procps_vmstat_ref (struct vmstat_info *info); +int procps_vmstat_unref (struct vmstat_info **info); + +struct vmstat_result *procps_vmstat_get ( + struct vmstat_info *info, + enum vmstat_item item); + +struct vmstat_stack *procps_vmstat_select ( + struct vmstat_info *info, + enum vmstat_item *items, + int numitems); + + +#ifdef XTRA_PROCPS_DEBUG +# include "xtra-procps-debug.h" +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/library/include/wchan.h b/library/include/wchan.h new file mode 100644 index 0000000..ef1d689 --- /dev/null +++ b/library/include/wchan.h @@ -0,0 +1,27 @@ +/* + * wchan.c - kernel symbol handling + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 1998-2003 Albert Cahalan + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PROCPS_PROC_WCHAN_H +#define PROCPS_PROC_WCHAN_H + +extern const char *lookup_wchan (int pid); + +#endif diff --git a/library/include/xtra-procps-debug.h b/library/include/xtra-procps-debug.h new file mode 100644 index 0000000..ead8075 --- /dev/null +++ b/library/include/xtra-procps-debug.h @@ -0,0 +1,208 @@ +/* + * libproc2 - Library to read proc filesystem + * + * Copyright © 2016-2023 Jim Warner <james.warner@comcast.net> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#define STRINGIFY_ARG(a) #a +#define STRINGIFY(a) STRINGIFY_ARG(a) + + +// --- DISKSTATS ------------------------------------------ +#if defined(PROCPS_DISKSTATS_H) && !defined(PROCPS_DISKSTATS_H_DEBUG) +#define PROCPS_DISKSTATS_H_DEBUG + +struct diskstats_result *xtra_diskstats_get ( + struct diskstats_info *info, + const char *name, + enum diskstats_item actual_enum, + const char *typestr, + const char *file, + int lineno); + +# undef DISKSTATS_GET +#define DISKSTATS_GET( info, name, actual_enum, type ) ( { \ + struct diskstats_result *r; \ + r = xtra_diskstats_get(info, name, actual_enum , STRINGIFY(type), __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) + +struct diskstats_result *xtra_diskstats_val ( + int relative_enum, + const char *typestr, + const struct diskstats_stack *stack, + struct diskstats_info *info, + const char *file, + int lineno); + +# undef DISKSTATS_VAL +#define DISKSTATS_VAL( relative_enum, type, stack, info ) ( { \ + struct diskstats_result *r; \ + r = xtra_diskstats_val(relative_enum, STRINGIFY(type), stack, info, __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) +#endif // . . . . . . . . . . + + +// --- MEMINFO -------------------------------------------- +#if defined(PROCPS_MEMINFO_H) && !defined(PROCPS_MEMINFO_H_DEBUG) +#define PROCPS_MEMINFO_H_DEBUG + +struct meminfo_result *xtra_meminfo_get ( + struct meminfo_info *info, + enum meminfo_item actual_enum, + const char *typestr, + const char *file, + int lineno); + +# undef MEMINFO_GET +#define MEMINFO_GET( info, actual_enum, type ) ( { \ + struct meminfo_result *r; \ + r = xtra_meminfo_get(info, actual_enum , STRINGIFY(type), __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) + +struct meminfo_result *xtra_meminfo_val ( + int relative_enum, + const char *typestr, + const struct meminfo_stack *stack, + struct meminfo_info *info, + const char *file, + int lineno); + +# undef MEMINFO_VAL +#define MEMINFO_VAL( relative_enum, type, stack, info ) ( { \ + struct meminfo_result *r; \ + r = xtra_meminfo_val(relative_enum, STRINGIFY(type), stack, info, __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) +#endif // . . . . . . . . . . + + +// --- PIDS ----------------------------------------------- +#if defined(PROCPS_PIDS_H) && !defined(PROCPS_PIDS_H_DEBUG) +#define PROCPS_PIDS_H_DEBUG + +struct pids_result *xtra_pids_val ( + int relative_enum, + const char *typestr, + const struct pids_stack *stack, + struct pids_info *info, + const char *file, + int lineno); + +# undef PIDS_VAL +#define PIDS_VAL( relative_enum, type, stack, info ) ( { \ + struct pids_result *r; \ + r = xtra_pids_val(relative_enum, STRINGIFY(type), stack, info, __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) +#endif // . . . . . . . . . . + + +// --- SLABINFO ------------------------------------------- +#if defined(PROCPS_SLABINFO_H) && !defined(PROCPS_SLABINFO_H_DEBUG) +#define PROCPS_SLABINFO_H_DEBUG + +struct slabinfo_result *xtra_slabinfo_get ( + struct slabinfo_info *info, + enum slabinfo_item actual_enum, + const char *typestr, + const char *file, + int lineno); + +# undef SLABINFO_GET +#define SLABINFO_GET( info, actual_enum, type ) ( { \ + struct slabinfo_result *r; \ + r = xtra_slabinfo_get(info, actual_enum , STRINGIFY(type), __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) + +struct slabinfo_result *xtra_slabinfo_val ( + int relative_enum, + const char *typestr, + const struct slabinfo_stack *stack, + struct slabinfo_info *info, + const char *file, + int lineno); + +# undef SLABINFO_VAL +#define SLABINFO_VAL( relative_enum, type, stack, info ) ( { \ + struct slabinfo_result *r; \ + r = xtra_slabinfo_val(relative_enum, STRINGIFY(type), stack, info, __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) +#endif // . . . . . . . . . . + + +// --- STAT ----------------------------------------------- +#if defined(PROCPS_STAT_H) && !defined(PROCPS_STAT_H_DEBUG) +#define PROCPS_STAT_H_DEBUG + +struct stat_result *xtra_stat_get ( + struct stat_info *info, + enum stat_item actual_enum, + const char *typestr, + const char *file, + int lineno); + +# undef STAT_GET +#define STAT_GET( info, actual_enum, type ) ( { \ + struct stat_result *r; \ + r = xtra_stat_get(info, actual_enum , STRINGIFY(type), __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) + +struct stat_result *xtra_stat_val ( + int relative_enum, + const char *typestr, + const struct stat_stack *stack, + struct stat_info *info, + const char *file, + int lineno); + +# undef STAT_VAL +#define STAT_VAL( relative_enum, type, stack, info ) ( { \ + struct stat_result *r; \ + r = xtra_stat_val(relative_enum, STRINGIFY(type), stack, info, __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) +#endif // . . . . . . . . . . + + +// --- VMSTAT --------------------------------------------- +#if defined(PROCPS_VMSTAT_H) && !defined(PROCPS_VMSTAT_H_DEBUG) +#define PROCPS_VMSTAT_H_DEBUG + +struct vmstat_result *xtra_vmstat_get ( + struct vmstat_info *info, + enum vmstat_item actual_enum, + const char *typestr, + const char *file, + int lineno); + +# undef VMSTAT_GET +#define VMSTAT_GET( info, actual_enum, type ) ( { \ + struct vmstat_result *r; \ + r = xtra_vmstat_get(info, actual_enum , STRINGIFY(type), __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) + +struct vmstat_result *xtra_vmstat_val ( + int relative_enum, + const char *typestr, + const struct vmstat_stack *stack, + struct vmstat_info *info, + const char *file, + int lineno); + +# undef VMSTAT_VAL +#define VMSTAT_VAL( relative_enum, type, stack, info ) ( { \ + struct vmstat_result *r; \ + r = xtra_vmstat_val(relative_enum, STRINGIFY(type), stack, info, __FILE__, __LINE__); \ + r ? r->result . type : 0; } ) +#endif // . . . . . . . . . . diff --git a/library/libproc2.pc.in b/library/libproc2.pc.in new file mode 100644 index 0000000..99fd97e --- /dev/null +++ b/library/libproc2.pc.in @@ -0,0 +1,11 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: libproc2 +Description: Library to control and query process state +Version: @VERSION@ +Libs: -L${libdir} -lproc2 +Libs.private: +Cflags: -I${includedir} diff --git a/library/libproc2.sym b/library/libproc2.sym new file mode 100644 index 0000000..bb84ba9 --- /dev/null +++ b/library/libproc2.sym @@ -0,0 +1,67 @@ +LIBPROC_2 { +global: + fatal_proc_unmounted; + procps_cpu_count; + procps_diskstats_new; + procps_diskstats_ref; + procps_diskstats_unref; + procps_diskstats_get; + procps_diskstats_reap; + procps_diskstats_select; + procps_diskstats_sort; + procps_hertz_get; + procps_linux_version; + procps_loadavg; + procps_meminfo_new; + procps_meminfo_ref; + procps_meminfo_unref; + procps_meminfo_get; + procps_meminfo_select; + procps_ns_get_name; + procps_ns_get_id; + procps_ns_read_pid; + procps_pid_length; + procps_pids_new; + procps_pids_ref; + procps_pids_unref; + procps_pids_get; + procps_pids_reap; + procps_pids_reset; + procps_pids_select; + procps_pids_sort; + procps_slabinfo_new; + procps_slabinfo_ref; + procps_slabinfo_unref; + procps_slabinfo_get; + procps_slabinfo_reap; + procps_slabinfo_select; + procps_slabinfo_sort; + procps_stat_new; + procps_stat_ref; + procps_stat_unref; + procps_stat_get; + procps_stat_reap; + procps_stat_select; + procps_stat_sort; + procps_uptime; + procps_uptime_sprint; + procps_uptime_sprint_short; + procps_vmstat_new; + procps_vmstat_ref; + procps_vmstat_unref; + procps_vmstat_get; + procps_vmstat_select; + xtra_diskstats_get; + xtra_diskstats_val; + xtra_meminfo_get; + xtra_meminfo_val; + xtra_pids_val; + xtra_slabinfo_get; + xtra_slabinfo_val; + xtra_stat_get; + xtra_stat_val; + xtra_vmstat_get; + xtra_vmstat_val; +local: + *; +}; diff --git a/library/meminfo.c b/library/meminfo.c new file mode 100644 index 0000000..4289a23 --- /dev/null +++ b/library/meminfo.c @@ -0,0 +1,1016 @@ +/* + * meminfo.c - memory related definitions for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <errno.h> +#include <fcntl.h> +#include <search.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> + +#include <sys/stat.h> +#include <sys/types.h> + +#include "procps-private.h" +#include "meminfo.h" + + +#define MEMINFO_FILE "/proc/meminfo" +#define MEMINFO_BUFF 8192 + +/* ------------------------------------------------------------------------- + + this provision can be used to ensure that our Item_table was synchronized | + with those enumerators found in the associated header file. It's intended | + to only be used locally (& temporarily) at some point prior to a release! | */ +// #define ITEMTABLE_DEBUG //----------------------------------------------- | +// ------------------------------------------------------------------------- + + + +struct meminfo_data { + unsigned long Active; + unsigned long Active_anon; // as: Active(anon): man 5 proc: 'to be documented' + unsigned long Active_file; // as: Active(file): man 5 proc: 'to be documented' + unsigned long AnonHugePages; + unsigned long AnonPages; + unsigned long Bounce; + unsigned long Buffers; + unsigned long Cached; + unsigned long CmaFree; + unsigned long CmaTotal; + unsigned long CommitLimit; + unsigned long Committed_AS; + unsigned long DirectMap1G; + unsigned long DirectMap2M; + unsigned long DirectMap4M; + unsigned long DirectMap4k; + unsigned long Dirty; + unsigned long FileHugePages; + unsigned long FilePmdMapped; + unsigned long HardwareCorrupted; // man 5 proc: 'to be documented' + unsigned long HighFree; + unsigned long HighTotal; + unsigned long HugePages_Free; + unsigned long HugePages_Rsvd; + unsigned long HugePages_Surp; + unsigned long HugePages_Total; + unsigned long Hugepagesize; + unsigned long Hugetlb; + unsigned long Inactive; + unsigned long Inactive_anon; // as: Inactive(anon): man 5 proc: 'to be documented' + unsigned long Inactive_file; // as: Inactive(file): man 5 proc: 'to be documented' + unsigned long KReclaimable; + unsigned long KernelStack; + unsigned long LowFree; + unsigned long LowTotal; + unsigned long Mapped; + unsigned long MemAvailable; + unsigned long MemFree; + unsigned long MemTotal; + unsigned long Mlocked; // man 5 proc: 'to be documented' + unsigned long MmapCopy; // man 5 proc: 'to be documented' + unsigned long NFS_Unstable; + unsigned long PageTables; + unsigned long Percpu; + unsigned long SReclaimable; + unsigned long SUnreclaim; + unsigned long ShadowCallStack; + unsigned long Shmem; + unsigned long ShmemHugePages; + unsigned long ShmemPmdMapped; + unsigned long Slab; + unsigned long SwapCached; + unsigned long SwapFree; + unsigned long SwapTotal; + unsigned long Unevictable; // man 5 proc: 'to be documented' + unsigned long VmallocChunk; + unsigned long VmallocTotal; + unsigned long VmallocUsed; + unsigned long Writeback; + unsigned long WritebackTmp; + + unsigned long derived_mem_cached; + unsigned long derived_mem_hi_used; + unsigned long derived_mem_lo_used; + unsigned long derived_mem_used; + unsigned long derived_swap_used; +}; + +struct mem_hist { + struct meminfo_data new; + struct meminfo_data old; +}; + +struct stacks_extent { + int ext_numstacks; + struct stacks_extent *next; + struct meminfo_stack **stacks; +}; + +struct meminfo_info { + int refcount; + int meminfo_fd; + struct mem_hist hist; + int numitems; + enum meminfo_item *items; + struct stacks_extent *extents; + struct hsearch_data hashtab; + struct meminfo_result get_this; + time_t sav_secs; +}; + + +// ___ Results 'Set' Support |||||||||||||||||||||||||||||||||||||||||||||||||| + +#define setNAME(e) set_meminfo_ ## e +#define setDECL(e) static void setNAME(e) \ + (struct meminfo_result *R, struct mem_hist *H) + +// regular assignment +#define MEM_set(e,t,x) setDECL(e) { R->result. t = H->new. x; } +// delta assignment +#define HST_set(e,t,x) setDECL(e) { R->result. t = ( H->new. x - H->old. x ); } + +setDECL(noop) { (void)R; (void)H; } +setDECL(extra) { (void)H; R->result.ul_int = 0; } + +MEM_set(MEM_ACTIVE, ul_int, Active) +MEM_set(MEM_ACTIVE_ANON, ul_int, Active_anon) +MEM_set(MEM_ACTIVE_FILE, ul_int, Active_file) +MEM_set(MEM_ANON, ul_int, AnonPages) +MEM_set(MEM_AVAILABLE, ul_int, MemAvailable) +MEM_set(MEM_BOUNCE, ul_int, Bounce) +MEM_set(MEM_BUFFERS, ul_int, Buffers) +MEM_set(MEM_CACHED, ul_int, Cached) +MEM_set(MEM_CACHED_ALL, ul_int, derived_mem_cached) +MEM_set(MEM_CMA_FREE, ul_int, CmaFree) +MEM_set(MEM_CMA_TOTAL, ul_int, CmaTotal) +MEM_set(MEM_COMMITTED_AS, ul_int, Committed_AS) +MEM_set(MEM_COMMIT_LIMIT, ul_int, CommitLimit) +MEM_set(MEM_DIRECTMAP_1G, ul_int, DirectMap1G) +MEM_set(MEM_DIRECTMAP_2M, ul_int, DirectMap2M) +MEM_set(MEM_DIRECTMAP_4K, ul_int, DirectMap4k) +MEM_set(MEM_DIRECTMAP_4M, ul_int, DirectMap4M) +MEM_set(MEM_DIRTY, ul_int, Dirty) +MEM_set(MEM_FILE_HUGEPAGES, ul_int, FileHugePages) +MEM_set(MEM_FILE_PMDMAPPED, ul_int, FilePmdMapped) +MEM_set(MEM_FREE, ul_int, MemFree) +MEM_set(MEM_HARD_CORRUPTED, ul_int, HardwareCorrupted) +MEM_set(MEM_HIGH_FREE, ul_int, HighFree) +MEM_set(MEM_HIGH_TOTAL, ul_int, HighTotal) +MEM_set(MEM_HIGH_USED, ul_int, derived_mem_hi_used) +MEM_set(MEM_HUGETBL, ul_int, Hugetlb) +MEM_set(MEM_HUGE_ANON, ul_int, AnonHugePages) +MEM_set(MEM_HUGE_FREE, ul_int, HugePages_Free) +MEM_set(MEM_HUGE_RSVD, ul_int, HugePages_Rsvd) +MEM_set(MEM_HUGE_SIZE, ul_int, Hugepagesize) +MEM_set(MEM_HUGE_SURPLUS, ul_int, HugePages_Surp) +MEM_set(MEM_HUGE_TOTAL, ul_int, HugePages_Total) +MEM_set(MEM_INACTIVE, ul_int, Inactive) +MEM_set(MEM_INACTIVE_ANON, ul_int, Inactive_anon) +MEM_set(MEM_INACTIVE_FILE, ul_int, Inactive_file) +MEM_set(MEM_KERNEL_RECLAIM, ul_int, KReclaimable) +MEM_set(MEM_KERNEL_STACK, ul_int, KernelStack) +MEM_set(MEM_LOCKED, ul_int, Mlocked) +MEM_set(MEM_LOW_FREE, ul_int, LowFree) +MEM_set(MEM_LOW_TOTAL, ul_int, LowTotal) +MEM_set(MEM_LOW_USED, ul_int, derived_mem_lo_used) +MEM_set(MEM_MAPPED, ul_int, Mapped) +MEM_set(MEM_MAP_COPY, ul_int, MmapCopy) +MEM_set(MEM_NFS_UNSTABLE, ul_int, NFS_Unstable) +MEM_set(MEM_PAGE_TABLES, ul_int, PageTables) +MEM_set(MEM_PER_CPU, ul_int, Percpu) +MEM_set(MEM_SHADOWCALLSTACK, ul_int, ShadowCallStack) +MEM_set(MEM_SHARED, ul_int, Shmem) +MEM_set(MEM_SHMEM_HUGE, ul_int, ShmemHugePages) +MEM_set(MEM_SHMEM_HUGE_MAP, ul_int, ShmemPmdMapped) +MEM_set(MEM_SLAB, ul_int, Slab) +MEM_set(MEM_SLAB_RECLAIM, ul_int, SReclaimable) +MEM_set(MEM_SLAB_UNRECLAIM, ul_int, SUnreclaim) +MEM_set(MEM_TOTAL, ul_int, MemTotal) +MEM_set(MEM_UNEVICTABLE, ul_int, Unevictable) +MEM_set(MEM_USED, ul_int, derived_mem_used) +MEM_set(MEM_VM_ALLOC_CHUNK, ul_int, VmallocChunk) +MEM_set(MEM_VM_ALLOC_TOTAL, ul_int, VmallocTotal) +MEM_set(MEM_VM_ALLOC_USED, ul_int, VmallocUsed) +MEM_set(MEM_WRITEBACK, ul_int, Writeback) +MEM_set(MEM_WRITEBACK_TMP, ul_int, WritebackTmp) + +HST_set(DELTA_ACTIVE, s_int, Active) +HST_set(DELTA_ACTIVE_ANON, s_int, Active_anon) +HST_set(DELTA_ACTIVE_FILE, s_int, Active_file) +HST_set(DELTA_ANON, s_int, AnonPages) +HST_set(DELTA_AVAILABLE, s_int, MemAvailable) +HST_set(DELTA_BOUNCE, s_int, Bounce) +HST_set(DELTA_BUFFERS, s_int, Buffers) +HST_set(DELTA_CACHED, s_int, Cached) +HST_set(DELTA_CACHED_ALL, s_int, derived_mem_cached) +HST_set(DELTA_CMA_FREE, s_int, CmaFree) +HST_set(DELTA_CMA_TOTAL, s_int, CmaTotal) +HST_set(DELTA_COMMITTED_AS, s_int, Committed_AS) +HST_set(DELTA_COMMIT_LIMIT, s_int, CommitLimit) +HST_set(DELTA_DIRECTMAP_1G, s_int, DirectMap1G) +HST_set(DELTA_DIRECTMAP_2M, s_int, DirectMap2M) +HST_set(DELTA_DIRECTMAP_4K, s_int, DirectMap4k) +HST_set(DELTA_DIRECTMAP_4M, s_int, DirectMap4M) +HST_set(DELTA_DIRTY, s_int, Dirty) +HST_set(DELTA_FILE_HUGEPAGES, s_int, FileHugePages) +HST_set(DELTA_FILE_PMDMAPPED, s_int, FilePmdMapped) +HST_set(DELTA_FREE, s_int, MemFree) +HST_set(DELTA_HARD_CORRUPTED, s_int, HardwareCorrupted) +HST_set(DELTA_HIGH_FREE, s_int, HighFree) +HST_set(DELTA_HIGH_TOTAL, s_int, HighTotal) +HST_set(DELTA_HIGH_USED, s_int, derived_mem_hi_used) +HST_set(DELTA_HUGETBL, s_int, Hugetlb) +HST_set(DELTA_HUGE_ANON, s_int, AnonHugePages) +HST_set(DELTA_HUGE_FREE, s_int, HugePages_Free) +HST_set(DELTA_HUGE_RSVD, s_int, HugePages_Rsvd) +HST_set(DELTA_HUGE_SIZE, s_int, Hugepagesize) +HST_set(DELTA_HUGE_SURPLUS, s_int, HugePages_Surp) +HST_set(DELTA_HUGE_TOTAL, s_int, HugePages_Total) +HST_set(DELTA_INACTIVE, s_int, Inactive) +HST_set(DELTA_INACTIVE_ANON, s_int, Inactive_anon) +HST_set(DELTA_INACTIVE_FILE, s_int, Inactive_file) +HST_set(DELTA_KERNEL_RECLAIM, s_int, KReclaimable) +HST_set(DELTA_KERNEL_STACK, s_int, KernelStack) +HST_set(DELTA_LOCKED, s_int, Mlocked) +HST_set(DELTA_LOW_FREE, s_int, LowFree) +HST_set(DELTA_LOW_TOTAL, s_int, LowTotal) +HST_set(DELTA_LOW_USED, s_int, derived_mem_lo_used) +HST_set(DELTA_MAPPED, s_int, Mapped) +HST_set(DELTA_MAP_COPY, s_int, MmapCopy) +HST_set(DELTA_NFS_UNSTABLE, s_int, NFS_Unstable) +HST_set(DELTA_PAGE_TABLES, s_int, PageTables) +HST_set(DELTA_PER_CPU, s_int, Percpu) +HST_set(DELTA_SHADOWCALLSTACK, s_int, ShadowCallStack) +HST_set(DELTA_SHARED, s_int, Shmem) +HST_set(DELTA_SHMEM_HUGE, s_int, ShmemHugePages) +HST_set(DELTA_SHMEM_HUGE_MAP, s_int, ShmemPmdMapped) +HST_set(DELTA_SLAB, s_int, Slab) +HST_set(DELTA_SLAB_RECLAIM, s_int, SReclaimable) +HST_set(DELTA_SLAB_UNRECLAIM, s_int, SUnreclaim) +HST_set(DELTA_TOTAL, s_int, MemTotal) +HST_set(DELTA_UNEVICTABLE, s_int, Unevictable) +HST_set(DELTA_USED, s_int, derived_mem_used) +HST_set(DELTA_VM_ALLOC_CHUNK, s_int, VmallocChunk) +HST_set(DELTA_VM_ALLOC_TOTAL, s_int, VmallocTotal) +HST_set(DELTA_VM_ALLOC_USED, s_int, VmallocUsed) +HST_set(DELTA_WRITEBACK, s_int, Writeback) +HST_set(DELTA_WRITEBACK_TMP, s_int, WritebackTmp) + +MEM_set(SWAP_CACHED, ul_int, SwapCached) +MEM_set(SWAP_FREE, ul_int, SwapFree) +MEM_set(SWAP_TOTAL, ul_int, SwapTotal) +MEM_set(SWAP_USED, ul_int, derived_swap_used) + +HST_set(SWAP_DELTA_CACHED, s_int, SwapCached) +HST_set(SWAP_DELTA_FREE, s_int, SwapFree) +HST_set(SWAP_DELTA_TOTAL, s_int, SwapTotal) +HST_set(SWAP_DELTA_USED, s_int, derived_swap_used) + +#undef setDECL +#undef MEM_set +#undef HST_set + + +// ___ Controlling Table |||||||||||||||||||||||||||||||||||||||||||||||||||||| + +typedef void (*SET_t)(struct meminfo_result *, struct mem_hist *); +#ifdef ITEMTABLE_DEBUG +#define RS(e) (SET_t)setNAME(e), MEMINFO_ ## e, STRINGIFY(MEMINFO_ ## e) +#else +#define RS(e) (SET_t)setNAME(e) +#endif + +#define TS(t) STRINGIFY(t) +#define TS_noop "" + + /* + * Need it be said? + * This table must be kept in the exact same order as + * those 'enum meminfo_item' guys ! */ +static struct { + SET_t setsfunc; // the actual result setting routine +#ifdef ITEMTABLE_DEBUG + int enumnumb; // enumerator (must match position!) + char *enum2str; // enumerator name as a char* string +#endif + char *type2str; // the result type as a string value +} Item_table[] = { +/* setsfunc type2str + ------------------------- ---------- */ + { RS(noop), TS_noop }, + { RS(extra), TS_noop }, + + { RS(MEM_ACTIVE), TS(ul_int) }, + { RS(MEM_ACTIVE_ANON), TS(ul_int) }, + { RS(MEM_ACTIVE_FILE), TS(ul_int) }, + { RS(MEM_ANON), TS(ul_int) }, + { RS(MEM_AVAILABLE), TS(ul_int) }, + { RS(MEM_BOUNCE), TS(ul_int) }, + { RS(MEM_BUFFERS), TS(ul_int) }, + { RS(MEM_CACHED), TS(ul_int) }, + { RS(MEM_CACHED_ALL), TS(ul_int) }, + { RS(MEM_CMA_FREE), TS(ul_int) }, + { RS(MEM_CMA_TOTAL), TS(ul_int) }, + { RS(MEM_COMMITTED_AS), TS(ul_int) }, + { RS(MEM_COMMIT_LIMIT), TS(ul_int) }, + { RS(MEM_DIRECTMAP_1G), TS(ul_int) }, + { RS(MEM_DIRECTMAP_2M), TS(ul_int) }, + { RS(MEM_DIRECTMAP_4K), TS(ul_int) }, + { RS(MEM_DIRECTMAP_4M), TS(ul_int) }, + { RS(MEM_DIRTY), TS(ul_int) }, + { RS(MEM_FILE_HUGEPAGES), TS(ul_int) }, + { RS(MEM_FILE_PMDMAPPED), TS(ul_int) }, + { RS(MEM_FREE), TS(ul_int) }, + { RS(MEM_HARD_CORRUPTED), TS(ul_int) }, + { RS(MEM_HIGH_FREE), TS(ul_int) }, + { RS(MEM_HIGH_TOTAL), TS(ul_int) }, + { RS(MEM_HIGH_USED), TS(ul_int) }, + { RS(MEM_HUGETBL), TS(ul_int) }, + { RS(MEM_HUGE_ANON), TS(ul_int) }, + { RS(MEM_HUGE_FREE), TS(ul_int) }, + { RS(MEM_HUGE_RSVD), TS(ul_int) }, + { RS(MEM_HUGE_SIZE), TS(ul_int) }, + { RS(MEM_HUGE_SURPLUS), TS(ul_int) }, + { RS(MEM_HUGE_TOTAL), TS(ul_int) }, + { RS(MEM_INACTIVE), TS(ul_int) }, + { RS(MEM_INACTIVE_ANON), TS(ul_int) }, + { RS(MEM_INACTIVE_FILE), TS(ul_int) }, + { RS(MEM_KERNEL_RECLAIM), TS(ul_int) }, + { RS(MEM_KERNEL_STACK), TS(ul_int) }, + { RS(MEM_LOCKED), TS(ul_int) }, + { RS(MEM_LOW_FREE), TS(ul_int) }, + { RS(MEM_LOW_TOTAL), TS(ul_int) }, + { RS(MEM_LOW_USED), TS(ul_int) }, + { RS(MEM_MAPPED), TS(ul_int) }, + { RS(MEM_MAP_COPY), TS(ul_int) }, + { RS(MEM_NFS_UNSTABLE), TS(ul_int) }, + { RS(MEM_PAGE_TABLES), TS(ul_int) }, + { RS(MEM_PER_CPU), TS(ul_int) }, + { RS(MEM_SHADOWCALLSTACK), TS(ul_int) }, + { RS(MEM_SHARED), TS(ul_int) }, + { RS(MEM_SHMEM_HUGE), TS(ul_int) }, + { RS(MEM_SHMEM_HUGE_MAP), TS(ul_int) }, + { RS(MEM_SLAB), TS(ul_int) }, + { RS(MEM_SLAB_RECLAIM), TS(ul_int) }, + { RS(MEM_SLAB_UNRECLAIM), TS(ul_int) }, + { RS(MEM_TOTAL), TS(ul_int) }, + { RS(MEM_UNEVICTABLE), TS(ul_int) }, + { RS(MEM_USED), TS(ul_int) }, + { RS(MEM_VM_ALLOC_CHUNK), TS(ul_int) }, + { RS(MEM_VM_ALLOC_TOTAL), TS(ul_int) }, + { RS(MEM_VM_ALLOC_USED), TS(ul_int) }, + { RS(MEM_WRITEBACK), TS(ul_int) }, + { RS(MEM_WRITEBACK_TMP), TS(ul_int) }, + + { RS(DELTA_ACTIVE), TS(s_int) }, + { RS(DELTA_ACTIVE_ANON), TS(s_int) }, + { RS(DELTA_ACTIVE_FILE), TS(s_int) }, + { RS(DELTA_ANON), TS(s_int) }, + { RS(DELTA_AVAILABLE), TS(s_int) }, + { RS(DELTA_BOUNCE), TS(s_int) }, + { RS(DELTA_BUFFERS), TS(s_int) }, + { RS(DELTA_CACHED), TS(s_int) }, + { RS(DELTA_CACHED_ALL), TS(s_int) }, + { RS(DELTA_CMA_FREE), TS(s_int) }, + { RS(DELTA_CMA_TOTAL), TS(s_int) }, + { RS(DELTA_COMMITTED_AS), TS(s_int) }, + { RS(DELTA_COMMIT_LIMIT), TS(s_int) }, + { RS(DELTA_DIRECTMAP_1G), TS(s_int) }, + { RS(DELTA_DIRECTMAP_2M), TS(s_int) }, + { RS(DELTA_DIRECTMAP_4K), TS(s_int) }, + { RS(DELTA_DIRECTMAP_4M), TS(s_int) }, + { RS(DELTA_DIRTY), TS(s_int) }, + { RS(DELTA_FILE_HUGEPAGES), TS(s_int) }, + { RS(DELTA_FILE_PMDMAPPED), TS(s_int) }, + { RS(DELTA_FREE), TS(s_int) }, + { RS(DELTA_HARD_CORRUPTED), TS(s_int) }, + { RS(DELTA_HIGH_FREE), TS(s_int) }, + { RS(DELTA_HIGH_TOTAL), TS(s_int) }, + { RS(DELTA_HIGH_USED), TS(s_int) }, + { RS(DELTA_HUGETBL), TS(s_int) }, + { RS(DELTA_HUGE_ANON), TS(s_int) }, + { RS(DELTA_HUGE_FREE), TS(s_int) }, + { RS(DELTA_HUGE_RSVD), TS(s_int) }, + { RS(DELTA_HUGE_SIZE), TS(s_int) }, + { RS(DELTA_HUGE_SURPLUS), TS(s_int) }, + { RS(DELTA_HUGE_TOTAL), TS(s_int) }, + { RS(DELTA_INACTIVE), TS(s_int) }, + { RS(DELTA_INACTIVE_ANON), TS(s_int) }, + { RS(DELTA_INACTIVE_FILE), TS(s_int) }, + { RS(DELTA_KERNEL_RECLAIM), TS(s_int) }, + { RS(DELTA_KERNEL_STACK), TS(s_int) }, + { RS(DELTA_LOCKED), TS(s_int) }, + { RS(DELTA_LOW_FREE), TS(s_int) }, + { RS(DELTA_LOW_TOTAL), TS(s_int) }, + { RS(DELTA_LOW_USED), TS(s_int) }, + { RS(DELTA_MAPPED), TS(s_int) }, + { RS(DELTA_MAP_COPY), TS(s_int) }, + { RS(DELTA_NFS_UNSTABLE), TS(s_int) }, + { RS(DELTA_PAGE_TABLES), TS(s_int) }, + { RS(DELTA_PER_CPU), TS(s_int) }, + { RS(DELTA_SHADOWCALLSTACK), TS(s_int) }, + { RS(DELTA_SHARED), TS(s_int) }, + { RS(DELTA_SHMEM_HUGE), TS(s_int) }, + { RS(DELTA_SHMEM_HUGE_MAP), TS(s_int) }, + { RS(DELTA_SLAB), TS(s_int) }, + { RS(DELTA_SLAB_RECLAIM), TS(s_int) }, + { RS(DELTA_SLAB_UNRECLAIM), TS(s_int) }, + { RS(DELTA_TOTAL), TS(s_int) }, + { RS(DELTA_UNEVICTABLE), TS(s_int) }, + { RS(DELTA_USED), TS(s_int) }, + { RS(DELTA_VM_ALLOC_CHUNK), TS(s_int) }, + { RS(DELTA_VM_ALLOC_TOTAL), TS(s_int) }, + { RS(DELTA_VM_ALLOC_USED), TS(s_int) }, + { RS(DELTA_WRITEBACK), TS(s_int) }, + { RS(DELTA_WRITEBACK_TMP), TS(s_int) }, + + { RS(SWAP_CACHED), TS(ul_int) }, + { RS(SWAP_FREE), TS(ul_int) }, + { RS(SWAP_TOTAL), TS(ul_int) }, + { RS(SWAP_USED), TS(ul_int) }, + + { RS(SWAP_DELTA_CACHED), TS(s_int) }, + { RS(SWAP_DELTA_FREE), TS(s_int) }, + { RS(SWAP_DELTA_TOTAL), TS(s_int) }, + { RS(SWAP_DELTA_USED), TS(s_int) }, +}; + + /* please note, + * this enum MUST be 1 greater than the highest value of any enum */ +enum meminfo_item MEMINFO_logical_end = MAXTABLE(Item_table); + +#undef setNAME +#undef RS + + +// ___ Private Functions |||||||||||||||||||||||||||||||||||||||||||||||||||||| + +static inline void meminfo_assign_results ( + struct meminfo_stack *stack, + struct mem_hist *hist) +{ + struct meminfo_result *this = stack->head; + + for (;;) { + enum meminfo_item item = this->item; + if (item >= MEMINFO_logical_end) + break; + Item_table[item].setsfunc(this, hist); + ++this; + } + return; +} // end: meminfo_assign_results + + +static void meminfo_extents_free_all ( + struct meminfo_info *info) +{ + while (info->extents) { + struct stacks_extent *p = info->extents; + info->extents = info->extents->next; + free(p); + }; +} // end: meminfo_extents_free_all + + +static inline struct meminfo_result *meminfo_itemize_stack ( + struct meminfo_result *p, + int depth, + enum meminfo_item *items) +{ + struct meminfo_result *p_sav = p; + int i; + + for (i = 0; i < depth; i++) { + p->item = items[i]; + ++p; + } + return p_sav; +} // end: meminfo_itemize_stack + + +static inline int meminfo_items_check_failed ( + int numitems, + enum meminfo_item *items) +{ + int i; + + /* if an enum is passed instead of an address of one or more enums, ol' gcc + * will silently convert it to an address (possibly NULL). only clang will + * offer any sort of warning like the following: + * + * warning: incompatible integer to pointer conversion passing 'int' to parameter of type 'enum meminfo_item *' + * my_stack = procps_meminfo_select(info, MEMINFO_noop, num); + * ^~~~~~~~~~~~~~~~ + */ + if (numitems < 1 + || (void *)items < (void *)(unsigned long)(2 * MEMINFO_logical_end)) + return 1; + + for (i = 0; i < numitems; i++) { + // a meminfo_item is currently unsigned, but we'll protect our future + if (items[i] < 0) + return 1; + if (items[i] >= MEMINFO_logical_end) + return 1; + } + + return 0; +} // end: meminfo_items_check_failed + + +static int meminfo_make_hash_failed ( + struct meminfo_info *info) +{ + #define htVAL(f) e.key = STRINGIFY(f); e.data = &info->hist.new. f; \ + if (!hsearch_r(e, ENTER, &ep, &info->hashtab)) return 1; + #define htXTRA(k,f) e.key = STRINGIFY(k); e.data = &info->hist.new. f; \ + if (!hsearch_r(e, ENTER, &ep, &info->hashtab)) return 1; + ENTRY e, *ep; + size_t n; + + // will also include those derived fields (more is better) + n = sizeof(struct meminfo_data) / sizeof(unsigned long); + // we'll follow the hsearch recommendation of an extra 25% + if (!hcreate_r(n + (n / 4), &info->hashtab)) + return 1; + + htVAL(Active) + htXTRA(Active(anon), Active_anon) + htXTRA(Active(file), Active_file) + htVAL(AnonHugePages) + htVAL(AnonPages) + htVAL(Bounce) + htVAL(Buffers) + htVAL(Cached) + htVAL(CmaFree) + htVAL(CmaTotal) + htVAL(CommitLimit) + htVAL(Committed_AS) + htVAL(DirectMap1G) + htVAL(DirectMap2M) + htVAL(DirectMap4M) + htVAL(DirectMap4k) + htVAL(Dirty) + htVAL(FileHugePages) + htVAL(FilePmdMapped) + htVAL(HardwareCorrupted) + htVAL(HighFree) + htVAL(HighTotal) + htVAL(HugePages_Free) + htVAL(HugePages_Rsvd) + htVAL(HugePages_Surp) + htVAL(HugePages_Total) + htVAL(Hugepagesize) + htVAL(Hugetlb) + htVAL(Inactive) + htXTRA(Inactive(anon), Inactive_anon) + htXTRA(Inactive(file), Inactive_file) + htVAL(KReclaimable) + htVAL(KernelStack) + htVAL(LowFree) + htVAL(LowTotal) + htVAL(Mapped) + htVAL(MemAvailable) + htVAL(MemFree) + htVAL(MemTotal) + htVAL(Mlocked) + htVAL(MmapCopy) + htVAL(NFS_Unstable) + htVAL(PageTables) + htVAL(Percpu) + htVAL(SReclaimable) + htVAL(SUnreclaim) + htVAL(ShadowCallStack) + htVAL(Shmem) + htVAL(ShmemHugePages) + htVAL(ShmemPmdMapped) + htVAL(Slab) + htVAL(SwapCached) + htVAL(SwapFree) + htVAL(SwapTotal) + htVAL(Unevictable) + htVAL(VmallocChunk) + htVAL(VmallocTotal) + htVAL(VmallocUsed) + htVAL(Writeback) + htVAL(WritebackTmp) + + return 0; + #undef htVAL + #undef htXTRA +} // end: meminfo_make_hash_failed + + +/* + * meminfo_read_failed(): + * + * Read the data out of /proc/meminfo putting the information + * into the supplied info structure + */ +static int meminfo_read_failed ( + struct meminfo_info *info) +{ + /* a 'memory history reference' macro for readability, + so we can focus the field names ... */ + #define mHr(f) info->hist.new. f + char buf[MEMINFO_BUFF]; + char *head, *tail; + int size; + unsigned long *valptr; + signed long mem_used; + + // remember history from last time around + memcpy(&info->hist.old, &info->hist.new, sizeof(struct meminfo_data)); + // clear out the soon to be 'current' values + memset(&info->hist.new, 0, sizeof(struct meminfo_data)); + + if (-1 == info->meminfo_fd + && (-1 == (info->meminfo_fd = open(MEMINFO_FILE, O_RDONLY)))) + return 1; + + if (lseek(info->meminfo_fd, 0L, SEEK_SET) == -1) + return 1; + + for (;;) { + if ((size = read(info->meminfo_fd, buf, sizeof(buf)-1)) < 0) { + if (errno == EINTR || errno == EAGAIN) + continue; + return 1; + } + break; + } + if (size == 0) { + errno = EIO; + return 1; + } + buf[size] = '\0'; + + head = buf; + + for (;;) { + static __thread ENTRY e; // keep coverity off our backs (e.data) + ENTRY *ep; + + if (!(tail = strchr(head, ':'))) + break; + *tail = '\0'; + valptr = NULL; + + e.key = head; + if (hsearch_r(e, FIND, &ep, &info->hashtab)) + valptr = ep->data; + head = tail + 1; + if (valptr) + *valptr = strtoul(head, NULL, 10); + + if (!(tail = strchr(head, '\n'))) + break; + head = tail + 1; + } + + if (0 == mHr(MemAvailable)) + mHr(MemAvailable) = mHr(MemFree); + mHr(derived_mem_cached) = mHr(Cached) + mHr(SReclaimable); + + /* if 'available' is greater than 'total' or our calculation of mem_used + overflows, that's symptomatic of running within a lxc container where + such values will be dramatically distorted over those of the host. */ + if (mHr(MemAvailable) > mHr(MemTotal)) + mHr(MemAvailable) = mHr(MemFree); + mem_used = mHr(MemTotal) - mHr(MemAvailable); + if (mem_used < 0) + mem_used = mHr(MemTotal) - mHr(MemFree); + mHr(derived_mem_used) = (unsigned long)mem_used; + + if (mHr(HighFree) < mHr(HighTotal)) + mHr(derived_mem_hi_used) = mHr(HighTotal) - mHr(HighFree); + + if (0 == mHr(LowTotal)) { + mHr(LowTotal) = mHr(MemTotal); + mHr(LowFree) = mHr(MemFree); + } + if (mHr(LowFree) < mHr(LowTotal)) + mHr(derived_mem_lo_used) = mHr(LowTotal) - mHr(LowFree); + + if (mHr(SwapFree) < mHr(SwapTotal)) + mHr(derived_swap_used) = mHr(SwapTotal) - mHr(SwapFree); + + return 0; + #undef mHr +} // end: meminfo_read_failed + + +/* + * meminfo_stacks_alloc(): + * + * Allocate and initialize one or more stacks each of which is anchored in an + * associated context structure. + * + * All such stacks will have their result structures properly primed with + * 'items', while the result itself will be zeroed. + * + * Returns a stacks_extent struct anchoring the 'heads' of each new stack. + */ +static struct stacks_extent *meminfo_stacks_alloc ( + struct meminfo_info *info, + int maxstacks) +{ + struct stacks_extent *p_blob; + struct meminfo_stack **p_vect; + struct meminfo_stack *p_head; + size_t vect_size, head_size, list_size, blob_size; + void *v_head, *v_list; + int i; + + vect_size = sizeof(void *) * maxstacks; // size of the addr vectors | + vect_size += sizeof(void *); // plus NULL addr delimiter | + head_size = sizeof(struct meminfo_stack); // size of that head struct | + list_size = sizeof(struct meminfo_result)*info->numitems; // any single results stack | + blob_size = sizeof(struct stacks_extent); // the extent anchor itself | + blob_size += vect_size; // plus room for addr vects | + blob_size += head_size * maxstacks; // plus room for head thing | + blob_size += list_size * maxstacks; // plus room for our stacks | + + /* note: all of this memory is allocated in a single blob, facilitating a later free(). | + as a minimum, it is important that the result structures themselves always are | + contiguous within each stack since they're accessed through relative position. | */ + if (NULL == (p_blob = calloc(1, blob_size))) + return NULL; + + p_blob->next = info->extents; // push this extent onto... | + info->extents = p_blob; // ...some existing extents | + p_vect = (void *)p_blob + sizeof(struct stacks_extent); // prime our vector pointer | + p_blob->stacks = p_vect; // set actual vectors start | + v_head = (void *)p_vect + vect_size; // prime head pointer start | + v_list = v_head + (head_size * maxstacks); // prime our stacks pointer | + + for (i = 0; i < maxstacks; i++) { + p_head = (struct meminfo_stack *)v_head; + p_head->head = meminfo_itemize_stack((struct meminfo_result *)v_list, info->numitems, info->items); + p_blob->stacks[i] = p_head; + v_list += list_size; + v_head += head_size; + } + p_blob->ext_numstacks = maxstacks; + return p_blob; +} // end: meminfo_stacks_alloc + + +// ___ Public Functions ||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +// --- standard required functions -------------------------------------------- + +/* + * procps_meminfo_new: + * + * Create a new container to hold the stat information + * + * The initial refcount is 1, and needs to be decremented + * to release the resources of the structure. + * + * Returns: < 0 on failure, 0 on success along with + * a pointer to a new context struct + */ +PROCPS_EXPORT int procps_meminfo_new ( + struct meminfo_info **info) +{ + struct meminfo_info *p; + +#ifdef ITEMTABLE_DEBUG + int i, failed = 0; + for (i = 0; i < MAXTABLE(Item_table); i++) { + if (i != Item_table[i].enumnumb) { + fprintf(stderr, "%s: enum/table error: Item_table[%d] was %s, but its value is %d\n" + , __FILE__, i, Item_table[i].enum2str, Item_table[i].enumnumb); + failed = 1; + } + } + if (failed) _Exit(EXIT_FAILURE); +#endif + + if (info == NULL || *info != NULL) + return -EINVAL; + if (!(p = calloc(1, sizeof(struct meminfo_info)))) + return -ENOMEM; + + p->refcount = 1; + p->meminfo_fd = -1; + + if (meminfo_make_hash_failed(p)) { + free(p); + return -errno; + } + + /* do a priming read here for the following potential benefits: | + 1) ensure there will be no problems with subsequent access | + 2) make delta results potentially useful, even if 1st time | + 3) elimnate need for history distortions 1st time 'switch' | */ + if (meminfo_read_failed(p)) { + procps_meminfo_unref(&p); + return -errno; + } + + *info = p; + return 0; +} // end: procps_meminfo_new + + +PROCPS_EXPORT int procps_meminfo_ref ( + struct meminfo_info *info) +{ + if (info == NULL) + return -EINVAL; + + info->refcount++; + return info->refcount; +} // end: procps_meminfo_ref + + +PROCPS_EXPORT int procps_meminfo_unref ( + struct meminfo_info **info) +{ + if (info == NULL || *info == NULL) + return -EINVAL; + + (*info)->refcount--; + + if ((*info)->refcount < 1) { + int errno_sav = errno; + + if ((*info)->meminfo_fd != -1) + close((*info)->meminfo_fd); + + if ((*info)->extents) + meminfo_extents_free_all((*info)); + if ((*info)->items) + free((*info)->items); + hdestroy_r(&(*info)->hashtab); + + free(*info); + *info = NULL; + + errno = errno_sav; + return 0; + } + return (*info)->refcount; +} // end: procps_meminfo_unref + + +// --- variable interface functions ------------------------------------------- + +PROCPS_EXPORT struct meminfo_result *procps_meminfo_get ( + struct meminfo_info *info, + enum meminfo_item item) +{ + time_t cur_secs; + + errno = EINVAL; + if (info == NULL) + return NULL; + if (item < 0 || item >= MEMINFO_logical_end) + return NULL; + errno = 0; + + /* we will NOT read the meminfo file with every call - rather, we'll offer + a granularity of 1 second between reads ... */ + cur_secs = time(NULL); + if (1 <= cur_secs - info->sav_secs) { + if (meminfo_read_failed(info)) + return NULL; + info->sav_secs = cur_secs; + } + + info->get_this.item = item; + // with 'get', we must NOT honor the usual 'noop' guarantee + info->get_this.result.ul_int = 0; + Item_table[item].setsfunc(&info->get_this, &info->hist); + + return &info->get_this; +} // end: procps_meminfo_get + + +/* procps_meminfo_select(): + * + * Harvest all the requested MEM and/or SWAP information then return + * it in a results stack. + * + * Returns: pointer to a meminfo_stack struct on success, NULL on error. + */ +PROCPS_EXPORT struct meminfo_stack *procps_meminfo_select ( + struct meminfo_info *info, + enum meminfo_item *items, + int numitems) +{ + errno = EINVAL; + if (info == NULL || items == NULL) + return NULL; + if (meminfo_items_check_failed(numitems, items)) + return NULL; + errno = 0; + + /* is this the first time or have things changed since we were last called? + if so, gotta' redo all of our stacks stuff ... */ + if (info->numitems != numitems + 1 + || memcmp(info->items, items, sizeof(enum meminfo_item) * numitems)) { + // allow for our MEMINFO_logical_end + if (!(info->items = realloc(info->items, sizeof(enum meminfo_item) * (numitems + 1)))) + return NULL; + memcpy(info->items, items, sizeof(enum meminfo_item) * numitems); + info->items[numitems] = MEMINFO_logical_end; + info->numitems = numitems + 1; + if (info->extents) + meminfo_extents_free_all(info); + } + if (!info->extents + && (!meminfo_stacks_alloc(info, 1))) + return NULL; + + if (meminfo_read_failed(info)) + return NULL; + meminfo_assign_results(info->extents->stacks[0], &info->hist); + + return info->extents->stacks[0]; +} // end: procps_meminfo_select + + +// --- special debugging function(s) ------------------------------------------ +/* + * The following isn't part of the normal programming interface. Rather, + * it exists to validate result types referenced in application programs. + * + * It's used only when: + * 1) the 'XTRA_PROCPS_DEBUG' has been defined, or + * 2) an #include of 'xtra-procps-debug.h' is used + */ + +PROCPS_EXPORT struct meminfo_result *xtra_meminfo_get ( + struct meminfo_info *info, + enum meminfo_item actual_enum, + const char *typestr, + const char *file, + int lineno) +{ + struct meminfo_result *r = procps_meminfo_get(info, actual_enum); + + if (actual_enum < 0 || actual_enum >= MEMINFO_logical_end) { + fprintf(stderr, "%s line %d: invalid item = %d, type = %s\n" + , file, lineno, actual_enum, typestr); + } + if (r) { + char *str = Item_table[r->item].type2str; + if (str[0] + && (strcmp(typestr, str))) + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return r; +} // end: xtra_meminfo_get_ + + +PROCPS_EXPORT struct meminfo_result *xtra_meminfo_val ( + int relative_enum, + const char *typestr, + const struct meminfo_stack *stack, + struct meminfo_info *info, + const char *file, + int lineno) +{ + char *str; + int i; + + for (i = 0; stack->head[i].item < MEMINFO_logical_end; i++) + ; + if (relative_enum < 0 || relative_enum >= i) { + fprintf(stderr, "%s line %d: invalid relative_enum = %d, valid range = 0-%d\n" + , file, lineno, relative_enum, i-1); + return NULL; + } + str = Item_table[stack->head[relative_enum].item].type2str; + if (str[0] + && (strcmp(typestr, str))) { + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return &stack->head[relative_enum]; + (void)info; +} // end: xtra_meminfo_val diff --git a/library/namespace.c b/library/namespace.c new file mode 100644 index 0000000..04e4c45 --- /dev/null +++ b/library/namespace.c @@ -0,0 +1,116 @@ +/* + * namespace.c - Library API for Linux namespaces + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <errno.h> +#include <stdio.h> +#include <string.h> +#include <sys/stat.h> + +#include "misc.h" +#include "procps-private.h" + +#define NSPATHLEN 64 + +static const char *ns_names[] = { + [PROCPS_NS_CGROUP] = "cgroup", + [PROCPS_NS_IPC] = "ipc", + [PROCPS_NS_MNT] = "mnt", + [PROCPS_NS_NET] = "net", + [PROCPS_NS_PID] = "pid", + [PROCPS_NS_TIME] = "time", + [PROCPS_NS_USER] = "user", + [PROCPS_NS_UTS] = "uts" +}; + + +/* + * procps_ns_get_name: + * + * Find the name of the namespace with the given ID + * + * @id: The ID of the required namespace, see + * namespace_type + * + * Returns: static string of the namespace + */ +PROCPS_EXPORT const char *procps_ns_get_name(const int id) +{ + if (id >= PROCPS_NS_COUNT || id < 0) + return NULL; + return ns_names[id]; +} + +/* + * procps_ns_get_id: + * + * Find the namespace ID that matches the given + * name. + * + * @name: the name of the required namespace + * + * Returns: ID of found name + * < 0 means error + */ +PROCPS_EXPORT int procps_ns_get_id(const char *name) +{ + int i; + + if (name == NULL) + return -EINVAL; + for (i=0; i < PROCPS_NS_COUNT; i++) + if (!strcmp(ns_names[i], name)) + return i; + return -EINVAL; +} + +/* + * procs_ns_read_pid: + * + * Find all namespaces for the given process. + * @pid: Process ID for required process + * @nsp: Pointer to the struct procps_ns + * + * Returns: + * 0 on success + * < 0 on error + */ +PROCPS_EXPORT int procps_ns_read_pid( + const int pid, + struct procps_ns *nsp) +{ + char path[NSPATHLEN+1]; + struct stat st; + int i; + + if (nsp == NULL) + return -EINVAL; + if (pid < 1) + return -EINVAL; + + for (i=0; i < PROCPS_NS_COUNT; i++) { + snprintf(path, NSPATHLEN, "/proc/%d/ns/%s", pid, ns_names[i]); + if (0 == stat(path, &st)) + nsp->ns[i] = (unsigned long)st.st_ino; + else + nsp->ns[i] = 0; + } + return 0; +} diff --git a/library/numa.c b/library/numa.c new file mode 100644 index 0000000..3fca413 --- /dev/null +++ b/library/numa.c @@ -0,0 +1,114 @@ +/* + * NUMA node support for <PIDS> & <STAT> interfaces + * + * Copyright © 2017-2023 Jim Warner <james.warner@comcast.net> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef NUMA_DISABLE +#include <dlfcn.h> +#endif +#include <stdlib.h> + +#include "numa.h" + +/* + * We're structured so that if numa_init() is NOT called or that ./configure | + * --disable-numa WAS specified, then calls to both of our primary functions | + * of numa_max_node() plus numa_node_of_cpu() would always return a negative | + * 1 which signifies that NUMA information isn't available. That ./configure | + * option might be required when libdl.so (necessary for dlopen) is missing. | + */ + + +/* ------------------------------------------------------------------------- + + a strictly development #define, existing specifically for the top program | + ( and it has no affect if ./configure --disable-numa has been specified ) | */ +//#define PRETEND_NUMA // pretend there are 3 'discontiguous' numa nodes | +// ------------------------------------------------------------------------- + + + +static int null_max_node (void) { return -1; } +static int null_node_of_cpu (int n) { (void)n; return -1; } + + +#ifndef NUMA_DISABLE + #ifdef PRETEND_NUMA +static int fake_max_node (void) { return 3; } +static int fake_node_of_cpu (int n) { return (1 == (n % 4)) ? 0 : (n % 4); } + #endif +#endif + + +#ifndef NUMA_DISABLE +static void *libnuma_handle; +#endif +int (*numa_max_node) (void) = null_max_node; +int (*numa_node_of_cpu) (int) = null_node_of_cpu; + + +void numa_init (void) { + static int initialized; + + if (initialized) + return; + +#ifndef NUMA_DISABLE + #ifndef PRETEND_NUMA + // we'll try for the most recent version, then a version we know works... + if ((libnuma_handle = dlopen("libnuma.so", RTLD_LAZY)) + || (libnuma_handle = dlopen("libnuma.so.1", RTLD_LAZY))) { + numa_max_node = dlsym(libnuma_handle, "numa_max_node"); + numa_node_of_cpu = dlsym(libnuma_handle, "numa_node_of_cpu"); + if (numa_max_node == NULL + || (numa_node_of_cpu == NULL)) { + // this dlclose is safe - we've yet to call numa_node_of_cpu + // ( there's one other dlclose which has now been disabled ) + dlclose(libnuma_handle); + libnuma_handle = NULL; + numa_max_node = null_max_node; + numa_node_of_cpu = null_node_of_cpu; + } + } + #else + libnuma_handle = (void *)-1; + numa_max_node = fake_max_node; + numa_node_of_cpu = fake_node_of_cpu; + #endif +#endif + initialized = 1; +} // end: numa_init + + +void numa_uninit (void) { +#ifndef PRETEND_NUMA + /* note: we'll skip a dlcose() to avoid the following libnuma memory + * leak which is triggered after a call to numa_node_of_cpu(): + * ==1234== LEAK SUMMARY: + * ==1234== definitely lost: 512 bytes in 1 blocks + * ==1234== indirectly lost: 48 bytes in 2 blocks + * ==1234== ... + * [ thanks very much libnuma for all the pains you have caused us ] + */ +// if (libnuma_handle) +// dlclose(libnuma_handle); +#endif +} // end: numa_uninit + + +#if defined(PRETEND_NUMA) && defined(NUMA_DISABLE) +# warning 'PRETEND_NUMA' ignored, 'NUMA_DISABLE' is active +#endif diff --git a/library/pids.c b/library/pids.c new file mode 100644 index 0000000..6ae94ad --- /dev/null +++ b/library/pids.c @@ -0,0 +1,1700 @@ +/* + * pids.c - process related definitions for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +//efine _GNU_SOURCE // for qsort_r + +#include <ctype.h> +#include <errno.h> +#include <fcntl.h> +#include <limits.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <sys/stat.h> +#include <sys/types.h> + +#include "devname.h" +#include "misc.h" +#include "numa.h" +#include "readproc.h" +#include "wchan.h" + +#include "procps-private.h" +#include "pids.h" + + +//#define UNREF_RPTHASH // report hash details at uref() time + +#define FILL_ID_MAX 255 // upper limit with select of pid/uid +#define STACKS_INIT 1024 // amount of initial stack allocation +#define STACKS_GROW 128 // amount reap stack allocations grow +#define NEWOLD_INIT 1024 // amount for initial hist allocation +#define NEWOLD_GROW 128 // amt by which hist allocations grow + +/* ------------------------------------------------------------------------- + + this provision can be used to ensure that our Item_table was synchronized | + with those enumerators found in the associated header file. It's intended | + to only be used locally (& temporarily) at some point prior to a release! | */ +// #define ITEMTABLE_DEBUG //----------------------------------------------- | +// ------------------------------------------------------------------------- + + + +struct stacks_extent { + int ext_numstacks; + struct stacks_extent *next; + struct pids_stack **stacks; +}; + +struct fetch_support { + struct pids_stack **anchor; // reap/select consolidated extents + int n_alloc; // number of above pointers allocated + int n_inuse; // number of above pointers occupied + int n_alloc_save; // last known results.stacks allocation + struct pids_fetch results; // counts + stacks for return to caller + struct pids_counts counts; // actual counts pointed to by 'results' +}; + +typedef void (*SET_t)(struct pids_info *, struct pids_result *, proc_t *); + +struct pids_info { + int refcount; + int maxitems; // includes 'logical_end' delimiter + enum pids_item *items; // includes 'logical_end' delimiter + struct stacks_extent *extents; // anchor for all resettable extents + struct stacks_extent *otherexts; // anchor for invariant extents // <=== currently unused + struct fetch_support fetch; // support for procps_pids_reap, select, fatal + int history_yes; // need historical data + struct history_info *hist; // pointer to historical support data + proc_t*(*read_something)(PROCTAB*, proc_t*); // readproc/readeither via which + unsigned pgs2k_shift; // to convert some proc vaules + unsigned oldflags; // the old library PROC_FILL flagss + PROCTAB *fetch_PT; // oldlib interface for 'select' & 'reap' + unsigned long hertz; // for the 'TIME' & 'UTILIZATION' calculations + unsigned long long boot_tics; // for TIME_ELAPSED & 'UTILIZATION' calculations + PROCTAB *get_PT; // oldlib interface for active 'get' + struct stacks_extent *get_ext; // for active 'get' (also within 'extents') + enum pids_fetch_type get_type; // last known type of 'get' request + int seterr; // an ENOMEM encountered during assign + proc_t get_proc; // the proc_t used by procps_pids_get + proc_t fetch_proc; // the proc_t used by pids_stacks_fetch + SET_t *func_array; // extracted Item_table 'setsfunc' pointers +}; + + +// ___ Free Storage Support ||||||||||||||||||||||||||||||||||||||||||||||||||| + +#define freNAME(t) free_pids_ ## t + +static void freNAME(str) (struct pids_result *R) { + if (R->result.str) free(R->result.str); +} + +static void freNAME(strv) (struct pids_result *R) { + if (R->result.strv && *R->result.strv) free(*R->result.strv); +} + + +// ___ Results 'Set' Support |||||||||||||||||||||||||||||||||||||||||||||||||| + +#define setNAME(e) set_pids_ ## e +#define setDECL(e) static void setNAME(e) \ + (struct pids_info *I, struct pids_result *R, proc_t *P) + +/* convert pages to kib */ +#define CVT_set(e,t,x) setDECL(e) { \ + R->result. t = (long)(P-> x) << I -> pgs2k_shift; } +/* strdup of a static char array */ +#define DUP_set(e,x) setDECL(e) { \ + freNAME(str)(R); \ + if (!(R->result.str = strdup(P-> x))) I->seterr = 1; } +/* regular assignment copy */ +#define REG_set(e,t,x) setDECL(e) { \ + (void)I; R->result. t = P-> x; } +/* take ownership of a normal single string if possible, else return + some sort of hint that they duplicated this char * item ... */ +#define STR_set(e,x) setDECL(e) { \ + freNAME(str)(R); \ + if (NULL != P-> x) { R->result.str = P-> x; P-> x = NULL; } \ + else { R->result.str = strdup("[ duplicate " STRINGIFY(e) " ]"); \ + if (!R->result.str) I->seterr = 1; } } +/* take ownership of true vectorized strings if possible, else return + some sort of hint that they duplicated this char ** item ... */ +#define VEC_set(e,x) setDECL(e) { \ + freNAME(strv)(R); \ + if (NULL != P-> x) { R->result.strv = P-> x; P-> x = NULL; } \ + else { R->result.strv = vectorize_this_str("[ duplicate " STRINGIFY(e) " ]"); \ + if (!R->result.strv) I->seterr = 1; } } + + +setDECL(noop) { (void)I; (void)R; (void)P; } +setDECL(extra) { (void)I; (void)P; R->result.ull_int = 0; } + +REG_set(ADDR_CODE_END, ul_int, end_code) +REG_set(ADDR_CODE_START, ul_int, start_code) +REG_set(ADDR_CURR_EIP, ul_int, kstk_eip) +REG_set(ADDR_CURR_ESP, ul_int, kstk_esp) +REG_set(ADDR_STACK_START, ul_int, start_stack) +REG_set(AUTOGRP_ID, s_int, autogrp_id) +REG_set(AUTOGRP_NICE, s_int, autogrp_nice) +STR_set(CGNAME, cgname) +STR_set(CGROUP, cgroup) +VEC_set(CGROUP_V, cgroup_v) +STR_set(CMD, cmd) +STR_set(CMDLINE, cmdline) +VEC_set(CMDLINE_V, cmdline_v) +STR_set(ENVIRON, environ) +VEC_set(ENVIRON_V, environ_v) +STR_set(EXE, exe) +REG_set(EXIT_SIGNAL, s_int, exit_signal) +REG_set(FLAGS, ul_int, flags) +REG_set(FLT_MAJ, ul_int, maj_flt) +setDECL(FLT_MAJ_C) { (void)I; R->result.ul_int = P->maj_flt + P->cmaj_flt; } +REG_set(FLT_MAJ_DELTA, s_int, maj_delta) +REG_set(FLT_MIN, ul_int, min_flt) +setDECL(FLT_MIN_C) { (void)I; R->result.ul_int = P->min_flt + P->cmin_flt; } +REG_set(FLT_MIN_DELTA, s_int, min_delta) +REG_set(ID_EGID, u_int, egid) +REG_set(ID_EGROUP, str, egroup) +REG_set(ID_EUID, u_int, euid) +REG_set(ID_EUSER, str, euser) +REG_set(ID_FGID, u_int, fgid) +REG_set(ID_FGROUP, str, fgroup) +REG_set(ID_FUID, u_int, fuid) +REG_set(ID_FUSER, str, fuser) +REG_set(ID_LOGIN, s_int, luid) +REG_set(ID_PGRP, s_int, pgrp) +REG_set(ID_PID, s_int, tid) +REG_set(ID_PPID, s_int, ppid) +REG_set(ID_RGID, u_int, rgid) +REG_set(ID_RGROUP, str, rgroup) +REG_set(ID_RUID, u_int, ruid) +REG_set(ID_RUSER, str, ruser) +REG_set(ID_SESSION, s_int, session) +REG_set(ID_SGID, u_int, sgid) +REG_set(ID_SGROUP, str, sgroup) +REG_set(ID_SUID, u_int, suid) +REG_set(ID_SUSER, str, suser) +REG_set(ID_TGID, s_int, tgid) +REG_set(ID_TID, s_int, tid) +REG_set(ID_TPGID, s_int, tpgid) +REG_set(IO_READ_BYTES, ul_int, read_bytes) +REG_set(IO_READ_CHARS, ul_int, rchar) +REG_set(IO_READ_OPS, ul_int, syscr) +REG_set(IO_WRITE_BYTES, ul_int, write_bytes) +REG_set(IO_WRITE_CBYTES, ul_int, cancelled_write_bytes) +REG_set(IO_WRITE_CHARS, ul_int, wchar) +REG_set(IO_WRITE_OPS, ul_int, syscw) +REG_set(LXCNAME, str, lxcname) +CVT_set(MEM_CODE, ul_int, trs) +REG_set(MEM_CODE_PGS, ul_int, trs) +CVT_set(MEM_DATA, ul_int, drs) +REG_set(MEM_DATA_PGS, ul_int, drs) +CVT_set(MEM_RES, ul_int, resident) +REG_set(MEM_RES_PGS, ul_int, resident) +CVT_set(MEM_SHR, ul_int, share) +REG_set(MEM_SHR_PGS, ul_int, share) +CVT_set(MEM_VIRT, ul_int, size) +REG_set(MEM_VIRT_PGS, ul_int, size) +REG_set(NICE, s_int, nice) +REG_set(NLWP, s_int, nlwp) +REG_set(NS_CGROUP, ul_int, ns.ns[0]) +REG_set(NS_IPC, ul_int, ns.ns[1]) +REG_set(NS_MNT, ul_int, ns.ns[2]) +REG_set(NS_NET, ul_int, ns.ns[3]) +REG_set(NS_PID, ul_int, ns.ns[4]) +REG_set(NS_TIME, ul_int, ns.ns[5]) +REG_set(NS_USER, ul_int, ns.ns[6]) +REG_set(NS_UTS, ul_int, ns.ns[7]) +REG_set(OOM_ADJ, s_int, oom_adj) +REG_set(OOM_SCORE, s_int, oom_score) +REG_set(PRIORITY, s_int, priority) +REG_set(PRIORITY_RT, s_int, rtprio) +REG_set(PROCESSOR, s_int, processor) +setDECL(PROCESSOR_NODE) { (void)I; R->result.s_int = numa_node_of_cpu(P->processor); } +REG_set(RSS, ul_int, rss) +REG_set(RSS_RLIM, ul_int, rss_rlim) +REG_set(SCHED_CLASS, s_int, sched) +STR_set(SD_MACH, sd_mach) +STR_set(SD_OUID, sd_ouid) +STR_set(SD_SEAT, sd_seat) +STR_set(SD_SESS, sd_sess) +STR_set(SD_SLICE, sd_slice) +STR_set(SD_UNIT, sd_unit) +STR_set(SD_UUNIT, sd_uunit) +DUP_set(SIGBLOCKED, blocked) +DUP_set(SIGCATCH, sigcatch) +DUP_set(SIGIGNORE, sigignore) +DUP_set(SIGNALS, signal) +DUP_set(SIGPENDING, _sigpnd) +REG_set(SMAP_ANONYMOUS, ul_int, smap_Anonymous) +REG_set(SMAP_HUGE_ANON, ul_int, smap_AnonHugePages) +REG_set(SMAP_HUGE_FILE, ul_int, smap_FilePmdMapped) +REG_set(SMAP_HUGE_SHMEM, ul_int, smap_ShmemPmdMapped) +REG_set(SMAP_HUGE_TLBPRV, ul_int, smap_Private_Hugetlb) +REG_set(SMAP_HUGE_TLBSHR, ul_int, smap_Shared_Hugetlb) +REG_set(SMAP_LAZY_FREE, ul_int, smap_LazyFree) +REG_set(SMAP_LOCKED, ul_int, smap_Locked) +REG_set(SMAP_PRV_CLEAN, ul_int, smap_Private_Clean) +REG_set(SMAP_PRV_DIRTY, ul_int, smap_Private_Dirty) +setDECL(SMAP_PRV_TOTAL) { (void)I; R->result.ul_int = P->smap_Private_Clean + P->smap_Private_Dirty; } +REG_set(SMAP_PSS, ul_int, smap_Pss) +REG_set(SMAP_PSS_ANON, ul_int, smap_Pss_Anon) +REG_set(SMAP_PSS_FILE, ul_int, smap_Pss_File) +REG_set(SMAP_PSS_SHMEM, ul_int, smap_Pss_Shmem) +REG_set(SMAP_REFERENCED, ul_int, smap_Referenced) +REG_set(SMAP_RSS, ul_int, smap_Rss) +REG_set(SMAP_SHR_CLEAN, ul_int, smap_Shared_Clean) +REG_set(SMAP_SHR_DIRTY, ul_int, smap_Shared_Dirty) +REG_set(SMAP_SWAP, ul_int, smap_Swap) +REG_set(SMAP_SWAP_PSS, ul_int, smap_SwapPss) +REG_set(STATE, s_ch, state) +STR_set(SUPGIDS, supgid) +STR_set(SUPGROUPS, supgrp) +setDECL(TICS_ALL) { (void)I; R->result.ull_int = P->utime + P->stime; } +setDECL(TICS_ALL_C) { (void)I; R->result.ull_int = P->utime + P->stime + P->cutime + P->cstime; } +REG_set(TICS_ALL_DELTA, u_int, pcpu) +REG_set(TICS_BEGAN, ull_int, start_time) +REG_set(TICS_BLKIO, ull_int, blkio_tics) +REG_set(TICS_GUEST, ull_int, gtime) +setDECL(TICS_GUEST_C) { (void)I; R->result.ull_int = P->gtime + P->cgtime; } +REG_set(TICS_SYSTEM, ull_int, stime) +setDECL(TICS_SYSTEM_C) { (void)I; R->result.ull_int = P->stime + P->cstime; } +REG_set(TICS_USER, ull_int, utime) +setDECL(TICS_USER_C) { (void)I; R->result.ull_int = P->utime + P->cutime; } +setDECL(TIME_ALL) { R->result.real = ((double)P->utime + P->stime) / I->hertz; } +setDECL(TIME_ALL_C) { R->result.real = ((double)P->utime + P->stime + P->cutime + P->cstime) / I->hertz; } +setDECL(TIME_ELAPSED) { double t = I->boot_tics - P->start_time; if (t > 0) R->result.real = t / I->hertz; } +setDECL(TIME_START) { R->result.real = (double)P->start_time / I->hertz; } +REG_set(TTY, s_int, tty) +setDECL(TTY_NAME) { char buf[64]; freNAME(str)(R); dev_to_tty(buf, sizeof(buf), P->tty, P->tid, ABBREV_DEV); if (!(R->result.str = strdup(buf))) I->seterr = 1; } +setDECL(TTY_NUMBER) { char buf[64]; freNAME(str)(R); dev_to_tty(buf, sizeof(buf), P->tty, P->tid, ABBREV_DEV|ABBREV_TTY|ABBREV_PTS); if (!(R->result.str = strdup(buf))) I->seterr = 1; } +setDECL(UTILIZATION) { double t = I->boot_tics - P->start_time; if (t > 0) R->result.real = ((P->utime + P->stime) * 100.0f) / t; } +setDECL(UTILIZATION_C) { double t = I->boot_tics - P->start_time; if (t > 0) R->result.real = ((P->utime + P->stime + P->cutime + P->cstime) * 100.0f) / t; } +REG_set(VM_DATA, ul_int, vm_data) +REG_set(VM_EXE, ul_int, vm_exe) +REG_set(VM_LIB, ul_int, vm_lib) +REG_set(VM_RSS, ul_int, vm_rss) +REG_set(VM_RSS_ANON, ul_int, vm_rss_anon) +REG_set(VM_RSS_FILE, ul_int, vm_rss_file) +REG_set(VM_RSS_LOCKED, ul_int, vm_lock) +REG_set(VM_RSS_SHARED, ul_int, vm_rss_shared) +REG_set(VM_SIZE, ul_int, vm_size) +REG_set(VM_STACK, ul_int, vm_stack) +REG_set(VM_SWAP, ul_int, vm_swap) +setDECL(VM_USED) { (void)I; R->result.ul_int = P->vm_swap + P->vm_rss; } +REG_set(VSIZE_BYTES, ul_int, vsize) +setDECL(WCHAN_NAME) { freNAME(str)(R); if (!(R->result.str = strdup(lookup_wchan(P->tid)))) I->seterr = 1;; } + +#undef setDECL +#undef CVT_set +#undef DUP_set +#undef REG_set +#undef STR_set +#undef VEC_set + + +// ___ Sorting Support |||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +struct sort_parms { + int offset; + enum pids_sort_order order; +}; + +#define srtNAME(t) sort_pids_ ## t +#define srtDECL(t) static int srtNAME(t) \ + (const struct pids_stack **A, const struct pids_stack **B, struct sort_parms *P) + +#define NUM_srt(T) srtDECL(T) { \ + const struct pids_result *a = (*A)->head + P->offset; \ + const struct pids_result *b = (*B)->head + P->offset; \ + return P->order * (a->result. T - b->result. T); } + +#define REG_srt(T) srtDECL(T) { \ + const struct pids_result *a = (*A)->head + P->offset; \ + const struct pids_result *b = (*B)->head + P->offset; \ + if ( a->result. T > b->result. T ) return P->order > 0 ? 1 : -1; \ + if ( a->result. T < b->result. T ) return P->order > 0 ? -1 : 1; \ + return 0; } + +NUM_srt(s_ch) +NUM_srt(s_int) + +REG_srt(u_int) +REG_srt(ul_int) +REG_srt(ull_int) + +REG_srt(real) + +srtDECL(str) { + const struct pids_result *a = (*A)->head + P->offset; + const struct pids_result *b = (*B)->head + P->offset; + return P->order * strcoll(a->result.str, b->result.str); +} + +srtDECL(strv) { + const struct pids_result *a = (*A)->head + P->offset; + const struct pids_result *b = (*B)->head + P->offset; + if (!a->result.strv || !b->result.strv) return 0; + return P->order * strcoll((*a->result.strv), (*b->result.strv)); +} + +srtDECL(strvers) { + const struct pids_result *a = (*A)->head + P->offset; + const struct pids_result *b = (*B)->head + P->offset; + return P->order * strverscmp(a->result.str, b->result.str); +} + +srtDECL(noop) { + (void)A; (void)B; (void)P; + return 0; +} + +#undef srtDECL +#undef NUM_srt +#undef REG_srt + + +// ___ Controlling Table |||||||||||||||||||||||||||||||||||||||||||||||||||||| + +#define f_either PROC_SPARE_1 // either status or stat (favor stat) +#define f_exe PROC_FILL_EXE +#define f_grp PROC_FILLGRP +#define f_io PROC_FILLIO +#define f_login PROC_FILL_LUID +#define f_lxc PROC_FILL_LXC +#define f_ns PROC_FILLNS +#define f_oom PROC_FILLOOM +#define f_smaps PROC_FILLSMAPS +#define f_stat PROC_FILLSTAT +#define f_statm PROC_FILLMEM +#define f_status PROC_FILLSTATUS +#define f_systemd PROC_FILLSYSTEMD +#define f_usr PROC_FILLUSR + // these next three will yield true verctorized strings +#define v_arg PROC_FILLARG +#define v_cgroup PROC_FILLCGROUP +#define v_env PROC_FILLENV + // these next three will yield a single string (never vectorized) +#define x_cgroup PROC_EDITCGRPCVT +#define x_cmdline PROC_EDITCMDLCVT +#define x_environ PROC_EDITENVRCVT + // these next three will also force PROC_FILLSTATUS +#define x_ogroup PROC_FILL_OGROUPS +#define x_ouser PROC_FILL_OUSERS +#define x_supgrp PROC_FILL_SUPGRP + // placed here so an 'f' prefix wouldn't make 'em first +#define z_autogrp PROC_FILLAUTOGRP + +typedef void (*FRE_t)(struct pids_result *); +typedef int (*QSR_t)(const void *, const void *, void *); + +#ifdef ITEMTABLE_DEBUG +#define RS(e) (SET_t)setNAME(e), PIDS_ ## e, STRINGIFY(PIDS_ ## e) +#else +#define RS(e) (SET_t)setNAME(e) +#endif +#define FF(t) (FRE_t)freNAME(t) +#define QS(t) (QSR_t)srtNAME(t) +#define TS(t) STRINGIFY(t) +#define TS_noop "" + + /* + * Need it be said? + * This table must be kept in the exact same order as + * those 'enum pids_item' guys ! */ +static struct { + SET_t setsfunc; // the actual result setting routine +#ifdef ITEMTABLE_DEBUG + int enumnumb; // enumerator (must match position!) + char *enum2str; // enumerator name as a char* string +#endif + unsigned oldflags; // PROC_FILLxxxx flags for this item + FRE_t freefunc; // free function for strings storage + QSR_t sortfunc; // sort cmp func for a specific type + int needhist; // a result requires history support + char *type2str; // the result type as a string value +} Item_table[] = { +/* setsfunc oldflags freefunc sortfunc needhist type2str + --------------------- ---------- --------- ------------- -------- ----------- */ + { RS(noop), 0, NULL, QS(noop), 0, TS_noop }, // user only, never altered + { RS(extra), 0, NULL, QS(ull_int), 0, TS_noop }, // user only, reset to zero + + { RS(ADDR_CODE_END), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(ADDR_CODE_START), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(ADDR_CURR_EIP), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(ADDR_CURR_ESP), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(ADDR_STACK_START), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(AUTOGRP_ID), z_autogrp, NULL, QS(s_int), 0, TS(s_int) }, + { RS(AUTOGRP_NICE), z_autogrp, NULL, QS(s_int), 0, TS(s_int) }, + { RS(CGNAME), x_cgroup, FF(str), QS(str), 0, TS(str) }, + { RS(CGROUP), x_cgroup, FF(str), QS(str), 0, TS(str) }, + { RS(CGROUP_V), v_cgroup, FF(strv), QS(strv), 0, TS(strv) }, + { RS(CMD), f_either, FF(str), QS(str), 0, TS(str) }, + { RS(CMDLINE), x_cmdline, FF(str), QS(str), 0, TS(str) }, + { RS(CMDLINE_V), v_arg, FF(strv), QS(strv), 0, TS(strv) }, + { RS(ENVIRON), x_environ, FF(str), QS(str), 0, TS(str) }, + { RS(ENVIRON_V), v_env, FF(strv), QS(strv), 0, TS(strv) }, + { RS(EXE), f_exe, FF(str), QS(str), 0, TS(str) }, + { RS(EXIT_SIGNAL), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(FLAGS), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(FLT_MAJ), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(FLT_MAJ_C), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(FLT_MAJ_DELTA), f_stat, NULL, QS(s_int), +1, TS(s_int) }, + { RS(FLT_MIN), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(FLT_MIN_C), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(FLT_MIN_DELTA), f_stat, NULL, QS(s_int), +1, TS(s_int) }, + { RS(ID_EGID), 0, NULL, QS(u_int), 0, TS(u_int) }, // oldflags: free w/ simple_read + { RS(ID_EGROUP), f_grp, NULL, QS(str), 0, TS(str) }, + { RS(ID_EUID), 0, NULL, QS(u_int), 0, TS(u_int) }, // oldflags: free w/ simple_read + { RS(ID_EUSER), f_usr, NULL, QS(str), 0, TS(str) }, // freefunc NULL w/ cached string + { RS(ID_FGID), f_status, NULL, QS(u_int), 0, TS(u_int) }, + { RS(ID_FGROUP), x_ogroup, NULL, QS(str), 0, TS(str) }, + { RS(ID_FUID), f_status, NULL, QS(u_int), 0, TS(u_int) }, + { RS(ID_FUSER), x_ouser, NULL, QS(str), 0, TS(str) }, // freefunc NULL w/ cached string + { RS(ID_LOGIN), f_login, NULL, QS(s_int), 0, TS(s_int) }, + { RS(ID_PGRP), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(ID_PID), 0, NULL, QS(s_int), 0, TS(s_int) }, // oldflags: free w/ simple_nextpid + { RS(ID_PPID), f_either, NULL, QS(s_int), 0, TS(s_int) }, + { RS(ID_RGID), f_status, NULL, QS(u_int), 0, TS(u_int) }, + { RS(ID_RGROUP), x_ogroup, NULL, QS(str), 0, TS(str) }, + { RS(ID_RUID), f_status, NULL, QS(u_int), 0, TS(u_int) }, + { RS(ID_RUSER), x_ouser, NULL, QS(str), 0, TS(str) }, // freefunc NULL w/ cached string + { RS(ID_SESSION), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(ID_SGID), f_status, NULL, QS(u_int), 0, TS(u_int) }, + { RS(ID_SGROUP), x_ogroup, NULL, QS(str), 0, TS(str) }, + { RS(ID_SUID), f_status, NULL, QS(u_int), 0, TS(u_int) }, + { RS(ID_SUSER), x_ouser, NULL, QS(str), 0, TS(str) }, // freefunc NULL w/ cached string + { RS(ID_TGID), 0, NULL, QS(s_int), 0, TS(s_int) }, // oldflags: free w/ simple_nextpid + { RS(ID_TID), 0, NULL, QS(s_int), 0, TS(s_int) }, // oldflags: free w/ simple_nexttid + { RS(ID_TPGID), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(IO_READ_BYTES), f_io, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(IO_READ_CHARS), f_io, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(IO_READ_OPS), f_io, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(IO_WRITE_BYTES), f_io, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(IO_WRITE_CBYTES), f_io, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(IO_WRITE_CHARS), f_io, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(IO_WRITE_OPS), f_io, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(LXCNAME), f_lxc, NULL, QS(str), 0, TS(str) }, // freefunc NULL w/ cached string + { RS(MEM_CODE), f_statm, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(MEM_CODE_PGS), f_statm, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(MEM_DATA), f_statm, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(MEM_DATA_PGS), f_statm, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(MEM_RES), f_statm, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(MEM_RES_PGS), f_statm, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(MEM_SHR), f_statm, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(MEM_SHR_PGS), f_statm, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(MEM_VIRT), f_statm, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(MEM_VIRT_PGS), f_statm, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(NICE), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(NLWP), f_either, NULL, QS(s_int), 0, TS(s_int) }, + { RS(NS_CGROUP), f_ns, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(NS_IPC), f_ns, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(NS_MNT), f_ns, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(NS_NET), f_ns, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(NS_PID), f_ns, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(NS_TIME), f_ns, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(NS_USER), f_ns, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(NS_UTS), f_ns, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(OOM_ADJ), f_oom, NULL, QS(s_int), 0, TS(s_int) }, + { RS(OOM_SCORE), f_oom, NULL, QS(s_int), 0, TS(s_int) }, + { RS(PRIORITY), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(PRIORITY_RT), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(PROCESSOR), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(PROCESSOR_NODE), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(RSS), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(RSS_RLIM), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SCHED_CLASS), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(SD_MACH), f_systemd, FF(str), QS(str), 0, TS(str) }, + { RS(SD_OUID), f_systemd, FF(str), QS(str), 0, TS(str) }, + { RS(SD_SEAT), f_systemd, FF(str), QS(str), 0, TS(str) }, + { RS(SD_SESS), f_systemd, FF(str), QS(str), 0, TS(str) }, + { RS(SD_SLICE), f_systemd, FF(str), QS(str), 0, TS(str) }, + { RS(SD_UNIT), f_systemd, FF(str), QS(str), 0, TS(str) }, + { RS(SD_UUNIT), f_systemd, FF(str), QS(str), 0, TS(str) }, + { RS(SIGBLOCKED), f_status, FF(str), QS(str), 0, TS(str) }, + { RS(SIGCATCH), f_status, FF(str), QS(str), 0, TS(str) }, + { RS(SIGIGNORE), f_status, FF(str), QS(str), 0, TS(str) }, + { RS(SIGNALS), f_status, FF(str), QS(str), 0, TS(str) }, + { RS(SIGPENDING), f_status, FF(str), QS(str), 0, TS(str) }, + { RS(SMAP_ANONYMOUS), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_HUGE_ANON), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_HUGE_FILE), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_HUGE_SHMEM), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_HUGE_TLBPRV), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_HUGE_TLBSHR), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_LAZY_FREE), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_LOCKED), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_PRV_CLEAN), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_PRV_DIRTY), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_PRV_TOTAL), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_PSS), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_PSS_ANON), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_PSS_FILE), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_PSS_SHMEM), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_REFERENCED), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_RSS), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_SHR_CLEAN), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_SHR_DIRTY), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_SWAP), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(SMAP_SWAP_PSS), f_smaps, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(STATE), f_either, NULL, QS(s_ch), 0, TS(s_ch) }, + { RS(SUPGIDS), f_status, FF(str), QS(str), 0, TS(str) }, + { RS(SUPGROUPS), x_supgrp, FF(str), QS(str), 0, TS(str) }, + { RS(TICS_ALL), f_stat, NULL, QS(ull_int), 0, TS(ull_int) }, + { RS(TICS_ALL_C), f_stat, NULL, QS(ull_int), 0, TS(ull_int) }, + { RS(TICS_ALL_DELTA), f_stat, NULL, QS(u_int), +1, TS(u_int) }, + { RS(TICS_BEGAN), f_stat, NULL, QS(ull_int), 0, TS(ull_int) }, + { RS(TICS_BLKIO), f_stat, NULL, QS(ull_int), 0, TS(ull_int) }, + { RS(TICS_GUEST), f_stat, NULL, QS(ull_int), 0, TS(ull_int) }, + { RS(TICS_GUEST_C), f_stat, NULL, QS(ull_int), 0, TS(ull_int) }, + { RS(TICS_SYSTEM), f_stat, NULL, QS(ull_int), 0, TS(ull_int) }, + { RS(TICS_SYSTEM_C), f_stat, NULL, QS(ull_int), 0, TS(ull_int) }, + { RS(TICS_USER), f_stat, NULL, QS(ull_int), 0, TS(ull_int) }, + { RS(TICS_USER_C), f_stat, NULL, QS(ull_int), 0, TS(ull_int) }, + { RS(TIME_ALL), f_stat, NULL, QS(real), 0, TS(real) }, + { RS(TIME_ALL_C), f_stat, NULL, QS(real), 0, TS(real) }, + { RS(TIME_ELAPSED), f_stat, NULL, QS(real), 0, TS(real) }, + { RS(TIME_START), f_stat, NULL, QS(real), 0, TS(real) }, + { RS(TTY), f_stat, NULL, QS(s_int), 0, TS(s_int) }, + { RS(TTY_NAME), f_stat, FF(str), QS(strvers), 0, TS(str) }, + { RS(TTY_NUMBER), f_stat, FF(str), QS(strvers), 0, TS(str) }, + { RS(UTILIZATION), f_stat, NULL, QS(real), 0, TS(real) }, + { RS(UTILIZATION_C), f_stat, NULL, QS(real), 0, TS(real) }, + { RS(VM_DATA), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_EXE), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_LIB), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_RSS), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_RSS_ANON), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_RSS_FILE), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_RSS_LOCKED), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_RSS_SHARED), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_SIZE), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_STACK), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_SWAP), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VM_USED), f_status, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(VSIZE_BYTES), f_stat, NULL, QS(ul_int), 0, TS(ul_int) }, + { RS(WCHAN_NAME), 0, FF(str), QS(str), 0, TS(str) }, // oldflags: tid already free +}; + + /* please note, + * this enum MUST be 1 greater than the highest value of any enum */ +enum pids_item PIDS_logical_end = MAXTABLE(Item_table); + +#undef setNAME +#undef freNAME +#undef srtNAME +#undef RS +#undef FF +#undef QS + +//#undef f_either // needed later +#undef f_exe +#undef f_grp +#undef f_io +#undef f_login +#undef f_lxc +#undef f_ns +#undef f_oom +#undef f_smaps +//#undef f_stat // needed later +#undef f_statm +//#undef f_status // needed later +#undef f_systemd +#undef f_usr +#undef v_arg +#undef v_cgroup +#undef v_env +#undef x_cgroup +#undef x_cmdline +#undef x_environ +#undef x_ogroup +#undef x_ouser +#undef x_supgrp +#undef z_autogrp + + +// ___ History Support Private Functions |||||||||||||||||||||||||||||||||||||| +// ( stolen from top when he wasn't looking ) ------------------------------- + +#define HHASH_SIZE 4096 +#define _HASH_PID_(K) (K & (HHASH_SIZE - 1)) + +#define Hr(x) info->hist->x // 'hist ref', minimize stolen impact + +typedef unsigned long long TIC_t; + +typedef struct HST_t { + TIC_t tics; // last frame's tics count + unsigned long maj, min; // last frame's maj/min_flt counts + int pid; // record 'key' + int lnk; // next on hash chain +} HST_t; + + +struct history_info { + int num_tasks; // used as index (tasks tallied) + int HHist_siz; // max number of HST_t structs + HST_t *PHist_sav; // alternating 'old/new' HST_t anchors + HST_t *PHist_new; + int HHash_one [HHASH_SIZE]; // the actual hash tables + int HHash_two [HHASH_SIZE]; // (accessed via PHash_sav/PHash_new) + int HHash_nul [HHASH_SIZE]; // an 'empty' hash table image + int *PHash_sav; // alternating 'old/new' hash tables + int *PHash_new; // (aka. the 'one/two' actual tables) +}; + + +static void pids_config_history ( + struct pids_info *info) +{ + int i; + + for (i = 0; i < HHASH_SIZE; i++) // make the 'empty' table image + Hr(HHash_nul[i]) = -1; + memcpy(Hr(HHash_one), Hr(HHash_nul), sizeof(Hr(HHash_nul))); + memcpy(Hr(HHash_two), Hr(HHash_nul), sizeof(Hr(HHash_nul))); + Hr(PHash_sav) = Hr(HHash_one); // alternating 'old/new' hash tables + Hr(PHash_new) = Hr(HHash_two); +} // end: pids_config_history + + +static inline HST_t *pids_histget ( + struct pids_info *info, + int pid) +{ + int V = Hr(PHash_sav[_HASH_PID_(pid)]); + + while (-1 < V) { + if (Hr(PHist_sav[V].pid) == pid) + return &Hr(PHist_sav[V]); + V = Hr(PHist_sav[V].lnk); + } + return NULL; +} // end: pids_histget + + +static inline void pids_histput ( + struct pids_info *info, + unsigned this) +{ + int V = _HASH_PID_(Hr(PHist_new[this].pid)); + + Hr(PHist_new[this].lnk) = Hr(PHash_new[V]); + Hr(PHash_new[V] = this); +} // end: pids_histput + +#undef _HASH_PID_ + + +static inline int pids_make_hist ( + struct pids_info *info, + proc_t *p) +{ + TIC_t tics; + HST_t *h; + int slot = info->hist->num_tasks; + + if (slot + 1 >= Hr(HHist_siz)) { + Hr(HHist_siz) += NEWOLD_GROW; + Hr(PHist_sav) = realloc(Hr(PHist_sav), sizeof(HST_t) * Hr(HHist_siz)); + Hr(PHist_new) = realloc(Hr(PHist_new), sizeof(HST_t) * Hr(HHist_siz)); + if (!Hr(PHist_sav) || !Hr(PHist_new)) + return 0; + } + Hr(PHist_new[slot].pid) = p->tid; + Hr(PHist_new[slot].maj) = p->maj_flt; + Hr(PHist_new[slot].min) = p->min_flt; + Hr(PHist_new[slot].tics) = tics = (p->utime + p->stime); + + pids_histput(info, slot); + + if ((h = pids_histget(info, p->tid))) { + tics -= h->tics; + p->maj_delta = p->maj_flt - h->maj; + p->min_delta = p->min_flt - h->min; + } + /* here we're saving elapsed tics, which will include any + tasks not previously seen via that pids_histget() guy! */ + p->pcpu = tics; + + info->hist->num_tasks++; + return 1; +} // end: pids_make_hist + + +static inline void pids_toggle_history ( + struct pids_info *info) +{ + void *v; + + v = Hr(PHist_sav); + Hr(PHist_sav) = Hr(PHist_new); + Hr(PHist_new) = v; + + v = Hr(PHash_sav); + Hr(PHash_sav) = Hr(PHash_new); + Hr(PHash_new) = v; + memcpy(Hr(PHash_new), Hr(HHash_nul), sizeof(Hr(HHash_nul))); + + info->hist->num_tasks = 0; +} // end: pids_toggle_history + + +#ifdef UNREF_RPTHASH +static void pids_unref_rpthash ( + struct pids_info *info) +{ + int i, j, pop, total_occupied, maxdepth, maxdepth_sav, numdepth + , cross_foot, sz = HHASH_SIZE * (int)sizeof(int) + , hsz = (int)sizeof(HST_t) * Hr(HHist_siz); + int depths[HHASH_SIZE]; + + for (i = 0, total_occupied = 0, maxdepth = 0; i < HHASH_SIZE; i++) { + int V = Hr(PHash_new[i]); + j = 0; + if (-1 < V) { + ++total_occupied; + while (-1 < V) { + V = Hr(PHist_new[V].lnk); + if (-1 < V) j++; + } + } + depths[i] = j; + if (maxdepth < j) maxdepth = j; + } + maxdepth_sav = maxdepth; + + fprintf(stderr, + "\n History Memory Costs:" + "\n\tHST_t size = %d, total allocated = %d," + "\n\tthus PHist_new & PHist_sav consumed %dk (%d) total bytes." + "\n" + "\n\tTwo hash tables provide for %d entries each + 1 extra 'empty' image," + "\n\tthus %dk (%d) bytes per table for %dk (%d) total bytes." + "\n" + "\n\tGrand total = %dk (%d) bytes." + "\n" + "\n Hash Results Report:" + "\n\tTotal hashed = %d" + "\n\tLevel-0 hash entries = %d (%d%% occupied)" + "\n\tMax Depth = %d" + "\n\n" + , (int)sizeof(HST_t), Hr(HHist_siz) + , hsz / 1024, hsz + , HHASH_SIZE + , sz / 1024, sz, (sz * 3) / 1024, sz * 3 + , (hsz + (sz * 3)) / 1024, hsz + (sz * 3) + , info->hist->num_tasks + , total_occupied, (total_occupied * 100) / HHASH_SIZE + , maxdepth); + + if (total_occupied) { + for (pop = total_occupied, cross_foot = 0; maxdepth; maxdepth--) { + for (i = 0, numdepth = 0; i < HHASH_SIZE; i++) + if (depths[i] == maxdepth) ++numdepth; + if (numdepth) fprintf(stderr, + "\t %5d (%3d%%) hash table entries at depth %d\n" + , numdepth, (numdepth * 100) / total_occupied, maxdepth); + pop -= numdepth; + cross_foot += numdepth; + if (0 == pop && cross_foot == total_occupied) break; + } + if (pop) { + fprintf(stderr, "\t %5d (%3d%%) unchained entries (at depth 0)\n" + , pop, (pop * 100) / total_occupied); + cross_foot += pop; + } + fprintf(stderr, + "\t -----\n" + "\t %5d total entries occupied\n", cross_foot); + + if (maxdepth_sav > 1) { + fprintf(stderr, "\n PIDs at max depth: "); + for (i = 0; i < HHASH_SIZE; i++) + if (depths[i] == maxdepth_sav) { + j = Hr(PHash_new[i]); + fprintf(stderr, "\n\tpos %4d: %05d", i, Hr(PHist_new[j].pid)); + while (-1 < j) { + j = Hr(PHist_new[j].lnk); + if (-1 < j) fprintf(stderr, ", %05d", Hr(PHist_new[j].pid)); + } + } + fprintf(stderr, "\n"); + } + } +} // end: pids_unref_rpthash +#endif // UNREF_RPTHASH + +#undef Hr +#undef HHASH_SIZE + + +// ___ Standard Private Functions ||||||||||||||||||||||||||||||||||||||||||||| + +static inline int pids_assign_results ( + struct pids_info *info, + struct pids_stack *stack, + proc_t *p) +{ + struct pids_result *this = stack->head; + SET_t *that = &info->func_array[0]; + + info->seterr = 0; + while (*that) { + (*that)(info, this, p); + ++this; + ++that; + } + return !info->seterr; +} // end: pids_assign_results + + +static inline void pids_cleanup_stack ( + struct pids_result *this) +{ + for (;;) { + enum pids_item item = this->item; + if (item >= PIDS_logical_end) + break; + if (Item_table[item].freefunc) + Item_table[item].freefunc(this); + this->result.ull_int = 0; + ++this; + } +} // end: pids_cleanup_stack + + +static inline void pids_cleanup_stacks_all ( + struct pids_info *info) +{ + struct stacks_extent *ext = info->extents; + int i; + + while (ext) { + for (i = 0; ext->stacks[i]; i++) + pids_cleanup_stack(ext->stacks[i]->head); + ext = ext->next; + }; +} // end: pids_cleanup_stacks_all + + +#if 0 // not currently needed after 'fatal_proc_unmounted' was refactored + /* + * This routine exists in case we ever want to offer something like + * 'static' or 'invarient' results stacks. By unsplicing an extent + * from the info anchor it will be isolated from future reset/free. */ +static struct stacks_extent *pids_extent_cut ( + struct pids_info *info, + struct stacks_extent *ext) +{ + struct stacks_extent *p = info->extents; + + if (ext) { + if (ext == p) { + info->extents = p->next; + return ext; + } + do { + if (ext == p->next) { + p->next = p->next->next; + return ext; + } + p = p->next; + } while (p); + } + return NULL; +} // end: pids_extent_cut +#endif // ---------------------------------------------------------------- + + +static inline struct pids_result *pids_itemize_stack ( + struct pids_result *p, + int depth, + enum pids_item *items) +{ + struct pids_result *p_sav = p; + int i; + + for (i = 0; i < depth; i++) { + p->item = items[i]; + ++p; + } + return p_sav; +} // end: pids_itemize_stack + + +static void pids_itemize_stacks_all ( + struct pids_info *info) +{ + struct stacks_extent *ext = info->extents; + + while (ext) { + int i; + for (i = 0; ext->stacks[i]; i++) + pids_itemize_stack(ext->stacks[i]->head, info->maxitems, info->items); + ext = ext->next; + }; +} // end: pids_itemize_stacks_all + + +static inline int pids_items_check_failed ( + enum pids_item *items, + int numitems) +{ + int i; + + /* if an enum is passed instead of an address of one or more enums, ol' gcc + * will silently convert it to an address (possibly NULL). only clang will + * offer any sort of warning like the following: + * + * warning: incompatible integer to pointer conversion passing 'int' to parameter of type 'enum pids_item *' + * if (procps_pids_new(&info, PIDS_noop, 3) < 0) + * ^~~~~~~~~~~~~~~~ + */ + if (numitems < 1 + || (void *)items < (void *)0x8000) // twice as big as our largest enum + return 1; + + for (i = 0; i < numitems; i++) { + // a pids_item is currently unsigned, but we'll protect our future + if (items[i] < 0) + return 1; + if (items[i] >= PIDS_logical_end) { + return 1; + } + } + return 0; +} // end: pids_items_check_failed + + +static inline void pids_libflags_set ( + struct pids_info *info) +{ + enum pids_item e; + int i; + + info->oldflags = info->history_yes = 0; + for (i = 0; i < info->maxitems; i++) { + if (((e = info->items[i])) >= PIDS_logical_end) + break; + info->oldflags |= Item_table[e].oldflags; + info->history_yes |= Item_table[e].needhist; + } + if (info->oldflags & f_either) { + if (!(info->oldflags & (f_stat | f_status))) + info->oldflags |= f_stat; + } + return; +} // end: pids_libflags_set + + +static inline void pids_oldproc_close ( + PROCTAB **this) +{ + if (*this != NULL) { + int errsav = errno; + closeproc(*this); + *this = NULL; + errno = errsav; + } +} // end: pids_oldproc_close + + +static inline int pids_oldproc_open ( + PROCTAB **this, + unsigned flags, + ...) +{ + va_list vl; + int *ids; + int num = 0; + + if (*this == NULL) { + va_start(vl, flags); + ids = va_arg(vl, int*); + if (flags & PROC_UID) num = va_arg(vl, int); + va_end(vl); + if (NULL == (*this = openproc(flags, ids, num))) + return 0; + } + return 1; +} // end: pids_oldproc_open + + +static int pids_prep_func_array ( + struct pids_info *info) +{ + int i; + + if (!(info->func_array = realloc(info->func_array, sizeof(SET_t) * info->maxitems))) + return 0; + for (i = 0; i < info->maxitems -1; i++) + info->func_array[i] = Item_table[info->items[i]].setsfunc; + info->func_array[i] = NULL; + return 1; +} // end: pids_prep_func_array + + +static inline int pids_proc_tally ( + struct pids_info *info, + struct pids_counts *counts, + proc_t *p) +{ + switch (p->state) { + case 'R': + ++counts->running; + break; + case 'D': // 'D' (disk sleep) + case 'S': + ++counts->sleeping; + break; + case 't': // 't' (tracing stop) + case 'T': + ++counts->stopped; + break; + case 'Z': + ++counts->zombied; + break; + default: + /* currently: 'I' (idle), + 'P' (parked), + 'X' (dead - actually 'dying' & probably never seen) + */ + ++counts->other; + break; + } + ++counts->total; + + if (info->history_yes) + return pids_make_hist(info, p); + return 1; +} // end: pids_proc_tally + + +/* + * pids_stacks_alloc(): + * + * Allocate and initialize one or more stacks each of which is anchored in an + * associated context structure. + * + * All such stacks will will have their result structures properly primed with + * 'items', while the result itself will be zeroed. + * + * Returns an array of pointers representing the 'heads' of each new stack. + */ +static struct stacks_extent *pids_stacks_alloc ( + struct pids_info *info, + int maxstacks) +{ + struct stacks_extent *p_blob; + struct pids_stack **p_vect; + struct pids_stack *p_head; + size_t vect_size, head_size, list_size, blob_size; + void *v_head, *v_list; + int i; + + vect_size = sizeof(void *) * maxstacks; // size of the addr vectors | + vect_size += sizeof(void *); // plus NULL addr delimiter | + head_size = sizeof(struct pids_stack); // size of that head struct | + list_size = sizeof(struct pids_result) * info->maxitems; // any single results stack | + blob_size = sizeof(struct stacks_extent); // the extent anchor itself | + blob_size += vect_size; // plus room for addr vects | + blob_size += head_size * maxstacks; // plus room for head thing | + blob_size += list_size * maxstacks; // plus room for our stacks | + + /* note: all of our memory is allocated in a single blob, facilitating a later free(). | + as a minimum, it is important that the result structures themselves always be | + contiguous for every stack since they are accessed through relative position. | */ + if (NULL == (p_blob = calloc(1, blob_size))) + return NULL; + + p_blob->next = info->extents; // push this extent onto... | + info->extents = p_blob; // ...some existing extents | + p_vect = (void *)p_blob + sizeof(struct stacks_extent); // prime our vector pointer | + p_blob->stacks = p_vect; // set actual vectors start | + v_head = (void *)p_vect + vect_size; // prime head pointer start | + v_list = v_head + (head_size * maxstacks); // prime our stacks pointer | + + for (i = 0; i < maxstacks; i++) { + p_head = (struct pids_stack *)v_head; + p_head->head = pids_itemize_stack((struct pids_result *)v_list, info->maxitems, info->items); + p_blob->stacks[i] = p_head; + v_list += list_size; + v_head += head_size; + } + p_blob->ext_numstacks = maxstacks; + return p_blob; +} // end: pids_stacks_alloc + + +static int pids_stacks_fetch ( + struct pids_info *info) +{ + #define n_alloc info->fetch.n_alloc + #define n_inuse info->fetch.n_inuse + #define n_saved info->fetch.n_alloc_save + struct stacks_extent *ext; + + // initialize stuff ----------------------------------- + if (!info->fetch.anchor) { + if (!(info->fetch.anchor = calloc(STACKS_INIT, sizeof(void *)))) + return -1; + if (!(ext = pids_stacks_alloc(info, STACKS_INIT))) + return -1; // here, errno was set to ENOMEM + memcpy(info->fetch.anchor, ext->stacks, sizeof(void *) * STACKS_INIT); + n_alloc = STACKS_INIT; + } + pids_toggle_history(info); + memset(&info->fetch.counts, 0, sizeof(struct pids_counts)); + + // iterate stuff -------------------------------------- + n_inuse = 0; + while (info->read_something(info->fetch_PT, &info->fetch_proc)) { + if (!(n_inuse < n_alloc)) { + n_alloc += STACKS_GROW; + if (!(info->fetch.anchor = realloc(info->fetch.anchor, sizeof(void *) * n_alloc)) + || (!(ext = pids_stacks_alloc(info, STACKS_GROW)))) + return -1; // here, errno was set to ENOMEM + memcpy(info->fetch.anchor + n_inuse, ext->stacks, sizeof(void *) * STACKS_GROW); + } + if (!pids_proc_tally(info, &info->fetch.counts, &info->fetch_proc)) + return -1; // here, errno was set to ENOMEM + if (!pids_assign_results(info, info->fetch.anchor[n_inuse++], &info->fetch_proc)) + return -1; // here, errno was set to ENOMEM + } + /* while the possibility is extremely remote, the readproc.c (read_something) | + simple_readproc and simple_readtask guys could have encountered this error | + in which case they would have returned a NULL, thus ending our while loop. | */ + if (errno == ENOMEM) + return -1; + + // finalize stuff ------------------------------------- + /* note: we go to this trouble of maintaining a duplicate of the consolidated | + extent stacks addresses represented as our 'anchor' since these ptrs | + are exposed to a user (um, not that we don't trust 'em or anything). | + plus, we can NULL delimit these ptrs which we couldn't do otherwise. | */ + if (n_saved < n_inuse + 1) { + n_saved = n_inuse + 1; + if (!(info->fetch.results.stacks = realloc(info->fetch.results.stacks, sizeof(void *) * n_saved))) + return -1; + } + memcpy(info->fetch.results.stacks, info->fetch.anchor, sizeof(void *) * n_inuse); + info->fetch.results.stacks[n_inuse] = NULL; + + return n_inuse; // callers beware, this might be zero ! + #undef n_alloc + #undef n_inuse + #undef n_saved +} // end: pids_stacks_fetch + + +// ___ Public Functions ||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +// --- standard required functions -------------------------------------------- + +/* + * procps_pids_new(): + * + * @info: location of returned new structure + * + * Returns: < 0 on failure, 0 on success along with + * a pointer to a new context struct + */ +PROCPS_EXPORT int procps_pids_new ( + struct pids_info **info, + enum pids_item *items, + int numitems) +{ + struct pids_info *p; + int pgsz; + +#ifdef ITEMTABLE_DEBUG + int i, failed = 0; + for (i = 0; i < MAXTABLE(Item_table); i++) { + if (i != Item_table[i].enumnumb) { + fprintf(stderr, "%s: enum/table error: Item_table[%d] was %s, but its value is %d\n" + , __FILE__, i, Item_table[i].enum2str, Item_table[i].enumnumb); + failed = 1; + } + } + if (PIDS_SELECT_PID != PROC_PID) { + fprintf(stderr, "%s: header error: PIDS_SELECT_PID = 0x%04x, PROC_PID = 0x%04x\n" + , __FILE__, PIDS_SELECT_PID, PROC_PID); + failed = 1; + } + if (PIDS_SELECT_PID_THREADS != PIDS_SELECT_PID + 1) { + fprintf(stderr, "%s: header error: PIDS_SELECT_PID_THREADS = 0x%04x, should be 0x%04x\n" + , __FILE__, PIDS_SELECT_PID_THREADS, PIDS_SELECT_PID + 1); + failed = 1; + } + if (PIDS_SELECT_UID != PROC_UID) { + fprintf(stderr, "%s: header error: PIDS_SELECT_UID = 0x%04x, PROC_UID = 0x%04x\n" + , __FILE__, PIDS_SELECT_UID, PROC_UID); + failed = 1; + } + if (PIDS_SELECT_UID_THREADS != PIDS_SELECT_UID + 1) { + fprintf(stderr, "%s: header error: PIDS_SELECT_UID_THREADS = 0x%04x, should be 0x%04x\n" + , __FILE__, PIDS_SELECT_UID_THREADS, PIDS_SELECT_UID + 1); + failed = 1; + } + // our select() function & select enumerators assume the following ... + if (PIDS_FETCH_THREADS_TOO != 1) { + fprintf(stderr, "%s: header error: PIDS_FETCH_THREADS_TOO = %d, should be 1\n" + , __FILE__, PIDS_FETCH_THREADS_TOO); + failed = 1; + } + if (failed) _Exit(EXIT_FAILURE); +#endif + + if (info == NULL || *info != NULL) + return -EINVAL; + if (!(p = calloc(1, sizeof(struct pids_info)))) + return -ENOMEM; + + /* if we're without items or numitems, a later call to + procps_pids_reset() will become mandatory */ + if (items && numitems) { + if (pids_items_check_failed(items, numitems)) { + free(p); + return -EINVAL; + } + // allow for our PIDS_logical_end + p->maxitems = numitems + 1; + if (!(p->items = calloc(p->maxitems, sizeof(enum pids_item)))) { + free(p); + return -ENOMEM; + } + memcpy(p->items, items, sizeof(enum pids_item) * numitems); + p->items[numitems] = PIDS_logical_end; + pids_libflags_set(p); + if (!pids_prep_func_array(p)) + return -ENOMEM; + } + + if (!(p->hist = calloc(1, sizeof(struct history_info))) + || (!(p->hist->PHist_new = calloc(NEWOLD_INIT, sizeof(HST_t)))) + || (!(p->hist->PHist_sav = calloc(NEWOLD_INIT, sizeof(HST_t))))) { + free(p->items); + if (p->hist) { + free(p->hist->PHist_sav); // this & next might be NULL ... + free(p->hist->PHist_new); + free(p->hist); + } + free(p); + return -ENOMEM; + } + p->hist->HHist_siz = NEWOLD_INIT; + pids_config_history(p); + + pgsz = getpagesize(); + while (pgsz > 1024) { pgsz >>= 1; p->pgs2k_shift++; } + p->hertz = procps_hertz_get(); + + numa_init(); + + p->fetch.results.counts = &p->fetch.counts; + + p->refcount = 1; + *info = p; + return 0; +} // end: procps_pids_new + + +PROCPS_EXPORT int procps_pids_ref ( + struct pids_info *info) +{ + if (info == NULL) + return -EINVAL; + + info->refcount++; + return info->refcount; +} // end: procps_pids_ref + + +PROCPS_EXPORT int procps_pids_unref ( + struct pids_info **info) +{ + if (info == NULL || *info == NULL) + return -EINVAL; + + (*info)->refcount--; + + if ((*info)->refcount < 1) { +#ifdef UNREF_RPTHASH + pids_unref_rpthash(*info); +#endif + if ((*info)->extents) { + pids_cleanup_stacks_all(*info); + do { + struct stacks_extent *p = (*info)->extents; + (*info)->extents = (*info)->extents->next; + free(p); + } while ((*info)->extents); + } + if ((*info)->otherexts) { + struct stacks_extent *nextext, *ext = (*info)->otherexts; + while (ext) { + nextext = ext->next; + pids_cleanup_stack(ext->stacks[0]->head); + free(ext); + ext = nextext; + }; + } + if ((*info)->fetch.anchor) + free((*info)->fetch.anchor); + if ((*info)->fetch.results.stacks) + free((*info)->fetch.results.stacks); + + if ((*info)->items) + free((*info)->items); + if ((*info)->hist) { + free((*info)->hist->PHist_sav); + free((*info)->hist->PHist_new); + free((*info)->hist); + } + + if ((*info)->get_ext) + pids_oldproc_close(&(*info)->get_PT); + + if ((*info)->func_array) + free((*info)->func_array); + + numa_uninit(); + + free(*info); + *info = NULL; + return 0; + } + return (*info)->refcount; +} // end: procps_pids_unref + + +// --- variable interface functions ------------------------------------------- + +PROCPS_EXPORT struct pids_stack *fatal_proc_unmounted ( + struct pids_info *info, + int return_self) +{ + struct pids_fetch *fetched; + unsigned tid; + + /* this is very likely the *only* newlib function where the + context (pids_info) of NULL will ever be permitted */ + if (!look_up_our_self() + || (!return_self)) + return NULL; + + tid = getpid(); + if (!(fetched = procps_pids_select(info, &tid, 1, PIDS_SELECT_PID))) + return NULL; + return fetched->stacks[0]; +} // end: fatal_proc_unmounted + + +PROCPS_EXPORT struct pids_stack *procps_pids_get ( + struct pids_info *info, + enum pids_fetch_type which) +{ + double up_secs; + + errno = EINVAL; + if (info == NULL) + return NULL; + if (which != PIDS_FETCH_TASKS_ONLY && which != PIDS_FETCH_THREADS_TOO) + return NULL; + /* with items & numitems technically optional at 'new' time, it's + expected 'reset' will have been called -- but just in case ... */ + if (!info->maxitems) + return NULL; + + if (!info->get_ext) { + if (!(info->get_ext = pids_stacks_alloc(info, 1))) + return NULL; // here, errno was overridden with ENOMEM +fresh_start: + if (!pids_oldproc_open(&info->get_PT, info->oldflags)) + return NULL; // here, errno was overridden with ENOMEM/others + info->get_type = which; + info->read_something = which ? readeither : readproc; + } + + if (info->get_type != which) { + pids_oldproc_close(&info->get_PT); + goto fresh_start; + } + errno = 0; + + /* when in a namespace with proc mounted subset=pid, + we will be restricted to process information only */ + info->boot_tics = 0; + if (0 >= procps_uptime(&up_secs, NULL)) + info->boot_tics = up_secs * info->hertz; + + if (NULL == info->read_something(info->get_PT, &info->get_proc)) + return NULL; + if (!pids_assign_results(info, info->get_ext->stacks[0], &info->get_proc)) + return NULL; + return info->get_ext->stacks[0]; +} // end: procps_pids_get + + +/* procps_pids_reap(): + * + * Harvest all the available tasks/threads and provide the result + * stacks along with a summary of the information gathered. + * + * Returns: pointer to a pids_fetch struct on success, NULL on error. + */ +PROCPS_EXPORT struct pids_fetch *procps_pids_reap ( + struct pids_info *info, + enum pids_fetch_type which) +{ + double up_secs; + int rc; + + errno = EINVAL; + if (info == NULL) + return NULL; + if (which != PIDS_FETCH_TASKS_ONLY && which != PIDS_FETCH_THREADS_TOO) + return NULL; + /* with items & numitems technically optional at 'new' time, it's + expected 'reset' will have been called -- but just in case ... */ + if (!info->maxitems) + return NULL; + errno = 0; + + if (!pids_oldproc_open(&info->fetch_PT, info->oldflags)) + return NULL; + info->read_something = which ? readeither : readproc; + + /* when in a namespace with proc mounted subset=pid, + we will be restricted to process information only */ + info->boot_tics = 0; + if (0 >= procps_uptime(&up_secs, NULL)) + info->boot_tics = up_secs * info->hertz; + + rc = pids_stacks_fetch(info); + + pids_oldproc_close(&info->fetch_PT); + // we better have found at least 1 pid + return (rc > 0) ? &info->fetch.results : NULL; +} // end: procps_pids_reap + + +PROCPS_EXPORT int procps_pids_reset ( + struct pids_info *info, + enum pids_item *newitems, + int newnumitems) +{ + if (info == NULL || newitems == NULL) + return -EINVAL; + if (pids_items_check_failed(newitems, newnumitems)) + return -EINVAL; + + pids_cleanup_stacks_all(info); + + /* shame on this caller, they didn't change anything. and unless they have + altered the depth of the stacks we're not gonna change anything either! */ + if (info->maxitems == newnumitems + 1 + && !memcmp(info->items, newitems, sizeof(enum pids_item) * newnumitems)) + return 0; + + if (info->maxitems < newnumitems + 1) { + while (info->extents) { + struct stacks_extent *p = info->extents; + info->extents = p->next; + free(p); + }; + if (info->get_ext) { + pids_oldproc_close(&info->get_PT); + info->get_ext = NULL; + } + if (info->fetch.anchor) { + free(info->fetch.anchor); + info->fetch.anchor = NULL; + } + // allow for our PIDS_logical_end + info->maxitems = newnumitems + 1; + if (!(info->items = realloc(info->items, sizeof(enum pids_item) * info->maxitems))) + return -ENOMEM; + } + + memcpy(info->items, newitems, sizeof(enum pids_item) * newnumitems); + info->items[newnumitems] = PIDS_logical_end; + // account for above PIDS_logical_end + info->maxitems = newnumitems + 1; + + // if extents were freed above, this next guy will have no effect + // so we'll rely on pids_stacks_alloc() to itemize ... + pids_itemize_stacks_all(info); + pids_libflags_set(info); + if (!pids_prep_func_array(info)) + return -ENOMEM; + + return 0; +} // end: procps_pids_reset + + +/* procps_pids_select(): + * + * Harvest any processes matching the specified PID or UID and provide the + * result stacks along with a summary of the information gathered. + * + * Returns: pointer to a pids_fetch struct on success, NULL on error. + */ +PROCPS_EXPORT struct pids_fetch *procps_pids_select ( + struct pids_info *info, + unsigned *these, + int numthese, + enum pids_select_type which) +{ + unsigned ids[FILL_ID_MAX + 1]; + double up_secs; + int rc; + + errno = EINVAL; + if (info == NULL || these == NULL) + return NULL; + if (numthese < 1 || numthese > FILL_ID_MAX) + return NULL; + if ((which != PIDS_SELECT_PID && which != PIDS_SELECT_UID) + && ((which != PIDS_SELECT_PID_THREADS && which != PIDS_SELECT_UID_THREADS))) + return NULL; + /* with items & numitems technically optional at 'new' time, it's + expected 'reset' will have been called -- but just in case ... */ + if (!info->maxitems) + return NULL; + errno = 0; + + // this zero delimiter is really only needed with PIDS_SELECT_PID + memcpy(ids, these, sizeof(unsigned) * numthese); + ids[numthese] = 0; + + if (!pids_oldproc_open(&info->fetch_PT, (info->oldflags | which), ids, numthese)) + return NULL; + info->read_something = (which & PIDS_FETCH_THREADS_TOO) ? readeither : readproc; + + /* when in a namespace with proc mounted subset=pid, + we will be restricted to process information only */ + info->boot_tics = 0; + if (0 >= procps_uptime(&up_secs, NULL)) + info->boot_tics = up_secs * info->hertz; + + rc = pids_stacks_fetch(info); + + pids_oldproc_close(&info->fetch_PT); + // no guarantee any pids/uids were found + return (rc >= 0) ? &info->fetch.results : NULL; +} // end: procps_pids_select + + +/* + * procps_pids_sort(): + * + * Sort stacks anchored in the passed stack pointers array + * based on the designated sort enumerator and specified order. + * + * Returns those same addresses sorted. + * + * Note: all of the stacks must be homogeneous (of equal length and content). + */ +PROCPS_EXPORT struct pids_stack **procps_pids_sort ( + struct pids_info *info, + struct pids_stack *stacks[], + int numstacked, + enum pids_item sortitem, + enum pids_sort_order order) +{ + struct sort_parms parms; + struct pids_result *p; + int offset; + + errno = EINVAL; + if (info == NULL || stacks == NULL) + return NULL; + // a pids_item is currently unsigned, but we'll protect our future + if (sortitem < 0 || sortitem >= PIDS_logical_end) + return NULL; + if (order != PIDS_SORT_ASCEND && order != PIDS_SORT_DESCEND) + return NULL; + if (numstacked < 2) + return stacks; + + offset = 0; + p = stacks[0]->head; + for (;;) { + if (p->item == sortitem) + break; + ++offset; + if (offset >= info->maxitems) + return NULL; + if (p->item >= PIDS_logical_end) + return NULL; + ++p; + } + errno = 0; + + parms.offset = offset; + parms.order = order; + + qsort_r(stacks, numstacked, sizeof(void *), (QSR_t)Item_table[p->item].sortfunc, &parms); + return stacks; +} // end: procps_pids_sort + + +// --- special debugging function(s) ------------------------------------------ +/* + * The following isn't part of the normal programming interface. Rather, + * it exists to validate result types referenced in application programs. + * + * It's used only when: + * 1) the 'XTRA_PROCPS_DEBUG' has been defined, or + * 2) an #include of 'xtra-procps-debug.h' is used + */ + +PROCPS_EXPORT struct pids_result *xtra_pids_val ( + int relative_enum, + const char *typestr, + const struct pids_stack *stack, + struct pids_info *info, + const char *file, + int lineno) +{ + char *str; + int i; + + for (i = 0; stack->head[i].item < PIDS_logical_end; i++) + ; + if (relative_enum < 0 || relative_enum >= i) { + fprintf(stderr, "%s line %d: invalid relative_enum = %d, valid range = 0-%d\n" + , file, lineno, relative_enum, i-1); + return NULL; + } + str = Item_table[stack->head[relative_enum].item].type2str; + if (str[0] + && (strcmp(typestr, str))) { + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return &stack->head[relative_enum]; + (void)info; +} // end: xtra_pids_val diff --git a/library/pwcache.c b/library/pwcache.c new file mode 100644 index 0000000..f75e207 --- /dev/null +++ b/library/pwcache.c @@ -0,0 +1,99 @@ +/* + * pwcache.c - memory cache passwd file handling + * + * Copyright © 2011-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2002 Albert Cahalan + * + * Older version: + * Copyright © 1992-1998 Michael K. Johnson <johnsonm@redhat.com> + * Note: most likely none of his code remains + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <stdlib.h> +#include <pwd.h> +#include <grp.h> + +#include "pwcache.h" +#include "procps-private.h" + +// might as well fill cache lines... else we waste memory anyway + +#define HASHSIZE 64 /* power of 2 */ +#define HASH(x) ((x) & (HASHSIZE - 1)) + +static char ERRname[] = "?"; + +static __thread struct pwbuf { + struct pwbuf *next; + uid_t uid; + char name[P_G_SZ]; +} *pwhash[HASHSIZE]; + +char *pwcache_get_user(uid_t uid) { + struct pwbuf **p; + struct passwd *pw; + + p = &pwhash[HASH(uid)]; + while (*p) { + if ((*p)->uid == uid) + return((*p)->name); + p = &(*p)->next; + } + if (!(*p = (struct pwbuf *)malloc(sizeof(struct pwbuf)))) + return ERRname; + (*p)->uid = uid; + pw = getpwuid(uid); + if(!pw || strlen(pw->pw_name) >= P_G_SZ) + sprintf((*p)->name, "%u", uid); + else + strcpy((*p)->name, pw->pw_name); + + (*p)->next = NULL; + return((*p)->name); +} + +static __thread struct grpbuf { + struct grpbuf *next; + gid_t gid; + char name[P_G_SZ]; +} *grphash[HASHSIZE]; + +char *pwcache_get_group(gid_t gid) { + struct grpbuf **g; + struct group *gr; + + g = &grphash[HASH(gid)]; + while (*g) { + if ((*g)->gid == gid) + return((*g)->name); + g = &(*g)->next; + } + if (!(*g = (struct grpbuf *)malloc(sizeof(struct grpbuf)))) + return ERRname;; + (*g)->gid = gid; + gr = getgrgid(gid); + if (!gr || strlen(gr->gr_name) >= P_G_SZ) + sprintf((*g)->name, "%u", gid); + else + strcpy((*g)->name, gr->gr_name); + (*g)->next = NULL; + return((*g)->name); +} diff --git a/library/readproc.c b/library/readproc.c new file mode 100644 index 0000000..2dfe4c9 --- /dev/null +++ b/library/readproc.c @@ -0,0 +1,1627 @@ +/* + * readproc - interface to process table + * + * Copyright © 2002-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2011-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 1998-2010 Albert Cahalan + * Copyright © 2010-2011 Jan Görig <jgorig@redhat.com> + * Copyright © 1998 Michael K. Johnson + * Copyright © 1996 Charles L. Blake. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include <stdarg.h> +#include <string.h> +#include <unistd.h> +#include <signal.h> +#include <fcntl.h> +#include <dirent.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <limits.h> +#include <stdint.h> +#ifdef WITH_SYSTEMD +#include <systemd/sd-login.h> +#endif +#ifdef WITH_ELOGIND +#include <elogind/sd-login.h> +#endif + +#include "devname.h" +#include "escape.h" +#include "misc.h" +#include "pwcache.h" +#include "readproc.h" + +// sometimes it's easier to do this manually, w/o gcc helping +#ifdef PROF +extern void __cyg_profile_func_enter(void*,void*); +#define ENTER(x) __cyg_profile_func_enter((void*)x,(void*)x) +#define LEAVE(x) __cyg_profile_func_exit((void*)x,(void*)x) +#else +#define ENTER(x) +#define LEAVE(x) +#endif + +#ifdef FALSE_THREADS +#define IS_THREAD(q) ( q->tid != q->tgid ) +#endif + +// utility buffers of MAX_BUFSZ bytes each, available to +// any function following an openproc() call +static __thread char *src_buffer, + *dst_buffer; +#define MAX_BUFSZ 1024*64*2 + +// dynamic 'utility' buffer support for file2str() calls +struct utlbuf_s { + char *buf; // dynamically grown buffer + int siz; // current len of the above +} utlbuf_s; + +static int task_dir_missing; + + +// free any additional dynamically acquired storage associated with a proc_t +static inline void free_acquired (proc_t *p) { + /* + * here we free those items that might exist even when not explicitly | + * requested by our caller. it is expected that pid.c will then free | + * any remaining dynamic memory which might be dangling off a proc_t. | */ + if (p->cgname) free(p->cgname); + if (p->cgroup) free(p->cgroup); + if (p->cmd) free(p->cmd); + if (p->sd_mach) free(p->sd_mach); + if (p->sd_ouid) free(p->sd_ouid); + if (p->sd_seat) free(p->sd_seat); + if (p->sd_sess) free(p->sd_sess); + if (p->sd_slice) free(p->sd_slice); + if (p->sd_unit) free(p->sd_unit); + if (p->sd_uunit) free(p->sd_uunit); + if (p->supgid) free(p->supgid); + + memset(p, '\0', sizeof(proc_t)); +} + + +/////////////////////////////////////////////////////////////////////////// + +typedef struct status_table_struct { + unsigned char name[8]; // /proc/*/status field name + unsigned char len; // name length +#ifdef LABEL_OFFSET + long offset; // jump address offset +#else + void *addr; +#endif +} status_table_struct; + +#ifdef LABEL_OFFSET +#define F(x) {#x, sizeof(#x)-1, (long)(&&case_##x-&&base)}, +#else +#define F(x) {#x, sizeof(#x)-1, &&case_##x}, +#endif +#define NUL {"", 0, 0}, + +#define GPERF_TABLE_SIZE 128 + +// Derived from: +// gperf -7 --language=ANSI-C --key-positions=1,3,4 -C -n -c <if-not-piped> +// ( --key-positions verified by omission & reported "Computed positions" ) +// +// Suggested method: +// Grep this file for "case_", then strip those down to the name. +// Eliminate duplicates (due to #ifs), the ' case_' prefix and +// any c comments. Leave the colon and newline so that "Pid:\n", +// "Threads:\n", etc. would be lines, but no quote, no escape, etc. +// +// After a pipe through gperf, insert the resulting 'asso_values' +// into our 'asso' array. Then convert the gperf 'wordlist' array +// into our 'table' array by wrapping the string literals within +// the F macro and replacing empty strings with the NUL define. +// +// In the status_table_struct watch out for name size (grrr, expanding) +// and the number of entries. Currently, the table is padded to 128 +// entries and we therefore mask with 127. + +static int status2proc (char *S, proc_t *restrict P, int is_proc) { + long Threads = 0; + long Tgid = 0; + long Pid = 0; + + // 128 entries because we trust the kernel to use ASCII names + static const unsigned char asso[] = + { + 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, + 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, + 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, + 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, + 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, + 101, 101, 101, 101, 101, 101, 101, 101, 6, 101, + 101, 101, 101, 101, 101, 45, 55, 25, 31, 50, + 50, 10, 0, 35, 101, 101, 21, 101, 30, 101, + 20, 36, 0, 5, 0, 40, 0, 0, 101, 101, + 101, 101, 101, 101, 101, 101, 101, 30, 101, 15, + 0, 1, 101, 10, 101, 10, 101, 101, 101, 25, + 101, 40, 0, 101, 0, 50, 6, 40, 101, 1, + 35, 101, 101, 101, 101, 101, 101, 101 + }; + + static const status_table_struct table[GPERF_TABLE_SIZE] = { + F(VmHWM) + F(Threads) + NUL NUL NUL + F(VmRSS) + F(VmSwap) + NUL NUL NUL + F(Tgid) + F(VmStk) + NUL NUL NUL + F(VmSize) + F(Gid) + NUL NUL NUL + F(VmPTE) + F(VmPeak) + NUL NUL NUL + F(ShdPnd) + F(Pid) + NUL NUL NUL + F(PPid) + F(VmLib) + NUL NUL NUL + F(SigPnd) + F(VmLck) + NUL NUL NUL + F(SigCgt) + F(State) + NUL NUL NUL + F(CapPrm) + F(Uid) + NUL NUL NUL + F(SigIgn) + F(SigQ) + NUL NUL NUL + F(RssShmem) + F(Name) + NUL NUL NUL + F(CapInh) + F(VmData) + NUL NUL NUL + F(FDSize) + NUL NUL NUL NUL + F(SigBlk) + NUL NUL NUL NUL + F(CapEff) + NUL NUL NUL NUL + F(CapBnd) + NUL NUL NUL NUL + F(VmExe) + NUL NUL NUL NUL + F(Groups) + NUL NUL NUL NUL + F(RssAnon) + NUL NUL NUL NUL + F(RssFile) + }; + +#undef F +#undef NUL + +ENTER(0x220); + + goto base; + + for(;;){ + char *colon; + status_table_struct entry; + + // advance to next line + S = strchr(S, '\n'); + if(!S) break; // if no newline + S++; + + // examine a field name (hash and compare) + base: + if(!*S) break; + if((!S[0] || !S[1] || !S[2] || !S[3])) break; + entry = table[(GPERF_TABLE_SIZE -1) & (asso[S[3]&127] + asso[S[2]&127] + asso[S[0]&127])]; + colon = strchr(S, ':'); + if(!colon) break; + if(colon[1]!='\t') break; + if(colon-S != entry.len) continue; + if(memcmp(entry.name,S,colon-S)) continue; + + S = colon+2; // past the '\t' + +#ifdef LABEL_OFFSET + goto *(&&base + entry.offset); +#else + goto *entry.addr; +#endif + + case_Name: + { char buf[64], raw[64]; + unsigned u = 0; + while(u < sizeof(raw) - 1u){ + int c = *S++; + if(c=='\n') break; + if(c=='\0') break; // should never happen + if(c=='\\'){ + c = *S++; + if(c=='\n') break; // should never happen + if(!c) break; // should never happen + if(c=='n') c='\n'; // else we assume it is '\\' + } + raw[u++] = c; + } + raw[u] = '\0'; +#ifdef FALSE_THREADS + if (!IS_THREAD(P)) { +#endif + if (!P->cmd) { + escape_str(buf, raw, sizeof(buf)); + if (!(P->cmd = strdup(buf))) return 1; + } +#ifdef FALSE_THREADS + } +#endif + S--; // put back the '\n' or '\0' + continue; + } + case_ShdPnd: + memcpy(P->signal, S, 16); + P->signal[16] = '\0'; + continue; + case_SigBlk: + memcpy(P->blocked, S, 16); + P->blocked[16] = '\0'; + continue; + case_SigCgt: + memcpy(P->sigcatch, S, 16); + P->sigcatch[16] = '\0'; + continue; + case_SigIgn: + memcpy(P->sigignore, S, 16); + P->sigignore[16] = '\0'; + continue; + case_SigPnd: + memcpy(P->_sigpnd, S, 16); + P->_sigpnd[16] = '\0'; + continue; + case_State: + P->state = *S; + continue; + case_Tgid: + Tgid = strtol(S,&S,10); + continue; + case_Pid: + Pid = strtol(S,&S,10); + continue; + case_PPid: + P->ppid = strtol(S,&S,10); + continue; + case_Threads: + Threads = strtol(S,&S,10); + continue; + case_Uid: + P->ruid = strtol(S,&S,10); + P->euid = strtol(S,&S,10); + P->suid = strtol(S,&S,10); + P->fuid = strtol(S,&S,10); + continue; + case_Gid: + P->rgid = strtol(S,&S,10); + P->egid = strtol(S,&S,10); + P->sgid = strtol(S,&S,10); + P->fgid = strtol(S,&S,10); + continue; + case_VmData: + P->vm_data = (unsigned long)strtol(S,&S,10); + continue; + case_VmExe: + P->vm_exe = (unsigned long)strtol(S,&S,10); + continue; + case_VmLck: + P->vm_lock = (unsigned long)strtol(S,&S,10); + continue; + case_VmLib: + P->vm_lib = (unsigned long)strtol(S,&S,10); + continue; + case_VmRSS: + P->vm_rss = (unsigned long)strtol(S,&S,10); + continue; + case_RssAnon: // subset of VmRSS, linux-4.5 + P->vm_rss_anon = (unsigned long)strtol(S,&S,10); + continue; + case_RssFile: // subset of VmRSS, linux-4.5 + P->vm_rss_file = (unsigned long)strtol(S,&S,10); + continue; + case_RssShmem: // subset of VmRSS, linux-4.5 + P->vm_rss_shared = (unsigned long)strtol(S,&S,10); + continue; + case_VmSize: + P->vm_size = (unsigned long)strtol(S,&S,10); + continue; + case_VmStk: + P->vm_stack = (unsigned long)strtol(S,&S,10); + continue; + case_VmSwap: // Linux 2.6.34 + P->vm_swap = (unsigned long)strtol(S,&S,10); + continue; + case_Groups: + { char *ss = S, *nl = strchr(S, '\n'); + size_t j; + +#ifdef FALSE_THREADS + if (IS_THREAD(P)) continue; +#endif + while (' ' == *ss || '\t' == *ss) ss++; + if (ss >= nl) continue; + j = nl ? (size_t)(nl - ss) : strlen(ss); + if (j > 0 && j < INT_MAX) { + P->supgid = malloc(j+1); // +1 in case space disappears + if (!P->supgid) + return 1; + memcpy(P->supgid, ss, j); + if (' ' != P->supgid[--j]) ++j; + P->supgid[j] = '\0'; // whack the space or the newline + for ( ; j; j--) + if (' ' == P->supgid[j]) + P->supgid[j] = ','; + } + continue; + } + case_CapBnd: + case_CapEff: + case_CapInh: + case_CapPrm: + case_FDSize: + case_SigQ: + case_VmHWM: // 2005, peak VmRSS unless VmRSS is bigger + case_VmPTE: + case_VmPeak: // 2005, peak VmSize unless VmSize is bigger + continue; + } + +#if 0 + // recent kernels supply per-tgid pending signals + if(is_proc && *ShdPnd){ + memcpy(P->signal, ShdPnd, 16); + P->signal[16] = '\0'; + } +#endif + + // recent kernels supply per-tgid pending signals + if(!is_proc || !P->signal[0]){ + memcpy(P->signal, P->_sigpnd, 16); + P->signal[16] = '\0'; + } + + // Linux 2.4.13-pre1 to max 2.4.xx have a useless "Tgid" + // that is not initialized for built-in kernel tasks. + // Only 2.6.0 and above have "Threads" (nlwp) info. + + if(Threads){ + P->nlwp = Threads; + P->tgid = Tgid; // the POSIX PID value + P->tid = Pid; // the thread ID + }else{ + P->nlwp = 1; + P->tgid = Pid; + P->tid = Pid; + } + +#ifdef FALSE_THREADS + if (!IS_THREAD(P)) { +#endif + if (!P->supgid) { + P->supgid = strdup("-"); + if (!P->supgid) + return 1; + } +#ifdef FALSE_THREADS + } +#endif +LEAVE(0x220); + return 0; +} +#undef GPERF_TABLE_SIZE + + +static int supgrps_from_supgids (proc_t *p) { + char *g, *s; + int t; + +#ifdef FALSE_THREADS + if (IS_THREAD(p)) return 0; +#endif + if (!p->supgid || '-' == *p->supgid) + goto wrap_up; + + s = p->supgid; + t = 0; + do { + const int max = P_G_SZ+2; + char *end = NULL; + gid_t gid; + int len; + + while (',' == *s) ++s; + gid = strtol(s, &end, 10); + if (end <= s) break; + s = end; + g = pwcache_get_group(gid); + + if ((t >= INT_MAX - max) + || (!(p->supgrp = realloc(p->supgrp, t + max)))) + return 1; + + len = snprintf(p->supgrp+t, max, "%s%s", t ? "," : "", g); + if (len <= 0) (p->supgrp+t)[len = 0] = '\0'; + else if (len >= max) len = max-1; + t += len; + } while (*s); + +wrap_up: + if (!p->supgrp + && !(p->supgrp = strdup("-"))) + return 1; + return 0; +} + + +/////////////////////////////////////////////////////////////////////// + +static inline void oomscore2proc(const char *S, proc_t *restrict P) +{ + sscanf(S, "%d", &P->oom_score); +} + +static inline void oomadj2proc(const char *S, proc_t *restrict P) +{ + sscanf(S, "%d", &P->oom_adj); +} + + +/////////////////////////////////////////////////////////////////////// + +static int sd2proc (proc_t *restrict p) { +#if defined(WITH_SYSTEMD) || defined(WITH_ELOGIND) + char buf[64]; + uid_t uid; + + if (0 > sd_pid_get_machine_name(p->tid, &p->sd_mach)) { + if (!(p->sd_mach = strdup("-"))) + return 1; + } + if (0 > sd_pid_get_owner_uid(p->tid, &uid)) { + if (!(p->sd_ouid = strdup("-"))) + return 1; + } else { + snprintf(buf, sizeof(buf), "%d", (int)uid); + if (!(p->sd_ouid = strdup(buf))) + return 1; + } + if (0 > sd_pid_get_session(p->tid, &p->sd_sess)) { + if (!(p->sd_sess = strdup("-"))) + return 1; + if (!(p->sd_seat = strdup("-"))) + return 1; + } else { + if (0 > sd_session_get_seat(p->sd_sess, &p->sd_seat)) + if (!(p->sd_seat = strdup("-"))) + return 1; + } + if (0 > sd_pid_get_slice(p->tid, &p->sd_slice)) + if (!(p->sd_slice = strdup("-"))) + return 1; + if (0 > sd_pid_get_unit(p->tid, &p->sd_unit)) + if (!(p->sd_unit = strdup("-"))) + return 1; + if (0 > sd_pid_get_user_unit(p->tid, &p->sd_uunit)) + if (!(p->sd_uunit = strdup("-"))) + return 1; +#else + if (!(p->sd_mach = strdup("?"))) + return 1; + if (!(p->sd_ouid = strdup("?"))) + return 1; + if (!(p->sd_seat = strdup("?"))) + return 1; + if (!(p->sd_sess = strdup("?"))) + return 1; + if (!(p->sd_slice = strdup("?"))) + return 1; + if (!(p->sd_unit = strdup("?"))) + return 1; + if (!(p->sd_uunit = strdup("?"))) + return 1; +#endif + return 0; +} + + +/////////////////////////////////////////////////////////////////////// + +// Reads /proc/*/stat files, being careful not to trip over processes with +// names like ":-) 1 2 3 4 5 6". +static int stat2proc (const char *S, proc_t *restrict P) { + char buf[64], raw[64]; + size_t num; + char *tmp; + +ENTER(0x160); + + /* fill in default values for older kernels */ + P->processor = 0; + P->rtprio = -1; + P->sched = -1; + P->nlwp = 0; + + S = strchr(S, '('); + if (!S) return 0; + S++; + tmp = strrchr(S, ')'); + if (!tmp || !tmp[1]) return 0; +#ifdef FALSE_THREADS + if (!IS_THREAD(P)) { +#endif + if (!P->cmd) { + num = tmp - S; + memcpy(raw, S, num); + raw[num] = '\0'; + escape_str(buf, raw, sizeof(buf)); + if (!(P->cmd = strdup(buf))) return 1; + } +#ifdef FALSE_THREADS + } +#endif + S = tmp + 2; // skip ") " + + sscanf(S, + "%c " // state + "%d %d %d %d %d " // ppid, pgrp, sid, tty_nr, tty_pgrp + "%lu %lu %lu %lu %lu " // flags, min_flt, cmin_flt, maj_flt, cmaj_flt + "%llu %llu %llu %llu " // utime, stime, cutime, cstime + "%d %d " // priority, nice + "%d " // num_threads + "%lu " // 'alarm' == it_real_value (obsolete, always 0) + "%llu " // start_time + "%lu " // vsize + "%lu " // rss + "%lu %lu %lu %lu %lu %lu " // rsslim, start_code, end_code, start_stack, esp, eip + "%*s %*s %*s %*s " // pending, blocked, sigign, sigcatch <=== DISCARDED + "%lu %*u %*u " // 0 (former wchan), 0, 0 <=== Placeholders only + "%d %d " // exit_signal, task_cpu + "%d %d " // rt_priority, policy (sched) + "%llu %llu %llu", // blkio_ticks, gtime, cgtime + &P->state, + &P->ppid, &P->pgrp, &P->session, &P->tty, &P->tpgid, + &P->flags, &P->min_flt, &P->cmin_flt, &P->maj_flt, &P->cmaj_flt, + &P->utime, &P->stime, &P->cutime, &P->cstime, + &P->priority, &P->nice, + &P->nlwp, + &P->alarm, + &P->start_time, + &P->vsize, + &P->rss, + &P->rss_rlim, &P->start_code, &P->end_code, &P->start_stack, &P->kstk_esp, &P->kstk_eip, +/* P->signal, P->blocked, P->sigignore, P->sigcatch, */ /* can't use */ + &P->wchan, /* &P->nswap, &P->cnswap, */ /* nswap and cnswap dead for 2.4.xx and up */ +/* -- Linux 2.0.35 ends here -- */ + &P->exit_signal, &P->processor, /* 2.2.1 ends with "exit_signal" */ +/* -- Linux 2.2.8 to 2.5.17 end here -- */ + &P->rtprio, &P->sched, /* both added to 2.5.18 */ + &P->blkio_tics, &P->gtime, &P->cgtime + ); + + if(!P->nlwp) + P->nlwp = 1; + + return 0; +LEAVE(0x160); +} + + +///////////////////////////////////////////////////////////////////////// + +static void statm2proc(const char *s, proc_t *restrict P) { + sscanf(s, "%lu %lu %lu %lu %lu %lu %lu", + &P->size, &P->resident, &P->share, + &P->trs, &P->lrs, &P->drs, &P->dt); +} + +static void io2proc(const char *s, proc_t *restrict P) { + sscanf(s, "rchar: %lu wchar: %lu syscr: %lu syscw: %lu read_bytes: %lu write_bytes: %lu cancelled_write_bytes: %lu", + &P->rchar, &P->wchar, &P->syscr, + &P->syscw, &P->read_bytes, &P->write_bytes, &P->cancelled_write_bytes); +} + + // Assuming permissions have allowed the read of smaps_rollup, this + // guy will extract some %lu data. Considering the number of items, + // we are between small enough to use a sscanf and large enough for + // a search.h approach. Thus we roll (get it?) our own custom code. +static void smaps2proc (const char *s, proc_t *restrict P) { + #define enMAX (int)((sizeof(smaptab) / sizeof(smaptab[0]))) + // 1st proc_t data field + #define fZERO tid + // a smaptab entry generator + #define mkENT(F) { #F ":", -1, offsetof(proc_t, smap_ ## F) } + // make a target field + #define mkOBJ(X) ( (unsigned long *)((void *)&P->fZERO + smaptab[X].offs) ) + static struct { + const char *item; + int slen; + int offs; + } smaptab[] = { + /* Size smaps only, not rollup */ + /* KernelPageSize " */ + /* MMUPageSize " */ + mkENT(Rss), + mkENT(Pss), + mkENT(Pss_Anon), /* rollup only, not smaps */ + mkENT(Pss_File), /* " */ + mkENT(Pss_Shmem), /* " */ + mkENT(Shared_Clean), + mkENT(Shared_Dirty), + mkENT(Private_Clean), + mkENT(Private_Dirty), + mkENT(Referenced), + mkENT(Anonymous), + mkENT(LazyFree), + mkENT(AnonHugePages), + mkENT(ShmemPmdMapped), + mkENT(FilePmdMapped), + mkENT(Shared_Hugetlb), + mkENT(Private_Hugetlb), + mkENT(Swap), + mkENT(SwapPss), + mkENT(Locked) + /* THPeligible smaps only, not rollup */ + /* ProtectionKey " */ + /* VmFlags " */ + }; + char *head, *tail; + int i; + + if (smaptab[0].slen < 0) { + for (i = 0; i < enMAX; i++) + smaptab[i].slen = (int)strlen(smaptab[i].item); + } + for (i = 0; i < enMAX; i++) { + if (!(head = strstr(s, smaptab[i].item))) + continue; + head += smaptab[i].slen; + *mkOBJ(i) = strtoul(head, &tail, 10); + // saves some overhead BUT makes us dependent on current order + s = tail; + } + #undef enMAX + #undef fZERO + #undef mkENT + #undef mkOBJ +} + +static int file2str(const char *directory, const char *what, struct utlbuf_s *ub) { + #define buffGRW 1024 + char path[PROCPATHLEN]; + int fd, num, tot_read = 0, len; + + /* on first use we preallocate a buffer of minimum size to emulate + former 'local static' behavior -- even if this read fails, that + buffer will likely soon be used for another subdirectory anyway + ( besides, with the calloc call we will never need use memcpy ) */ + if (ub->buf) ub->buf[0] = '\0'; + else { + ub->buf = calloc(1, (ub->siz = buffGRW)); + if (!ub->buf) return -1; + } + len = snprintf(path, sizeof path, "%s/%s", directory, what); + if (len <= 0 || (size_t)len >= sizeof path) return -1; + if (-1 == (fd = open(path, O_RDONLY, 0))) return -1; + while (0 < (num = read(fd, ub->buf + tot_read, ub->siz - tot_read))) { + tot_read += num; + if (tot_read < ub->siz) break; + if (ub->siz >= INT_MAX - buffGRW) { + tot_read--; + break; + } + if (!(ub->buf = realloc(ub->buf, (ub->siz += buffGRW)))) { + close(fd); + return -1; + } + }; + ub->buf[tot_read] = '\0'; + close(fd); + if (tot_read < 1) return -1; + return tot_read; + #undef buffGRW +} + + +static char **file2strvec(const char *directory, const char *what) { + char buf[2048]; /* read buf bytes at a time */ + char *p, *rbuf = 0, *endbuf, **q, **ret, *strp; + int fd, tot = 0, n, c, end_of_file = 0; + int align; + + const int len = snprintf(buf, sizeof buf, "%s/%s", directory, what); + if(len <= 0 || (size_t)len >= sizeof buf) return NULL; + fd = open(buf, O_RDONLY, 0); + if(fd==-1) return NULL; + + /* read whole file into a memory buffer, allocating as we go */ + while ((n = read(fd, buf, sizeof buf - 1)) >= 0) { + if (n < (int)(sizeof buf - 1)) + end_of_file = 1; + if (n <= 0 && tot <= 0) { /* nothing read now, nothing read before */ + break; /* process died between our open and read */ + } + /* ARG_LEN is our guesstimated median length of a command-line argument + or environment variable (the minimum is 1, the maximum is 131072) */ + #define ARG_LEN 64 + if (tot >= INT_MAX / (ARG_LEN + (int)sizeof(char*)) * ARG_LEN - n) { + end_of_file = 1; /* integer overflow: null-terminate and break */ + n = 0; /* but tot > 0 */ + } + #undef ARG_LEN + if (end_of_file && + ((n > 0 && buf[n-1] != '\0') || /* last read char not null */ + (n <= 0 && rbuf && rbuf[tot-1] != '\0'))) /* last read char not null */ + + buf[n++] = '\0'; /* so append null-terminator */ + + if (n <= 0) break; /* unneeded (end_of_file = 1) but avoid realloc */ + rbuf = realloc(rbuf, tot + n); /* allocate more memory */ + if (!rbuf) { + close(fd); + return NULL; + } + memcpy(rbuf + tot, buf, n); /* copy buffer into it */ + tot += n; /* increment total byte ctr */ + if (end_of_file) + break; + } + close(fd); + if (n < 0 || tot <= 0) { /* error, or nothing read */ + if (rbuf) free(rbuf); + return NULL; /* read error */ + } + + rbuf[tot-1] = '\0'; /* belt and suspenders (the while loop did it, too) */ + endbuf = rbuf + tot; /* count space for pointers */ + align = (sizeof(char*)-1) - ((tot + sizeof(char*)-1) & (sizeof(char*)-1)); + c = sizeof(char*); /* one extra for NULL term */ + for (p = rbuf; p < endbuf; p++) { + if (!*p || *p == '\n') { + if (c >= INT_MAX - (tot + (int)sizeof(char*) + align)) break; + c += sizeof(char*); + } + if (*p == '\n') + *p = 0; + } + + rbuf = realloc(rbuf, tot + c + align); /* make room for ptrs AT END */ + if (!rbuf) return NULL; + endbuf = rbuf + tot; /* addr just past data buf */ + q = ret = (char**) (endbuf+align); /* ==> free(*ret) to dealloc */ + for (strp = p = rbuf; p < endbuf; p++) { + if (!*p) { /* NUL char implies that */ + if (c < 2 * (int)sizeof(char*)) break; + c -= sizeof(char*); + *q++ = strp; /* point ptrs to the strings */ + strp = p+1; /* next string -> next char */ + } + } + *q = 0; /* null ptr list terminator */ + return ret; +} + + + // this is the former under utilized 'read_cmdline', which has been + // generalized in support of these new libproc flags: + // PROC_EDITCGRPCVT, PROC_EDITCMDLCVT and PROC_EDITENVRCVT +static int read_unvectored(char *restrict const dst, unsigned sz, const char *whom, const char *what, char sep) { + char path[PROCPATHLEN]; + int fd, len; + unsigned n = 0; + + if(sz <= 0) return 0; + if(sz >= INT_MAX) sz = INT_MAX-1; + dst[0] = '\0'; + + len = snprintf(path, sizeof(path), "%s/%s", whom, what); + if(len <= 0 || (size_t)len >= sizeof(path)) return 0; + fd = open(path, O_RDONLY); + if(fd==-1) return 0; + + for(;;){ + ssize_t r = read(fd,dst+n,sz-n); + if(r==-1){ + if(errno==EINTR) continue; + break; + } + if(r<=0) break; // EOF + n += r; + if(n==sz) { // filled the buffer + --n; // make room for '\0' + break; + } + } + close(fd); + if(n){ + unsigned i = n; + while(i && dst[i-1]=='\0') --i; // skip trailing zeroes + while(i--) + if(dst[i]=='\n' || dst[i]=='\0') dst[i]=sep; + if(dst[n-1]==' ') dst[n-1]='\0'; + } + dst[n] = '\0'; + return n; +} + + +char **vectorize_this_str (const char *src) { + #define pSZ (sizeof(char*)) + char *cpy, **vec; + size_t adj, tot; + + tot = strlen(src) + 1; // prep for our vectors + if (tot < 1 || tot >= INT_MAX) tot = INT_MAX-1; // integer overflow? + adj = (pSZ-1) - ((tot + pSZ-1) & (pSZ-1)); // calc alignment bytes + cpy = calloc(1, tot + adj + (2 * pSZ)); // get new larger buffer + if (!cpy) return NULL; // oops, looks like ENOMEM + snprintf(cpy, tot, "%s", src); // duplicate their string + vec = (char**)(cpy + tot + adj); // prep pointer to pointers + *vec = cpy; // point 1st vector to string + *(vec+1) = NULL; // null ptr 'list' delimit + return vec; // ==> free(*vec) to dealloc + #undef pSZ +} + + + // This littl' guy just serves those true vectorized fields + // ( when a /proc source field didn't exist ) +static int vectorize_dash_rc (char ***vec) { + if (!(*vec = vectorize_this_str("-"))) + return 1; + return 0; +} + + + // This routine reads a 'cgroup' for the designated proc_t and + // guarantees the caller a valid proc_t.cgroup pointer. +static int fill_cgroup_cvt (const char *directory, proc_t *restrict p) { + #define vMAX ( MAX_BUFSZ - (int)(dst - dst_buffer) ) + char *src, *dst, *grp, *eob, *name; + int tot, x, len; + + *(dst = dst_buffer) = '\0'; // empty destination + tot = read_unvectored(src_buffer, MAX_BUFSZ, directory, "cgroup", '\0'); + for (src = src_buffer, eob = src_buffer + tot; src < eob; src += x) { + x = 1; // loop assist + if (!*src) continue; + x = strlen((grp = src)); + if ('/' == grp[x - 1]) continue; // skip empty root cgroups +#if 0 + grp += strspn(grp, "0123456789:"); // jump past group number +#endif + if (vMAX <= 1) break; + len = snprintf(dst, vMAX, "%s", (dst > dst_buffer) ? "," : ""); + if (len < 0 || len >= vMAX) break; + dst += len; + dst += escape_str(dst, grp, vMAX); + } + if (!(p->cgroup = strdup(dst_buffer[0] ? dst_buffer : "-"))) + return 1; + name = strstr(p->cgroup, ":name="); + if (name && *(name+6)) name += 6; else name = p->cgroup; + if (!(p->cgname = strdup(name))) + return 1; + return 0; + #undef vMAX +} + + + // This routine reads a 'cmdline' for the designated proc_t, "escapes" + // the result into a single string while guaranteeing the caller a + // valid proc_t.cmdline pointer. +static int fill_cmdline_cvt (const char *directory, proc_t *restrict p) { + #define uFLG ( ESC_BRACKETS | ESC_DEFUNCT ) + if (read_unvectored(src_buffer, MAX_BUFSZ, directory, "cmdline", ' ')) + escape_str(dst_buffer, src_buffer, MAX_BUFSZ); + else + escape_command(dst_buffer, p, MAX_BUFSZ, uFLG); + p->cmdline = strdup(dst_buffer[0] ? dst_buffer : "?"); + if (!p->cmdline) + return 1; + return 0; + #undef uFLG +} + + + // This routine reads an 'environ' for the designated proc_t and + // guarantees the caller a valid proc_t.environ pointer. +static int fill_environ_cvt (const char *directory, proc_t *restrict p) { + dst_buffer[0] = '\0'; + if (read_unvectored(src_buffer, MAX_BUFSZ, directory, "environ", ' ')) + escape_str(dst_buffer, src_buffer, MAX_BUFSZ); + p->environ = strdup(dst_buffer[0] ? dst_buffer : "-"); + if (!p->environ) + return 1; + return 0; +} + + + // Provide the means to value proc_t.lxcname (perhaps only with "-") while + // tracking all names already seen thus avoiding the overhead of repeating + // malloc() and free() calls. +static char *lxc_containers (const char *path) { + static __thread struct utlbuf_s ub = { NULL, 0 }; // util buffer for whole cgroup + static char lxc_none[] = "-"; + static char lxc_oops[] = "?"; // used when memory alloc fails + /* + try to locate the lxc delimiter eyecatcher somewhere in a task's cgroup + directory -- the following are from nested privileged plus unprivileged + containers, where the '/lxc/' delimiter precedes the container name ... + 10:cpuset:/lxc/lxc-P/lxc/lxc-P-nested + 10:cpuset:/user.slice/user-1000.slice/session-c2.scope/lxc/lxc-U/lxc/lxc-U-nested + + ... some minor complications are the potential addition of more cgroups + for a controller displacing the lxc name (normally last on a line), and + environments with unexpected /proc/##/cgroup ordering/contents as with: + 10:cpuset:/lxc/lxc-P/lxc/lxc-P-nested/MY-NEW-CGROUP + or + 2:name=systemd:/ + 1:cpuset,cpu,cpuacct,devices,freezer,net_cls,blkio,perf_event,net_prio:/lxc/lxc-P + */ + if (file2str(path, "cgroup", &ub) > 0) { + /* ouch, the next defaults could be changed at lxc ./configure time + ( and a changed 'lxc.cgroup.pattern' is only available to root ) */ + static const char *lxc_delm1 = "lxc.payload."; // with lxc-4.0.0 + static const char *lxc_delm2 = "lxc.payload/"; // thru lxc-3.2.1 + static const char *lxc_delm3 = "lxc/"; // thru lxc-3.0.3 + const char *delim; + char *p1; + + if ((p1 = strstr(ub.buf, (delim = lxc_delm1))) + || ((p1 = strstr(ub.buf, (delim = lxc_delm2))) + || ((p1 = strstr(ub.buf, (delim = lxc_delm3)))))) { + static __thread struct lxc_ele { + struct lxc_ele *next; + char *name; + } *anchor = NULL; + struct lxc_ele *ele = anchor; + int delim_len = strlen(delim); + char *p2; + + if ((p2 = strchr(p1, '\n'))) // isolate a controller's line + *p2 = '\0'; + do { // deal with nested containers + p2 = p1 + delim_len; + p1 = strstr(p2, delim); + } while (p1); + if ((p1 = strchr(p2, '/'))) // isolate name only substring + *p1 = '\0'; + while (ele) { // have we already seen a name + if (!strcmp(ele->name, p2)) + return ele->name; // return just a recycled name + ele = ele->next; + } + if (!(ele = (struct lxc_ele *)malloc(sizeof(struct lxc_ele)))) + return lxc_oops; + if (!(ele->name = strdup(p2))) { + free(ele); + return lxc_oops; + } + ele->next = anchor; // push the new container name + anchor = ele; + return ele->name; // return a new container name + } + } + return lxc_none; +} + + + // Provide the user id at login (or -1 if not available) +static int login_uid (const char *path) { + char buf[PROCPATHLEN]; + int fd, id, in; + + id = -1; + snprintf(buf, sizeof(buf), "%s/loginuid", path); + if ((fd = open(buf, O_RDONLY, 0)) != -1) { + in = read(fd, buf, sizeof(buf) - 1); + close(fd); + if (in > 0) { + buf[in] = '\0'; + id = atoi(buf); + } + } + return id; +} + + +static char *readlink_exe (const char *path){ + char buf[PROCPATHLEN]; + int in; + + snprintf(buf, sizeof(buf), "%s/exe", path); + in = (int)readlink(buf, src_buffer, MAX_BUFSZ-1); + if (in > 0) { + src_buffer[in] = '\0'; + escape_str(dst_buffer, src_buffer, MAX_BUFSZ); + return strdup(dst_buffer); + } + return strdup("-"); +} + + + // Provide the autogroup fields (or -1 if not available) +static void autogroup_fill (const char *path, proc_t *p) { + char buf[PROCPATHLEN]; + int fd, in; + + p->autogrp_id = -1; + snprintf(buf, sizeof(buf), "%s/autogroup", path); + if ((fd = open(buf, O_RDONLY, 0)) != -1) { + in = read(fd, buf, sizeof(buf) - 1); + close(fd); + if (in > 0) { + buf[in] = '\0'; + sscanf(buf, "/autogroup-%d nice %d" + , &p->autogrp_id, &p->autogrp_nice); + } + } +} + + +/////////////////////////////////////////////////////////////////////// + +/* These are some nice GNU C expression subscope "inline" functions. + * The can be used with arbitrary types and evaluate their arguments + * exactly once. + */ + +/* Test if item X of type T is present in the 0 terminated list L */ +# define XinL(T, X, L) ( { \ + T x = (X), *l = (L); \ + while (*l && *l != x) l++; \ + *l == x; \ + } ) + +/* Test if item X of type T is present in the list L of length N */ +# define XinLN(T, X, L, N) ( { \ + T x = (X), *l = (L); \ + int i = 0, n = (N); \ + while (i < n && l[i] != x) i++; \ + i < n && l[i] == x; \ + } ) + + +////////////////////////////////////////////////////////////////////////////////// +// This reads process info from /proc in the traditional way, for one process. +// The pid (tgid? tid?) is already in p, and a path to it in path, with some +// room to spare. +static proc_t *simple_readproc(PROCTAB *restrict const PT, proc_t *restrict const p) { + static __thread struct utlbuf_s ub = { NULL, 0 }; // buf for stat,statm,status + static __thread struct stat sb; // stat() buffer + char *restrict const path = PT->path; + unsigned flags = PT->flags; + int rc = 0; + + if (stat(path, &sb) == -1) /* no such dirent (anymore) */ + goto next_proc; + + if ((flags & PROC_UID) && !XinLN(uid_t, sb.st_uid, PT->uids, PT->nuid)) + goto next_proc; /* not one of the requested uids */ + + p->euid = sb.st_uid; /* need a way to get real uid */ + p->egid = sb.st_gid; /* need a way to get real gid */ + + if (flags & PROC_FILLSTAT) { // read /proc/#/stat + if (file2str(path, "stat", &ub) == -1) + goto next_proc; + rc += stat2proc(ub.buf, p); + } + + if (flags & PROC_FILLIO) { // read /proc/#/io + if (file2str(path, "io", &ub) != -1) + io2proc(ub.buf, p); + } + + if (flags & PROC_FILLSMAPS) { // read /proc/#/smaps_rollup + if (file2str(path, "smaps_rollup", &ub) != -1) + smaps2proc(ub.buf, p); + } + + if (flags & PROC_FILLMEM) { // read /proc/#/statm + if (file2str(path, "statm", &ub) != -1) + statm2proc(ub.buf, p); + } + + if (flags & PROC_FILLSTATUS) { // read /proc/#/status + if (file2str(path, "status", &ub) != -1){ + rc += status2proc(ub.buf, p, 1); + if (flags & (PROC_FILL_SUPGRP & ~PROC_FILLSTATUS)) + rc += supgrps_from_supgids(p); + if (flags & (PROC_FILL_OUSERS & ~PROC_FILLSTATUS)) { + p->ruser = pwcache_get_user(p->ruid); + p->suser = pwcache_get_user(p->suid); + p->fuser = pwcache_get_user(p->fuid); + } + if (flags & (PROC_FILL_OGROUPS & ~PROC_FILLSTATUS)) { + p->rgroup = pwcache_get_group(p->rgid); + p->sgroup = pwcache_get_group(p->sgid); + p->fgroup = pwcache_get_group(p->fgid); + } + } + } + + // if multithreaded, some values are crap + if(p->nlwp > 1) + p->wchan = ~0ul; + + /* some number->text resolving which is time consuming */ + /* ( names are cached, so memcpy to arrays was silly ) */ + if (flags & PROC_FILLUSR) + p->euser = pwcache_get_user(p->euid); + if (flags & PROC_FILLGRP) + p->egroup = pwcache_get_group(p->egid); + + if (flags & PROC_FILLENV) // read /proc/#/environ + if (!(p->environ_v = file2strvec(path, "environ"))) + rc += vectorize_dash_rc(&p->environ_v); + if (flags & PROC_EDITENVRCVT) + rc += fill_environ_cvt(path, p); + + if (flags & PROC_FILLARG) // read /proc/#/cmdline + if (!(p->cmdline_v = file2strvec(path, "cmdline"))) + rc += vectorize_dash_rc(&p->cmdline_v); + if (flags & PROC_EDITCMDLCVT) + rc += fill_cmdline_cvt(path, p); + + if ((flags & PROC_FILLCGROUP)) // read /proc/#/cgroup + if (!(p->cgroup_v = file2strvec(path, "cgroup"))) + rc += vectorize_dash_rc(&p->cgroup_v); + if (flags & PROC_EDITCGRPCVT) + rc += fill_cgroup_cvt(path, p); + + if (flags & PROC_FILLOOM) { + if (file2str(path, "oom_score", &ub) != -1) + oomscore2proc(ub.buf, p); + if (file2str(path, "oom_score_adj", &ub) != -1) + oomadj2proc(ub.buf, p); + } + + if (flags & PROC_FILLNS) // read /proc/#/ns/* + procps_ns_read_pid(p->tid, &(p->ns)); + + + if (flags & PROC_FILLSYSTEMD) // get sd-login.h stuff + rc += sd2proc(p); + + if (flags & PROC_FILL_LXC) // value the lxc name + p->lxcname = lxc_containers(path); + + if (flags & PROC_FILL_LUID) // value the login user id + p->luid = login_uid(path); + + if (flags & PROC_FILL_EXE) { + if (!(p->exe = readlink_exe(path))) + rc += 1; + } + + if (flags & PROC_FILLAUTOGRP) // value the 2 autogroup fields + autogroup_fill(path, p); + + // openproc() ensured that a ppid will be present when needed ... + if (rc == 0) { + if (PT->hide_kernel && (p->ppid == 2 || p->tid == 2)) { + free_acquired(p); + return NULL; + } + return p; + } + errno = ENOMEM; +next_proc: + return NULL; +} + + +////////////////////////////////////////////////////////////////////////////////// +// This reads /proc/*/task/* data, for one task. +// t is the POSIX thread (task group member, generally not the leader) +// path is a path to the task, with some room to spare. +static proc_t *simple_readtask(PROCTAB *restrict const PT, proc_t *restrict const t, char *restrict const path) { + static __thread struct utlbuf_s ub = { NULL, 0 }; // buf for stat,statm,status + static __thread struct stat sb; // stat() buffer + unsigned flags = PT->flags; + int rc = 0; + + if (stat(path, &sb) == -1) /* no such dirent (anymore) */ + goto next_task; + +// if ((flags & PROC_UID) && !XinLN(uid_t, sb.st_uid, PT->uids, PT->nuid)) +// goto next_task; /* not one of the requested uids */ + + t->euid = sb.st_uid; /* need a way to get real uid */ + t->egid = sb.st_gid; /* need a way to get real gid */ + + if (flags & PROC_FILLSTAT) { // read /proc/#/task/#/stat + if (file2str(path, "stat", &ub) == -1) + goto next_task; + rc += stat2proc(ub.buf, t); + } + + if (flags & PROC_FILLIO) { // read /proc/#/task/#/io + if (file2str(path, "io", &ub) != -1) + io2proc(ub.buf, t); + } + + if (flags & PROC_FILLSMAPS) { // read /proc/#/task/#/smaps_rollup + if (file2str(path, "smaps_rollup", &ub) != -1) + smaps2proc(ub.buf, t); + } + + if (flags & PROC_FILLMEM) { // read /proc/#/task/#/statm + if (file2str(path, "statm", &ub) != -1) + statm2proc(ub.buf, t); + } + + if (flags & PROC_FILLSTATUS) { // read /proc/#/task/#/status + if (file2str(path, "status", &ub) != -1) { + rc += status2proc(ub.buf, t, 0); + if (flags & (PROC_FILL_SUPGRP & ~PROC_FILLSTATUS)) + rc += supgrps_from_supgids(t); + if (flags & (PROC_FILL_OUSERS & ~PROC_FILLSTATUS)) { + t->ruser = pwcache_get_user(t->ruid); + t->suser = pwcache_get_user(t->suid); + t->fuser = pwcache_get_user(t->fuid); + } + if (flags & (PROC_FILL_OGROUPS & ~PROC_FILLSTATUS)) { + t->rgroup = pwcache_get_group(t->rgid); + t->sgroup = pwcache_get_group(t->sgid); + t->fgroup = pwcache_get_group(t->fgid); + } + } + } + + /* some number->text resolving which is time consuming */ + /* ( names are cached, so memcpy to arrays was silly ) */ + if (flags & PROC_FILLUSR) + t->euser = pwcache_get_user(t->euid); + if (flags & PROC_FILLGRP) + t->egroup = pwcache_get_group(t->egid); + +#ifdef FALSE_THREADS + if (!IS_THREAD(t)) { +#endif + if (flags & PROC_FILLARG) // read /proc/#/task/#/cmdline + if (!(t->cmdline_v = file2strvec(path, "cmdline"))) + rc += vectorize_dash_rc(&t->cmdline_v); + if (flags & PROC_EDITCMDLCVT) + rc += fill_cmdline_cvt(path, t); + + if (flags & PROC_FILLENV) // read /proc/#/task/#/environ + if (!(t->environ_v = file2strvec(path, "environ"))) + rc += vectorize_dash_rc(&t->environ_v); + if (flags & PROC_EDITENVRCVT) + rc += fill_environ_cvt(path, t); + + if ((flags & PROC_FILLCGROUP)) // read /proc/#/task/#/cgroup + if (!(t->cgroup_v = file2strvec(path, "cgroup"))) + rc += vectorize_dash_rc(&t->cgroup_v); + if (flags & PROC_EDITCGRPCVT) + rc += fill_cgroup_cvt(path, t); + + if (flags & PROC_FILLSYSTEMD) // get sd-login.h stuff + rc += sd2proc(t); + + if (flags & PROC_FILL_EXE) { + if (!(t->exe = readlink_exe(path))) + rc += 1; + } +#ifdef FALSE_THREADS + } +#endif + + if (flags & PROC_FILLOOM) { + if (file2str(path, "oom_score", &ub) != -1) + oomscore2proc(ub.buf, t); + if (file2str(path, "oom_score_adj", &ub) != -1) + oomadj2proc(ub.buf, t); + } + if (flags & PROC_FILLNS) // read /proc/#/task/#/ns/* + procps_ns_read_pid(t->tid, &(t->ns)); + + if (flags & PROC_FILL_LXC) + t->lxcname = lxc_containers(path); + + if (flags & PROC_FILL_LUID) + t->luid = login_uid(path); + + if (flags & PROC_FILLAUTOGRP) // value the 2 autogroup fields + autogroup_fill(path, t); + + // openproc() ensured that a ppid will be present when needed ... + if (rc == 0) { + if (PT->hide_kernel && (t->ppid == 2 || t->tid == 2)) { + free_acquired(t); + return NULL; + } + return t; + } + errno = ENOMEM; +next_task: + return NULL; +} + + +////////////////////////////////////////////////////////////////////////////////// +// This finds processes in /proc in the traditional way. +// Return non-zero on success. +static int simple_nextpid(PROCTAB *restrict const PT, proc_t *restrict const p) { + static __thread struct dirent *ent; /* dirent handle */ + char *restrict const path = PT->path; + for (;;) { + ent = readdir(PT->procfs); + if (!ent || !ent->d_name[0]) break; + if (*ent->d_name > '0' && *ent->d_name <= '9') { + errno = 0; + p->tgid = strtoul(ent->d_name, NULL, 10); + if (errno == 0) { + p->tid = p->tgid; + snprintf(path, PROCPATHLEN, "/proc/%d", p->tgid); + return 1; + } + } + } + return 0; +} + + +////////////////////////////////////////////////////////////////////////////////// +// This finds tasks in /proc/*/task/ in the traditional way. +// Return non-zero on success. +static int simple_nexttid(PROCTAB *restrict const PT, const proc_t *restrict const p, proc_t *restrict const t, char *restrict const path) { + static __thread struct dirent *ent; /* dirent handle */ + if(PT->taskdir_user != p->tgid){ + if(PT->taskdir){ + closedir(PT->taskdir); + } + // use "path" as some tmp space + snprintf(path, PROCPATHLEN, "/proc/%d/task", p->tgid); + PT->taskdir = opendir(path); + if(!PT->taskdir) return 0; + PT->taskdir_user = p->tgid; + } + for (;;) { + ent = readdir(PT->taskdir); + if(!ent || !ent->d_name[0]) return 0; + if(*ent->d_name > '0' && *ent->d_name <= '9') break; + } + t->tid = strtoul(ent->d_name, NULL, 10); + t->tgid = p->tgid; +//t->ppid = p->ppid; // cover for kernel behavior? we want both actually...? + snprintf(path, PROCPATHLEN, "/proc/%d/task/%.10s", p->tgid, ent->d_name); + return 1; +} + + +////////////////////////////////////////////////////////////////////////////////// +// This "finds" processes in a list that was given to openproc(). +// Return non-zero on success. (tgid is a real headache) +static int listed_nextpid (PROCTAB *PT, proc_t *p) { + static __thread struct utlbuf_s ub = { NULL, 0 }; + pid_t pid = *(PT->pids)++; + char *path = PT->path; + + if (pid) { + snprintf(path, PROCPATHLEN, "/proc/%d", pid); + p->tid = p->tgid = pid; // this tgid may be a huge fib | + + /* the 'status' directory is the only place where we find the | + task's real tgid. it's a bit expensive, but remember we're | + dealing with fewer processes, unlike the other 'next' guys | + (plus we need not parse the whole thing like status2proc)! | */ + + if (file2str(path, "status", &ub) != -1) { + char *str = strstr(ub.buf, "Tgid:"); + if (str) + p->tgid = atoi(str + 5); // this tgid is the proper one | + } + } + return pid; +} + + +////////////////////////////////////////////////////////////////////////////////// +/* readproc: return a pointer to a proc_t filled with requested info about the + * next process available matching the restriction set. If no more such + * processes are available, return a null pointer (boolean false). Use the + * passed buffer instead of allocating space if it is non-NULL. */ + +/* This is optimized so that if a PID list is given, only those files are + * searched for in /proc. If other lists are given in addition to the PID list, + * the same logic can follow through as for the no-PID list case. This is + * fairly complex, but it does try to not to do any unnecessary work. + */ +proc_t *readproc(PROCTAB *restrict const PT, proc_t *restrict p) { + proc_t *ret; + + free_acquired(p); + + for(;;){ + // fills in the path, plus p->tid and p->tgid + if (!PT->finder(PT,p)) goto out; + + // go read the process data + ret = PT->reader(PT,p); + if(ret) return ret; + } + +out: + return NULL; +} + + +////////////////////////////////////////////////////////////////////////////////// +// readeither: return a pointer to a proc_t filled with requested info about +// the next unique process or task available. If no more are available, +// return a null pointer (boolean false). +proc_t *readeither (PROCTAB *restrict const PT, proc_t *restrict x) { + static __thread proc_t skel_p; // skeleton proc_t, only uses tid + tgid + static __thread proc_t *new_p; // for process/task transitions + static __thread int canary; + char path[PROCPATHLEN]; + proc_t *ret; + + free_acquired(x); + + if (new_p) { + if (new_p->tid != canary) new_p = NULL; + goto next_task; + } + +next_proc: + new_p = NULL; + for (;;) { + // fills in the PT->path, plus skel_p.tid and skel_p.tgid + if (!PT->finder(PT,&skel_p)) goto end_procs; // simple_nextpid + if (!task_dir_missing) break; + if ((ret = PT->reader(PT,x))) return ret; // simple_readproc + } + +next_task: + // fills in our path, plus x->tid and x->tgid + if ((!(PT->taskfinder(PT,&skel_p,x,path))) // simple_nexttid + || (!(ret = PT->taskreader(PT,x,path)))) { // simple_readtask + goto next_proc; + } + if (!new_p) { + new_p = ret; + canary = new_p->tid; + } + return ret; + +end_procs: + return NULL; +} + + +////////////////////////////////////////////////////////////////////////////////// + +// initiate a process table scan +PROCTAB *openproc(unsigned flags, ...) { + va_list ap; + struct stat sbuf; + static __thread int did_stat; + static __thread int hide_kernel = -1; + PROCTAB *PT = calloc(1, sizeof(PROCTAB)); + + if (!PT) + return NULL; + if (hide_kernel < 0) + hide_kernel = (NULL != getenv("LIBPROC_HIDE_KERNEL")); + if (!did_stat){ + task_dir_missing = stat("/proc/self/task", &sbuf); + did_stat = 1; + } + PT->taskdir = NULL; + PT->taskdir_user = -1; + PT->taskfinder = simple_nexttid; + PT->taskreader = simple_readtask; + + PT->reader = simple_readproc; + if (flags & PROC_PID){ + PT->procfs = NULL; + PT->finder = listed_nextpid; + }else{ + PT->procfs = opendir("/proc"); + if (!PT->procfs) { free(PT); return NULL; } + PT->finder = simple_nextpid; + } + PT->flags = flags; + + va_start(ap, flags); + if (flags & PROC_PID) + PT->pids = va_arg(ap, pid_t*); + else if (flags & PROC_UID){ + PT->uids = va_arg(ap, uid_t*); + PT->nuid = va_arg(ap, int); + } + va_end(ap); + + if (hide_kernel > 0) { + PT->hide_kernel = 1; + // we'll need the ppid, ensure it's obtained via cheapest means ... + if (!(PT->flags & (PROC_FILLSTAT | PROC_FILLSTATUS))) + PT->flags |= PROC_FILLSTAT; + } + + if (!src_buffer + && !(src_buffer = malloc(MAX_BUFSZ))) { + closedir(PT->procfs); + free(PT); + return NULL; + } + if (!dst_buffer + && !(dst_buffer = malloc(MAX_BUFSZ))) { + closedir(PT->procfs); + free(src_buffer); + free(PT); + return NULL; + } + + return PT; +} + + +// terminate a process table scan +void closeproc(PROCTAB *PT) { + if (PT){ + if (PT->procfs) closedir(PT->procfs); + if (PT->taskdir) closedir(PT->taskdir); + memset(PT,'#',sizeof(PROCTAB)); + free(PT); + } +} + + +////////////////////////////////////////////////////////////////////////////////// +int look_up_our_self(void) { + struct utlbuf_s ub = { NULL, 0 }; + int rc = 0; + proc_t p; + + memset(&p, 0, sizeof(proc_t)); + if(file2str("/proc/self", "stat", &ub) == -1){ + fprintf(stderr, "Error, do this: mount -t proc proc /proc\n"); + _exit(47); + } + rc = stat2proc(ub.buf, &p); // parse /proc/self/stat + free_acquired(&p); + free(ub.buf); + return !rc; +} + +#undef IS_THREAD +#undef MAX_BUFSZ diff --git a/library/slabinfo.c b/library/slabinfo.c new file mode 100644 index 0000000..b87f353 --- /dev/null +++ b/library/slabinfo.c @@ -0,0 +1,1044 @@ +/* + * slabinfo.c - slab pools related definitions for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2004-2006 Albert Cahalan + * Copyright © 2003 Chris Rivera + * Copyright © 2003 Fabian Frederick + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <ctype.h> +#include <errno.h> +#include <fcntl.h> +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> + +#include <sys/stat.h> +#include <sys/types.h> + +#include "procps-private.h" +#include "slabinfo.h" + + +#define SLABINFO_FILE "/proc/slabinfo" +#define SLABINFO_LINE_LEN 2048 +#define SLABINFO_NAME_LEN 128 + +#define STACKS_INCR 128 // amount reap stack allocations grow + +/* ---------------------------------------------------------------------------- + + this #define will be used to help ensure that our Item_table is synchronized | + with all the enumerators found in the associated header file. It is intended | + to only be defined locally (and temporarily) at some point prior to release! | */ +// #define ITEMTABLE_DEBUG //-------------------------------------------------- | +// ---------------------------------------------------------------------------- + + +/* + Because 'select' could, at most, return only node[0] values and since 'reap' | + would be forced to duplicate global slabs stuff in every node results stack, | + the following #define can be used to enforce strictly logical return values. | + select: allow only SLABINFO & SLABS items + reap: allow only SLABINFO & SLAB items + Without the #define, these functions always return something even if just 0. | + get: return only SLABS results, else 0 + select: return only SLABINFO & SLABS results, else zero + reap: return any requested, even when duplicated in each cache's stack */ +//#define ENFORCE_LOGICAL // ensure only logical items accepted by select/reap + + +struct slabs_summ { + unsigned int nr_objs; // number of objects, among all caches + unsigned int nr_active_objs; // number of active objects, among all caches + unsigned int nr_pages; // number of pages consumed by all objects + unsigned int nr_slabs; // number of slabs, among all caches + unsigned int nr_active_slabs; // number of active slabs, among all caches + unsigned int nr_caches; // number of caches + unsigned int nr_active_caches; // number of active caches + unsigned int avg_obj_size; // average object size + unsigned int min_obj_size; // size of smallest object + unsigned int max_obj_size; // size of largest object + unsigned long active_size; // size of all active objects + unsigned long total_size; // size of all objects +}; + +struct slabs_node { + char name[SLABINFO_NAME_LEN+1]; // name of this cache + unsigned long cache_size; // size of entire cache + unsigned int nr_objs; // number of objects in this cache + unsigned int nr_active_objs; // number of active objects + unsigned int obj_size; // size of each object + unsigned int objs_per_slab; // number of objects per slab + unsigned int pages_per_slab; // number of pages per slab + unsigned int nr_slabs; // number of slabs in this cache + unsigned int nr_active_slabs; // number of active slabs + unsigned int use; // percent full: total / active +}; + +struct slabs_hist { + struct slabs_summ new; + struct slabs_summ old; +}; + +struct stacks_extent { + int ext_numstacks; + struct stacks_extent *next; + struct slabinfo_stack **stacks; +}; + +struct ext_support { + int numitems; // includes 'logical_end' delimiter + enum slabinfo_item *items; // includes 'logical_end' delimiter + struct stacks_extent *extents; // anchor for these extents +#ifdef ENFORCE_LOGICAL + enum slabinfo_item lowest; // range of allowable enums + enum slabinfo_item highest; +#endif +}; + +struct fetch_support { + struct slabinfo_stack **anchor; // fetch consolidated extents + int n_alloc; // number of above pointers allocated + int n_inuse; // number of above pointers occupied + int n_alloc_save; // last known reap.stacks allocation + struct slabinfo_reaped results; // count + stacks for return to caller +}; + +struct slabinfo_info { + int refcount; + FILE *slabinfo_fp; + int nodes_alloc; // nodes alloc()ed + int nodes_used; // nodes using alloced memory + struct slabs_node *nodes; // first slabnode of this list + struct slabs_hist slabs; // new/old slabs_summ data + struct ext_support select_ext; // supports concurrent select/reap + struct ext_support fetch_ext; // supports concurrent select/reap + struct fetch_support fetch; // support for procps_slabinfo_reap + struct slabs_node nul_node; // used by slabinfo_get/select + struct slabinfo_result get_this; // used by slabinfo_get + time_t sav_secs; // used by slabinfo_get +}; + + +// ___ Results 'Set' Support |||||||||||||||||||||||||||||||||||||||||||||||||| + +#define setNAME(e) set_ ## e +#define setDECL(e) static void setNAME(e) \ + (struct slabinfo_result *R, struct slabs_hist *S, struct slabs_node *N) + +// regular assignment +#define REG_set(e,t,x) setDECL(e) { (void)N; R->result. t = S->new. x; } +#define NOD_set(e,t,x) setDECL(e) { (void)S; R->result. t = N-> x; } +// delta assignment +#define HST_set(e,t,x) setDECL(e) { (void)N; R->result. t = (signed long)S->new. x - S->old. x; } + +setDECL(SLABINFO_noop) { (void)R; (void)S; (void)N; } +setDECL(SLABINFO_extra) { (void)S; (void)N; R->result.ul_int = 0; } + +NOD_set(SLAB_NAME, str, name) +NOD_set(SLAB_NUM_OBJS, u_int, nr_objs) +NOD_set(SLAB_ACTIVE_OBJS, u_int, nr_active_objs) +NOD_set(SLAB_OBJ_SIZE, u_int, obj_size) +NOD_set(SLAB_OBJ_PER_SLAB, u_int, objs_per_slab) +NOD_set(SLAB_NUMS_SLABS, u_int, nr_slabs) +NOD_set(SLAB_ACTIVE_SLABS, u_int, nr_active_slabs) +NOD_set(SLAB_PAGES_PER_SLAB, u_int, pages_per_slab) +NOD_set(SLAB_PERCENT_USED, u_int, use) +NOD_set(SLAB_SIZE_TOTAL, ul_int, cache_size) + +REG_set(SLABS_CACHES_TOTAL, u_int, nr_caches) +REG_set(SLABS_CACHES_ACTIVE, u_int, nr_active_caches) +REG_set(SLABS_NUM_OBJS, u_int, nr_objs) +REG_set(SLABS_ACTIVE_OBJS, u_int, nr_active_objs) +REG_set(SLABS_OBJ_SIZE_AVG, u_int, avg_obj_size) +REG_set(SLABS_OBJ_SIZE_MIN, u_int, min_obj_size) +REG_set(SLABS_OBJ_SIZE_MAX, u_int, max_obj_size) +REG_set(SLABS_NUMS_SLABS, u_int, nr_slabs) +REG_set(SLABS_ACTIVE_SLABS, u_int, nr_active_slabs) +REG_set(SLABS_PAGES_TOTAL, u_int, nr_pages) +REG_set(SLABS_SIZE_ACTIVE, ul_int, active_size) +REG_set(SLABS_SIZE_TOTAL, ul_int, total_size) + +HST_set(SLABS_DELTA_CACHES_TOTAL, s_int, nr_caches) +HST_set(SLABS_DELTA_CACHES_ACTIVE, s_int, nr_active_caches) +HST_set(SLABS_DELTA_NUM_OBJS, s_int, nr_objs) +HST_set(SLABS_DELTA_ACTIVE_OBJS, s_int, nr_active_objs) +HST_set(SLABS_DELTA_OBJ_SIZE_AVG, s_int, avg_obj_size) +HST_set(SLABS_DELTA_OBJ_SIZE_MIN, s_int, min_obj_size) +HST_set(SLABS_DELTA_OBJ_SIZE_MAX, s_int, max_obj_size) +HST_set(SLABS_DELTA_NUMS_SLABS, s_int, nr_slabs) +HST_set(SLABS_DELTA_ACTIVE_SLABS, s_int, nr_active_slabs) +HST_set(SLABS_DELTA_PAGES_TOTAL, s_int, nr_pages) +HST_set(SLABS_DELTA_SIZE_ACTIVE, s_int, active_size) +HST_set(SLABS_DELTA_SIZE_TOTAL, s_int, total_size) + +#undef setDECL +#undef REG_set +#undef NOD_set +#undef HST_set + + +// ___ Sorting Support |||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +struct sort_parms { + int offset; + enum slabinfo_sort_order order; +}; + +#define srtNAME(t) sort_slabinfo_ ## t +#define srtDECL(t) static int srtNAME(t) \ + (const struct slabinfo_stack **A, const struct slabinfo_stack **B, struct sort_parms *P) + +srtDECL(u_int) { + const struct slabinfo_result *a = (*A)->head + P->offset; \ + const struct slabinfo_result *b = (*B)->head + P->offset; \ + if ( a->result.u_int > b->result.u_int ) return P->order > 0 ? 1 : -1; \ + if ( a->result.u_int < b->result.u_int ) return P->order > 0 ? -1 : 1; \ + return 0; +} + +srtDECL(ul_int) { + const struct slabinfo_result *a = (*A)->head + P->offset; \ + const struct slabinfo_result *b = (*B)->head + P->offset; \ + if ( a->result.ul_int > b->result.ul_int ) return P->order > 0 ? 1 : -1; \ + if ( a->result.ul_int < b->result.ul_int ) return P->order > 0 ? -1 : 1; \ + return 0; +} + +srtDECL(str) { + const struct slabinfo_result *a = (*A)->head + P->offset; + const struct slabinfo_result *b = (*B)->head + P->offset; + return P->order * strcoll(a->result.str, b->result.str); +} + +srtDECL(noop) { \ + (void)A; (void)B; (void)P; \ + return 0; +} + +#undef srtDECL + + +// ___ Controlling Table |||||||||||||||||||||||||||||||||||||||||||||||||||||| + +typedef void (*SET_t)(struct slabinfo_result *, struct slabs_hist *, struct slabs_node *); +#ifdef ITEMTABLE_DEBUG +#define RS(e) (SET_t)setNAME(e), e, STRINGIFY(e) +#else +#define RS(e) (SET_t)setNAME(e) +#endif + +typedef int (*QSR_t)(const void *, const void *, void *); +#define QS(t) (QSR_t)srtNAME(t) + +#define TS(t) STRINGIFY(t) +#define TS_noop "" + + /* + * Need it be said? + * This table must be kept in the exact same order as + * those *enum slabinfo_item* guys ! */ +static struct { + SET_t setsfunc; // the actual result setting routine +#ifdef ITEMTABLE_DEBUG + int enumnumb; // enumerator (must match position!) + char *enum2str; // enumerator name as a char* string +#endif + QSR_t sortfunc; // sort cmp func for a specific type + char *type2str; // the result type as a string value +} Item_table[] = { +/* setsfunc sortfunc type2str + ------------------------------ ----------- ---------- */ + { RS(SLABINFO_noop), QS(noop), TS_noop }, + { RS(SLABINFO_extra), QS(ul_int), TS_noop }, + + { RS(SLAB_NAME), QS(str), TS(str) }, + { RS(SLAB_NUM_OBJS), QS(u_int), TS(u_int) }, + { RS(SLAB_ACTIVE_OBJS), QS(u_int), TS(u_int) }, + { RS(SLAB_OBJ_SIZE), QS(u_int), TS(u_int) }, + { RS(SLAB_OBJ_PER_SLAB), QS(u_int), TS(u_int) }, + { RS(SLAB_NUMS_SLABS), QS(u_int), TS(u_int) }, + { RS(SLAB_ACTIVE_SLABS), QS(u_int), TS(u_int) }, + { RS(SLAB_PAGES_PER_SLAB), QS(u_int), TS(u_int) }, + { RS(SLAB_PERCENT_USED), QS(u_int), TS(u_int) }, + { RS(SLAB_SIZE_TOTAL), QS(ul_int), TS(ul_int) }, + + { RS(SLABS_CACHES_TOTAL), QS(noop), TS(u_int) }, + { RS(SLABS_CACHES_ACTIVE), QS(noop), TS(u_int) }, + { RS(SLABS_NUM_OBJS), QS(noop), TS(u_int) }, + { RS(SLABS_ACTIVE_OBJS), QS(noop), TS(u_int) }, + { RS(SLABS_OBJ_SIZE_AVG), QS(noop), TS(u_int) }, + { RS(SLABS_OBJ_SIZE_MIN), QS(noop), TS(u_int) }, + { RS(SLABS_OBJ_SIZE_MAX), QS(noop), TS(u_int) }, + { RS(SLABS_NUMS_SLABS), QS(noop), TS(u_int) }, + { RS(SLABS_ACTIVE_SLABS), QS(noop), TS(u_int) }, + { RS(SLABS_PAGES_TOTAL), QS(noop), TS(u_int) }, + { RS(SLABS_SIZE_ACTIVE), QS(noop), TS(ul_int) }, + { RS(SLABS_SIZE_TOTAL), QS(noop), TS(ul_int) }, + + { RS(SLABS_DELTA_CACHES_TOTAL), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_CACHES_ACTIVE), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_NUM_OBJS), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_ACTIVE_OBJS), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_OBJ_SIZE_AVG), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_OBJ_SIZE_MIN), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_OBJ_SIZE_MAX), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_NUMS_SLABS), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_ACTIVE_SLABS), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_PAGES_TOTAL), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_SIZE_ACTIVE), QS(noop), TS(s_int) }, + { RS(SLABS_DELTA_SIZE_TOTAL), QS(noop), TS(s_int) }, +}; + + /* please note, + * this enum MUST be 1 greater than the highest value of any enum */ +enum slabinfo_item SLABINFO_logical_end = MAXTABLE(Item_table); + +#undef setNAME +#undef srtNAME +#undef RS +#undef QS + + +// ___ Private Functions |||||||||||||||||||||||||||||||||||||||||||||||||||||| +// --- slabnode specific support ---------------------------------------------- + +/* Alloc up more slabnode memory, if required + */ +static int alloc_slabnodes ( + struct slabinfo_info *info) +{ + struct slabs_node *new_nodes; + int new_count; + + if (info->nodes_used < info->nodes_alloc) + return 1; + /* Increment the allocated number of slabs */ + new_count = info->nodes_alloc * 5/4+30; + + new_nodes = realloc(info->nodes, sizeof(struct slabs_node) * new_count); + if (!new_nodes) + return 0; + info->nodes = new_nodes; + info->nodes_alloc = new_count; + return 1; +} // end: alloc_slabnodes + + +/* + * get_slabnode - allocate slab_info structures using a free list + * + * In the fast path, we simply return a node off the free list. In the slow + * list, we malloc() a new node. The free list is never automatically reaped, + * both for simplicity and because the number of slab caches is fairly + * constant. + */ +static int get_slabnode ( + struct slabinfo_info *info, + struct slabs_node **node) +{ + if (info->nodes_used == info->nodes_alloc) { + if (!alloc_slabnodes(info)) + return 0; // here, errno was set to ENOMEM + } + *node = &(info->nodes[info->nodes_used++]); + return 1; +} // end: get_slabnode + + +/* parse_slabinfo20: + * + * Actual parse routine for slabinfo 2.x (2.6 kernels) + * Note: difference between 2.0 and 2.1 is in the ": globalstat" part where version 2.1 + * has extra column <nodeallocs>. We don't use ": globalstat" part in both versions. + * + * Formats (we don't use "statistics" extensions) + * + * slabinfo - version: 2.1 + * # name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> \ + * : tunables <batchcount> <limit> <sharedfactor> \ + * : slabdata <active_slabs> <num_slabs> <sharedavail> + * + * slabinfo - version: 2.1 (statistics) + * # name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> \ + * : tunables <batchcount> <limit> <sharedfactor> \ + * : slabdata <active_slabs> <num_slabs> <sharedavail> \ + * : globalstat <listallocs> <maxobjs> <grown> <reaped> <error> <maxfreeable> <freelimit> <nodeallocs> \ + * : cpustat <allochit> <allocmiss> <freehit> <freemiss> + * + * slabinfo - version: 2.0 + * # name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> \ + * : tunables <batchcount> <limit> <sharedfactor> \ + * : slabdata <active_slabs> <num_slabs> <sharedavail> + * + * slabinfo - version: 2.0 (statistics) + * # name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> \ + * : tunables <batchcount> <limit> <sharedfactor> \ + * : slabdata <active_slabs> <num_slabs> <sharedavail> \ + * : globalstat <listallocs> <maxobjs> <grown> <reaped> <error> <maxfreeable> <freelimit> \ + * : cpustat <allochit> <allocmiss> <freehit> <freemiss> + */ +static int parse_slabinfo20 ( + struct slabinfo_info *info) +{ + struct slabs_node *node; + char buffer[SLABINFO_LINE_LEN]; + int page_size = getpagesize(); + struct slabs_summ *slabs = &(info->slabs.new); + + slabs->min_obj_size = INT_MAX; + slabs->max_obj_size = 0; + + while (fgets(buffer, SLABINFO_LINE_LEN, info->slabinfo_fp )) { + if (buffer[0] == '#') + continue; + + if (!get_slabnode(info, &node)) + return 1; // here, errno was set to ENOMEM + + if (sscanf(buffer, + "%" STRINGIFY(SLABINFO_NAME_LEN) "s" \ + "%u %u %u %u %u : tunables %*u %*u %*u : slabdata %u %u %*u", + node->name, + &node->nr_active_objs, &node->nr_objs, + &node->obj_size, &node->objs_per_slab, + &node->pages_per_slab, &node->nr_active_slabs, + &node->nr_slabs) < 8) { + errno = ERANGE; + return 1; + } + + if (!node->name[0]) + snprintf(node->name, sizeof(node->name), "%s", "unknown"); + + if (node->obj_size < slabs->min_obj_size) + slabs->min_obj_size = node->obj_size; + if (node->obj_size > slabs->max_obj_size) + slabs->max_obj_size = node->obj_size; + + /* cache_size is not accurate, it's the upper limit of memory used by this slab. + * When system using slub(most common case) is under high memory pressure, there + * are slab order fallbacks, which means pages_per_slab is not constant and may decrease. + */ + node->cache_size = (unsigned long)node->nr_slabs * node->pages_per_slab * page_size; + + if (node->nr_objs) { + node->use = (unsigned int)(100 * ((float)node->nr_active_objs / node->nr_objs)); + slabs->nr_active_caches++; + } else + node->use = 0; + + slabs->nr_objs += node->nr_objs; + slabs->nr_active_objs += node->nr_active_objs; + slabs->total_size += (unsigned long)node->nr_objs * node->obj_size; + slabs->active_size += (unsigned long)node->nr_active_objs * node->obj_size; + slabs->nr_pages += node->nr_slabs * node->pages_per_slab; + slabs->nr_slabs += node->nr_slabs; + slabs->nr_active_slabs += node->nr_active_slabs; + slabs->nr_caches++; + } + + if (slabs->nr_objs) + slabs->avg_obj_size = slabs->total_size / slabs->nr_objs; + + return 0; +} // end: parse_slabinfo20 + + +/* slabinfo_read_failed(): + * + * Read the data out of /proc/slabinfo putting the information + * into the supplied info container + * + * Returns: 0 on success, 1 on error + */ +static int slabinfo_read_failed ( + struct slabinfo_info *info) +{ + char line[SLABINFO_LINE_LEN]; + int major, minor; + + memcpy(&info->slabs.old, &info->slabs.new, sizeof(struct slabs_summ)); + memset(&(info->slabs.new), 0, sizeof(struct slabs_summ)); + if (!alloc_slabnodes(info)) + return 1; // here, errno was set to ENOMEM + + memset(info->nodes, 0, sizeof(struct slabs_node)*info->nodes_alloc); + info->nodes_used = 0; + + if (NULL == info->slabinfo_fp + && (info->slabinfo_fp = fopen(SLABINFO_FILE, "r")) == NULL) + return 1; + + if (fseek(info->slabinfo_fp, 0L, SEEK_SET) < 0) + return 1; + + /* Parse the version string */ + if (!fgets(line, SLABINFO_LINE_LEN, info->slabinfo_fp)) + return 1; + + if (2 != sscanf(line, "slabinfo - version: %d.%d", &major, &minor) + || (major != 2)) { + errno = ERANGE; + return 1; + } + + return parse_slabinfo20(info); +} // end: slabinfo_read_failed + + +// ___ Private Functions |||||||||||||||||||||||||||||||||||||||||||||||||||||| +// --- generalized support ---------------------------------------------------- + +static inline void slabinfo_assign_results ( + struct slabinfo_stack *stack, + struct slabs_hist *summ, + struct slabs_node *node) +{ + struct slabinfo_result *this = stack->head; + + for (;;) { + enum slabinfo_item item = this->item; + if (item >= SLABINFO_logical_end) + break; + Item_table[item].setsfunc(this, summ, node); + ++this; + } + return; +} // end: slabinfo_assign_results + + +static void slabinfo_extents_free_all ( + struct ext_support *this) +{ + while (this->extents) { + struct stacks_extent *p = this->extents; + this->extents = this->extents->next; + free(p); + }; +} // end: slabinfo_extents_free_all + + +static inline struct slabinfo_result *slabinfo_itemize_stack ( + struct slabinfo_result *p, + int depth, + enum slabinfo_item *items) +{ + struct slabinfo_result *p_sav = p; + int i; + + for (i = 0; i < depth; i++) { + p->item = items[i]; + ++p; + } + return p_sav; +} // end: slabinfo_itemize_stack + + +static inline int slabinfo_items_check_failed ( + struct ext_support *this, + enum slabinfo_item *items, + int numitems) +{ + int i; + + /* if an enum is passed instead of an address of one or more enums, ol' gcc + * will silently convert it to an address (possibly NULL). only clang will + * offer any sort of warning like the following: + * + * warning: incompatible integer to pointer conversion passing 'int' to parameter of type 'enum slabinfo_item *' + * my_stack = procps_slabinfo_select(info, SLABINFO_noop, num); + * ^~~~~~~~~~~~~~~~ + */ + if (numitems < 1 + || (void *)items < (void *)(unsigned long)(2 * SLABINFO_logical_end)) + return 1; + + for (i = 0; i < numitems; i++) { +#ifdef ENFORCE_LOGICAL + if (items[i] == SLABINFO_noop + || (items[i] == SLABINFO_extra)) + continue; + if (items[i] < this->lowest + || (items[i] > this->highest)) + return 1; +#else + // a slabinfo_item is currently unsigned, but we'll protect our future + if (items[i] < 0) + return 1; + if (items[i] >= SLABINFO_logical_end) + return 1; + (void)this; +#endif + } + + return 0; +} // end: slabinfo_items_check_failed + + +/* + * slabinfo_stacks_alloc(): + * + * Allocate and initialize one or more stacks each of which is anchored in an + * associated context structure. + * + * All such stacks will have their result structures properly primed with + * 'items', while the result itself will be zeroed. + * + * Returns a stacks_extent struct anchoring the 'heads' of each new stack. + */ +static struct stacks_extent *slabinfo_stacks_alloc ( + struct ext_support *this, + int maxstacks) +{ + struct stacks_extent *p_blob; + struct slabinfo_stack **p_vect; + struct slabinfo_stack *p_head; + size_t vect_size, head_size, list_size, blob_size; + void *v_head, *v_list; + int i; + + vect_size = sizeof(void *) * maxstacks; // size of the addr vectors | + vect_size += sizeof(void *); // plus NULL addr delimiter | + head_size = sizeof(struct slabinfo_stack); // size of that head struct | + list_size = sizeof(struct slabinfo_result)*this->numitems; // any single results stack | + blob_size = sizeof(struct stacks_extent); // the extent anchor itself | + blob_size += vect_size; // plus room for addr vects | + blob_size += head_size * maxstacks; // plus room for head thing | + blob_size += list_size * maxstacks; // plus room for our stacks | + + /* note: all of our memory is allocated in one single blob, facilitating a later free(). | + as a minimum, it is important that those result structures themselves always be | + contiguous within each stack since they are accessed through relative position. | */ + if (NULL == (p_blob = calloc(1, blob_size))) + return NULL; + + p_blob->next = this->extents; // push this extent onto... | + this->extents = p_blob; // ...some existing extents | + p_vect = (void *)p_blob + sizeof(struct stacks_extent); // prime our vector pointer | + p_blob->stacks = p_vect; // set actual vectors start | + v_head = (void *)p_vect + vect_size; // prime head pointer start | + v_list = v_head + (head_size * maxstacks); // prime our stacks pointer | + + for (i = 0; i < maxstacks; i++) { + p_head = (struct slabinfo_stack *)v_head; + p_head->head = slabinfo_itemize_stack((struct slabinfo_result *)v_list, this->numitems, this->items); + p_blob->stacks[i] = p_head; + v_list += list_size; + v_head += head_size; + } + p_blob->ext_numstacks = maxstacks; + return p_blob; +} // end: slabinfo_stacks_alloc + + +static int slabinfo_stacks_fetch ( + struct slabinfo_info *info) +{ + #define n_alloc info->fetch.n_alloc + #define n_inuse info->fetch.n_inuse + #define n_saved info->fetch.n_alloc_save + struct stacks_extent *ext; + + // initialize stuff ----------------------------------- + if (!info->fetch.anchor) { + if (!(info->fetch.anchor = calloc(sizeof(void *), STACKS_INCR))) + return -1; + n_alloc = STACKS_INCR; + } + if (!info->fetch_ext.extents) { + if (!(ext = slabinfo_stacks_alloc(&info->fetch_ext, n_alloc))) + return -1; // here, errno was set to ENOMEM + memcpy(info->fetch.anchor, ext->stacks, sizeof(void *) * n_alloc); + } + + // iterate stuff -------------------------------------- + n_inuse = 0; + while (n_inuse < info->nodes_used) { + if (!(n_inuse < n_alloc)) { + n_alloc += STACKS_INCR; + if ((!(info->fetch.anchor = realloc(info->fetch.anchor, sizeof(void *) * n_alloc))) + || (!(ext = slabinfo_stacks_alloc(&info->fetch_ext, STACKS_INCR)))) + return -1; // here, errno was set to ENOMEM + memcpy(info->fetch.anchor + n_inuse, ext->stacks, sizeof(void *) * STACKS_INCR); + } + slabinfo_assign_results(info->fetch.anchor[n_inuse], &info->slabs, &info->nodes[n_inuse]); + ++n_inuse; + } + + // finalize stuff ------------------------------------- + /* note: we go to this trouble of maintaining a duplicate of the consolidated | + extent stacks addresses represented as our 'anchor' since these ptrs | + are exposed to a user (um, not that we don't trust 'em or anything). | + plus, we can NULL delimit these ptrs which we couldn't do otherwise. | */ + if (n_saved < n_inuse + 1) { + n_saved = n_inuse + 1; + if (!(info->fetch.results.stacks = realloc(info->fetch.results.stacks, sizeof(void *) * n_saved))) + return -1; + } + memcpy(info->fetch.results.stacks, info->fetch.anchor, sizeof(void *) * n_inuse); + info->fetch.results.stacks[n_inuse] = NULL; + info->fetch.results.total = n_inuse; + + return n_inuse; + #undef n_alloc + #undef n_inuse + #undef n_saved +} // end: slabinfo_stacks_fetch + + +static int slabinfo_stacks_reconfig_maybe ( + struct ext_support *this, + enum slabinfo_item *items, + int numitems) +{ + if (slabinfo_items_check_failed(this, items, numitems)) + return -1; + /* is this the first time or have things changed since we were last called? + if so, gotta' redo all of our stacks stuff ... */ + if (this->numitems != numitems + 1 + || memcmp(this->items, items, sizeof(enum slabinfo_item) * numitems)) { + // allow for our SLABINFO_logical_end + if (!(this->items = realloc(this->items, sizeof(enum slabinfo_item) * (numitems + 1)))) + return -1; + memcpy(this->items, items, sizeof(enum slabinfo_item) * numitems); + this->items[numitems] = SLABINFO_logical_end; + this->numitems = numitems + 1; + slabinfo_extents_free_all(this); + return 1; + } + return 0; +} // end: slabinfo_stacks_reconfig_maybe + + +// ___ Public Functions ||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +// --- standard required functions -------------------------------------------- + +/* + * procps_slabinfo_new(): + * + * @info: location of returned new structure + * + * Returns: < 0 on failure, 0 on success along with + * a pointer to a new context struct + */ +PROCPS_EXPORT int procps_slabinfo_new ( + struct slabinfo_info **info) +{ + struct slabinfo_info *p; + +#ifdef ITEMTABLE_DEBUG + int i, failed = 0; + for (i = 0; i < MAXTABLE(Item_table); i++) { + if (i != Item_table[i].enumnumb) { + fprintf(stderr, "%s: enum/table error: Item_table[%d] was %s, but its value is %d\n" + , __FILE__, i, Item_table[i].enum2str, Item_table[i].enumnumb); + failed = 1; + } + } + if (failed) _Exit(EXIT_FAILURE); +#endif + + if (info == NULL || *info != NULL) + return -EINVAL; + if (!(p = calloc(1, sizeof(struct slabinfo_info)))) + return -ENOMEM; + +#ifdef ENFORCE_LOGICAL + p->select_ext.lowest = SLABS_CACHES_TOTAL; + p->select_ext.highest = SLABS_DELTA_SIZE_TOTAL; + p->fetch_ext.lowest = SLAB_NAME; + p->fetch_ext.highest = SLAB_SIZE_TOTAL; +#endif + + p->refcount = 1; + + /* do a priming read here for the following potential benefits: | + 1) see if that caller's permissions were sufficient (root) | + 2) make delta results potentially useful, even if 1st time | + 3) elimnate need for history distortions 1st time 'switch' | */ + if (slabinfo_read_failed(p)) { + procps_slabinfo_unref(&p); + return -errno; + } + + *info = p; + return 0; +} // end: procps_slabinfo_new + + +PROCPS_EXPORT int procps_slabinfo_ref ( + struct slabinfo_info *info) +{ + if (info == NULL) + return -EINVAL; + + info->refcount++; + return info->refcount; +} // end: procps_slabinfo_ref + + +PROCPS_EXPORT int procps_slabinfo_unref ( + struct slabinfo_info **info) +{ + if (info == NULL || *info == NULL) + return -EINVAL; + + (*info)->refcount--; + + if ((*info)->refcount < 1) { + int errno_sav = errno; + + if ((*info)->slabinfo_fp) { + fclose((*info)->slabinfo_fp); + (*info)->slabinfo_fp = NULL; + } + if ((*info)->select_ext.extents) + slabinfo_extents_free_all((&(*info)->select_ext)); + if ((*info)->select_ext.items) + free((*info)->select_ext.items); + + if ((*info)->fetch.anchor) + free((*info)->fetch.anchor); + if ((*info)->fetch.results.stacks) + free((*info)->fetch.results.stacks); + + if ((*info)->fetch_ext.extents) + slabinfo_extents_free_all(&(*info)->fetch_ext); + if ((*info)->fetch_ext.items) + free((*info)->fetch_ext.items); + + free((*info)->nodes); + + free(*info); + *info = NULL; + + errno = errno_sav; + return 0; + } + return (*info)->refcount; +} // end: procps_slabinfo_unref + + +// --- variable interface functions ------------------------------------------- + +PROCPS_EXPORT struct slabinfo_result *procps_slabinfo_get ( + struct slabinfo_info *info, + enum slabinfo_item item) +{ + time_t cur_secs; + + errno = EINVAL; + if (info == NULL) + return NULL; + if (item < 0 || item >= SLABINFO_logical_end) + return NULL; + errno = 0; + + /* we will NOT read the slabinfo file with every call - rather, we'll offer + a granularity of 1 second between reads ... */ + cur_secs = time(NULL); + if (1 <= cur_secs - info->sav_secs) { + if (slabinfo_read_failed(info)) + return NULL; + info->sav_secs = cur_secs; + } + + info->get_this.item = item; + // with 'get', we must NOT honor the usual 'noop' guarantee + info->get_this.result.ul_int = 0; + Item_table[item].setsfunc(&info->get_this, &info->slabs, &info->nul_node); + + return &info->get_this; +} // end: procps_slabinfo_get + + +/* procps_slabinfo_reap(): + * + * Harvest all the requested SLAB (individual nodes) information + * providing the result stacks along with the total number of nodes. + * + * Returns: pointer to a slabinfo_reaped struct on success, NULL on error. + */ +PROCPS_EXPORT struct slabinfo_reaped *procps_slabinfo_reap ( + struct slabinfo_info *info, + enum slabinfo_item *items, + int numitems) +{ + errno = EINVAL; + if (info == NULL || items == NULL) + return NULL; + if (0 > slabinfo_stacks_reconfig_maybe(&info->fetch_ext, items, numitems)) + return NULL; // here, errno may be overridden with ENOMEM + errno = 0; + + if (slabinfo_read_failed(info)) + return NULL; + if (0 > slabinfo_stacks_fetch(info)) + return NULL; + + return &info->fetch.results; +} // end: procps_slabinfo_reap + + +/* procps_slabinfo_select(): + * + * Obtain all the requested SLABS (global) information then return + * it in a single library provided results stack. + * + * Returns: pointer to a slabinfo_stack struct on success, NULL on error. + */ +PROCPS_EXPORT struct slabinfo_stack *procps_slabinfo_select ( + struct slabinfo_info *info, + enum slabinfo_item *items, + int numitems) +{ + errno = EINVAL; + if (info == NULL || items == NULL) + return NULL; + if (0 > slabinfo_stacks_reconfig_maybe(&info->select_ext, items, numitems)) + return NULL; // here, errno may be overridden with ENOMEM + errno = 0; + + if (!info->select_ext.extents + && (!slabinfo_stacks_alloc(&info->select_ext, 1))) + return NULL; + + if (slabinfo_read_failed(info)) + return NULL; + slabinfo_assign_results(info->select_ext.extents->stacks[0], &info->slabs, &info->nul_node); + + return info->select_ext.extents->stacks[0]; +} // end: procps_slabinfo_select + + +/* + * procps_slabinfo_sort(): + * + * Sort stacks anchored in the passed stack pointers array + * based on the designated sort enumerator and specified order. + * + * Returns those same addresses sorted. + * + * Note: all of the stacks must be homogeneous (of equal length and content). + */ +PROCPS_EXPORT struct slabinfo_stack **procps_slabinfo_sort ( + struct slabinfo_info *info, + struct slabinfo_stack *stacks[], + int numstacked, + enum slabinfo_item sortitem, + enum slabinfo_sort_order order) +{ + struct slabinfo_result *p; + struct sort_parms parms; + int offset; + + errno = EINVAL; + if (info == NULL || stacks == NULL) + return NULL; + // a slabinfo_item is currently unsigned, but we'll protect our future + if (sortitem < 0 || sortitem >= SLABINFO_logical_end) + return NULL; + if (order != SLABINFO_SORT_ASCEND && order != SLABINFO_SORT_DESCEND) + return NULL; + if (numstacked < 2) + return stacks; + + offset = 0; + p = stacks[0]->head; + for (;;) { + if (p->item == sortitem) + break; + ++offset; + if (p->item >= SLABINFO_logical_end) + return NULL; + ++p; + } + errno = 0; + + parms.offset = offset; + parms.order = order; + + qsort_r(stacks, numstacked, sizeof(void *), (QSR_t)Item_table[p->item].sortfunc, &parms); + return stacks; +} // end: procps_slabinfo_sort + + +// --- special debugging function(s) ------------------------------------------ +/* + * The following isn't part of the normal programming interface. Rather, + * it exists to validate result types referenced in application programs. + * + * It's used only when: + * 1) the 'XTRA_PROCPS_DEBUG' has been defined, or + * 2) an #include of 'xtra-procps-debug.h' is used + */ + +PROCPS_EXPORT struct slabinfo_result *xtra_slabinfo_get ( + struct slabinfo_info *info, + enum slabinfo_item actual_enum, + const char *typestr, + const char *file, + int lineno) +{ + struct slabinfo_result *r = procps_slabinfo_get(info, actual_enum); + + if (actual_enum < 0 || actual_enum >= SLABINFO_logical_end) { + fprintf(stderr, "%s line %d: invalid item = %d, type = %s\n" + , file, lineno, actual_enum, typestr); + } + if (r) { + char *str = Item_table[r->item].type2str; + if (str[0] + && (strcmp(typestr, str))) + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return r; +} // end: xtra_slabinfo_get_ + + +PROCPS_EXPORT struct slabinfo_result *xtra_slabinfo_val ( + int relative_enum, + const char *typestr, + const struct slabinfo_stack *stack, + struct slabinfo_info *info, + const char *file, + int lineno) +{ + char *str; + int i; + + for (i = 0; stack->head[i].item < SLABINFO_logical_end; i++) + ; + if (relative_enum < 0 || relative_enum >= i) { + fprintf(stderr, "%s line %d: invalid relative_enum = %d, valid range = 0-%d\n" + , file, lineno, relative_enum, i-1); + return NULL; + } + str = Item_table[stack->head[relative_enum].item].type2str; + if (str[0] + && (strcmp(typestr, str))) { + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return &stack->head[relative_enum]; + (void)info; +} // end: xtra_slabinfo_val diff --git a/library/stat.c b/library/stat.c new file mode 100644 index 0000000..131cad5 --- /dev/null +++ b/library/stat.c @@ -0,0 +1,1443 @@ +/* + * stat.c - cpu/numa related definitions for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> + +#include <sys/stat.h> +#include <sys/types.h> + +#include "numa.h" + +#include "procps-private.h" +#include "stat.h" + + +#define STAT_FILE "/proc/stat" +#define CORE_FILE "/proc/cpuinfo" + +#define CORE_BUFSIZ 1024 // buf size for line of /proc/cpuinfo +#define BUFFER_INCR 8192 // amount i/p buffer allocations grow +#define STACKS_INCR 64 // amount reap stack allocations grow +#define NEWOLD_INCR 64 // amount jiffs hist allocations grow + +#define ECORE_BEGIN 10 // PRETEND_E_CORES begin at this cpu# + +/* ------------------------------------------------------------------------- + + this provision just does what its name sugggests - it will create several | + E-Core cpus for testing that STAT_TIC_ID_CORE & STAT_TIC_TYPE_CORE stuff! |*/ +// #define PRETEND_E_CORES //----------------------------------------------- | +// ------------------------------------------------------------------------- + + +/* ------------------------------------------------------------------------- + + this provision can be used to ensure that our Item_table was synchronized | + with those enumerators found in the associated header file. It's intended | + to only be used locally (& temporarily) at some point prior to a release! | */ +// #define ITEMTABLE_DEBUG //----------------------------------------------- | +// ------------------------------------------------------------------------- + + +/* ------------------------------------------------------------------------- + + because 'reap' would be forced to duplicate the global SYS stuff in every | + TIC type results stack, the following #define can be used to enforce that | + only STAT_noop and STAT_extra plus all the STAT_TIC items will be allowed | */ +//#define ENFORCE_LOGICAL // ensure only logical items are accepted by reap | +// ------------------------------------------------------------------------- + + +/* --------------------------------------------------------------------------+ + this next define is equivalent to the master top's CPU_ZEROTICS provision | + except that here in newlib we'll take an opposite approach to our default | */ +//#define CPU_IDLE_FORCED // show as 100% idle if fewer ticks than expected | +// --------------------------------------------------------------------------+ + +#ifdef CPU_IDLE_FORCED + /* this is the % used in establishing a ticks threshold below which some | + cpu will be treated 'idle' rather than reflect misleading tick values | */ +#define TICS_THRESHOLD ( 100 / 20 ) +#endif + +struct stat_jifs { + unsigned long long user, nice, system, idle, iowait, irq, sirq, stolen, guest, gnice; + unsigned long long xusr, xsys, xidl, xbsy, xtot; +}; + +struct stat_core { + int id; + int type; // 2 = p-core, 1 = e-core, 0 = unsure + int thread_1; + int thread_2; + struct stat_core *next; +}; + +struct stat_data { + unsigned long intr; + unsigned long ctxt; + unsigned long btime; + unsigned long procs_created; + unsigned long procs_blocked; + unsigned long procs_running; +}; + +struct hist_sys { + struct stat_data new; + struct stat_data old; +}; + +struct hist_tic { + int id; + int numa_node; + int count; + struct stat_jifs new; + struct stat_jifs old; +#ifdef CPU_IDLE_FORCED + unsigned long edge; // only valued/valid with cpu summary +#endif + struct stat_core *core; + int saved_id; +}; + +struct stacks_extent { + int ext_numstacks; + struct stacks_extent *next; + struct stat_stack **stacks; +}; + +struct item_support { + int num; // includes 'logical_end' delimiter + enum stat_item *enums; // includes 'logical_end' delimiter +}; + +struct ext_support { + struct item_support *items; // how these stacks are configured + struct stacks_extent *extents; // anchor for these extents +}; + +struct tic_support { + int n_alloc; // number of below structs allocated + int n_inuse; // number of below structs occupied + struct hist_tic *tics; // actual new/old jiffies +}; + +struct reap_support { + int total; // independently obtained # of cpus/nodes + struct ext_support fetch; // extents plus items details + struct tic_support hist; // cpu and node jiffies management + int n_alloc; // last known anchor pointers allocation + struct stat_stack **anchor; // reapable stacks (consolidated extents) + int n_alloc_save; // last known results.stacks allocation + struct stat_reap result; // summary + stacks returned to caller +}; + +struct stat_info { + int refcount; + FILE *stat_fp; + char *stat_buf; // grows to accommodate all /proc/stat + int stat_buf_size; // current size for the above stat_buf + int cpu_count_hwm; // if changed, triggers new cores scan + struct hist_sys sys_hist; // SYS type management + struct hist_tic cpu_hist; // TIC type management for cpu summary + struct reap_support cpus; // TIC type management for real cpus + struct reap_support nodes; // TIC type management for numa nodes + struct ext_support cpu_summary; // supports /proc/stat line #1 results + struct ext_support select; // support for 'procps_stat_select()' + struct stat_reaped results; // for return to caller after a reap + struct stat_result get_this; // for return to caller after a get + struct item_support reap_items; // items used for reap (shared among 3) + struct item_support select_items; // items unique to select + time_t sav_secs; // used by procps_stat_get to limit i/o + struct stat_core *cores; // linked list, also linked from hist_tic +}; + +// ___ Results 'Set' Support |||||||||||||||||||||||||||||||||||||||||||||||||| + +#define setNAME(e) set_stat_ ## e +#define setDECL(e) static void setNAME(e) \ + (struct stat_result *R, struct hist_sys *S, struct hist_tic *T) + +// regular assignment +#define TIC_set(e,t,x) setDECL(e) { \ + (void)S; R->result. t = T->new. x; } +#define SYS_set(e,t,x) setDECL(e) { \ + (void)T; R->result. t = S->new. x; } +// delta assignment +#define TICsetH(e,t,x) setDECL(e) { \ + (void)S; R->result. t = ( T->new. x - T->old. x ); \ + if (R->result. t < 0) R->result. t = 0; } +#define SYSsetH(e,t,x) setDECL(e) { \ + (void)T; R->result. t = ( S->new. x - S->old. x ); } + +setDECL(noop) { (void)R; (void)S; (void)T; } +setDECL(extra) { (void)S; (void)T; R->result.ull_int = 0; } + +setDECL(TIC_ID) { (void)S; R->result.s_int = T->id; } +setDECL(TIC_ID_CORE) { (void)S; R->result.s_int = (T->core) ? T->core->id : -1; } +setDECL(TIC_NUMA_NODE) { (void)S; R->result.s_int = T->numa_node; } +setDECL(TIC_NUM_CONTRIBUTORS) { (void)S; R->result.s_int = T->count; } +setDECL(TIC_TYPE_CORE) { (void)S; R->result.s_int = (T->core) ? T->core->type : 0; } + +TIC_set(TIC_USER, ull_int, user) +TIC_set(TIC_NICE, ull_int, nice) +TIC_set(TIC_SYSTEM, ull_int, system) +TIC_set(TIC_IDLE, ull_int, idle) +TIC_set(TIC_IOWAIT, ull_int, iowait) +TIC_set(TIC_IRQ, ull_int, irq) +TIC_set(TIC_SOFTIRQ, ull_int, sirq) +TIC_set(TIC_STOLEN, ull_int, stolen) +TIC_set(TIC_GUEST, ull_int, guest) +TIC_set(TIC_GUEST_NICE, ull_int, gnice) + +TICsetH(TIC_DELTA_USER, sl_int, user) +TICsetH(TIC_DELTA_NICE, sl_int, nice) +TICsetH(TIC_DELTA_SYSTEM, sl_int, system) +TICsetH(TIC_DELTA_IDLE, sl_int, idle) +TICsetH(TIC_DELTA_IOWAIT, sl_int, iowait) +TICsetH(TIC_DELTA_IRQ, sl_int, irq) +TICsetH(TIC_DELTA_SOFTIRQ, sl_int, sirq) +TICsetH(TIC_DELTA_STOLEN, sl_int, stolen) +TICsetH(TIC_DELTA_GUEST, sl_int, guest) +TICsetH(TIC_DELTA_GUEST_NICE, sl_int, gnice) + +TIC_set(TIC_SUM_USER, ull_int, xusr) +TIC_set(TIC_SUM_SYSTEM, ull_int, xsys) +TIC_set(TIC_SUM_IDLE, ull_int, xidl) +TIC_set(TIC_SUM_BUSY, ull_int, xbsy) +TIC_set(TIC_SUM_TOTAL, ull_int, xtot) + +TICsetH(TIC_SUM_DELTA_USER, sl_int, xusr) +TICsetH(TIC_SUM_DELTA_SYSTEM, sl_int, xsys) +TICsetH(TIC_SUM_DELTA_IDLE, sl_int, xidl) +TICsetH(TIC_SUM_DELTA_BUSY, sl_int, xbsy) +TICsetH(TIC_SUM_DELTA_TOTAL, sl_int, xtot) + +SYS_set(SYS_CTX_SWITCHES, ul_int, ctxt) +SYS_set(SYS_INTERRUPTS, ul_int, intr) +SYS_set(SYS_PROC_BLOCKED, ul_int, procs_blocked) +SYS_set(SYS_PROC_CREATED, ul_int, procs_created) +SYS_set(SYS_PROC_RUNNING, ul_int, procs_running) +SYS_set(SYS_TIME_OF_BOOT, ul_int, btime) + +SYSsetH(SYS_DELTA_CTX_SWITCHES, s_int, ctxt) +SYSsetH(SYS_DELTA_INTERRUPTS, s_int, intr) +SYSsetH(SYS_DELTA_PROC_BLOCKED, s_int, procs_blocked) +SYSsetH(SYS_DELTA_PROC_CREATED, s_int, procs_created) +SYSsetH(SYS_DELTA_PROC_RUNNING, s_int, procs_running) + +#undef setDECL +#undef TIC_set +#undef SYS_set +#undef TICsetH +#undef SYSsetH + + +// ___ Sorting Support |||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +struct sort_parms { + int offset; + enum stat_sort_order order; +}; + +#define srtNAME(t) sort_stat_ ## t +#define srtDECL(t) static int srtNAME(t) \ + (const struct stat_stack **A, const struct stat_stack **B, struct sort_parms *P) + +srtDECL(s_int) { + const struct stat_result *a = (*A)->head + P->offset; \ + const struct stat_result *b = (*B)->head + P->offset; \ + return P->order * (a->result.s_int - b->result.s_int); +} + +srtDECL(sl_int) { + const struct stat_result *a = (*A)->head + P->offset; \ + const struct stat_result *b = (*B)->head + P->offset; \ + return P->order * (a->result.sl_int - b->result.sl_int); +} + +srtDECL(ul_int) { + const struct stat_result *a = (*A)->head + P->offset; \ + const struct stat_result *b = (*B)->head + P->offset; \ + if ( a->result.ul_int > b->result.ul_int ) return P->order > 0 ? 1 : -1; \ + if ( a->result.ul_int < b->result.ul_int ) return P->order > 0 ? -1 : 1; \ + return 0; +} + +srtDECL(ull_int) { + const struct stat_result *a = (*A)->head + P->offset; \ + const struct stat_result *b = (*B)->head + P->offset; \ + if ( a->result.ull_int > b->result.ull_int ) return P->order > 0 ? 1 : -1; \ + if ( a->result.ull_int < b->result.ull_int ) return P->order > 0 ? -1 : 1; \ + return 0; +} + +srtDECL(noop) { \ + (void)A; (void)B; (void)P; \ + return 0; +} + +#undef srtDECL + + +// ___ Controlling Table |||||||||||||||||||||||||||||||||||||||||||||||||||||| + +typedef void (*SET_t)(struct stat_result *, struct hist_sys *, struct hist_tic *); +#ifdef ITEMTABLE_DEBUG +#define RS(e) (SET_t)setNAME(e), STAT_ ## e, STRINGIFY(STAT_ ## e) +#else +#define RS(e) (SET_t)setNAME(e) +#endif + +typedef int (*QSR_t)(const void *, const void *, void *); +#define QS(t) (QSR_t)srtNAME(t) + +#define TS(t) STRINGIFY(t) +#define TS_noop "" + + /* + * Need it be said? + * This table must be kept in the exact same order as + * those 'enum stat_item' guys ! */ +static struct { + SET_t setsfunc; // the actual result setting routine +#ifdef ITEMTABLE_DEBUG + int enumnumb; // enumerator (must match position!) + char *enum2str; // enumerator name as a char* string +#endif + QSR_t sortfunc; // sort cmp func for a specific type + char *type2str; // the result type as a string value +} Item_table[] = { +/* setsfunc sortfunc type2str + --------------------------- ------------ ----------- */ + { RS(noop), QS(noop), TS_noop }, + { RS(extra), QS(ull_int), TS_noop }, + + { RS(TIC_ID), QS(s_int), TS(s_int) }, + { RS(TIC_ID_CORE), QS(s_int), TS(s_int) }, + { RS(TIC_NUMA_NODE), QS(s_int), TS(s_int) }, + { RS(TIC_NUM_CONTRIBUTORS), QS(s_int), TS(s_int) }, + { RS(TIC_TYPE_CORE), QS(s_int), TS(s_int) }, + { RS(TIC_USER), QS(ull_int), TS(ull_int) }, + { RS(TIC_NICE), QS(ull_int), TS(ull_int) }, + { RS(TIC_SYSTEM), QS(ull_int), TS(ull_int) }, + { RS(TIC_IDLE), QS(ull_int), TS(ull_int) }, + { RS(TIC_IOWAIT), QS(ull_int), TS(ull_int) }, + { RS(TIC_IRQ), QS(ull_int), TS(ull_int) }, + { RS(TIC_SOFTIRQ), QS(ull_int), TS(ull_int) }, + { RS(TIC_STOLEN), QS(ull_int), TS(ull_int) }, + { RS(TIC_GUEST), QS(ull_int), TS(ull_int) }, + { RS(TIC_GUEST_NICE), QS(ull_int), TS(ull_int) }, + + { RS(TIC_DELTA_USER), QS(sl_int), TS(sl_int) }, + { RS(TIC_DELTA_NICE), QS(sl_int), TS(sl_int) }, + { RS(TIC_DELTA_SYSTEM), QS(sl_int), TS(sl_int) }, + { RS(TIC_DELTA_IDLE), QS(sl_int), TS(sl_int) }, + { RS(TIC_DELTA_IOWAIT), QS(sl_int), TS(sl_int) }, + { RS(TIC_DELTA_IRQ), QS(sl_int), TS(sl_int) }, + { RS(TIC_DELTA_SOFTIRQ), QS(sl_int), TS(sl_int) }, + { RS(TIC_DELTA_STOLEN), QS(sl_int), TS(sl_int) }, + { RS(TIC_DELTA_GUEST), QS(sl_int), TS(sl_int) }, + { RS(TIC_DELTA_GUEST_NICE), QS(sl_int), TS(sl_int) }, + + { RS(TIC_SUM_USER), QS(ull_int), TS(ull_int) }, + { RS(TIC_SUM_SYSTEM), QS(ull_int), TS(ull_int) }, + { RS(TIC_SUM_IDLE), QS(ull_int), TS(ull_int) }, + { RS(TIC_SUM_BUSY), QS(ull_int), TS(ull_int) }, + { RS(TIC_SUM_TOTAL), QS(ull_int), TS(ull_int) }, + + { RS(TIC_SUM_DELTA_USER), QS(sl_int), TS(sl_int) }, + { RS(TIC_SUM_DELTA_SYSTEM), QS(sl_int), TS(sl_int) }, + { RS(TIC_SUM_DELTA_IDLE), QS(sl_int), TS(sl_int) }, + { RS(TIC_SUM_DELTA_BUSY), QS(sl_int), TS(sl_int) }, + { RS(TIC_SUM_DELTA_TOTAL), QS(sl_int), TS(sl_int) }, + + { RS(SYS_CTX_SWITCHES), QS(ul_int), TS(ul_int) }, + { RS(SYS_INTERRUPTS), QS(ul_int), TS(ul_int) }, + { RS(SYS_PROC_BLOCKED), QS(ul_int), TS(ul_int) }, + { RS(SYS_PROC_CREATED), QS(ul_int), TS(ul_int) }, + { RS(SYS_PROC_RUNNING), QS(ul_int), TS(ul_int) }, + { RS(SYS_TIME_OF_BOOT), QS(ul_int), TS(ul_int) }, + + { RS(SYS_DELTA_CTX_SWITCHES), QS(s_int), TS(s_int) }, + { RS(SYS_DELTA_INTERRUPTS), QS(s_int), TS(s_int) }, + { RS(SYS_DELTA_PROC_BLOCKED), QS(s_int), TS(s_int) }, + { RS(SYS_DELTA_PROC_CREATED), QS(s_int), TS(s_int) }, + { RS(SYS_DELTA_PROC_RUNNING), QS(s_int), TS(s_int) }, +}; + + /* please note, + * 1st enum MUST be kept in sync with highest TIC type + * 2nd enum MUST be 1 greater than the highest value of any enum */ +#ifdef ENFORCE_LOGICAL +enum stat_item STAT_TIC_highest = STAT_TIC_DELTA_GUEST_NICE; +#endif +enum stat_item STAT_logical_end = MAXTABLE(Item_table); + +#undef setNAME +#undef srtNAME +#undef RS +#undef QS + + +// ___ Private Functions |||||||||||||||||||||||||||||||||||||||||||||||||||||| + +static inline void stat_assign_results ( + struct stat_stack *stack, + struct hist_sys *sys_hist, + struct hist_tic *tic_hist) +{ + struct stat_result *this = stack->head; + + for (;;) { + enum stat_item item = this->item; + if (item >= STAT_logical_end) + break; + Item_table[item].setsfunc(this, sys_hist, tic_hist); + ++this; + } + return; +} // end: stat_assign_results + + +#define E_CORE 1 +#define P_CORE 2 +#define VACANT -1 + +static int stat_core_add ( + struct stat_info *info, + int a_core, + int a_cpu) +{ + struct stat_core *last = NULL, *core = info->cores; + + while (core) { + if (core->id == a_core) { + if (a_cpu == core->thread_1 + || (a_cpu == core->thread_2)) + return 1; + core->thread_2 = a_cpu; + core->type = P_CORE; + return 1; + } + last = core; + core = core->next; + } + if (!(core = calloc(1, sizeof(struct stat_core)))) + return 0; + if (last) last->next = core; + else info->cores = core; + core->id = a_core; + core->thread_1 = a_cpu; + core->thread_2 = VACANT; + return 1; +} // end: stat_core_add + + +static void stat_cores_check ( + struct stat_info *info) +{ + struct stat_core *core; +#ifndef PRETEND_E_CORES + int p_core = 0; + + core = info->cores; + while (core) { + if (core->type == P_CORE) { + p_core = 1; + break; + } + core = core->next; + } + if (p_core) { + core = info->cores; + do { + if (core->thread_2 == VACANT) + core->type = E_CORE; + } while ((core = core->next)); + } +#else + core = info->cores; + while (core) { + core->type = P_CORE; + if (core->thread_1 > ECORE_BEGIN + || (core->thread_2 > ECORE_BEGIN)) + core->type = E_CORE; + core = core->next; + } +#endif +} // end: stat_cores_check + +#undef E_CORE +#undef P_CORE +#undef VACANT + + +static void stat_cores_link ( + struct stat_info *info, + struct hist_tic *this) +{ + struct stat_core *core = info->cores; + + while (core) { + if (this->id == core->thread_1 + || (this->id == core->thread_2)) { + this->core = core; + break; + } + core = core->next; + } +} // end: stat_cores_link + + +static int stat_cores_verify ( + struct stat_info *info) +{ + char buf[CORE_BUFSIZ]; + int a_cpu, a_core; + FILE *fp; + + // be tolerant of a missing CORE_FILE ... + if (!(fp = fopen(CORE_FILE, "r"))) + return 1; + for (;;) { + if (NULL == fgets(buf, sizeof(buf), fp)) + break; + if (buf[0] != 'p') continue; + if (!strstr(buf, "processor")) + continue; + sscanf(buf, "processor : %d", &a_cpu); + for (;;) { + // be tolerant of missing empty line on last processor entry ... + if (NULL == fgets(buf, sizeof(buf), fp)) + goto wrap_up; + // be tolerant of a missing 'core id' on any processor entry ... + if (buf[0] == '\n') { + a_core = a_cpu; + break; + } + if (buf[0] != 'c') continue; + if (!strstr(buf, "core id")) + continue; + sscanf(buf, "core id : %d", &a_core); + break; + } + if (!stat_core_add(info, a_core, a_cpu)) { + fclose(fp); + return 0; + } + } +wrap_up: + fclose(fp); + stat_cores_check(info); + return 1; +} // end: stat_cores_verify + + +static inline void stat_derive_unique ( + struct hist_tic *this) +{ + /* note: we calculate these derived values in a manner consistent with + the calculations for cgroup accounting, as nearly as possible + ( see linux sources: ./kernel/cgroup/rstat.c, root_cgroup_cputime ) */ + this->new.xusr + = this->new.user + + this->new.nice; + this->new.xsys + = this->new.system + + this->new.irq + + this->new.sirq; + this->new.xidl + = this->new.idle + + this->new.iowait; + this->new.xtot + = this->new.xusr + this->new.xsys + this->new.xidl + + this->new.stolen + + this->new.guest + + this->new.gnice; + this->new.xbsy + = this->new.xtot - this->new.xidl; + + // don't distort deltas when cpus are taken offline or brought online + if (this->new.xusr < this->old.xusr + || (this->new.xsys < this->old.xsys) + || (this->new.xidl < this->old.xidl) + || (this->new.xbsy < this->old.xbsy) + || (this->new.xtot < this->old.xtot)) + memcpy(&this->old, &this->new, sizeof(struct stat_jifs)); +} // end: stat_derive_unique + + +static void stat_extents_free_all ( + struct ext_support *this) +{ + while (this->extents) { + struct stacks_extent *p = this->extents; + this->extents = this->extents->next; + free(p); + }; +} // end: stat_extents_free_all + + +static inline struct stat_result *stat_itemize_stack ( + struct stat_result *p, + int depth, + enum stat_item *items) +{ + struct stat_result *p_sav = p; + int i; + + for (i = 0; i < depth; i++) { + p->item = items[i]; + ++p; + } + return p_sav; +} // end: stat_itemize_stack + + +static inline int stat_items_check_failed ( + int numitems, + enum stat_item *items) +{ + int i; + + /* if an enum is passed instead of an address of one or more enums, ol' gcc + * will silently convert it to an address (possibly NULL). only clang will + * offer any sort of warning like the following: + * + * warning: incompatible integer to pointer conversion passing 'int' to parameter of type 'enum stat_item *' + * my_stack = procps_stat_select(info, STAT_noop, num); + * ^~~~~~~~~~~~~~~~ + */ + if (numitems < 1 + || (void *)items < (void *)(unsigned long)(2 * STAT_logical_end)) + return 1; + + for (i = 0; i < numitems; i++) { + // a stat_item is currently unsigned, but we'll protect our future + if (items[i] < 0) + return 1; + if (items[i] >= STAT_logical_end) { + return 1; + } + } + return 0; +} // end: stat_items_check_failed + + +static int stat_make_numa_hist ( + struct stat_info *info) +{ + struct hist_tic *cpu_ptr, *nod_ptr; + int i, node; + + /* are numa nodes dynamic like online cpus can be? + ( and be careful, this libnuma call returns the highest node id in use, ) + ( NOT an actual number of nodes - some of those 'slots' might be unused ) */ + if (!(info->nodes.total = numa_max_node() + 1)) + return 0; + + if (info->nodes.hist.n_alloc == 0 + || (info->nodes.total >= info->nodes.hist.n_alloc)) { + info->nodes.hist.n_alloc = info->nodes.total + NEWOLD_INCR; + info->nodes.hist.tics = realloc(info->nodes.hist.tics, info->nodes.hist.n_alloc * sizeof(struct hist_tic)); + if (info->nodes.hist.tics == NULL) + return -ENOMEM; + } + + // forget all of the prior node statistics & anticipate unassigned slots + memset(info->nodes.hist.tics, 0, info->nodes.hist.n_alloc * sizeof(struct hist_tic)); + nod_ptr = info->nodes.hist.tics; + for (i = 0; i < info->nodes.total; i++) { + nod_ptr->numa_node = STAT_NODE_INVALID; + nod_ptr->id = i; + ++nod_ptr; + } + + // spin thru each cpu and value the jiffs for it's numa node + for (i = 0; i < info->cpus.hist.n_inuse; i++) { + cpu_ptr = info->cpus.hist.tics + i; + if (-1 < (node = numa_node_of_cpu(cpu_ptr->id))) { + nod_ptr = info->nodes.hist.tics + node; + nod_ptr->new.user += cpu_ptr->new.user; nod_ptr->old.user += cpu_ptr->old.user; + nod_ptr->new.nice += cpu_ptr->new.nice; nod_ptr->old.nice += cpu_ptr->old.nice; + nod_ptr->new.system += cpu_ptr->new.system; nod_ptr->old.system += cpu_ptr->old.system; + nod_ptr->new.idle += cpu_ptr->new.idle; nod_ptr->old.idle += cpu_ptr->old.idle; + nod_ptr->new.iowait += cpu_ptr->new.iowait; nod_ptr->old.iowait += cpu_ptr->old.iowait; + nod_ptr->new.irq += cpu_ptr->new.irq; nod_ptr->old.irq += cpu_ptr->old.irq; + nod_ptr->new.sirq += cpu_ptr->new.sirq; nod_ptr->old.sirq += cpu_ptr->old.sirq; + nod_ptr->new.stolen += cpu_ptr->new.stolen; nod_ptr->old.stolen += cpu_ptr->old.stolen; + nod_ptr->new.guest += cpu_ptr->new.guest; nod_ptr->old.guest += cpu_ptr->old.guest; + nod_ptr->new.gnice += cpu_ptr->new.gnice; nod_ptr->old.gnice += cpu_ptr->old.gnice; + + nod_ptr->new.xusr += cpu_ptr->new.xusr; nod_ptr->old.xusr += cpu_ptr->old.xusr; + nod_ptr->new.xsys += cpu_ptr->new.xsys; nod_ptr->old.xsys += cpu_ptr->old.xsys; + nod_ptr->new.xidl += cpu_ptr->new.xidl; nod_ptr->old.xidl += cpu_ptr->old.xidl; + nod_ptr->new.xbsy += cpu_ptr->new.xbsy; nod_ptr->old.xbsy += cpu_ptr->old.xbsy; + nod_ptr->new.xtot += cpu_ptr->new.xtot; nod_ptr->old.xtot += cpu_ptr->old.xtot; + + cpu_ptr->numa_node = nod_ptr->numa_node = node; + nod_ptr->count++; ; + } + } + info->nodes.hist.n_inuse = info->nodes.total; + return info->nodes.hist.n_inuse; +} // end: stat_make_numa_hist + + +static int stat_read_failed ( + struct stat_info *info) +{ + struct hist_tic *sum_ptr, *cpu_ptr; + char *bp, *b; + int i, rc, num, tot_read; + unsigned long long llnum; + + if (!info->cpus.hist.n_alloc) { + info->cpus.hist.tics = calloc(NEWOLD_INCR, sizeof(struct hist_tic)); + if (!(info->cpus.hist.tics)) + return 1; + info->cpus.hist.n_alloc = NEWOLD_INCR; + info->cpus.hist.n_inuse = 0; + } + + if (!info->stat_fp + && (!(info->stat_fp = fopen(STAT_FILE, "r")))) + return 1; + fflush(info->stat_fp); + rewind(info->stat_fp); + + #define maxSIZ info->stat_buf_size + #define curSIZ ( maxSIZ - tot_read ) + #define curPOS ( info->stat_buf + tot_read ) + /* we slurp in the entire directory thus avoiding repeated calls to fread, | + especially for a massively parallel environment. additionally, each cpu | + line is then frozen in time rather than changing until we get around to | + accessing it. this helps to minimize (not eliminate) some distortions. | */ + tot_read = 0; + while ((0 < (num = fread(curPOS, 1, curSIZ, info->stat_fp)))) { + tot_read += num; + if (tot_read < maxSIZ) + break; + maxSIZ += BUFFER_INCR; + if (!(info->stat_buf = realloc(info->stat_buf, maxSIZ))) + return 1; + }; + #undef maxSIZ + #undef curSIZ + #undef curPOS + + if (!feof(info->stat_fp)) { + errno = EIO; + return 1; + } + info->stat_buf[tot_read] = '\0'; + bp = info->stat_buf; + + sum_ptr = &info->cpu_hist; + // remember summary from last time around + memcpy(&sum_ptr->old, &sum_ptr->new, sizeof(struct stat_jifs)); + + sum_ptr->id = STAT_SUMMARY_ID; // mark as summary + sum_ptr->numa_node = STAT_NODE_INVALID; // mark as invalid + + // now value the cpu summary tics from line #1 +#ifdef __CYGWIN__ + if (4 > sscanf(bp, "cpu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu" +#else + if (8 > sscanf(bp, "cpu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu" +#endif + , &sum_ptr->new.user, &sum_ptr->new.nice, &sum_ptr->new.system + , &sum_ptr->new.idle, &sum_ptr->new.iowait, &sum_ptr->new.irq + , &sum_ptr->new.sirq, &sum_ptr->new.stolen + , &sum_ptr->new.guest, &sum_ptr->new.gnice)) { + errno = ERANGE; + return 1; + } + stat_derive_unique(sum_ptr); +#ifdef CPU_IDLE_FORCED + /* if any cpu accumulated substantially fewer tics than what is expected | + we'll force it to be treated as 'idle' so as not to return misleading | + statistics (and that sum_ptr->count also serves as first time switch) | */ + if (sum_ptr->count) sum_ptr->edge = + ((sum_ptr->new.xtot - sum_ptr->old.xtot) / sum_ptr->count) / TICS_THRESHOLD; +#endif + + i = 0; +reap_em_again: + cpu_ptr = info->cpus.hist.tics + i; // adapt to relocated if reap_em_again + + do { + static int once_sw; + + bp = 1 + strchr(bp, '\n'); + // remember this cpu from last time around + memcpy(&cpu_ptr->old, &cpu_ptr->new, sizeof(struct stat_jifs)); + // next can be overridden under 'stat_make_numa_hist' + cpu_ptr->numa_node = STAT_NODE_INVALID; + cpu_ptr->count = 1; + +#ifdef __CYGWIN__ + if (4 > (rc = sscanf(bp, "cpu%d %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu" +#else + if (8 > (rc = sscanf(bp, "cpu%d %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu" +#endif + , &cpu_ptr->id + , &cpu_ptr->new.user, &cpu_ptr->new.nice, &cpu_ptr->new.system + , &cpu_ptr->new.idle, &cpu_ptr->new.iowait, &cpu_ptr->new.irq + , &cpu_ptr->new.sirq, &cpu_ptr->new.stolen + , &cpu_ptr->new.guest, &cpu_ptr->new.gnice))) { + break; // we must tolerate cpus taken offline + } + stat_derive_unique(cpu_ptr); + + // force a one time core link for cpu0 (if possible) ... + if (!once_sw) + once_sw = cpu_ptr->saved_id = -1; + + /* this happens if cpus are taken offline/brought back online + so we better force the proper current core association ... */ + if (cpu_ptr->saved_id != cpu_ptr->id) { + cpu_ptr->saved_id = cpu_ptr->id; + cpu_ptr->core = NULL; + stat_cores_link(info, cpu_ptr); + } + +#ifdef CPU_IDLE_FORCED + // first time through (that priming read) sum_ptr->edge will be zero | + if (cpu_ptr->new.xtot < sum_ptr->edge) { + cpu_ptr->old.xtot = cpu_ptr->old.xbsy = cpu_ptr->old.xidl = cpu_ptr->old.xusr = cpu_ptr->old.xsys + = cpu_ptr->new.xbsy = cpu_ptr->new.xusr = cpu_ptr->new.xsys = 0; + cpu_ptr->new.xtot = cpu_ptr->new.xidl = 1; + } +#endif + ++cpu_ptr; + ++i; + } while (i < info->cpus.hist.n_alloc); + + if (i == info->cpus.hist.n_alloc && rc >= 8) { + info->cpus.hist.n_alloc += NEWOLD_INCR; + info->cpus.hist.tics = realloc(info->cpus.hist.tics, info->cpus.hist.n_alloc * sizeof(struct hist_tic)); + if (!(info->cpus.hist.tics)) + return 1; + goto reap_em_again; + } + + info->cpus.total = info->cpus.hist.n_inuse = sum_ptr->count = i; + /* whoa, if a new cpu was brought online, we better + ensure that no new cores have now become visible */ + if (info->cpu_count_hwm < info->cpus.total) { + /* next means it's not the first time, so we'll re-verify. + otherwise, procps_stat_new() already setup any cores so + that they could be linked above during tics processing. */ + if (info->cpu_count_hwm) { + if (!stat_cores_verify(info)) + return 1; + } + info->cpu_count_hwm = info->cpus.total; + } + + // remember sys_hist stuff from last time around + memcpy(&info->sys_hist.old, &info->sys_hist.new, sizeof(struct stat_data)); + + llnum = 0; + if ((b = strstr(bp, "intr "))) + sscanf(b, "intr %llu", &llnum); + info->sys_hist.new.intr = llnum; + + llnum = 0; + if ((b = strstr(bp, "ctxt "))) + sscanf(b, "ctxt %llu", &llnum); + info->sys_hist.new.ctxt = llnum; + + llnum = 0; + if ((b = strstr(bp, "btime "))) + sscanf(b, "btime %llu", &llnum); + info->sys_hist.new.btime = llnum; + + llnum = 0; + if ((b = strstr(bp, "processes "))) + sscanf(b, "processes %llu", &llnum); + info->sys_hist.new.procs_created = llnum; + + llnum = 0; + if ((b = strstr(bp, "procs_blocked "))) + sscanf(b, "procs_blocked %llu", &llnum); + info->sys_hist.new.procs_blocked = llnum; + + llnum = 0; + if ((b = strstr(bp, "procs_running "))) + sscanf(b, "procs_running %llu", &llnum); + if (llnum) + llnum--; //exclude itself + info->sys_hist.new.procs_running = llnum; + + return 0; +} // end: stat_read_failed + + +/* + * stat_stacks_alloc(): + * + * Allocate and initialize one or more stacks each of which is anchored in an + * associated context structure. + * + * All such stacks will have their result structures properly primed with + * 'items', while the result itself will be zeroed. + * + * Returns a stack_extent struct anchoring the 'heads' of each new stack. + */ +static struct stacks_extent *stat_stacks_alloc ( + struct ext_support *this, + int maxstacks) +{ + struct stacks_extent *p_blob; + struct stat_stack **p_vect; + struct stat_stack *p_head; + size_t vect_size, head_size, list_size, blob_size; + void *v_head, *v_list; + int i; + + vect_size = sizeof(void *) * maxstacks; // size of the addr vectors | + vect_size += sizeof(void *); // plus NULL addr delimiter | + head_size = sizeof(struct stat_stack); // size of that head struct | + list_size = sizeof(struct stat_result) * this->items->num; // any single results stack | + blob_size = sizeof(struct stacks_extent); // the extent anchor itself | + blob_size += vect_size; // plus room for addr vects | + blob_size += head_size * maxstacks; // plus room for head thing | + blob_size += list_size * maxstacks; // plus room for our stacks | + + /* note: all of our memory is allocated in one single blob, facilitating a later free(). | + as a minimum, it is important that those result structures themselves always be | + contiguous within each stack since they are accessed through relative position. | */ + if (NULL == (p_blob = calloc(1, blob_size))) + return NULL; + + p_blob->next = this->extents; // push this extent onto... | + this->extents = p_blob; // ...some existing extents | + p_vect = (void *)p_blob + sizeof(struct stacks_extent); // prime our vector pointer | + p_blob->stacks = p_vect; // set actual vectors start | + v_head = (void *)p_vect + vect_size; // prime head pointer start | + v_list = v_head + (head_size * maxstacks); // prime our stacks pointer | + + for (i = 0; i < maxstacks; i++) { + p_head = (struct stat_stack *)v_head; + p_head->head = stat_itemize_stack((struct stat_result *)v_list, this->items->num, this->items->enums); + p_blob->stacks[i] = p_head; + v_list += list_size; + v_head += head_size; + } + p_blob->ext_numstacks = maxstacks; + return p_blob; +} // end: stat_stacks_alloc + + +static int stat_stacks_fetch ( + struct stat_info *info, + struct reap_support *this) +{ + #define n_alloc this->n_alloc + #define n_inuse this->hist.n_inuse + #define n_saved this->n_alloc_save + struct stacks_extent *ext; + int i; + + // initialize stuff ----------------------------------- + if (!this->anchor) { + if (!(this->anchor = calloc(sizeof(void *), STACKS_INCR))) + return -1; + n_alloc = STACKS_INCR; + } + if (!this->fetch.extents) { + if (!(ext = stat_stacks_alloc(&this->fetch, n_alloc))) + return -1; // here, errno was set to ENOMEM + memcpy(this->anchor, ext->stacks, sizeof(void *) * n_alloc); + } + + // iterate stuff -------------------------------------- + for (i = 0; i < n_inuse; i++) { + if (!(i < n_alloc)) { + n_alloc += STACKS_INCR; + if ((!(this->anchor = realloc(this->anchor, sizeof(void *) * n_alloc))) + || (!(ext = stat_stacks_alloc(&this->fetch, STACKS_INCR)))) + return -1; // here, errno was set to ENOMEM + memcpy(this->anchor + i, ext->stacks, sizeof(void *) * STACKS_INCR); + } + stat_assign_results(this->anchor[i], &info->sys_hist, &this->hist.tics[i]); + } + + // finalize stuff ------------------------------------- + /* note: we go to this trouble of maintaining a duplicate of the consolidated | + extent stacks addresses represented as our 'anchor' since these ptrs | + are exposed to a user (um, not that we don't trust 'em or anything). | + plus, we can NULL delimit these ptrs which we couldn't do otherwise. | */ + if (n_saved < i + 1) { + n_saved = i + 1; + if (!(this->result.stacks = realloc(this->result.stacks, sizeof(void *) * n_saved))) + return -1; + } + memcpy(this->result.stacks, this->anchor, sizeof(void *) * i); + this->result.stacks[i] = NULL; + this->result.total = i; + + // callers beware, this might be zero (maybe no libnuma.so) ... + return this->result.total; + #undef n_alloc + #undef n_inuse + #undef n_saved +} // end: stat_stacks_fetch + + +static int stat_stacks_reconfig_maybe ( + struct ext_support *this, + enum stat_item *items, + int numitems) +{ + if (stat_items_check_failed(numitems, items)) + return -1; + /* is this the first time or have things changed since we were last called? + if so, gotta' redo all of our stacks stuff ... */ + if (this->items->num != numitems + 1 + || memcmp(this->items->enums, items, sizeof(enum stat_item) * numitems)) { + // allow for our STAT_logical_end + if (!(this->items->enums = realloc(this->items->enums, sizeof(enum stat_item) * (numitems + 1)))) + return -1; + memcpy(this->items->enums, items, sizeof(enum stat_item) * numitems); + this->items->enums[numitems] = STAT_logical_end; + this->items->num = numitems + 1; + stat_extents_free_all(this); + return 1; + } + return 0; +} // end: stat_stacks_reconfig_maybe + + +static struct stat_stack *stat_update_single_stack ( + struct stat_info *info, + struct ext_support *this) +{ + if (!this->extents + && !(stat_stacks_alloc(this, 1))) + return NULL; + + stat_assign_results(this->extents->stacks[0], &info->sys_hist, &info->cpu_hist); + + return this->extents->stacks[0]; +} // end: stat_update_single_stack + + + +// ___ Public Functions ||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +// --- standard required functions -------------------------------------------- + +/* + * procps_stat_new: + * + * Create a new container to hold the stat information + * + * The initial refcount is 1, and needs to be decremented + * to release the resources of the structure. + * + * Returns: < 0 on failure, 0 on success along with + * a pointer to a new context struct + */ +PROCPS_EXPORT int procps_stat_new ( + struct stat_info **info) +{ + struct stat_info *p; + +#ifdef ITEMTABLE_DEBUG + int i, failed = 0; + for (i = 0; i < MAXTABLE(Item_table); i++) { + if (i != Item_table[i].enumnumb) { + fprintf(stderr, "%s: enum/table error: Item_table[%d] was %s, but its value is %d\n" + , __FILE__, i, Item_table[i].enum2str, Item_table[i].enumnumb); + failed = 1; + } + } + if (failed) _Exit(EXIT_FAILURE); +#endif + + if (info == NULL || *info != NULL) + return -EINVAL; + if (!(p = calloc(1, sizeof(struct stat_info)))) + return -ENOMEM; + if (!(p->stat_buf = calloc(1, BUFFER_INCR))) { + free(p); + return -ENOMEM; + } + p->stat_buf_size = BUFFER_INCR; + p->refcount = 1; + + p->results.cpus = &p->cpus.result; + p->results.numa = &p->nodes.result; + + // these 3 are for reap, sharing a single set of items + p->cpu_summary.items = p->cpus.fetch.items = p->nodes.fetch.items = &p->reap_items; + + // the select guy has its own set of items + p->select.items = &p->select_items; + + numa_init(); + + // identify the current P-cores and E-cores, if any + if (!stat_cores_verify(p)) { + procps_stat_unref(&p); + return -errno; + } + + /* do a priming read here for the following potential benefits: | + 1) ensure there will be no problems with subsequent access | + 2) make delta results potentially useful, even if 1st time | + 3) elimnate need for history distortions 1st time 'switch' | */ + if (stat_read_failed(p)) { + procps_stat_unref(&p); + return -errno; + } + + *info = p; + return 0; +} // end :procps_stat_new + + +PROCPS_EXPORT int procps_stat_ref ( + struct stat_info *info) +{ + if (info == NULL) + return -EINVAL; + + info->refcount++; + return info->refcount; +} // end: procps_stat_ref + + +PROCPS_EXPORT int procps_stat_unref ( + struct stat_info **info) +{ + if (info == NULL || *info == NULL) + return -EINVAL; + + (*info)->refcount--; + + if ((*info)->refcount < 1) { + int errno_sav = errno; + + if ((*info)->stat_fp) + fclose((*info)->stat_fp); + if ((*info)->stat_buf) + free((*info)->stat_buf); + + if ((*info)->cpus.anchor) + free((*info)->cpus.anchor); + if ((*info)->cpus.result.stacks) + free((*info)->cpus.result.stacks); + if ((*info)->cpus.hist.tics) + free((*info)->cpus.hist.tics); + if ((*info)->cpus.fetch.extents) + stat_extents_free_all(&(*info)->cpus.fetch); + + if ((*info)->nodes.anchor) + free((*info)->nodes.anchor); + if ((*info)->nodes.result.stacks) + free((*info)->nodes.result.stacks); + if ((*info)->nodes.hist.tics) + free((*info)->nodes.hist.tics); + if ((*info)->nodes.fetch.extents) + stat_extents_free_all(&(*info)->nodes.fetch); + + if ((*info)->cpu_summary.extents) + stat_extents_free_all(&(*info)->cpu_summary); + + if ((*info)->select.extents) + stat_extents_free_all(&(*info)->select); + + if ((*info)->reap_items.enums) + free((*info)->reap_items.enums); + if ((*info)->select_items.enums) + free((*info)->select_items.enums); + + if ((*info)->cores) { + struct stat_core *next, *this = (*info)->cores; + while (this) { + next = this->next; + free(this); + this = next; + }; + } + + numa_uninit(); + + free(*info); + *info = NULL; + + errno = errno_sav; + return 0; + } + return (*info)->refcount; +} // end: procps_stat_unref + + +// --- variable interface functions ------------------------------------------- + +PROCPS_EXPORT struct stat_result *procps_stat_get ( + struct stat_info *info, + enum stat_item item) +{ + time_t cur_secs; + + errno = EINVAL; + if (info == NULL) + return NULL; + if (item < 0 || item >= STAT_logical_end) + return NULL; + errno = 0; + + /* we will NOT read the source file with every call - rather, we'll offer + a granularity of 1 second between reads ... */ + cur_secs = time(NULL); + if (1 <= cur_secs - info->sav_secs) { + if (stat_read_failed(info)) + return NULL; + info->sav_secs = cur_secs; + } + + info->get_this.item = item; + // with 'get', we must NOT honor the usual 'noop' guarantee + info->get_this.result.ull_int = 0; + Item_table[item].setsfunc(&info->get_this, &info->sys_hist, &info->cpu_hist); + + return &info->get_this; +} // end: procps_stat_get + + +/* procps_stat_reap(): + * + * Harvest all the requested NUMA NODE and/or CPU information providing the + * result stacks along with totals and the cpu summary. + * + * Returns: pointer to a stat_reaped struct on success, NULL on error. + */ +PROCPS_EXPORT struct stat_reaped *procps_stat_reap ( + struct stat_info *info, + enum stat_reap_type what, + enum stat_item *items, + int numitems) +{ + int rc; + + errno = EINVAL; + if (info == NULL || items == NULL) + return NULL; + if (what != STAT_REAP_CPUS_ONLY && what != STAT_REAP_NUMA_NODES_TOO) + return NULL; + +#ifdef ENFORCE_LOGICAL +{ int i; + // those STAT_SYS_type enum's make sense only to 'select' ... + for (i = 0; i < numitems; i++) { + if (items[i] > STAT_TIC_highest) + return NULL; + } +} +#endif + if (0 > (rc = stat_stacks_reconfig_maybe(&info->cpu_summary, items, numitems))) + return NULL; // here, errno may be overridden with ENOMEM + if (rc) { + stat_extents_free_all(&info->cpus.fetch); + stat_extents_free_all(&info->nodes.fetch); + } + errno = 0; + + if (stat_read_failed(info)) + return NULL; + info->results.summary = stat_update_single_stack(info, &info->cpu_summary); + + /* unlike the other 'reap' functions, <stat> provides for two separate | + stacks pointer arrays exposed to callers. Thus, to keep our promise | + of NULL delimit we must ensure a minimal array for the optional one | */ + if (!info->nodes.result.stacks + && (!(info->nodes.result.stacks = malloc(sizeof(void *))))) + return NULL; + info->nodes.result.total = 0; + info->nodes.result.stacks[0] = NULL; + + switch (what) { + case STAT_REAP_CPUS_ONLY: + if (0 > stat_stacks_fetch(info, &info->cpus)) + return NULL; + break; + case STAT_REAP_NUMA_NODES_TOO: + /* note: if we're doing numa at all, we must do this numa history | + before we build (fetch) cpu stacks since that stat_read_failed | + guy always marks (temporarily) all the cpu node ids as invalid | */ + if (0 > stat_make_numa_hist(info)) + return NULL; + if (0 > stat_stacks_fetch(info, &info->nodes)) + return NULL; + if (0 > stat_stacks_fetch(info, &info->cpus)) + return NULL; + break; + default: + return NULL; + }; + + return &info->results; +} // end: procps_stat_reap + + +/* procps_stat_select(): + * + * Harvest all the requested TIC and/or SYS information then return + * it in a results stack. + * + * Returns: pointer to a stat_stack struct on success, NULL on error. + */ +PROCPS_EXPORT struct stat_stack *procps_stat_select ( + struct stat_info *info, + enum stat_item *items, + int numitems) +{ + errno = EINVAL; + if (info == NULL || items == NULL) + return NULL; + if (0 > stat_stacks_reconfig_maybe(&info->select, items, numitems)) + return NULL; // here, errno may be overridden with ENOMEM + errno = 0; + + if (stat_read_failed(info)) + return NULL; + + return stat_update_single_stack(info, &info->select); +} // end: procps_stat_select + + +/* + * procps_stat_sort(): + * + * Sort stacks anchored in the passed stack pointers array + * based on the designated sort enumerator and specified order. + * + * Returns those same addresses sorted. + * + * Note: all of the stacks must be homogeneous (of equal length and content). + */ +PROCPS_EXPORT struct stat_stack **procps_stat_sort ( + struct stat_info *info, + struct stat_stack *stacks[], + int numstacked, + enum stat_item sortitem, + enum stat_sort_order order) +{ + struct stat_result *p; + struct sort_parms parms; + int offset; + + errno = EINVAL; + if (info == NULL || stacks == NULL) + return NULL; + // a stat_item is currently unsigned, but we'll protect our future + if (sortitem < 0 || sortitem >= STAT_logical_end) + return NULL; + if (order != STAT_SORT_ASCEND && order != STAT_SORT_DESCEND) + return NULL; + if (numstacked < 2) + return stacks; + + offset = 0; + p = stacks[0]->head; + for (;;) { + if (p->item == sortitem) + break; + ++offset; + if (p->item >= STAT_logical_end) + return NULL; + ++p; + } + errno = 0; + + parms.offset = offset; + parms.order = order; + + qsort_r(stacks, numstacked, sizeof(void *), (QSR_t)Item_table[p->item].sortfunc, &parms); + return stacks; +} // end: procps_stat_sort + + +// --- special debugging function(s) ------------------------------------------ +/* + * The following isn't part of the normal programming interface. Rather, + * it exists to validate result types referenced in application programs. + * + * It's used only when: + * 1) the 'XTRA_PROCPS_DEBUG' has been defined, or + * 2) an #include of 'xtra-procps-debug.h' is used + */ + +PROCPS_EXPORT struct stat_result *xtra_stat_get ( + struct stat_info *info, + enum stat_item actual_enum, + const char *typestr, + const char *file, + int lineno) +{ + struct stat_result *r = procps_stat_get(info, actual_enum); + + if (actual_enum < 0 || actual_enum >= STAT_logical_end) { + fprintf(stderr, "%s line %d: invalid item = %d, type = %s\n" + , file, lineno, actual_enum, typestr); + } + if (r) { + char *str = Item_table[r->item].type2str; + if (str[0] + && (strcmp(typestr, str))) + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return r; +} // end: xtra_stat_get_ + + +PROCPS_EXPORT struct stat_result *xtra_stat_val ( + int relative_enum, + const char *typestr, + const struct stat_stack *stack, + struct stat_info *info, + const char *file, + int lineno) +{ + char *str; + int i; + + for (i = 0; stack->head[i].item < STAT_logical_end; i++) + ; + if (relative_enum < 0 || relative_enum >= i) { + fprintf(stderr, "%s line %d: invalid relative_enum = %d, valid range = 0-%d\n" + , file, lineno, relative_enum, i-1); + return NULL; + } + str = Item_table[stack->head[relative_enum].item].type2str; + if (str[0] + && (strcmp(typestr, str))) { + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return &stack->head[relative_enum]; + (void)info; +} // end: xtra_stat_val diff --git a/library/sysinfo.c b/library/sysinfo.c new file mode 100644 index 0000000..35a9922 --- /dev/null +++ b/library/sysinfo.c @@ -0,0 +1,167 @@ +/* + * File for parsing top-level /proc entities. + * + * Copyright © 2011-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2011-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 1998-2008 Albert Cahalan + * Copyright © 1992-1998 Michael K. Johnson <johnsonm@redhat.com> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include <locale.h> +#include <errno.h> + +#include <unistd.h> +#include <fcntl.h> +#ifdef __CYGWIN__ +#include <sys/param.h> +#endif +#include "misc.h" +#include "procps-private.h" + + +#define LOADAVG_FILE "/proc/loadavg" + +/* evals 'x' twice */ +#define SET_IF_DESIRED(x,y) do{ if(x) *(x) = (y); }while(0) + +/* return minimum of two values */ +#ifndef __CYGWIN__ +#define MIN(x,y) ((x) < (y) ? (x) : (y)) +#endif + +/* + * procps_hertz_get: + * + * + * Some values in /proc are expressed in units of 1/HZ seconds, where HZ + * is the kernel clock tick rate. One of these units is called a jiffy. + * The HZ value used in the kernel may vary according to hacker desire. + * + * On some architectures, the kernel provides an ELF note to indicate + * HZ. + * + * Returns: + * The discovered or assumed hertz value + */ +PROCPS_EXPORT long procps_hertz_get(void) +{ + long hz; + +#ifdef _SC_CLK_TCK + if ((hz = sysconf(_SC_CLK_TCK)) > 0) + return hz; +#endif +#ifdef HZ + return(HZ); +#endif + /* Last resort, assume 100 */ + return 100; +} + +/* + * procps_loadavg: + * @av1: location to store 1 minute load average + * @av5: location to store 5 minute load average + * @av15: location to store 15 minute load average + * + * Find the 1,5 and 15 minute load average of the system + * + * Returns: 0 on success <0 on error + */ +PROCPS_EXPORT int procps_loadavg( + double *restrict av1, + double *restrict av5, + double *restrict av15) +{ + double avg_1=0, avg_5=0, avg_15=0; + locale_t tmplocale; + int retval=0; + FILE *fp; + + if ((fp = fopen(LOADAVG_FILE, "r")) == NULL) + return -errno; + + tmplocale = newlocale(LC_NUMERIC_MASK, "C", (locale_t)0); + uselocale(tmplocale); + if (fscanf(fp, "%lf %lf %lf", &avg_1, &avg_5, &avg_15) < 3) + retval = -ERANGE; + + fclose(fp); + uselocale(LC_GLOBAL_LOCALE); + freelocale(tmplocale); + SET_IF_DESIRED(av1, avg_1); + SET_IF_DESIRED(av5, avg_5); + SET_IF_DESIRED(av15, avg_15); + return retval; +} + +///////////////////////////////////////////////////////////////////////////// + +#define PROCFS_PID_MAX "/proc/sys/kernel/pid_max" +#define DEFAULT_PID_LENGTH 5 + +/* + * procps_pid_length + * + * Return the length of the maximum possible pid. + * + * Returns either the strlen of PROCFS_PID_MAX or the + * best-guess DEFAULT_PID_LENGTH + */ +PROCPS_EXPORT unsigned int procps_pid_length(void) +{ + FILE *fp; + char pidbuf[24]; + static __thread int pid_length=0; + + if (pid_length) + return pid_length; + + pid_length = DEFAULT_PID_LENGTH; + if ((fp = fopen(PROCFS_PID_MAX, "r")) != NULL) { + if (fgets(pidbuf, sizeof(pidbuf), fp) != NULL) { + pid_length = strlen(pidbuf); + if (pidbuf[pid_length-1] == '\n') + --pid_length; + } + fclose(fp); + } + return pid_length; +} + +/////////////////////////////////////////////////////////////////////////// + +/* procps_cpu_count: + * + * Returns the number of CPUs that are currently online. + * + */ +long procps_cpu_count(void) +{ + long cpus; + + cpus = sysconf(_SC_NPROCESSORS_ONLN); + if (cpus < 1) + return 1; + return cpus; +} + diff --git a/library/tests/test_Itemtables.c b/library/tests/test_Itemtables.c new file mode 100644 index 0000000..4204700 --- /dev/null +++ b/library/tests/test_Itemtables.c @@ -0,0 +1,91 @@ +/* + * libprocps - Library to read proc filesystem + * Tests for Item_table/enumerator synchronization + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <stdlib.h> + +#include "diskstats.h" +#include "meminfo.h" +#include "pids.h" +#include "slabinfo.h" +#include "stat.h" +#include "vmstat.h" + +#include "tests.h" + +static int check_diskstats (void *data) { + struct diskstats_info *ctx = NULL; + testname = "Itemtable check, diskstats"; + if (0 == procps_diskstats_new(&ctx)) + procps_diskstats_unref(&ctx); + return 1; +} + +static int check_meminfo (void *data) { + struct meminfo_info *ctx = NULL; + testname = "Itemtable check, meminfo"; + if (0 == procps_meminfo_new(&ctx)) + procps_meminfo_unref(&ctx); + return 1; +} + +static int check_pids (void *data) { + struct pids_info *ctx = NULL; + testname = "Itemtable check, pids"; + if (0 == procps_pids_new(&ctx, NULL, 0)) + procps_pids_unref(&ctx); + return 1; +} + +static int check_slabinfo (void *data) { + struct slabinfo_info *ctx = NULL; + testname = "Itemtable check, slabinfo"; + if (0 == procps_slabinfo_new(&ctx)) + procps_slabinfo_unref(&ctx); + return 1; +} + +static int check_stat (void *data) { + struct stat_info *ctx = NULL; + testname = "Itemtable check, stat"; + if (0 == procps_stat_new(&ctx)) + procps_stat_unref(&ctx); + return 1; +} + +static int check_vmstat (void *data) { + struct vmstat_info *ctx = NULL; + testname = "Itemtable check, vmstat"; + if (0 == procps_vmstat_new(&ctx)) + procps_vmstat_unref(&ctx); + return 1; +} + +static TestFunction test_funcs[] = { + check_diskstats, + check_meminfo, + check_pids, + check_slabinfo, + check_stat, + check_vmstat, + NULL +}; + +int main (void) { + return run_tests(test_funcs, NULL); +} diff --git a/library/tests/test_namespace.c b/library/tests/test_namespace.c new file mode 100644 index 0000000..2c55c4f --- /dev/null +++ b/library/tests/test_namespace.c @@ -0,0 +1,76 @@ +/* + * libprocps - Library to read proc filesystem + * Tests for namespace library calls + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +#include "misc.h" +#include "tests.h" + +int check_name_minus(void *data) +{ + testname = "procps_ns_get_name() negative id"; + return (procps_ns_get_name(-1) == NULL); +} + +int check_name_over(void *data) +{ + testname = "procps_ns_get_name() id over limit"; + return (procps_ns_get_name(999) == NULL); +} + +int check_name_ipc(void *data) +{ + testname = "procps_ns_get_name() ipc"; + return (strcmp(procps_ns_get_name(PROCPS_NS_IPC),"ipc")==0); +} + +int check_id_null(void *data) +{ + testname = "procps_ns_get_id(NULL)"; + return (procps_ns_get_id(NULL) < 0); +} + +int check_id_unfound(void *data) +{ + testname = "procps_ns_get_id(unknown)"; + return (procps_ns_get_id("foobar") < 0); +} + +int check_id_mnt(void *data) +{ + testname = "procps_ns_get_id(mnt)"; + return (procps_ns_get_id("mnt") == PROCPS_NS_MNT); +} + +TestFunction test_funcs[] = { + check_name_minus, + check_name_over, + check_name_ipc, + check_id_null, + check_id_unfound, + check_id_mnt, + NULL +}; + +int main(int argc, char *argv[]) +{ + return run_tests(test_funcs, NULL); +} + diff --git a/library/tests/test_pids.c b/library/tests/test_pids.c new file mode 100644 index 0000000..eda0b73 --- /dev/null +++ b/library/tests/test_pids.c @@ -0,0 +1,75 @@ +/* + * libprocps - Library to read proc filesystem + * Tests for pids library calls + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#include <stdlib.h> +#include <stdio.h> +#include <errno.h> + +#include "pids.h" +#include "tests.h" + +enum pids_item items[] = { PIDS_ID_PID, PIDS_ID_PID }; +enum pids_item items2[] = { PIDS_ID_PID, PIDS_VM_RSS }; + +int check_pids_new_nullinfo(void *data) +{ + testname = "procps_pids_new() info=NULL returns -EINVAL"; + return (procps_pids_new(NULL, items, 0) == -EINVAL); +} + +int check_pids_new_toomany(void *data) +{ + struct pids_info *info; + testname = "procps_pids_new() too many items returns -EINVAL"; + return (procps_pids_new(&info, items, 1) == -EINVAL); +} + +int check_pids_new_and_unref(void *data) +{ + struct pids_info *info = NULL; + testname = "procps_pids new then unref"; + return ( (procps_pids_new(&info, items, 2) == 0) && + (procps_pids_unref(&info) == 0) && + info == NULL); +} + +int check_fatal_proc_unmounted(void *data) +{ + struct pids_info *info = NULL; + struct pids_stack *stack; + testname = "check_fatal_proc_unmounted"; + + return ( (procps_pids_new(&info, items2, 2) == 0) && + ( (stack = fatal_proc_unmounted(info, 1)) != NULL) && + ( PIDS_VAL(0, s_int, stack, info) > 0) && + ( PIDS_VAL(1, ul_int, stack, info) > 0)); +} + +TestFunction test_funcs[] = { + check_pids_new_nullinfo, + // skipped, ask Jim check_pids_new_toomany, + check_pids_new_and_unref, + check_fatal_proc_unmounted, + NULL }; + +int main(int argc, char *argv[]) +{ + return run_tests(test_funcs, NULL); +} + + diff --git a/library/tests/test_sysinfo.c b/library/tests/test_sysinfo.c new file mode 100644 index 0000000..8390ccd --- /dev/null +++ b/library/tests/test_sysinfo.c @@ -0,0 +1,64 @@ +/* + * libprocps - Library to read proc filesystem + * Tests for sysinfo library calls + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#include <stdlib.h> +#include <stdio.h> + +#include "misc.h" +#include "tests.h" + +int check_hertz(void *data) +{ + long hz; + testname = "procps_hertz_get()"; + + hz = procps_hertz_get(); + return (hz > 0); +} + +int check_loadavg(void *data) +{ + double a,b,c; + testname = "procps_loadavg()"; + + if (procps_loadavg(&a, &b, &c) == 0) + return 1; + return (a>0 && b>0 && c>0); +} + +int check_loadavg_null(void *data) +{ + testname = "procps_loadavg() with NULLs"; + if (procps_loadavg(NULL, NULL, NULL) == 0) + return 1; + return 0; +} + +TestFunction test_funcs[] = { + check_hertz, + check_loadavg, + check_loadavg_null, + NULL, +}; + +int main(int argc, char *argv[]) +{ + return run_tests(test_funcs, NULL); +} + + diff --git a/library/tests/test_uptime.c b/library/tests/test_uptime.c new file mode 100644 index 0000000..35d3e2e --- /dev/null +++ b/library/tests/test_uptime.c @@ -0,0 +1,97 @@ +/* + * libprocps - Library to read proc filesystem + * Tests for version library calls + * + * Copyright 2016 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#include <stdlib.h> +#include <stdio.h> + +#include "misc.h" +#include "tests.h" + +int check_uptime(void *data) +{ + testname = "procps_uptime()"; + double up=0, idle=0; + int rc; + rc = procps_uptime(&up, &idle); + return (rc == 0 && up > 0 && idle > 0); +} + +int check_uptime_nullup(void *data) +{ + double idle=0; + int rc; + testname = "procps_uptime() (up=NULL)"; + rc = procps_uptime(NULL, &idle); + return (rc == 0 && idle > 0); +} + +int check_uptime_nullidle(void *data) +{ + double up=0; + int rc; + testname = "procps_uptime() (idle=NULL)"; + rc = procps_uptime(&up, NULL); + return (rc == 0 && up > 0); +} + +int check_uptime_nullall(void *data) +{ + int rc; + testname = "procps_uptime() (up,idle=NULL)"; + rc = procps_uptime(NULL, NULL); + return (rc == 0); +} + +int check_uptime_sprint(void *data) +{ + char *str; + testname = "procps_uptime_sprint()"; + + str = procps_uptime_sprint(); + + return (str != NULL && str[0] != '\0'); +} + +int check_uptime_sprint_short(void *data) +{ + char *str; + testname = "procps_uptime_sprint_short()"; + + str = procps_uptime_sprint_short(); + + return (str != NULL && str[0] != '\0'); +} + +TestFunction test_funcs[] = { + check_uptime, + check_uptime_nullup, + check_uptime_nullidle, + check_uptime_nullall, + check_uptime_sprint, + check_uptime_sprint_short, + NULL, +}; + +int main(int argc, char *argv[]) +{ + return run_tests(test_funcs, NULL); +} + + diff --git a/library/tests/test_version.c b/library/tests/test_version.c new file mode 100644 index 0000000..f2f5e1f --- /dev/null +++ b/library/tests/test_version.c @@ -0,0 +1,72 @@ +/* + * libprocps - Library to read proc filesystem + * Tests for version library calls + * + * Copyright 2016 Craig Small <csmall@dropbear.xyz> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#include <stdlib.h> +#include <stdio.h> + +#include "misc.h" +#include "tests.h" + +int check_linux_version(void *data) +{ + testname = "procps_linux_version()"; + return (procps_linux_version() > 0); +} + +int check_conversion(void *data) +{ + testname = "LINUX_VERSION macro"; + struct testvals { + int retval; + int major, minor, patch; + }; + + struct testvals *tv; + struct testvals tvs[] = { + { 132096, 2, 4, 0 }, + { 132635, 2, 6, 27 }, + { 199936, 3, 13, 0 }, + { 263426, 4, 5, 2 }, + { 0, 0, 0, 0} + }; + + for (tv=tvs; tv->major != 0; tv++) + { + if (LINUX_VERSION(tv->major, tv->minor, tv->patch) != tv->retval) { + fprintf(stderr, "Failed %d != %d\n", LINUX_VERSION(tv->major, tv->minor, + tv->patch), tv->retval); + return 0; + } + } + return 1; +} + +TestFunction test_funcs[] = { + check_conversion, + check_linux_version, + NULL +}; + +int main(int argc, char *argv[]) +{ + return run_tests(test_funcs, NULL); +} + + diff --git a/library/uptime.c b/library/uptime.c new file mode 100644 index 0000000..1826343 --- /dev/null +++ b/library/uptime.c @@ -0,0 +1,268 @@ +/* + * uptime - uptime related functions - part of libproc2 + * + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 1998-2003 Albert Cahalan + * Copyright © 1992-1998 Michael K. Johnson <johnsonm@redhat.com> + * Copyright © 1993 J. Cowley + * Copyright © ???? Larry Greenfield <greenfie@gauss.rutgers.edu> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <errno.h> +#include <locale.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> +#include <utmp.h> +#ifdef WITH_SYSTEMD +#include <systemd/sd-daemon.h> +#include <systemd/sd-login.h> +#endif +#ifdef WITH_ELOGIND +#include <elogind/sd-daemon.h> +#include <elogind/sd-login.h> +#endif + +#include "misc.h" +#include "procps-private.h" + +#define UPTIME_FILE "/proc/uptime" + +static __thread char upbuf[256]; +static __thread char shortbuf[256]; + +static int count_users(void) +{ + int numuser = 0; + struct utmp *ut; + +#if defined(WITH_SYSTEMD) || defined(WITH_ELOGIND) + if (sd_booted() > 0) + return sd_get_sessions(NULL); +#endif + + setutent(); + while ((ut = getutent())) { + if ((ut->ut_type == USER_PROCESS) && (ut->ut_name[0] != '\0')) + numuser++; + } + endutent(); + + return numuser; +} + +/* + * uptime: + * + * Find the uptime and idle time of the system. + * These numbers are found in /proc/uptime + * Unlike other procps functions this closes the file each time + * Either uptime_secs or idle_secs can be null + * + * Returns: 0 on success and <0 on failure + */ +PROCPS_EXPORT int procps_uptime( + double *restrict uptime_secs, + double *restrict idle_secs) +{ + double up=0, idle=0; + locale_t tmplocale; + FILE *fp; + int rc; + + if ((fp = fopen(UPTIME_FILE, "r")) == NULL) + return -errno; + + tmplocale = newlocale(LC_NUMERIC_MASK, "C", (locale_t)0); + uselocale(tmplocale); + rc = fscanf(fp, "%lf %lf", &up, &idle); + fclose(fp); + uselocale(LC_GLOBAL_LOCALE); + freelocale(tmplocale); + + if (uptime_secs) + *uptime_secs = up; + if (idle_secs) + *idle_secs = idle; + + if (rc < 2) + return -ERANGE; + return 0; +} + +/* + * procps_uptime_sprint: + * + * Print current time in nice format + * + * Returns a statically allocated upbuf or NULL on error + */ +PROCPS_EXPORT char *procps_uptime_sprint(void) +{ + int upminutes, uphours, updays, users; + int pos; + time_t realseconds; + struct tm realtime; + double uptime_secs, idle_secs; + double av1, av5, av15; + + upbuf[0] = '\0'; + if (time(&realseconds) < 0) + return upbuf; + localtime_r(&realseconds, &realtime); + + if (procps_uptime(&uptime_secs, &idle_secs) < 0) + return upbuf; + + updays = ((int) uptime_secs / (60*60*24)); + uphours = ((int) uptime_secs / (60*60)) % 24; + upminutes = ((int) uptime_secs / (60)) % 60; + + pos = sprintf(upbuf, " %02d:%02d:%02d up ", + realtime.tm_hour, realtime.tm_min, realtime.tm_sec); + + if (updays) + pos += sprintf(upbuf + pos, "%d %s, ", updays, (updays > 1) ? "days" : "day"); + + if (uphours) + pos += sprintf(upbuf + pos, "%2d:%02d, ", uphours, upminutes); + else + pos += sprintf(upbuf + pos, "%d min, ", upminutes); + + users = count_users(); + procps_loadavg(&av1, &av5, &av15); + + if (users < 0) + pos += sprintf(upbuf + pos, " ? "); + else + pos += sprintf(upbuf + pos, "%2d ", users); + + pos += sprintf(upbuf + pos, "%s, load average: %.2f, %.2f, %.2f", + users > 1 ? "users" : "user", + av1, av5, av15); + + return upbuf; +} + +/* + * procps_uptime_sprint_short: + * + * Print current time in nice format + * + * Returns a statically allocated buffer or NULL on error + */ +PROCPS_EXPORT char *procps_uptime_sprint_short(void) +{ + int updecades, upyears, upweeks, updays, uphours = 0, upminutes = 0; + int pos = 3; + int comma = 0; + double uptime_secs, idle_secs; + + shortbuf[0] = '\0'; + if (procps_uptime(&uptime_secs, &idle_secs) < 0) + return shortbuf; + + if (uptime_secs>60*60*24*365*10) { + updecades = (int) uptime_secs / (60*60*24*365*10); + uptime_secs -= updecades*60*60*24*365*10; + } + else { + updecades = 0; + } + if (uptime_secs>60*60*24*365) { + upyears = (int) uptime_secs / (60*60*24*365); + uptime_secs -= upyears*60*60*24*365; + } + else { + upyears = 0; + } + if (uptime_secs>60*60*24*7) { + upweeks = (int) uptime_secs / (60*60*24*7); + uptime_secs -= upweeks*60*60*24*7; + } + else { + upweeks = 0; + } + if (uptime_secs>60*60*24) { + updays = (int) uptime_secs / (60*60*24); + uptime_secs -= updays*60*60*24; + } + else { + updays = 0; + } + if (uptime_secs>60*60) { + uphours = (int) uptime_secs / (60*60); + uptime_secs -= uphours*60*60; + } + if (uptime_secs>60) { + upminutes = (int) uptime_secs / 60; + uptime_secs -= upminutes*60; + } + /*updecades = (int) uptime_secs / (60*60*24*365*10); + upyears = ((int) uptime_secs / (60*60*24*365)) % 10; + upweeks = ((int) uptime_secs / (60*60*24*7)) % 52; + updays = ((int) uptime_secs / (60*60*24)) % 7; + uphours = ((int) uptime_secs / (60*60)) % 24; + upminutes = ((int) uptime_secs / (60)) % 60; +*/ + strcat(shortbuf, "up "); + + if (updecades) { + pos += sprintf(shortbuf + pos, "%d %s", + updecades, updecades > 1 ? "decades" : "decade"); + comma += 1; + } + + if (upyears) { + pos += sprintf(shortbuf + pos, "%s%d %s", + comma > 0 ? ", " : "", upyears, + upyears > 1 ? "years" : "year"); + comma += 1; + } + + if (upweeks) { + pos += sprintf(shortbuf + pos, "%s%d %s", + comma > 0 ? ", " : "", upweeks, + upweeks > 1 ? "weeks" : "week"); + comma += 1; + } + + if (updays) { + pos += sprintf(shortbuf + pos, "%s%d %s", + comma > 0 ? ", " : "", updays, + updays > 1 ? "days" : "day"); + comma += 1; + } + + if (uphours) { + pos += sprintf(shortbuf + pos, "%s%d %s", + comma > 0 ? ", " : "", uphours, + uphours > 1 ? "hours" : "hour"); + comma += 1; + } + + if (upminutes || (!upminutes && uptime_secs < 60)) { + pos += sprintf(shortbuf + pos, "%s%d %s", + comma > 0 ? ", " : "", upminutes, + upminutes != 1 ? "minutes" : "minute"); + comma += 1; + } + return shortbuf; +} diff --git a/library/version.c b/library/version.c new file mode 100644 index 0000000..eab3404 --- /dev/null +++ b/library/version.c @@ -0,0 +1,71 @@ +/* + * libproc2 - Library to read proc filesystem + * + * Copyright © 2002-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2013-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2011-2012 Sami Kerola <kerolasa@iki.fi> + * Copyright © 2002-2003 Albert Cahalan + * Copyright © 1996 Charles Blake <cblake@bbn.com> + * Copyright © 1995 Martin Schulze <joey@infodrom.north.de> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#include <errno.h> +#include <stdio.h> +#include "misc.h" +#include "procps-private.h" + +#ifdef __CYGWIN__ +#define PROCFS_OSRELEASE "/proc/version" +#define PROCFS_OSPATTERN "%*s version %u.%u.%u" +#else +#define PROCFS_OSRELEASE "/proc/sys/kernel/osrelease" +#define PROCFS_OSPATTERN "%u.%u.%u" +#endif + +/* + * procps_linux_version + * + * Return the current running Linux version release as shown in + * the procps filesystem. + * + * There are three ways you can get OS release: + * 1) /proc/sys/kernel/osrelease - returns correct version of procfs + * 2) /proc/version - returns version of kernel e.g. BSD this is wrong + * 3) uname and uts.release - same as /proc/version field #3 + * + * Returns: version as an integer + * Negative value means an error + */ +PROCPS_EXPORT int procps_linux_version(void) +{ + FILE *fp; + char buf[256]; + unsigned int x = 0, y = 0, z = 0; + int version_string_depth; + + if ((fp = fopen(PROCFS_OSRELEASE, "r")) == NULL) + return -errno; + if (fgets(buf, 256, fp) == NULL) { + fclose(fp); + return -EIO; + } + fclose(fp); + version_string_depth = sscanf(buf, PROCFS_OSPATTERN, &x, &y, &z); + if ((version_string_depth < 2) || /* Non-standard for all known kernels */ + ((version_string_depth < 3) && (x < 3))) /* Non-standard for 2.x.x kernels */ + return -ERANGE; + return LINUX_VERSION(x,y,z); +} diff --git a/library/vmstat.c b/library/vmstat.c new file mode 100644 index 0000000..f9ae715 --- /dev/null +++ b/library/vmstat.c @@ -0,0 +1,1513 @@ +/* + * vmstat.c - virtual memory related definitions for libproc2 + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2003 Albert Cahalan + * Copyright © 1996 Charles Blake <cblake@bbn.com> + * Copyright © 1995 Martin Schulze <joey@infodrom.north.de> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <errno.h> +#include <fcntl.h> +#include <search.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> + +#include <sys/stat.h> +#include <sys/types.h> + +#include "procps-private.h" +#include "vmstat.h" + + +#define VMSTAT_FILE "/proc/vmstat" +#define VMSTAT_BUFF 8192 + +/* ------------------------------------------------------------- + + this provision can be used to help ensure that our Item_table | + was synchronized with the enumerators found in the associated | + header file. It's intended to be used locally (& temporarily) | + at least once at some point prior to publishing new releases! | */ +// #define ITEMTABLE_DEBUG //----------------------------------- | +// ------------------------------------------------------------- + + +/* + * Perhaps someday we'll all learn what is in these fields. But | + * that might require available linux documentation progressing | + * beyond a state that was acknowledged in the following thread | + * + * http://www.spinics.net/lists/linux-man/msg09096.html + */ +struct vmstat_data { + unsigned long allocstall_dma; + unsigned long allocstall_dma32; + unsigned long allocstall_high; + unsigned long allocstall_movable; + unsigned long allocstall_normal; + unsigned long balloon_deflate; + unsigned long balloon_inflate; + unsigned long balloon_migrate; + unsigned long compact_daemon_free_scanned; + unsigned long compact_daemon_migrate_scanned; + unsigned long compact_daemon_wake; + unsigned long compact_fail; + unsigned long compact_free_scanned; + unsigned long compact_isolated; + unsigned long compact_migrate_scanned; + unsigned long compact_stall; + unsigned long compact_success; + unsigned long drop_pagecache; + unsigned long drop_slab; + unsigned long htlb_buddy_alloc_fail; + unsigned long htlb_buddy_alloc_success; + unsigned long kswapd_high_wmark_hit_quickly; + unsigned long kswapd_inodesteal; + unsigned long kswapd_low_wmark_hit_quickly; + unsigned long nr_active_anon; + unsigned long nr_active_file; + unsigned long nr_anon_pages; + unsigned long nr_anon_transparent_hugepages; + unsigned long nr_bounce; + unsigned long nr_dirtied; + unsigned long nr_dirty; + unsigned long nr_dirty_background_threshold; + unsigned long nr_dirty_threshold; + unsigned long nr_file_hugepages; + unsigned long nr_file_pages; + unsigned long nr_file_pmdmapped; + unsigned long nr_foll_pin_acquired; + unsigned long nr_foll_pin_released; + unsigned long nr_free_cma; + unsigned long nr_free_pages; + unsigned long nr_inactive_anon; + unsigned long nr_inactive_file; + unsigned long nr_isolated_anon; + unsigned long nr_isolated_file; + unsigned long nr_kernel_misc_reclaimable; + unsigned long nr_kernel_stack; + unsigned long nr_mapped; + unsigned long nr_mlock; + unsigned long nr_page_table_pages; + unsigned long nr_shadow_call_stack; + unsigned long nr_shmem; + unsigned long nr_shmem_hugepages; + unsigned long nr_shmem_pmdmapped; + unsigned long nr_slab_reclaimable; + unsigned long nr_slab_unreclaimable; +/* nr_tlb_local_flush_all; CONFIG_DEBUG_TLBFLUSH only */ +/* nr_tlb_local_flush_one; CONFIG_DEBUG_TLBFLUSH only */ +/* nr_tlb_remote_flush; CONFIG_DEBUG_TLBFLUSH only */ +/* nr_tlb_remote_flush_received; CONFIG_DEBUG_TLBFLUSH only */ + unsigned long nr_unevictable; + unsigned long nr_unstable; + unsigned long nr_vmscan_immediate_reclaim; + unsigned long nr_vmscan_write; + unsigned long nr_writeback; + unsigned long nr_writeback_temp; + unsigned long nr_written; + unsigned long nr_zone_active_anon; + unsigned long nr_zone_active_file; + unsigned long nr_zone_inactive_anon; + unsigned long nr_zone_inactive_file; + unsigned long nr_zone_unevictable; + unsigned long nr_zone_write_pending; + unsigned long nr_zspages; + unsigned long numa_foreign; + unsigned long numa_hint_faults; + unsigned long numa_hint_faults_local; + unsigned long numa_hit; + unsigned long numa_huge_pte_updates; + unsigned long numa_interleave; + unsigned long numa_local; + unsigned long numa_miss; + unsigned long numa_other; + unsigned long numa_pages_migrated; + unsigned long numa_pte_updates; + unsigned long oom_kill; + unsigned long pageoutrun; + unsigned long pgactivate; + unsigned long pgalloc_dma; + unsigned long pgalloc_dma32; + unsigned long pgalloc_high; + unsigned long pgalloc_movable; + unsigned long pgalloc_normal; + unsigned long pgdeactivate; + unsigned long pgfault; + unsigned long pgfree; + unsigned long pginodesteal; + unsigned long pglazyfree; + unsigned long pglazyfreed; + unsigned long pgmajfault; + unsigned long pgmigrate_fail; + unsigned long pgmigrate_success; + unsigned long pgpgin; + unsigned long pgpgout; + unsigned long pgrefill; + unsigned long pgrotated; + unsigned long pgscan_anon; + unsigned long pgscan_direct; + unsigned long pgscan_direct_throttle; + unsigned long pgscan_file; + unsigned long pgscan_kswapd; + unsigned long pgskip_dma; + unsigned long pgskip_dma32; + unsigned long pgskip_high; + unsigned long pgskip_movable; + unsigned long pgskip_normal; + unsigned long pgsteal_anon; + unsigned long pgsteal_direct; + unsigned long pgsteal_file; + unsigned long pgsteal_kswapd; + unsigned long pswpin; + unsigned long pswpout; + unsigned long slabs_scanned; + unsigned long swap_ra; + unsigned long swap_ra_hit; + unsigned long thp_collapse_alloc; + unsigned long thp_collapse_alloc_failed; + unsigned long thp_deferred_split_page; + unsigned long thp_fault_alloc; + unsigned long thp_fault_fallback; + unsigned long thp_fault_fallback_charge; + unsigned long thp_file_alloc; + unsigned long thp_file_fallback; + unsigned long thp_file_fallback_charge; + unsigned long thp_file_mapped; + unsigned long thp_split_page; + unsigned long thp_split_page_failed; + unsigned long thp_split_pmd; + unsigned long thp_split_pud; + unsigned long thp_swpout; + unsigned long thp_swpout_fallback; + unsigned long thp_zero_page_alloc; + unsigned long thp_zero_page_alloc_failed; + unsigned long unevictable_pgs_cleared; + unsigned long unevictable_pgs_culled; + unsigned long unevictable_pgs_mlocked; + unsigned long unevictable_pgs_munlocked; + unsigned long unevictable_pgs_rescued; + unsigned long unevictable_pgs_scanned; + unsigned long unevictable_pgs_stranded; +/* vmacache_find_calls; CONFIG_DEBUG_VM_VMACACHE only */ +/* vmacache_find_hits; CONFIG_DEBUG_VM_VMACACHE only */ + unsigned long workingset_activate; + unsigned long workingset_nodereclaim; + unsigned long workingset_nodes; + unsigned long workingset_refault; + unsigned long workingset_restore; + unsigned long zone_reclaim_failed; +}; + +struct vmstat_hist { + struct vmstat_data new; + struct vmstat_data old; +}; + +struct stacks_extent { + int ext_numstacks; + struct stacks_extent *next; + struct vmstat_stack **stacks; +}; + +struct vmstat_info { + int refcount; + int vmstat_fd; + struct vmstat_hist hist; + int numitems; + enum vmstat_item *items; + struct stacks_extent *extents; + struct hsearch_data hashtab; + struct vmstat_result get_this; + time_t sav_secs; +}; + + +// ___ Results 'Set' Support |||||||||||||||||||||||||||||||||||||||||||||||||| + +#define setNAME(e) set_vmstat_ ## e +#define setDECL(e) static void setNAME(e) \ + (struct vmstat_result *R, struct vmstat_hist *H) + +// regular assignment +#define REG_set(e,x) setDECL(e) { R->result.ul_int = H->new. x; } +// delta assignment +#define HST_set(e,x) setDECL(e) { R->result.sl_int = ( H->new. x - H->old. x ); } + +setDECL(noop) { (void)R; (void)H; } +setDECL(extra) { (void)H; R->result.ul_int = 0; } + +REG_set(ALLOCSTALL_DMA, allocstall_dma) +REG_set(ALLOCSTALL_DMA32, allocstall_dma32) +REG_set(ALLOCSTALL_HIGH, allocstall_high) +REG_set(ALLOCSTALL_MOVABLE, allocstall_movable) +REG_set(ALLOCSTALL_NORMAL, allocstall_normal) +REG_set(BALLOON_DEFLATE, balloon_deflate) +REG_set(BALLOON_INFLATE, balloon_inflate) +REG_set(BALLOON_MIGRATE, balloon_migrate) +REG_set(COMPACT_DAEMON_FREE_SCANNED, compact_daemon_free_scanned) +REG_set(COMPACT_DAEMON_MIGRATE_SCANNED, compact_daemon_migrate_scanned) +REG_set(COMPACT_DAEMON_WAKE, compact_daemon_wake) +REG_set(COMPACT_FAIL, compact_fail) +REG_set(COMPACT_FREE_SCANNED, compact_free_scanned) +REG_set(COMPACT_ISOLATED, compact_isolated) +REG_set(COMPACT_MIGRATE_SCANNED, compact_migrate_scanned) +REG_set(COMPACT_STALL, compact_stall) +REG_set(COMPACT_SUCCESS, compact_success) +REG_set(DROP_PAGECACHE, drop_pagecache) +REG_set(DROP_SLAB, drop_slab) +REG_set(HTLB_BUDDY_ALLOC_FAIL, htlb_buddy_alloc_fail) +REG_set(HTLB_BUDDY_ALLOC_SUCCESS, htlb_buddy_alloc_success) +REG_set(KSWAPD_HIGH_WMARK_HIT_QUICKLY, kswapd_high_wmark_hit_quickly) +REG_set(KSWAPD_INODESTEAL, kswapd_inodesteal) +REG_set(KSWAPD_LOW_WMARK_HIT_QUICKLY, kswapd_low_wmark_hit_quickly) +REG_set(NR_ACTIVE_ANON, nr_active_anon) +REG_set(NR_ACTIVE_FILE, nr_active_file) +REG_set(NR_ANON_PAGES, nr_anon_pages) +REG_set(NR_ANON_TRANSPARENT_HUGEPAGES, nr_anon_transparent_hugepages) +REG_set(NR_BOUNCE, nr_bounce) +REG_set(NR_DIRTIED, nr_dirtied) +REG_set(NR_DIRTY, nr_dirty) +REG_set(NR_DIRTY_BACKGROUND_THRESHOLD, nr_dirty_background_threshold) +REG_set(NR_DIRTY_THRESHOLD, nr_dirty_threshold) +REG_set(NR_FILE_HUGEPAGES, nr_file_hugepages) +REG_set(NR_FILE_PAGES, nr_file_pages) +REG_set(NR_FILE_PMDMAPPED, nr_file_pmdmapped) +REG_set(NR_FOLL_PIN_ACQUIRED, nr_foll_pin_acquired) +REG_set(NR_FOLL_PIN_RELEASED, nr_foll_pin_released) +REG_set(NR_FREE_CMA, nr_free_cma) +REG_set(NR_FREE_PAGES, nr_free_pages) +REG_set(NR_INACTIVE_ANON, nr_inactive_anon) +REG_set(NR_INACTIVE_FILE, nr_inactive_file) +REG_set(NR_ISOLATED_ANON, nr_isolated_anon) +REG_set(NR_ISOLATED_FILE, nr_isolated_file) +REG_set(NR_KERNEL_MISC_RECLAIMABLE, nr_kernel_misc_reclaimable) +REG_set(NR_KERNEL_STACK, nr_kernel_stack) +REG_set(NR_MAPPED, nr_mapped) +REG_set(NR_MLOCK, nr_mlock) +REG_set(NR_PAGE_TABLE_PAGES, nr_page_table_pages) +REG_set(NR_SHADOW_CALL_STACK, nr_shadow_call_stack) +REG_set(NR_SHMEM, nr_shmem) +REG_set(NR_SHMEM_HUGEPAGES, nr_shmem_hugepages) +REG_set(NR_SHMEM_PMDMAPPED, nr_shmem_pmdmapped) +REG_set(NR_SLAB_RECLAIMABLE, nr_slab_reclaimable) +REG_set(NR_SLAB_UNRECLAIMABLE, nr_slab_unreclaimable) +REG_set(NR_UNEVICTABLE, nr_unevictable) +REG_set(NR_UNSTABLE, nr_unstable) +REG_set(NR_VMSCAN_IMMEDIATE_RECLAIM, nr_vmscan_immediate_reclaim) +REG_set(NR_VMSCAN_WRITE, nr_vmscan_write) +REG_set(NR_WRITEBACK, nr_writeback) +REG_set(NR_WRITEBACK_TEMP, nr_writeback_temp) +REG_set(NR_WRITTEN, nr_written) +REG_set(NR_ZONE_ACTIVE_ANON, nr_zone_active_anon) +REG_set(NR_ZONE_ACTIVE_FILE, nr_zone_active_file) +REG_set(NR_ZONE_INACTIVE_ANON, nr_zone_inactive_anon) +REG_set(NR_ZONE_INACTIVE_FILE, nr_zone_inactive_file) +REG_set(NR_ZONE_UNEVICTABLE, nr_zone_unevictable) +REG_set(NR_ZONE_WRITE_PENDING, nr_zone_write_pending) +REG_set(NR_ZSPAGES, nr_zspages) +REG_set(NUMA_FOREIGN, numa_foreign) +REG_set(NUMA_HINT_FAULTS, numa_hint_faults) +REG_set(NUMA_HINT_FAULTS_LOCAL, numa_hint_faults_local) +REG_set(NUMA_HIT, numa_hit) +REG_set(NUMA_HUGE_PTE_UPDATES, numa_huge_pte_updates) +REG_set(NUMA_INTERLEAVE, numa_interleave) +REG_set(NUMA_LOCAL, numa_local) +REG_set(NUMA_MISS, numa_miss) +REG_set(NUMA_OTHER, numa_other) +REG_set(NUMA_PAGES_MIGRATED, numa_pages_migrated) +REG_set(NUMA_PTE_UPDATES, numa_pte_updates) +REG_set(OOM_KILL, oom_kill) +REG_set(PAGEOUTRUN, pageoutrun) +REG_set(PGACTIVATE, pgactivate) +REG_set(PGALLOC_DMA, pgalloc_dma) +REG_set(PGALLOC_DMA32, pgalloc_dma32) +REG_set(PGALLOC_HIGH, pgalloc_high) +REG_set(PGALLOC_MOVABLE, pgalloc_movable) +REG_set(PGALLOC_NORMAL, pgalloc_normal) +REG_set(PGDEACTIVATE, pgdeactivate) +REG_set(PGFAULT, pgfault) +REG_set(PGFREE, pgfree) +REG_set(PGINODESTEAL, pginodesteal) +REG_set(PGLAZYFREE, pglazyfree) +REG_set(PGLAZYFREED, pglazyfreed) +REG_set(PGMAJFAULT, pgmajfault) +REG_set(PGMIGRATE_FAIL, pgmigrate_fail) +REG_set(PGMIGRATE_SUCCESS, pgmigrate_success) +REG_set(PGPGIN, pgpgin) +REG_set(PGPGOUT, pgpgout) +REG_set(PGREFILL, pgrefill) +REG_set(PGROTATED, pgrotated) +REG_set(PGSCAN_ANON, pgscan_anon) +REG_set(PGSCAN_DIRECT, pgscan_direct) +REG_set(PGSCAN_DIRECT_THROTTLE, pgscan_direct_throttle) +REG_set(PGSCAN_FILE, pgscan_file) +REG_set(PGSCAN_KSWAPD, pgscan_kswapd) +REG_set(PGSKIP_DMA, pgskip_dma) +REG_set(PGSKIP_DMA32, pgskip_dma32) +REG_set(PGSKIP_HIGH, pgskip_high) +REG_set(PGSKIP_MOVABLE, pgskip_movable) +REG_set(PGSKIP_NORMAL, pgskip_normal) +REG_set(PGSTEAL_ANON, pgsteal_anon) +REG_set(PGSTEAL_DIRECT, pgsteal_direct) +REG_set(PGSTEAL_FILE, pgsteal_file) +REG_set(PGSTEAL_KSWAPD, pgsteal_kswapd) +REG_set(PSWPIN, pswpin) +REG_set(PSWPOUT, pswpout) +REG_set(SLABS_SCANNED, slabs_scanned) +REG_set(SWAP_RA, swap_ra) +REG_set(SWAP_RA_HIT, swap_ra_hit) +REG_set(THP_COLLAPSE_ALLOC, thp_collapse_alloc) +REG_set(THP_COLLAPSE_ALLOC_FAILED, thp_collapse_alloc_failed) +REG_set(THP_DEFERRED_SPLIT_PAGE, thp_deferred_split_page) +REG_set(THP_FAULT_ALLOC, thp_fault_alloc) +REG_set(THP_FAULT_FALLBACK, thp_fault_fallback) +REG_set(THP_FAULT_FALLBACK_CHARGE, thp_fault_fallback_charge) +REG_set(THP_FILE_ALLOC, thp_file_alloc) +REG_set(THP_FILE_FALLBACK, thp_file_fallback) +REG_set(THP_FILE_FALLBACK_CHARGE, thp_file_fallback_charge) +REG_set(THP_FILE_MAPPED, thp_file_mapped) +REG_set(THP_SPLIT_PAGE, thp_split_page) +REG_set(THP_SPLIT_PAGE_FAILED, thp_split_page_failed) +REG_set(THP_SPLIT_PMD, thp_split_pmd) +REG_set(THP_SPLIT_PUD, thp_split_pud) +REG_set(THP_SWPOUT, thp_swpout) +REG_set(THP_SWPOUT_FALLBACK, thp_swpout_fallback) +REG_set(THP_ZERO_PAGE_ALLOC, thp_zero_page_alloc) +REG_set(THP_ZERO_PAGE_ALLOC_FAILED, thp_zero_page_alloc_failed) +REG_set(UNEVICTABLE_PGS_CLEARED, unevictable_pgs_cleared) +REG_set(UNEVICTABLE_PGS_CULLED, unevictable_pgs_culled) +REG_set(UNEVICTABLE_PGS_MLOCKED, unevictable_pgs_mlocked) +REG_set(UNEVICTABLE_PGS_MUNLOCKED, unevictable_pgs_munlocked) +REG_set(UNEVICTABLE_PGS_RESCUED, unevictable_pgs_rescued) +REG_set(UNEVICTABLE_PGS_SCANNED, unevictable_pgs_scanned) +REG_set(UNEVICTABLE_PGS_STRANDED, unevictable_pgs_stranded) +REG_set(WORKINGSET_ACTIVATE, workingset_activate) +REG_set(WORKINGSET_NODERECLAIM, workingset_nodereclaim) +REG_set(WORKINGSET_NODES, workingset_nodes) +REG_set(WORKINGSET_REFAULT, workingset_refault) +REG_set(WORKINGSET_RESTORE, workingset_restore) +REG_set(ZONE_RECLAIM_FAILED, zone_reclaim_failed) + +HST_set(DELTA_ALLOCSTALL_DMA, allocstall_dma) +HST_set(DELTA_ALLOCSTALL_DMA32, allocstall_dma32) +HST_set(DELTA_ALLOCSTALL_HIGH, allocstall_high) +HST_set(DELTA_ALLOCSTALL_MOVABLE, allocstall_movable) +HST_set(DELTA_ALLOCSTALL_NORMAL, allocstall_normal) +HST_set(DELTA_BALLOON_DEFLATE, balloon_deflate) +HST_set(DELTA_BALLOON_INFLATE, balloon_inflate) +HST_set(DELTA_BALLOON_MIGRATE, balloon_migrate) +HST_set(DELTA_COMPACT_DAEMON_FREE_SCANNED, compact_daemon_free_scanned) +HST_set(DELTA_COMPACT_DAEMON_MIGRATE_SCANNED, compact_daemon_migrate_scanned) +HST_set(DELTA_COMPACT_DAEMON_WAKE, compact_daemon_wake) +HST_set(DELTA_COMPACT_FAIL, compact_fail) +HST_set(DELTA_COMPACT_FREE_SCANNED, compact_free_scanned) +HST_set(DELTA_COMPACT_ISOLATED, compact_isolated) +HST_set(DELTA_COMPACT_MIGRATE_SCANNED, compact_migrate_scanned) +HST_set(DELTA_COMPACT_STALL, compact_stall) +HST_set(DELTA_COMPACT_SUCCESS, compact_success) +HST_set(DELTA_DROP_PAGECACHE, drop_pagecache) +HST_set(DELTA_DROP_SLAB, drop_slab) +HST_set(DELTA_HTLB_BUDDY_ALLOC_FAIL, htlb_buddy_alloc_fail) +HST_set(DELTA_HTLB_BUDDY_ALLOC_SUCCESS, htlb_buddy_alloc_success) +HST_set(DELTA_KSWAPD_HIGH_WMARK_HIT_QUICKLY, kswapd_high_wmark_hit_quickly) +HST_set(DELTA_KSWAPD_INODESTEAL, kswapd_inodesteal) +HST_set(DELTA_KSWAPD_LOW_WMARK_HIT_QUICKLY, kswapd_low_wmark_hit_quickly) +HST_set(DELTA_NR_ACTIVE_ANON, nr_active_anon) +HST_set(DELTA_NR_ACTIVE_FILE, nr_active_file) +HST_set(DELTA_NR_ANON_PAGES, nr_anon_pages) +HST_set(DELTA_NR_ANON_TRANSPARENT_HUGEPAGES, nr_anon_transparent_hugepages) +HST_set(DELTA_NR_BOUNCE, nr_bounce) +HST_set(DELTA_NR_DIRTIED, nr_dirtied) +HST_set(DELTA_NR_DIRTY, nr_dirty) +HST_set(DELTA_NR_DIRTY_BACKGROUND_THRESHOLD, nr_dirty_background_threshold) +HST_set(DELTA_NR_DIRTY_THRESHOLD, nr_dirty_threshold) +HST_set(DELTA_NR_FILE_HUGEPAGES, nr_file_hugepages) +HST_set(DELTA_NR_FILE_PAGES, nr_file_pages) +HST_set(DELTA_NR_FILE_PMDMAPPED, nr_file_pmdmapped) +HST_set(DELTA_NR_FOLL_PIN_ACQUIRED, nr_foll_pin_acquired) +HST_set(DELTA_NR_FOLL_PIN_RELEASED, nr_foll_pin_released) +HST_set(DELTA_NR_FREE_CMA, nr_free_cma) +HST_set(DELTA_NR_FREE_PAGES, nr_free_pages) +HST_set(DELTA_NR_INACTIVE_ANON, nr_inactive_anon) +HST_set(DELTA_NR_INACTIVE_FILE, nr_inactive_file) +HST_set(DELTA_NR_ISOLATED_ANON, nr_isolated_anon) +HST_set(DELTA_NR_ISOLATED_FILE, nr_isolated_file) +HST_set(DELTA_NR_KERNEL_MISC_RECLAIMABLE, nr_kernel_misc_reclaimable) +HST_set(DELTA_NR_KERNEL_STACK, nr_kernel_stack) +HST_set(DELTA_NR_MAPPED, nr_mapped) +HST_set(DELTA_NR_MLOCK, nr_mlock) +HST_set(DELTA_NR_PAGE_TABLE_PAGES, nr_page_table_pages) +HST_set(DELTA_NR_SHADOW_CALL_STACK, nr_shadow_call_stack) +HST_set(DELTA_NR_SHMEM, nr_shmem) +HST_set(DELTA_NR_SHMEM_HUGEPAGES, nr_shmem_hugepages) +HST_set(DELTA_NR_SHMEM_PMDMAPPED, nr_shmem_pmdmapped) +HST_set(DELTA_NR_SLAB_RECLAIMABLE, nr_slab_reclaimable) +HST_set(DELTA_NR_SLAB_UNRECLAIMABLE, nr_slab_unreclaimable) +HST_set(DELTA_NR_UNEVICTABLE, nr_unevictable) +HST_set(DELTA_NR_UNSTABLE, nr_unstable) +HST_set(DELTA_NR_VMSCAN_IMMEDIATE_RECLAIM, nr_vmscan_immediate_reclaim) +HST_set(DELTA_NR_VMSCAN_WRITE, nr_vmscan_write) +HST_set(DELTA_NR_WRITEBACK, nr_writeback) +HST_set(DELTA_NR_WRITEBACK_TEMP, nr_writeback_temp) +HST_set(DELTA_NR_WRITTEN, nr_written) +HST_set(DELTA_NR_ZONE_ACTIVE_ANON, nr_zone_active_anon) +HST_set(DELTA_NR_ZONE_ACTIVE_FILE, nr_zone_active_file) +HST_set(DELTA_NR_ZONE_INACTIVE_ANON, nr_zone_inactive_anon) +HST_set(DELTA_NR_ZONE_INACTIVE_FILE, nr_zone_inactive_file) +HST_set(DELTA_NR_ZONE_UNEVICTABLE, nr_zone_unevictable) +HST_set(DELTA_NR_ZONE_WRITE_PENDING, nr_zone_write_pending) +HST_set(DELTA_NR_ZSPAGES, nr_zspages) +HST_set(DELTA_NUMA_FOREIGN, numa_foreign) +HST_set(DELTA_NUMA_HINT_FAULTS, numa_hint_faults) +HST_set(DELTA_NUMA_HINT_FAULTS_LOCAL, numa_hint_faults_local) +HST_set(DELTA_NUMA_HIT, numa_hit) +HST_set(DELTA_NUMA_HUGE_PTE_UPDATES, numa_huge_pte_updates) +HST_set(DELTA_NUMA_INTERLEAVE, numa_interleave) +HST_set(DELTA_NUMA_LOCAL, numa_local) +HST_set(DELTA_NUMA_MISS, numa_miss) +HST_set(DELTA_NUMA_OTHER, numa_other) +HST_set(DELTA_NUMA_PAGES_MIGRATED, numa_pages_migrated) +HST_set(DELTA_NUMA_PTE_UPDATES, numa_pte_updates) +HST_set(DELTA_OOM_KILL, oom_kill) +HST_set(DELTA_PAGEOUTRUN, pageoutrun) +HST_set(DELTA_PGACTIVATE, pgactivate) +HST_set(DELTA_PGALLOC_DMA, pgalloc_dma) +HST_set(DELTA_PGALLOC_DMA32, pgalloc_dma32) +HST_set(DELTA_PGALLOC_HIGH, pgalloc_high) +HST_set(DELTA_PGALLOC_MOVABLE, pgalloc_movable) +HST_set(DELTA_PGALLOC_NORMAL, pgalloc_normal) +HST_set(DELTA_PGDEACTIVATE, pgdeactivate) +HST_set(DELTA_PGFAULT, pgfault) +HST_set(DELTA_PGFREE, pgfree) +HST_set(DELTA_PGINODESTEAL, pginodesteal) +HST_set(DELTA_PGLAZYFREE, pglazyfree) +HST_set(DELTA_PGLAZYFREED, pglazyfreed) +HST_set(DELTA_PGMAJFAULT, pgmajfault) +HST_set(DELTA_PGMIGRATE_FAIL, pgmigrate_fail) +HST_set(DELTA_PGMIGRATE_SUCCESS, pgmigrate_success) +HST_set(DELTA_PGPGIN, pgpgin) +HST_set(DELTA_PGPGOUT, pgpgout) +HST_set(DELTA_PGREFILL, pgrefill) +HST_set(DELTA_PGROTATED, pgrotated) +HST_set(DELTA_PGSCAN_ANON, pgscan_anon) +HST_set(DELTA_PGSCAN_DIRECT, pgscan_direct) +HST_set(DELTA_PGSCAN_DIRECT_THROTTLE, pgscan_direct_throttle) +HST_set(DELTA_PGSCAN_FILE, pgscan_file) +HST_set(DELTA_PGSCAN_KSWAPD, pgscan_kswapd) +HST_set(DELTA_PGSKIP_DMA, pgskip_dma) +HST_set(DELTA_PGSKIP_DMA32, pgskip_dma32) +HST_set(DELTA_PGSKIP_HIGH, pgskip_high) +HST_set(DELTA_PGSKIP_MOVABLE, pgskip_movable) +HST_set(DELTA_PGSKIP_NORMAL, pgskip_normal) +HST_set(DELTA_PGSTEAL_ANON, pgsteal_anon) +HST_set(DELTA_PGSTEAL_DIRECT, pgsteal_direct) +HST_set(DELTA_PGSTEAL_FILE, pgsteal_file) +HST_set(DELTA_PGSTEAL_KSWAPD, pgsteal_kswapd) +HST_set(DELTA_PSWPIN, pswpin) +HST_set(DELTA_PSWPOUT, pswpout) +HST_set(DELTA_SLABS_SCANNED, slabs_scanned) +HST_set(DELTA_SWAP_RA, swap_ra) +HST_set(DELTA_SWAP_RA_HIT, swap_ra_hit) +HST_set(DELTA_THP_COLLAPSE_ALLOC, thp_collapse_alloc) +HST_set(DELTA_THP_COLLAPSE_ALLOC_FAILED, thp_collapse_alloc_failed) +HST_set(DELTA_THP_DEFERRED_SPLIT_PAGE, thp_deferred_split_page) +HST_set(DELTA_THP_FAULT_ALLOC, thp_fault_alloc) +HST_set(DELTA_THP_FAULT_FALLBACK, thp_fault_fallback) +HST_set(DELTA_THP_FAULT_FALLBACK_CHARGE, thp_fault_fallback_charge) +HST_set(DELTA_THP_FILE_ALLOC, thp_file_alloc) +HST_set(DELTA_THP_FILE_FALLBACK, thp_file_fallback) +HST_set(DELTA_THP_FILE_FALLBACK_CHARGE, thp_file_fallback_charge) +HST_set(DELTA_THP_FILE_MAPPED, thp_file_mapped) +HST_set(DELTA_THP_SPLIT_PAGE, thp_split_page) +HST_set(DELTA_THP_SPLIT_PAGE_FAILED, thp_split_page_failed) +HST_set(DELTA_THP_SPLIT_PMD, thp_split_pmd) +HST_set(DELTA_THP_SPLIT_PUD, thp_split_pud) +HST_set(DELTA_THP_SWPOUT, thp_swpout) +HST_set(DELTA_THP_SWPOUT_FALLBACK, thp_swpout_fallback) +HST_set(DELTA_THP_ZERO_PAGE_ALLOC, thp_zero_page_alloc) +HST_set(DELTA_THP_ZERO_PAGE_ALLOC_FAILED, thp_zero_page_alloc_failed) +HST_set(DELTA_UNEVICTABLE_PGS_CLEARED, unevictable_pgs_cleared) +HST_set(DELTA_UNEVICTABLE_PGS_CULLED, unevictable_pgs_culled) +HST_set(DELTA_UNEVICTABLE_PGS_MLOCKED, unevictable_pgs_mlocked) +HST_set(DELTA_UNEVICTABLE_PGS_MUNLOCKED, unevictable_pgs_munlocked) +HST_set(DELTA_UNEVICTABLE_PGS_RESCUED, unevictable_pgs_rescued) +HST_set(DELTA_UNEVICTABLE_PGS_SCANNED, unevictable_pgs_scanned) +HST_set(DELTA_UNEVICTABLE_PGS_STRANDED, unevictable_pgs_stranded) +HST_set(DELTA_WORKINGSET_ACTIVATE, workingset_activate) +HST_set(DELTA_WORKINGSET_NODERECLAIM, workingset_nodereclaim) +HST_set(DELTA_WORKINGSET_NODES, workingset_nodes) +HST_set(DELTA_WORKINGSET_REFAULT, workingset_refault) +HST_set(DELTA_WORKINGSET_RESTORE, workingset_restore) +HST_set(DELTA_ZONE_RECLAIM_FAILED, zone_reclaim_failed) + +#undef setDECL +#undef REG_set +#undef HST_set + + +// ___ Controlling Table |||||||||||||||||||||||||||||||||||||||||||||||||||||| + +typedef void (*SET_t)(struct vmstat_result *, struct vmstat_hist *); +#ifdef ITEMTABLE_DEBUG +#define RS(e) (SET_t)setNAME(e), VMSTAT_ ## e, STRINGIFY(VMSTAT_ ## e) +#else +#define RS(e) (SET_t)setNAME(e) +#endif + +#define TS(t) STRINGIFY(t) +#define TS_noop "" + + /* + * Need it be said? + * This table must be kept in the exact same order as + * those 'enum vmstat_item' guys ! */ +static struct { + SET_t setsfunc; // the actual result setting routine +#ifdef ITEMTABLE_DEBUG + int enumnumb; // enumerator (must match position!) + char *enum2str; // enumerator name as a char* string +#endif + char *type2str; // the result type as a string value +} Item_table[] = { +/* setsfunc type2str + ----------------------------------------- ---------- */ + { RS(noop), TS_noop }, + { RS(extra), TS_noop }, + + { RS(ALLOCSTALL_DMA), TS(ul_int) }, + { RS(ALLOCSTALL_DMA32), TS(ul_int) }, + { RS(ALLOCSTALL_HIGH), TS(ul_int) }, + { RS(ALLOCSTALL_MOVABLE), TS(ul_int) }, + { RS(ALLOCSTALL_NORMAL), TS(ul_int) }, + { RS(BALLOON_DEFLATE), TS(ul_int) }, + { RS(BALLOON_INFLATE), TS(ul_int) }, + { RS(BALLOON_MIGRATE), TS(ul_int) }, + { RS(COMPACT_DAEMON_FREE_SCANNED), TS(ul_int) }, + { RS(COMPACT_DAEMON_MIGRATE_SCANNED), TS(ul_int) }, + { RS(COMPACT_DAEMON_WAKE), TS(ul_int) }, + { RS(COMPACT_FAIL), TS(ul_int) }, + { RS(COMPACT_FREE_SCANNED), TS(ul_int) }, + { RS(COMPACT_ISOLATED), TS(ul_int) }, + { RS(COMPACT_MIGRATE_SCANNED), TS(ul_int) }, + { RS(COMPACT_STALL), TS(ul_int) }, + { RS(COMPACT_SUCCESS), TS(ul_int) }, + { RS(DROP_PAGECACHE), TS(ul_int) }, + { RS(DROP_SLAB), TS(ul_int) }, + { RS(HTLB_BUDDY_ALLOC_FAIL), TS(ul_int) }, + { RS(HTLB_BUDDY_ALLOC_SUCCESS), TS(ul_int) }, + { RS(KSWAPD_HIGH_WMARK_HIT_QUICKLY), TS(ul_int) }, + { RS(KSWAPD_INODESTEAL), TS(ul_int) }, + { RS(KSWAPD_LOW_WMARK_HIT_QUICKLY), TS(ul_int) }, + { RS(NR_ACTIVE_ANON), TS(ul_int) }, + { RS(NR_ACTIVE_FILE), TS(ul_int) }, + { RS(NR_ANON_PAGES), TS(ul_int) }, + { RS(NR_ANON_TRANSPARENT_HUGEPAGES), TS(ul_int) }, + { RS(NR_BOUNCE), TS(ul_int) }, + { RS(NR_DIRTIED), TS(ul_int) }, + { RS(NR_DIRTY), TS(ul_int) }, + { RS(NR_DIRTY_BACKGROUND_THRESHOLD), TS(ul_int) }, + { RS(NR_DIRTY_THRESHOLD), TS(ul_int) }, + { RS(NR_FILE_HUGEPAGES), TS(ul_int) }, + { RS(NR_FILE_PAGES), TS(ul_int) }, + { RS(NR_FILE_PMDMAPPED), TS(ul_int) }, + { RS(NR_FOLL_PIN_ACQUIRED), TS(ul_int) }, + { RS(NR_FOLL_PIN_RELEASED), TS(ul_int) }, + { RS(NR_FREE_CMA), TS(ul_int) }, + { RS(NR_FREE_PAGES), TS(ul_int) }, + { RS(NR_INACTIVE_ANON), TS(ul_int) }, + { RS(NR_INACTIVE_FILE), TS(ul_int) }, + { RS(NR_ISOLATED_ANON), TS(ul_int) }, + { RS(NR_ISOLATED_FILE), TS(ul_int) }, + { RS(NR_KERNEL_MISC_RECLAIMABLE), TS(ul_int) }, + { RS(NR_KERNEL_STACK), TS(ul_int) }, + { RS(NR_MAPPED), TS(ul_int) }, + { RS(NR_MLOCK), TS(ul_int) }, + { RS(NR_PAGE_TABLE_PAGES), TS(ul_int) }, + { RS(NR_SHADOW_CALL_STACK), TS(ul_int) }, + { RS(NR_SHMEM), TS(ul_int) }, + { RS(NR_SHMEM_HUGEPAGES), TS(ul_int) }, + { RS(NR_SHMEM_PMDMAPPED), TS(ul_int) }, + { RS(NR_SLAB_RECLAIMABLE), TS(ul_int) }, + { RS(NR_SLAB_UNRECLAIMABLE), TS(ul_int) }, + { RS(NR_UNEVICTABLE), TS(ul_int) }, + { RS(NR_UNSTABLE), TS(ul_int) }, + { RS(NR_VMSCAN_IMMEDIATE_RECLAIM), TS(ul_int) }, + { RS(NR_VMSCAN_WRITE), TS(ul_int) }, + { RS(NR_WRITEBACK), TS(ul_int) }, + { RS(NR_WRITEBACK_TEMP), TS(ul_int) }, + { RS(NR_WRITTEN), TS(ul_int) }, + { RS(NR_ZONE_ACTIVE_ANON), TS(ul_int) }, + { RS(NR_ZONE_ACTIVE_FILE), TS(ul_int) }, + { RS(NR_ZONE_INACTIVE_ANON), TS(ul_int) }, + { RS(NR_ZONE_INACTIVE_FILE), TS(ul_int) }, + { RS(NR_ZONE_UNEVICTABLE), TS(ul_int) }, + { RS(NR_ZONE_WRITE_PENDING), TS(ul_int) }, + { RS(NR_ZSPAGES), TS(ul_int) }, + { RS(NUMA_FOREIGN), TS(ul_int) }, + { RS(NUMA_HINT_FAULTS), TS(ul_int) }, + { RS(NUMA_HINT_FAULTS_LOCAL), TS(ul_int) }, + { RS(NUMA_HIT), TS(ul_int) }, + { RS(NUMA_HUGE_PTE_UPDATES), TS(ul_int) }, + { RS(NUMA_INTERLEAVE), TS(ul_int) }, + { RS(NUMA_LOCAL), TS(ul_int) }, + { RS(NUMA_MISS), TS(ul_int) }, + { RS(NUMA_OTHER), TS(ul_int) }, + { RS(NUMA_PAGES_MIGRATED), TS(ul_int) }, + { RS(NUMA_PTE_UPDATES), TS(ul_int) }, + { RS(OOM_KILL), TS(ul_int) }, + { RS(PAGEOUTRUN), TS(ul_int) }, + { RS(PGACTIVATE), TS(ul_int) }, + { RS(PGALLOC_DMA), TS(ul_int) }, + { RS(PGALLOC_DMA32), TS(ul_int) }, + { RS(PGALLOC_HIGH), TS(ul_int) }, + { RS(PGALLOC_MOVABLE), TS(ul_int) }, + { RS(PGALLOC_NORMAL), TS(ul_int) }, + { RS(PGDEACTIVATE), TS(ul_int) }, + { RS(PGFAULT), TS(ul_int) }, + { RS(PGFREE), TS(ul_int) }, + { RS(PGINODESTEAL), TS(ul_int) }, + { RS(PGLAZYFREE), TS(ul_int) }, + { RS(PGLAZYFREED), TS(ul_int) }, + { RS(PGMAJFAULT), TS(ul_int) }, + { RS(PGMIGRATE_FAIL), TS(ul_int) }, + { RS(PGMIGRATE_SUCCESS), TS(ul_int) }, + { RS(PGPGIN), TS(ul_int) }, + { RS(PGPGOUT), TS(ul_int) }, + { RS(PGREFILL), TS(ul_int) }, + { RS(PGROTATED), TS(ul_int) }, + { RS(PGSCAN_ANON), TS(ul_int) }, + { RS(PGSCAN_DIRECT), TS(ul_int) }, + { RS(PGSCAN_DIRECT_THROTTLE), TS(ul_int) }, + { RS(PGSCAN_FILE), TS(ul_int) }, + { RS(PGSCAN_KSWAPD), TS(ul_int) }, + { RS(PGSKIP_DMA), TS(ul_int) }, + { RS(PGSKIP_DMA32), TS(ul_int) }, + { RS(PGSKIP_HIGH), TS(ul_int) }, + { RS(PGSKIP_MOVABLE), TS(ul_int) }, + { RS(PGSKIP_NORMAL), TS(ul_int) }, + { RS(PGSTEAL_ANON), TS(ul_int) }, + { RS(PGSTEAL_DIRECT), TS(ul_int) }, + { RS(PGSTEAL_FILE), TS(ul_int) }, + { RS(PGSTEAL_KSWAPD), TS(ul_int) }, + { RS(PSWPIN), TS(ul_int) }, + { RS(PSWPOUT), TS(ul_int) }, + { RS(SLABS_SCANNED), TS(ul_int) }, + { RS(SWAP_RA), TS(ul_int) }, + { RS(SWAP_RA_HIT), TS(ul_int) }, + { RS(THP_COLLAPSE_ALLOC), TS(ul_int) }, + { RS(THP_COLLAPSE_ALLOC_FAILED), TS(ul_int) }, + { RS(THP_DEFERRED_SPLIT_PAGE), TS(ul_int) }, + { RS(THP_FAULT_ALLOC), TS(ul_int) }, + { RS(THP_FAULT_FALLBACK), TS(ul_int) }, + { RS(THP_FAULT_FALLBACK_CHARGE), TS(ul_int) }, + { RS(THP_FILE_ALLOC), TS(ul_int) }, + { RS(THP_FILE_FALLBACK), TS(ul_int) }, + { RS(THP_FILE_FALLBACK_CHARGE), TS(ul_int) }, + { RS(THP_FILE_MAPPED), TS(ul_int) }, + { RS(THP_SPLIT_PAGE), TS(ul_int) }, + { RS(THP_SPLIT_PAGE_FAILED), TS(ul_int) }, + { RS(THP_SPLIT_PMD), TS(ul_int) }, + { RS(THP_SPLIT_PUD), TS(ul_int) }, + { RS(THP_SWPOUT), TS(ul_int) }, + { RS(THP_SWPOUT_FALLBACK), TS(ul_int) }, + { RS(THP_ZERO_PAGE_ALLOC), TS(ul_int) }, + { RS(THP_ZERO_PAGE_ALLOC_FAILED), TS(ul_int) }, + { RS(UNEVICTABLE_PGS_CLEARED), TS(ul_int) }, + { RS(UNEVICTABLE_PGS_CULLED), TS(ul_int) }, + { RS(UNEVICTABLE_PGS_MLOCKED), TS(ul_int) }, + { RS(UNEVICTABLE_PGS_MUNLOCKED), TS(ul_int) }, + { RS(UNEVICTABLE_PGS_RESCUED), TS(ul_int) }, + { RS(UNEVICTABLE_PGS_SCANNED), TS(ul_int) }, + { RS(UNEVICTABLE_PGS_STRANDED), TS(ul_int) }, + { RS(WORKINGSET_ACTIVATE), TS(ul_int) }, + { RS(WORKINGSET_NODERECLAIM), TS(ul_int) }, + { RS(WORKINGSET_NODES), TS(ul_int) }, + { RS(WORKINGSET_REFAULT), TS(ul_int) }, + { RS(WORKINGSET_RESTORE), TS(ul_int) }, + { RS(ZONE_RECLAIM_FAILED), TS(ul_int) }, + + { RS(DELTA_ALLOCSTALL_DMA), TS(sl_int) }, + { RS(DELTA_ALLOCSTALL_DMA32), TS(sl_int) }, + { RS(DELTA_ALLOCSTALL_HIGH), TS(sl_int) }, + { RS(DELTA_ALLOCSTALL_MOVABLE), TS(sl_int) }, + { RS(DELTA_ALLOCSTALL_NORMAL), TS(sl_int) }, + { RS(DELTA_BALLOON_DEFLATE), TS(sl_int) }, + { RS(DELTA_BALLOON_INFLATE), TS(sl_int) }, + { RS(DELTA_BALLOON_MIGRATE), TS(sl_int) }, + { RS(DELTA_COMPACT_DAEMON_FREE_SCANNED), TS(sl_int) }, + { RS(DELTA_COMPACT_DAEMON_MIGRATE_SCANNED), TS(sl_int) }, + { RS(DELTA_COMPACT_DAEMON_WAKE), TS(sl_int) }, + { RS(DELTA_COMPACT_FAIL), TS(sl_int) }, + { RS(DELTA_COMPACT_FREE_SCANNED), TS(sl_int) }, + { RS(DELTA_COMPACT_ISOLATED), TS(sl_int) }, + { RS(DELTA_COMPACT_MIGRATE_SCANNED), TS(sl_int) }, + { RS(DELTA_COMPACT_STALL), TS(sl_int) }, + { RS(DELTA_COMPACT_SUCCESS), TS(sl_int) }, + { RS(DELTA_DROP_PAGECACHE), TS(sl_int) }, + { RS(DELTA_DROP_SLAB), TS(sl_int) }, + { RS(DELTA_HTLB_BUDDY_ALLOC_FAIL), TS(sl_int) }, + { RS(DELTA_HTLB_BUDDY_ALLOC_SUCCESS), TS(sl_int) }, + { RS(DELTA_KSWAPD_HIGH_WMARK_HIT_QUICKLY), TS(sl_int) }, + { RS(DELTA_KSWAPD_INODESTEAL), TS(sl_int) }, + { RS(DELTA_KSWAPD_LOW_WMARK_HIT_QUICKLY), TS(sl_int) }, + { RS(DELTA_NR_ACTIVE_ANON), TS(sl_int) }, + { RS(DELTA_NR_ACTIVE_FILE), TS(sl_int) }, + { RS(DELTA_NR_ANON_PAGES), TS(sl_int) }, + { RS(DELTA_NR_ANON_TRANSPARENT_HUGEPAGES), TS(sl_int) }, + { RS(DELTA_NR_BOUNCE), TS(sl_int) }, + { RS(DELTA_NR_DIRTIED), TS(sl_int) }, + { RS(DELTA_NR_DIRTY), TS(sl_int) }, + { RS(DELTA_NR_DIRTY_BACKGROUND_THRESHOLD), TS(sl_int) }, + { RS(DELTA_NR_DIRTY_THRESHOLD), TS(sl_int) }, + { RS(DELTA_NR_FILE_HUGEPAGES), TS(sl_int) }, + { RS(DELTA_NR_FILE_PAGES), TS(sl_int) }, + { RS(DELTA_NR_FILE_PMDMAPPED), TS(sl_int) }, + { RS(DELTA_NR_FOLL_PIN_ACQUIRED), TS(sl_int) }, + { RS(DELTA_NR_FOLL_PIN_RELEASED), TS(sl_int) }, + { RS(DELTA_NR_FREE_CMA), TS(sl_int) }, + { RS(DELTA_NR_FREE_PAGES), TS(sl_int) }, + { RS(DELTA_NR_INACTIVE_ANON), TS(sl_int) }, + { RS(DELTA_NR_INACTIVE_FILE), TS(sl_int) }, + { RS(DELTA_NR_ISOLATED_ANON), TS(sl_int) }, + { RS(DELTA_NR_ISOLATED_FILE), TS(sl_int) }, + { RS(DELTA_NR_KERNEL_MISC_RECLAIMABLE), TS(sl_int) }, + { RS(DELTA_NR_KERNEL_STACK), TS(sl_int) }, + { RS(DELTA_NR_MAPPED), TS(sl_int) }, + { RS(DELTA_NR_MLOCK), TS(sl_int) }, + { RS(DELTA_NR_PAGE_TABLE_PAGES), TS(sl_int) }, + { RS(DELTA_NR_SHADOW_CALL_STACK), TS(sl_int) }, + { RS(DELTA_NR_SHMEM), TS(sl_int) }, + { RS(DELTA_NR_SHMEM_HUGEPAGES), TS(sl_int) }, + { RS(DELTA_NR_SHMEM_PMDMAPPED), TS(sl_int) }, + { RS(DELTA_NR_SLAB_RECLAIMABLE), TS(sl_int) }, + { RS(DELTA_NR_SLAB_UNRECLAIMABLE), TS(sl_int) }, + { RS(DELTA_NR_UNEVICTABLE), TS(sl_int) }, + { RS(DELTA_NR_UNSTABLE), TS(sl_int) }, + { RS(DELTA_NR_VMSCAN_IMMEDIATE_RECLAIM), TS(sl_int) }, + { RS(DELTA_NR_VMSCAN_WRITE), TS(sl_int) }, + { RS(DELTA_NR_WRITEBACK), TS(sl_int) }, + { RS(DELTA_NR_WRITEBACK_TEMP), TS(sl_int) }, + { RS(DELTA_NR_WRITTEN), TS(sl_int) }, + { RS(DELTA_NR_ZONE_ACTIVE_ANON), TS(sl_int) }, + { RS(DELTA_NR_ZONE_ACTIVE_FILE), TS(sl_int) }, + { RS(DELTA_NR_ZONE_INACTIVE_ANON), TS(sl_int) }, + { RS(DELTA_NR_ZONE_INACTIVE_FILE), TS(sl_int) }, + { RS(DELTA_NR_ZONE_UNEVICTABLE), TS(sl_int) }, + { RS(DELTA_NR_ZONE_WRITE_PENDING), TS(sl_int) }, + { RS(DELTA_NR_ZSPAGES), TS(sl_int) }, + { RS(DELTA_NUMA_FOREIGN), TS(sl_int) }, + { RS(DELTA_NUMA_HINT_FAULTS), TS(sl_int) }, + { RS(DELTA_NUMA_HINT_FAULTS_LOCAL), TS(sl_int) }, + { RS(DELTA_NUMA_HIT), TS(sl_int) }, + { RS(DELTA_NUMA_HUGE_PTE_UPDATES), TS(sl_int) }, + { RS(DELTA_NUMA_INTERLEAVE), TS(sl_int) }, + { RS(DELTA_NUMA_LOCAL), TS(sl_int) }, + { RS(DELTA_NUMA_MISS), TS(sl_int) }, + { RS(DELTA_NUMA_OTHER), TS(sl_int) }, + { RS(DELTA_NUMA_PAGES_MIGRATED), TS(sl_int) }, + { RS(DELTA_NUMA_PTE_UPDATES), TS(sl_int) }, + { RS(DELTA_OOM_KILL), TS(sl_int) }, + { RS(DELTA_PAGEOUTRUN), TS(sl_int) }, + { RS(DELTA_PGACTIVATE), TS(sl_int) }, + { RS(DELTA_PGALLOC_DMA), TS(sl_int) }, + { RS(DELTA_PGALLOC_DMA32), TS(sl_int) }, + { RS(DELTA_PGALLOC_HIGH), TS(sl_int) }, + { RS(DELTA_PGALLOC_MOVABLE), TS(sl_int) }, + { RS(DELTA_PGALLOC_NORMAL), TS(sl_int) }, + { RS(DELTA_PGDEACTIVATE), TS(sl_int) }, + { RS(DELTA_PGFAULT), TS(sl_int) }, + { RS(DELTA_PGFREE), TS(sl_int) }, + { RS(DELTA_PGINODESTEAL), TS(sl_int) }, + { RS(DELTA_PGLAZYFREE), TS(sl_int) }, + { RS(DELTA_PGLAZYFREED), TS(sl_int) }, + { RS(DELTA_PGMAJFAULT), TS(sl_int) }, + { RS(DELTA_PGMIGRATE_FAIL), TS(sl_int) }, + { RS(DELTA_PGMIGRATE_SUCCESS), TS(sl_int) }, + { RS(DELTA_PGPGIN), TS(sl_int) }, + { RS(DELTA_PGPGOUT), TS(sl_int) }, + { RS(DELTA_PGREFILL), TS(sl_int) }, + { RS(DELTA_PGROTATED), TS(sl_int) }, + { RS(DELTA_PGSCAN_ANON), TS(sl_int) }, + { RS(DELTA_PGSCAN_DIRECT), TS(sl_int) }, + { RS(DELTA_PGSCAN_DIRECT_THROTTLE), TS(sl_int) }, + { RS(DELTA_PGSCAN_FILE), TS(sl_int) }, + { RS(DELTA_PGSCAN_KSWAPD), TS(sl_int) }, + { RS(DELTA_PGSKIP_DMA), TS(sl_int) }, + { RS(DELTA_PGSKIP_DMA32), TS(sl_int) }, + { RS(DELTA_PGSKIP_HIGH), TS(sl_int) }, + { RS(DELTA_PGSKIP_MOVABLE), TS(sl_int) }, + { RS(DELTA_PGSKIP_NORMAL), TS(sl_int) }, + { RS(DELTA_PGSTEAL_ANON), TS(sl_int) }, + { RS(DELTA_PGSTEAL_DIRECT), TS(sl_int) }, + { RS(DELTA_PGSTEAL_FILE), TS(sl_int) }, + { RS(DELTA_PGSTEAL_KSWAPD), TS(sl_int) }, + { RS(DELTA_PSWPIN), TS(sl_int) }, + { RS(DELTA_PSWPOUT), TS(sl_int) }, + { RS(DELTA_SLABS_SCANNED), TS(sl_int) }, + { RS(DELTA_SWAP_RA), TS(sl_int) }, + { RS(DELTA_SWAP_RA_HIT), TS(sl_int) }, + { RS(DELTA_THP_COLLAPSE_ALLOC), TS(sl_int) }, + { RS(DELTA_THP_COLLAPSE_ALLOC_FAILED), TS(sl_int) }, + { RS(DELTA_THP_DEFERRED_SPLIT_PAGE), TS(sl_int) }, + { RS(DELTA_THP_FAULT_ALLOC), TS(sl_int) }, + { RS(DELTA_THP_FAULT_FALLBACK), TS(sl_int) }, + { RS(DELTA_THP_FAULT_FALLBACK_CHARGE), TS(sl_int) }, + { RS(DELTA_THP_FILE_ALLOC), TS(sl_int) }, + { RS(DELTA_THP_FILE_FALLBACK), TS(sl_int) }, + { RS(DELTA_THP_FILE_FALLBACK_CHARGE), TS(sl_int) }, + { RS(DELTA_THP_FILE_MAPPED), TS(sl_int) }, + { RS(DELTA_THP_SPLIT_PAGE), TS(sl_int) }, + { RS(DELTA_THP_SPLIT_PAGE_FAILED), TS(sl_int) }, + { RS(DELTA_THP_SPLIT_PMD), TS(sl_int) }, + { RS(DELTA_THP_SPLIT_PUD), TS(sl_int) }, + { RS(DELTA_THP_SWPOUT), TS(sl_int) }, + { RS(DELTA_THP_SWPOUT_FALLBACK), TS(sl_int) }, + { RS(DELTA_THP_ZERO_PAGE_ALLOC), TS(sl_int) }, + { RS(DELTA_THP_ZERO_PAGE_ALLOC_FAILED), TS(sl_int) }, + { RS(DELTA_UNEVICTABLE_PGS_CLEARED), TS(sl_int) }, + { RS(DELTA_UNEVICTABLE_PGS_CULLED), TS(sl_int) }, + { RS(DELTA_UNEVICTABLE_PGS_MLOCKED), TS(sl_int) }, + { RS(DELTA_UNEVICTABLE_PGS_MUNLOCKED), TS(sl_int) }, + { RS(DELTA_UNEVICTABLE_PGS_RESCUED), TS(sl_int) }, + { RS(DELTA_UNEVICTABLE_PGS_SCANNED), TS(sl_int) }, + { RS(DELTA_UNEVICTABLE_PGS_STRANDED), TS(sl_int) }, + { RS(DELTA_WORKINGSET_ACTIVATE), TS(sl_int) }, + { RS(DELTA_WORKINGSET_NODERECLAIM), TS(sl_int) }, + { RS(DELTA_WORKINGSET_NODES), TS(sl_int) }, + { RS(DELTA_WORKINGSET_REFAULT), TS(sl_int) }, + { RS(DELTA_WORKINGSET_RESTORE), TS(sl_int) }, + { RS(DELTA_ZONE_RECLAIM_FAILED), TS(sl_int) }, +}; + + /* please note, + * this enum MUST be 1 greater than the highest value of any enum */ +enum vmstat_item VMSTAT_logical_end = MAXTABLE(Item_table); + +#undef setNAME +#undef RS + + +// ___ Private Functions |||||||||||||||||||||||||||||||||||||||||||||||||||||| + +static inline void vmstat_assign_results ( + struct vmstat_stack *stack, + struct vmstat_hist *hist) +{ + struct vmstat_result *this = stack->head; + + for (;;) { + enum vmstat_item item = this->item; + if (item >= VMSTAT_logical_end) + break; + Item_table[item].setsfunc(this, hist); + ++this; + } + return; +} // end: vmstat_assign_results + + +static void vmstat_extents_free_all ( + struct vmstat_info *info) +{ + while (info->extents) { + struct stacks_extent *p = info->extents; + info->extents = info->extents->next; + free(p); + }; +} // end: vmstat_extents_free_all + + +static inline struct vmstat_result *vmstat_itemize_stack ( + struct vmstat_result *p, + int depth, + enum vmstat_item *items) +{ + struct vmstat_result *p_sav = p; + int i; + + for (i = 0; i < depth; i++) { + p->item = items[i]; + ++p; + } + return p_sav; +} // end: vmstat_itemize_stack + + +static inline int vmstat_items_check_failed ( + int numitems, + enum vmstat_item *items) +{ + int i; + + /* if an enum is passed instead of an address of one or more enums, ol' gcc + * will silently convert it to an address (possibly NULL). only clang will + * offer any sort of warning like the following: + * + * warning: incompatible integer to pointer conversion passing 'int' to parameter of type 'enum vmstat_item *' + * my_stack = procps_vmstat_select(info, VMSTAT_noop, num); + * ^~~~~~~~~~~~~~~~ + */ + if (numitems < 1 + || (void *)items < (void *)(unsigned long)(2 * VMSTAT_logical_end)) + return 1; + + for (i = 0; i < numitems; i++) { + // a vmstat_item is currently unsigned, but we'll protect our future + if (items[i] < 0) + return 1; + if (items[i] >= VMSTAT_logical_end) + return 1; + } + + return 0; +} // end: vmstat_items_check_failed + + +static int vmstat_make_hash_failed ( + struct vmstat_info *info) +{ + #define htVAL(f) e.key = STRINGIFY(f); e.data = &info->hist.new. f; \ + if (!hsearch_r(e, ENTER, &ep, &info->hashtab)) return 1; + ENTRY e, *ep; + size_t n; + + n = sizeof(struct vmstat_data) / sizeof(unsigned long); + // we'll follow the hsearch recommendation of an extra 25% + if (!hcreate_r(n + (n / 4), &info->hashtab)) + return 1; + + htVAL(allocstall_dma) + htVAL(allocstall_dma32) + htVAL(allocstall_high) + htVAL(allocstall_movable) + htVAL(allocstall_normal) + htVAL(balloon_deflate) + htVAL(balloon_inflate) + htVAL(balloon_migrate) + htVAL(compact_daemon_free_scanned) + htVAL(compact_daemon_migrate_scanned) + htVAL(compact_daemon_wake) + htVAL(compact_fail) + htVAL(compact_free_scanned) + htVAL(compact_isolated) + htVAL(compact_migrate_scanned) + htVAL(compact_stall) + htVAL(compact_success) + htVAL(drop_pagecache) + htVAL(drop_slab) + htVAL(htlb_buddy_alloc_fail) + htVAL(htlb_buddy_alloc_success) + htVAL(kswapd_high_wmark_hit_quickly) + htVAL(kswapd_inodesteal) + htVAL(kswapd_low_wmark_hit_quickly) + htVAL(nr_active_anon) + htVAL(nr_active_file) + htVAL(nr_anon_pages) + htVAL(nr_anon_transparent_hugepages) + htVAL(nr_bounce) + htVAL(nr_dirtied) + htVAL(nr_dirty) + htVAL(nr_dirty_background_threshold) + htVAL(nr_dirty_threshold) + htVAL(nr_file_hugepages) + htVAL(nr_file_pages) + htVAL(nr_file_pmdmapped) + htVAL(nr_foll_pin_acquired) + htVAL(nr_foll_pin_released) + htVAL(nr_free_cma) + htVAL(nr_free_pages) + htVAL(nr_inactive_anon) + htVAL(nr_inactive_file) + htVAL(nr_isolated_anon) + htVAL(nr_isolated_file) + htVAL(nr_kernel_misc_reclaimable) + htVAL(nr_kernel_stack) + htVAL(nr_mapped) + htVAL(nr_mlock) + htVAL(nr_page_table_pages) + htVAL(nr_shadow_call_stack) + htVAL(nr_shmem) + htVAL(nr_shmem_hugepages) + htVAL(nr_shmem_pmdmapped) + htVAL(nr_slab_reclaimable) + htVAL(nr_slab_unreclaimable) + htVAL(nr_unevictable) + htVAL(nr_unstable) + htVAL(nr_vmscan_immediate_reclaim) + htVAL(nr_vmscan_write) + htVAL(nr_writeback) + htVAL(nr_writeback_temp) + htVAL(nr_written) + htVAL(nr_zone_active_anon) + htVAL(nr_zone_active_file) + htVAL(nr_zone_inactive_anon) + htVAL(nr_zone_inactive_file) + htVAL(nr_zone_unevictable) + htVAL(nr_zone_write_pending) + htVAL(nr_zspages) + htVAL(numa_foreign) + htVAL(numa_hint_faults) + htVAL(numa_hint_faults_local) + htVAL(numa_hit) + htVAL(numa_huge_pte_updates) + htVAL(numa_interleave) + htVAL(numa_local) + htVAL(numa_miss) + htVAL(numa_other) + htVAL(numa_pages_migrated) + htVAL(numa_pte_updates) + htVAL(oom_kill) + htVAL(pageoutrun) + htVAL(pgactivate) + htVAL(pgalloc_dma) + htVAL(pgalloc_dma32) + htVAL(pgalloc_high) + htVAL(pgalloc_movable) + htVAL(pgalloc_normal) + htVAL(pgdeactivate) + htVAL(pgfault) + htVAL(pgfree) + htVAL(pginodesteal) + htVAL(pglazyfree) + htVAL(pglazyfreed) + htVAL(pgmajfault) + htVAL(pgmigrate_fail) + htVAL(pgmigrate_success) + htVAL(pgpgin) + htVAL(pgpgout) + htVAL(pgrefill) + htVAL(pgrotated) + htVAL(pgscan_anon) + htVAL(pgscan_direct) + htVAL(pgscan_direct_throttle) + htVAL(pgscan_file) + htVAL(pgscan_kswapd) + htVAL(pgskip_dma) + htVAL(pgskip_dma32) + htVAL(pgskip_high) + htVAL(pgskip_movable) + htVAL(pgskip_normal) + htVAL(pgsteal_anon) + htVAL(pgsteal_direct) + htVAL(pgsteal_file) + htVAL(pgsteal_kswapd) + htVAL(pswpin) + htVAL(pswpout) + htVAL(slabs_scanned) + htVAL(swap_ra) + htVAL(swap_ra_hit) + htVAL(thp_collapse_alloc) + htVAL(thp_collapse_alloc_failed) + htVAL(thp_deferred_split_page) + htVAL(thp_fault_alloc) + htVAL(thp_fault_fallback) + htVAL(thp_fault_fallback_charge) + htVAL(thp_file_alloc) + htVAL(thp_file_fallback) + htVAL(thp_file_fallback_charge) + htVAL(thp_file_mapped) + htVAL(thp_split_page) + htVAL(thp_split_page_failed) + htVAL(thp_split_pmd) + htVAL(thp_split_pud) + htVAL(thp_swpout) + htVAL(thp_swpout_fallback) + htVAL(thp_zero_page_alloc) + htVAL(thp_zero_page_alloc_failed) + htVAL(unevictable_pgs_cleared) + htVAL(unevictable_pgs_culled) + htVAL(unevictable_pgs_mlocked) + htVAL(unevictable_pgs_munlocked) + htVAL(unevictable_pgs_rescued) + htVAL(unevictable_pgs_scanned) + htVAL(unevictable_pgs_stranded) + htVAL(workingset_activate) + htVAL(workingset_nodereclaim) + htVAL(workingset_nodes) + htVAL(workingset_refault) + htVAL(workingset_restore) + htVAL(zone_reclaim_failed) + + return 0; + #undef htVAL +} // end: vmstat_make_hash_failed + + +/* + * vmstat_read_failed(): + * + * Read the data out of /proc/vmstat putting the information + * into the supplied info structure + */ +static int vmstat_read_failed ( + struct vmstat_info *info) +{ + char buf[VMSTAT_BUFF]; + char *head, *tail; + int size; + unsigned long *valptr; + + // remember history from last time around + memcpy(&info->hist.old, &info->hist.new, sizeof(struct vmstat_data)); + // clear out the soon to be 'current' values + memset(&info->hist.new, 0, sizeof(struct vmstat_data)); + +#ifndef __CYGWIN__ /* /proc/vmstat does not exist */ + if (-1 == info->vmstat_fd + && (-1 == (info->vmstat_fd = open(VMSTAT_FILE, O_RDONLY)))) + return 1; + + if (lseek(info->vmstat_fd, 0L, SEEK_SET) == -1) + return 1; + + for (;;) { + if ((size = read(info->vmstat_fd, buf, sizeof(buf)-1)) < 0) { + if (errno == EINTR || errno == EAGAIN) + continue; + return 1; + } + break; + } + if (size == 0) { + errno = EIO; + return 1; + } + buf[size] = '\0'; + + head = buf; + + for (;;) { + static __thread ENTRY e; // keep coverity off our backs (e.data) + ENTRY *ep; + + if (!(tail = strchr(head, ' '))) + break; + *tail = '\0'; + valptr = NULL; + + e.key = head; + if (hsearch_r(e, FIND, &ep, &info->hashtab)) + valptr = ep->data; + head = tail + 1; + if (valptr) + *valptr = strtoul(head, NULL, 10); + + if (!(tail = strchr(head, '\n'))) + break; + head = tail + 1; + } +#endif /* !__CYGWIN__ */ + return 0; +} // end: vmstat_read_failed + + +/* + * vmstat_stacks_alloc(): + * + * Allocate and initialize one or more stacks each of which is anchored in an + * associated context structure. + * + * All such stacks will have their result structures properly primed with + * 'items', while the result itself will be zeroed. + * + * Returns a stacks_extent struct anchoring the 'heads' of each new stack. + */ +static struct stacks_extent *vmstat_stacks_alloc ( + struct vmstat_info *info, + int maxstacks) +{ + struct stacks_extent *p_blob; + struct vmstat_stack **p_vect; + struct vmstat_stack *p_head; + size_t vect_size, head_size, list_size, blob_size; + void *v_head, *v_list; + int i; + + vect_size = sizeof(void *) * maxstacks; // size of the addr vectors | + vect_size += sizeof(void *); // plus NULL addr delimiter | + head_size = sizeof(struct vmstat_stack); // size of that head struct | + list_size = sizeof(struct vmstat_result)*info->numitems; // any single results stack | + blob_size = sizeof(struct stacks_extent); // the extent anchor itself | + blob_size += vect_size; // plus room for addr vects | + blob_size += head_size * maxstacks; // plus room for head thing | + blob_size += list_size * maxstacks; // plus room for our stacks | + + /* note: all of our memory is allocated in a single blob, facilitating a later free(). | + as a minimum, it is important that the result structures themselves always be | + contiguous for every stack since they are accessed through relative position. | */ + if (NULL == (p_blob = calloc(1, blob_size))) + return NULL; + + p_blob->next = info->extents; // push this extent onto... | + info->extents = p_blob; // ...some existing extents | + p_vect = (void *)p_blob + sizeof(struct stacks_extent); // prime our vector pointer | + p_blob->stacks = p_vect; // set actual vectors start | + v_head = (void *)p_vect + vect_size; // prime head pointer start | + v_list = v_head + (head_size * maxstacks); // prime our stacks pointer | + + for (i = 0; i < maxstacks; i++) { + p_head = (struct vmstat_stack *)v_head; + p_head->head = vmstat_itemize_stack((struct vmstat_result *)v_list, info->numitems, info->items); + p_blob->stacks[i] = p_head; + v_list += list_size; + v_head += head_size; + } + p_blob->ext_numstacks = maxstacks; + return p_blob; +} // end: vmstat_stacks_alloc + + +// ___ Public Functions ||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +// --- standard required functions -------------------------------------------- + +/* + * procps_vmstat_new: + * + * Create a new container to hold the stat information + * + * The initial refcount is 1, and needs to be decremented + * to release the resources of the structure. + * + * Returns: < 0 on failure, 0 on success along with + * a pointer to a new context struct + */ +PROCPS_EXPORT int procps_vmstat_new ( + struct vmstat_info **info) +{ + struct vmstat_info *p; + +#ifdef ITEMTABLE_DEBUG + int i, failed = 0; + for (i = 0; i < MAXTABLE(Item_table); i++) { + if (i != Item_table[i].enumnumb) { + fprintf(stderr, "%s: enum/table error: Item_table[%d] was %s, but its value is %d\n" + , __FILE__, i, Item_table[i].enum2str, Item_table[i].enumnumb); + failed = 1; + } + } + if (failed) _Exit(EXIT_FAILURE); +#endif + + if (info == NULL || *info != NULL) + return -EINVAL; + if (!(p = calloc(1, sizeof(struct vmstat_info)))) + return -ENOMEM; + + p->refcount = 1; + p->vmstat_fd = -1; + + if (vmstat_make_hash_failed(p)) { + free(p); + return -errno; + } + + /* do a priming read here for the following potential benefits: | + 1) ensure there will be no problems with subsequent access | + 2) make delta results potentially useful, even if 1st time | + 3) elimnate need for history distortions 1st time 'switch' | */ + if (vmstat_read_failed(p)) { + procps_vmstat_unref(&p); + return -errno; + } + + *info = p; + return 0; +} // end: procps_vmstat_new + + +PROCPS_EXPORT int procps_vmstat_ref ( + struct vmstat_info *info) +{ + if (info == NULL) + return -EINVAL; + + info->refcount++; + return info->refcount; +} // end: procps_vmstat_ref + + +PROCPS_EXPORT int procps_vmstat_unref ( + struct vmstat_info **info) +{ + if (info == NULL || *info == NULL) + return -EINVAL; + + (*info)->refcount--; + + if ((*info)->refcount < 1) { + int errno_sav = errno; + + if ((*info)->vmstat_fd != -1) + close((*info)->vmstat_fd); + + if ((*info)->extents) + vmstat_extents_free_all((*info)); + if ((*info)->items) + free((*info)->items); + hdestroy_r(&(*info)->hashtab); + + free(*info); + *info = NULL; + + errno = errno_sav; + return 0; + } + return (*info)->refcount; +} // end: procps_vmstat_unref + + +// --- variable interface functions ------------------------------------------- + +PROCPS_EXPORT struct vmstat_result *procps_vmstat_get ( + struct vmstat_info *info, + enum vmstat_item item) +{ + time_t cur_secs; + + errno = EINVAL; + if (info == NULL) + return NULL; + if (item < 0 || item >= VMSTAT_logical_end) + return NULL; + errno = 0; + + /* we will NOT read the vmstat file with every call - rather, we'll offer + a granularity of 1 second between reads ... */ + cur_secs = time(NULL); + if (1 <= cur_secs - info->sav_secs) { + if (vmstat_read_failed(info)) + return NULL; + info->sav_secs = cur_secs; + } + + info->get_this.item = item; + // with 'get', we must NOT honor the usual 'noop' guarantee + info->get_this.result.ul_int = 0; + Item_table[item].setsfunc(&info->get_this, &info->hist); + + return &info->get_this; +} // end: procps_vmstat_get + + +/* procps_vmstat_select(): + * + * Harvest all the requested /proc/vmstat information then return + * it in a results stack. + * + * Returns: pointer to a vmstat_stack struct on success, NULL on error. + */ +PROCPS_EXPORT struct vmstat_stack *procps_vmstat_select ( + struct vmstat_info *info, + enum vmstat_item *items, + int numitems) +{ + errno = EINVAL; + if (info == NULL || items == NULL) + return NULL; + if (vmstat_items_check_failed(numitems, items)) + return NULL; + errno = 0; + + /* is this the first time or have things changed since we were last called? + if so, gotta' redo all of our stacks stuff ... */ + if (info->numitems != numitems + 1 + || memcmp(info->items, items, sizeof(enum vmstat_item) * numitems)) { + // allow for our VMSTAT_logical_end + if (!(info->items = realloc(info->items, sizeof(enum vmstat_item) * (numitems + 1)))) + return NULL; + memcpy(info->items, items, sizeof(enum vmstat_item) * numitems); + info->items[numitems] = VMSTAT_logical_end; + info->numitems = numitems + 1; + if (info->extents) + vmstat_extents_free_all(info); + } + if (!info->extents + && (!vmstat_stacks_alloc(info, 1))) + return NULL; + + if (vmstat_read_failed(info)) + return NULL; + vmstat_assign_results(info->extents->stacks[0], &info->hist); + + return info->extents->stacks[0]; +} // end: procps_vmstat_select + + +// --- special debugging function(s) ------------------------------------------ +/* + * The following isn't part of the normal programming interface. Rather, + * it exists to validate result types referenced in application programs. + * + * It's used only when: + * 1) the 'XTRA_PROCPS_DEBUG' has been defined, or + * 2) an #include of 'xtra-procps-debug.h' is used + */ + +PROCPS_EXPORT struct vmstat_result *xtra_vmstat_get ( + struct vmstat_info *info, + enum vmstat_item actual_enum, + const char *typestr, + const char *file, + int lineno) +{ + struct vmstat_result *r = procps_vmstat_get(info, actual_enum); + + if (actual_enum < 0 || actual_enum >= VMSTAT_logical_end) { + fprintf(stderr, "%s line %d: invalid item = %d, type = %s\n" + , file, lineno, actual_enum, typestr); + } + if (r) { + char *str = Item_table[r->item].type2str; + if (str[0] + && (strcmp(typestr, str))) + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return r; +} // end: xtra_vmstat_get_ + + +PROCPS_EXPORT struct vmstat_result *xtra_vmstat_val ( + int relative_enum, + const char *typestr, + const struct vmstat_stack *stack, + struct vmstat_info *info, + const char *file, + int lineno) +{ + char *str; + int i; + + for (i = 0; stack->head[i].item < VMSTAT_logical_end; i++) + ; + if (relative_enum < 0 || relative_enum >= i) { + fprintf(stderr, "%s line %d: invalid relative_enum = %d, valid range = 0-%d\n" + , file, lineno, relative_enum, i-1); + return NULL; + } + str = Item_table[stack->head[relative_enum].item].type2str; + if (str[0] + && (strcmp(typestr, str))) { + fprintf(stderr, "%s line %d: was %s, expected %s\n", file, lineno, typestr, str); + } + return &stack->head[relative_enum]; + (void)info; +} // end: xtra_vmstat_val diff --git a/library/wchan.c b/library/wchan.c new file mode 100644 index 0000000..d342fef --- /dev/null +++ b/library/wchan.c @@ -0,0 +1,54 @@ +/* + * wchan.c - kernel symbol handling + * + * Copyright © 2015-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 1998-2003 Albert Cahalan + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <stdio.h> +#include <string.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/stat.h> + +#include "wchan.h" // to verify prototype + + +const char *lookup_wchan (int pid) { + static __thread char buf[64]; + const char *ret = buf; + ssize_t num; + int fd; + + snprintf(buf, sizeof buf, "/proc/%d/wchan", pid); + fd = open(buf, O_RDONLY); + if (fd==-1) return "?"; + + num = read(fd, buf, sizeof buf - 1); + close(fd); + + if (num<1) return "?"; // allow for "0" + buf[num] = '\0'; + + if (buf[0]=='0' && buf[1]=='\0') return "-"; + + // lame ppc64 has a '.' in front of every name + if (*ret=='.') ret++; + while(*ret=='_') ret++; + + return ret; +} |