library: provide for validating result type references

During development, we now have a means for validating
that a type referenced in application code matches the
actual type set by the library. The new feature can be
activated through either of the following two methods:

1) ./configure CFLAGS='-DXTRA_PROCPS_DEBUG' (all pgms)

2) an #include <proc/xtra-procps-debug.h> (single pgm)

[ in the future, one could add a formal configure.ac ]
[ provision. but for now a manual approach is safer. ]

Lastly, for any module which provides a sort function,
the handling for both 'noop' & 'extra' enumerators was
made consistent. Now, 'noop' is not sorted and 'extra'
will be sorted as that module's widest supported type.

Signed-off-by: Jim Warner <james.warner@comcast.net>
This commit is contained in:
Jim Warner
2016-08-05 00:00:00 -05:00
committed by Craig Small
parent e0515e23e7
commit e3270d463d
10 changed files with 1103 additions and 567 deletions

View File

@@ -25,6 +25,7 @@
#include <errno.h>
#include <fcntl.h>
#include <search.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
@@ -454,258 +455,262 @@ HST_set(DELTA_ZONE_RECLAIM_FAILED, zone_reclaim_failed)
typedef void (*SET_t)(struct vmstat_result *, struct vmstat_hist *);
#define RS(e) (SET_t)setNAME(e)
#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
char *type2str; // the result type as a string value
} Item_table[] = {
/* setsfunc
--------------------------------------- */
{ RS(noop) },
{ RS(extra) },
/* setsfunc type2str
---------------------------------------- ---------- */
{ RS(noop), TS_noop },
{ RS(extra), TS_noop },
{ RS(ALLOCSTALL) },
{ RS(BALLOON_DEFLATE) },
{ RS(BALLOON_INFLATE) },
{ RS(BALLOON_MIGRATE) },
{ RS(COMPACT_FAIL) },
{ RS(COMPACT_FREE_SCANNED) },
{ RS(COMPACT_ISOLATED) },
{ RS(COMPACT_MIGRATE_SCANNED) },
{ RS(COMPACT_STALL) },
{ RS(COMPACT_SUCCESS) },
{ RS(DROP_PAGECACHE) },
{ RS(DROP_SLAB) },
{ RS(HTLB_BUDDY_ALLOC_FAIL) },
{ RS(HTLB_BUDDY_ALLOC_SUCCESS) },
{ RS(KSWAPD_HIGH_WMARK_HIT_QUICKLY) },
{ RS(KSWAPD_INODESTEAL) },
{ RS(KSWAPD_LOW_WMARK_HIT_QUICKLY) },
{ RS(NR_ACTIVE_ANON) },
{ RS(NR_ACTIVE_FILE) },
{ RS(NR_ALLOC_BATCH) },
{ RS(NR_ANON_PAGES) },
{ RS(NR_ANON_TRANSPARENT_HUGEPAGES) },
{ RS(NR_BOUNCE) },
{ RS(NR_DIRTIED) },
{ RS(NR_DIRTY) },
{ RS(NR_DIRTY_BACKGROUND_THRESHOLD) },
{ RS(NR_DIRTY_THRESHOLD) },
{ RS(NR_FILE_PAGES) },
{ RS(NR_FREE_CMA) },
{ RS(NR_FREE_PAGES) },
{ RS(NR_INACTIVE_ANON) },
{ RS(NR_INACTIVE_FILE) },
{ RS(NR_ISOLATED_ANON) },
{ RS(NR_ISOLATED_FILE) },
{ RS(NR_KERNEL_STACK) },
{ RS(NR_MAPPED) },
{ RS(NR_MLOCK) },
{ RS(NR_PAGES_SCANNED) },
{ RS(NR_PAGE_TABLE_PAGES) },
{ RS(NR_SHMEM) },
{ RS(NR_SLAB_RECLAIMABLE) },
{ RS(NR_SLAB_UNRECLAIMABLE) },
{ RS(NR_UNEVICTABLE) },
{ RS(NR_UNSTABLE) },
{ RS(NR_VMSCAN_IMMEDIATE_RECLAIM) },
{ RS(NR_VMSCAN_WRITE) },
{ RS(NR_WRITEBACK) },
{ RS(NR_WRITEBACK_TEMP) },
{ RS(NR_WRITTEN) },
{ RS(NUMA_FOREIGN) },
{ RS(NUMA_HINT_FAULTS) },
{ RS(NUMA_HINT_FAULTS_LOCAL) },
{ RS(NUMA_HIT) },
{ RS(NUMA_HUGE_PTE_UPDATES) },
{ RS(NUMA_INTERLEAVE) },
{ RS(NUMA_LOCAL) },
{ RS(NUMA_MISS) },
{ RS(NUMA_OTHER) },
{ RS(NUMA_PAGES_MIGRATED) },
{ RS(NUMA_PTE_UPDATES) },
{ RS(PAGEOUTRUN) },
{ RS(PGACTIVATE) },
{ RS(PGALLOC_DMA) },
{ RS(PGALLOC_DMA32) },
{ RS(PGALLOC_MOVABLE) },
{ RS(PGALLOC_NORMAL) },
{ RS(PGDEACTIVATE) },
{ RS(PGFAULT) },
{ RS(PGFREE) },
{ RS(PGINODESTEAL) },
{ RS(PGMAJFAULT) },
{ RS(PGMIGRATE_FAIL) },
{ RS(PGMIGRATE_SUCCESS) },
{ RS(PGPGIN) },
{ RS(PGPGOUT) },
{ RS(PGREFILL_DMA) },
{ RS(PGREFILL_DMA32) },
{ RS(PGREFILL_MOVABLE) },
{ RS(PGREFILL_NORMAL) },
{ RS(PGROTATED) },
{ RS(PGSCAN_DIRECT_DMA) },
{ RS(PGSCAN_DIRECT_DMA32) },
{ RS(PGSCAN_DIRECT_MOVABLE) },
{ RS(PGSCAN_DIRECT_NORMAL) },
{ RS(PGSCAN_DIRECT_THROTTLE) },
{ RS(PGSCAN_KSWAPD_DMA) },
{ RS(PGSCAN_KSWAPD_DMA32) },
{ RS(PGSCAN_KSWAPD_MOVEABLE) },
{ RS(PGSCAN_KSWAPD_NORMAL) },
{ RS(PGSTEAL_DIRECT_DMA) },
{ RS(PGSTEAL_DIRECT_DMA32) },
{ RS(PGSTEAL_DIRECT_MOVABLE) },
{ RS(PGSTEAL_DIRECT_NORMAL) },
{ RS(PGSTEAL_KSWAPD_DMA) },
{ RS(PGSTEAL_KSWAPD_DMA32) },
{ RS(PGSTEAL_KSWAPD_MOVABLE) },
{ RS(PGSTEAL_KSWAPD_NORMAL) },
{ RS(PSWPIN) },
{ RS(PSWPOUT) },
{ RS(SLABS_SCANNED) },
{ RS(THP_COLLAPSE_ALLOC) },
{ RS(THP_COLLAPSE_ALLOC_FAILED) },
{ RS(THP_FAULT_ALLOC) },
{ RS(THP_FAULT_FALLBACK) },
{ RS(THP_SPLIT) },
{ RS(THP_ZERO_PAGE_ALLOC) },
{ RS(THP_ZERO_PAGE_ALLOC_FAILED) },
{ RS(UNEVICTABLE_PGS_CLEARED) },
{ RS(UNEVICTABLE_PGS_CULLED) },
{ RS(UNEVICTABLE_PGS_MLOCKED) },
{ RS(UNEVICTABLE_PGS_MUNLOCKED) },
{ RS(UNEVICTABLE_PGS_RESCUED) },
{ RS(UNEVICTABLE_PGS_SCANNED) },
{ RS(UNEVICTABLE_PGS_STRANDED) },
{ RS(WORKINGSET_ACTIVATE) },
{ RS(WORKINGSET_NODERECLAIM) },
{ RS(WORKINGSET_REFAULT) },
{ RS(ZONE_RECLAIM_FAILED) },
{ RS(ALLOCSTALL), TS(ul_int) },
{ RS(BALLOON_DEFLATE), TS(ul_int) },
{ RS(BALLOON_INFLATE), TS(ul_int) },
{ RS(BALLOON_MIGRATE), 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_ALLOC_BATCH), 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_PAGES), 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_STACK), TS(ul_int) },
{ RS(NR_MAPPED), TS(ul_int) },
{ RS(NR_MLOCK), TS(ul_int) },
{ RS(NR_PAGES_SCANNED), TS(ul_int) },
{ RS(NR_PAGE_TABLE_PAGES), TS(ul_int) },
{ RS(NR_SHMEM), 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(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(PAGEOUTRUN), TS(ul_int) },
{ RS(PGACTIVATE), TS(ul_int) },
{ RS(PGALLOC_DMA), TS(ul_int) },
{ RS(PGALLOC_DMA32), 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(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_DMA), TS(ul_int) },
{ RS(PGREFILL_DMA32), TS(ul_int) },
{ RS(PGREFILL_MOVABLE), TS(ul_int) },
{ RS(PGREFILL_NORMAL), TS(ul_int) },
{ RS(PGROTATED), TS(ul_int) },
{ RS(PGSCAN_DIRECT_DMA), TS(ul_int) },
{ RS(PGSCAN_DIRECT_DMA32), TS(ul_int) },
{ RS(PGSCAN_DIRECT_MOVABLE), TS(ul_int) },
{ RS(PGSCAN_DIRECT_NORMAL), TS(ul_int) },
{ RS(PGSCAN_DIRECT_THROTTLE), TS(ul_int) },
{ RS(PGSCAN_KSWAPD_DMA), TS(ul_int) },
{ RS(PGSCAN_KSWAPD_DMA32), TS(ul_int) },
{ RS(PGSCAN_KSWAPD_MOVEABLE), TS(ul_int) },
{ RS(PGSCAN_KSWAPD_NORMAL), TS(ul_int) },
{ RS(PGSTEAL_DIRECT_DMA), TS(ul_int) },
{ RS(PGSTEAL_DIRECT_DMA32), TS(ul_int) },
{ RS(PGSTEAL_DIRECT_MOVABLE), TS(ul_int) },
{ RS(PGSTEAL_DIRECT_NORMAL), TS(ul_int) },
{ RS(PGSTEAL_KSWAPD_DMA), TS(ul_int) },
{ RS(PGSTEAL_KSWAPD_DMA32), TS(ul_int) },
{ RS(PGSTEAL_KSWAPD_MOVABLE), TS(ul_int) },
{ RS(PGSTEAL_KSWAPD_NORMAL), TS(ul_int) },
{ RS(PSWPIN), TS(ul_int) },
{ RS(PSWPOUT), TS(ul_int) },
{ RS(SLABS_SCANNED), TS(ul_int) },
{ RS(THP_COLLAPSE_ALLOC), TS(ul_int) },
{ RS(THP_COLLAPSE_ALLOC_FAILED), TS(ul_int) },
{ RS(THP_FAULT_ALLOC), TS(ul_int) },
{ RS(THP_FAULT_FALLBACK), TS(ul_int) },
{ RS(THP_SPLIT), 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_REFAULT), TS(ul_int) },
{ RS(ZONE_RECLAIM_FAILED), TS(ul_int) },
{ RS(DELTA_ALLOCSTALL) },
{ RS(DELTA_BALLOON_DEFLATE) },
{ RS(DELTA_BALLOON_INFLATE) },
{ RS(DELTA_BALLOON_MIGRATE) },
{ RS(DELTA_COMPACT_FAIL) },
{ RS(DELTA_COMPACT_FREE_SCANNED) },
{ RS(DELTA_COMPACT_ISOLATED) },
{ RS(DELTA_COMPACT_MIGRATE_SCANNED) },
{ RS(DELTA_COMPACT_STALL) },
{ RS(DELTA_COMPACT_SUCCESS) },
{ RS(DELTA_DROP_PAGECACHE) },
{ RS(DELTA_DROP_SLAB) },
{ RS(DELTA_HTLB_BUDDY_ALLOC_FAIL) },
{ RS(DELTA_HTLB_BUDDY_ALLOC_SUCCESS) },
{ RS(DELTA_KSWAPD_HIGH_WMARK_HIT_QUICKLY) },
{ RS(DELTA_KSWAPD_INODESTEAL) },
{ RS(DELTA_KSWAPD_LOW_WMARK_HIT_QUICKLY) },
{ RS(DELTA_NR_ACTIVE_ANON) },
{ RS(DELTA_NR_ACTIVE_FILE) },
{ RS(DELTA_NR_ALLOC_BATCH) },
{ RS(DELTA_NR_ANON_PAGES) },
{ RS(DELTA_NR_ANON_TRANSPARENT_HUGEPAGES) },
{ RS(DELTA_NR_BOUNCE) },
{ RS(DELTA_NR_DIRTIED) },
{ RS(DELTA_NR_DIRTY) },
{ RS(DELTA_NR_DIRTY_BACKGROUND_THRESHOLD) },
{ RS(DELTA_NR_DIRTY_THRESHOLD) },
{ RS(DELTA_NR_FILE_PAGES) },
{ RS(DELTA_NR_FREE_CMA) },
{ RS(DELTA_NR_FREE_PAGES) },
{ RS(DELTA_NR_INACTIVE_ANON) },
{ RS(DELTA_NR_INACTIVE_FILE) },
{ RS(DELTA_NR_ISOLATED_ANON) },
{ RS(DELTA_NR_ISOLATED_FILE) },
{ RS(DELTA_NR_KERNEL_STACK) },
{ RS(DELTA_NR_MAPPED) },
{ RS(DELTA_NR_MLOCK) },
{ RS(DELTA_NR_PAGES_SCANNED) },
{ RS(DELTA_NR_PAGE_TABLE_PAGES) },
{ RS(DELTA_NR_SHMEM) },
{ RS(DELTA_NR_SLAB_RECLAIMABLE) },
{ RS(DELTA_NR_SLAB_UNRECLAIMABLE) },
{ RS(DELTA_NR_UNEVICTABLE) },
{ RS(DELTA_NR_UNSTABLE) },
{ RS(DELTA_NR_VMSCAN_IMMEDIATE_RECLAIM) },
{ RS(DELTA_NR_VMSCAN_WRITE) },
{ RS(DELTA_NR_WRITEBACK) },
{ RS(DELTA_NR_WRITEBACK_TEMP) },
{ RS(DELTA_NR_WRITTEN) },
{ RS(DELTA_NUMA_FOREIGN) },
{ RS(DELTA_NUMA_HINT_FAULTS) },
{ RS(DELTA_NUMA_HINT_FAULTS_LOCAL) },
{ RS(DELTA_NUMA_HIT) },
{ RS(DELTA_NUMA_HUGE_PTE_UPDATES) },
{ RS(DELTA_NUMA_INTERLEAVE) },
{ RS(DELTA_NUMA_LOCAL) },
{ RS(DELTA_NUMA_MISS) },
{ RS(DELTA_NUMA_OTHER) },
{ RS(DELTA_NUMA_PAGES_MIGRATED) },
{ RS(DELTA_NUMA_PTE_UPDATES) },
{ RS(DELTA_PAGEOUTRUN) },
{ RS(DELTA_PGACTIVATE) },
{ RS(DELTA_PGALLOC_DMA) },
{ RS(DELTA_PGALLOC_DMA32) },
{ RS(DELTA_PGALLOC_MOVABLE) },
{ RS(DELTA_PGALLOC_NORMAL) },
{ RS(DELTA_PGDEACTIVATE) },
{ RS(DELTA_PGFAULT) },
{ RS(DELTA_PGFREE) },
{ RS(DELTA_PGINODESTEAL) },
{ RS(DELTA_PGMAJFAULT) },
{ RS(DELTA_PGMIGRATE_FAIL) },
{ RS(DELTA_PGMIGRATE_SUCCESS) },
{ RS(DELTA_PGPGIN) },
{ RS(DELTA_PGPGOUT) },
{ RS(DELTA_PGREFILL_DMA) },
{ RS(DELTA_PGREFILL_DMA32) },
{ RS(DELTA_PGREFILL_MOVABLE) },
{ RS(DELTA_PGREFILL_NORMAL) },
{ RS(DELTA_PGROTATED) },
{ RS(DELTA_PGSCAN_DIRECT_DMA) },
{ RS(DELTA_PGSCAN_DIRECT_DMA32) },
{ RS(DELTA_PGSCAN_DIRECT_MOVABLE) },
{ RS(DELTA_PGSCAN_DIRECT_NORMAL) },
{ RS(DELTA_PGSCAN_DIRECT_THROTTLE) },
{ RS(DELTA_PGSCAN_KSWAPD_DMA) },
{ RS(DELTA_PGSCAN_KSWAPD_DMA32) },
{ RS(DELTA_PGSCAN_KSWAPD_MOVEABLE) },
{ RS(DELTA_PGSCAN_KSWAPD_NORMAL) },
{ RS(DELTA_PGSTEAL_DIRECT_DMA) },
{ RS(DELTA_PGSTEAL_DIRECT_DMA32) },
{ RS(DELTA_PGSTEAL_DIRECT_MOVABLE) },
{ RS(DELTA_PGSTEAL_DIRECT_NORMAL) },
{ RS(DELTA_PGSTEAL_KSWAPD_DMA) },
{ RS(DELTA_PGSTEAL_KSWAPD_DMA32) },
{ RS(DELTA_PGSTEAL_KSWAPD_MOVABLE) },
{ RS(DELTA_PGSTEAL_KSWAPD_NORMAL) },
{ RS(DELTA_PSWPIN) },
{ RS(DELTA_PSWPOUT) },
{ RS(DELTA_SLABS_SCANNED) },
{ RS(DELTA_THP_COLLAPSE_ALLOC) },
{ RS(DELTA_THP_COLLAPSE_ALLOC_FAILED) },
{ RS(DELTA_THP_FAULT_ALLOC) },
{ RS(DELTA_THP_FAULT_FALLBACK) },
{ RS(DELTA_THP_SPLIT) },
{ RS(DELTA_THP_ZERO_PAGE_ALLOC) },
{ RS(DELTA_THP_ZERO_PAGE_ALLOC_FAILED) },
{ RS(DELTA_UNEVICTABLE_PGS_CLEARED) },
{ RS(DELTA_UNEVICTABLE_PGS_CULLED) },
{ RS(DELTA_UNEVICTABLE_PGS_MLOCKED) },
{ RS(DELTA_UNEVICTABLE_PGS_MUNLOCKED) },
{ RS(DELTA_UNEVICTABLE_PGS_RESCUED) },
{ RS(DELTA_UNEVICTABLE_PGS_SCANNED) },
{ RS(DELTA_UNEVICTABLE_PGS_STRANDED) },
{ RS(DELTA_WORKINGSET_ACTIVATE) },
{ RS(DELTA_WORKINGSET_NODERECLAIM) },
{ RS(DELTA_WORKINGSET_REFAULT) },
{ RS(DELTA_ZONE_RECLAIM_FAILED) },
{ RS(DELTA_ALLOCSTALL), 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_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_ALLOC_BATCH), 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_PAGES), 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_STACK), TS(sl_int) },
{ RS(DELTA_NR_MAPPED), TS(sl_int) },
{ RS(DELTA_NR_MLOCK), TS(sl_int) },
{ RS(DELTA_NR_PAGES_SCANNED), TS(sl_int) },
{ RS(DELTA_NR_PAGE_TABLE_PAGES), TS(sl_int) },
{ RS(DELTA_NR_SHMEM), 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_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_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_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_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_DMA), TS(sl_int) },
{ RS(DELTA_PGREFILL_DMA32), TS(sl_int) },
{ RS(DELTA_PGREFILL_MOVABLE), TS(sl_int) },
{ RS(DELTA_PGREFILL_NORMAL), TS(sl_int) },
{ RS(DELTA_PGROTATED), TS(sl_int) },
{ RS(DELTA_PGSCAN_DIRECT_DMA), TS(sl_int) },
{ RS(DELTA_PGSCAN_DIRECT_DMA32), TS(sl_int) },
{ RS(DELTA_PGSCAN_DIRECT_MOVABLE), TS(sl_int) },
{ RS(DELTA_PGSCAN_DIRECT_NORMAL), TS(sl_int) },
{ RS(DELTA_PGSCAN_DIRECT_THROTTLE), TS(sl_int) },
{ RS(DELTA_PGSCAN_KSWAPD_DMA), TS(sl_int) },
{ RS(DELTA_PGSCAN_KSWAPD_DMA32), TS(sl_int) },
{ RS(DELTA_PGSCAN_KSWAPD_MOVEABLE), TS(sl_int) },
{ RS(DELTA_PGSCAN_KSWAPD_NORMAL), TS(sl_int) },
{ RS(DELTA_PGSTEAL_DIRECT_DMA), TS(sl_int) },
{ RS(DELTA_PGSTEAL_DIRECT_DMA32), TS(sl_int) },
{ RS(DELTA_PGSTEAL_DIRECT_MOVABLE), TS(sl_int) },
{ RS(DELTA_PGSTEAL_DIRECT_NORMAL), TS(sl_int) },
{ RS(DELTA_PGSTEAL_KSWAPD_DMA), TS(sl_int) },
{ RS(DELTA_PGSTEAL_KSWAPD_DMA32), TS(sl_int) },
{ RS(DELTA_PGSTEAL_KSWAPD_MOVABLE), TS(sl_int) },
{ RS(DELTA_PGSTEAL_KSWAPD_NORMAL), TS(sl_int) },
{ RS(DELTA_PSWPIN), TS(sl_int) },
{ RS(DELTA_PSWPOUT), TS(sl_int) },
{ RS(DELTA_SLABS_SCANNED), TS(sl_int) },
{ RS(DELTA_THP_COLLAPSE_ALLOC), TS(sl_int) },
{ RS(DELTA_THP_COLLAPSE_ALLOC_FAILED), TS(sl_int) },
{ RS(DELTA_THP_FAULT_ALLOC), TS(sl_int) },
{ RS(DELTA_THP_FAULT_FALLBACK), TS(sl_int) },
{ RS(DELTA_THP_SPLIT), 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_REFAULT), TS(sl_int) },
{ RS(DELTA_ZONE_RECLAIM_FAILED), TS(sl_int) },
// dummy entry corresponding to VMSTAT_logical_end ...
{ NULL, }
{ NULL, NULL }
};
/* please note,
@@ -1242,3 +1247,56 @@ PROCPS_EXPORT struct vmstat_stack *procps_vmstat_select (
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) the '#include <proc/xtra-procps-debug.h>' 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 (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 void xtra_vmstat_val (
int relative_enum,
const char *typestr,
const struct vmstat_stack *stack,
struct vmstat_info *info,
const char *file,
int lineno)
{
struct vmstat_result *r;
char *str;
r = &stack->head[relative_enum];
if (r->item < 0 || r->item >= VMSTAT_logical_end) {
fprintf(stderr, "%s line %d: invalid item = %d, relative_enum = %d, type = %s\n"
, file, lineno, r->item, relative_enum, typestr);
return;
}
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);
} // end: xtra_vmstat_val