src/proc_vmstat.c

   1 #include "common.h"
   2
   3 int do_proc_vmstat(int update_every, unsigned long long dt) {
   4     (void)dt;
   5
   6     static procfile *ff = NULL;
   7     static int do_swapio = -1, do_io = -1, do_pgfaults = -1;
   8
   9     // static uint32_t hash_allocstall = 0;
  10     // static uint32_t hash_compact_blocks_moved = 0;
  11     // static uint32_t hash_compact_fail = 0;
  12     // static uint32_t hash_compact_pagemigrate_failed = 0;
  13     // static uint32_t hash_compact_pages_moved = 0;
  14     // static uint32_t hash_compact_stall = 0;
  15     // static uint32_t hash_compact_success = 0;
  16     // static uint32_t hash_htlb_buddy_alloc_fail = 0;
  17     // static uint32_t hash_htlb_buddy_alloc_success = 0;
  18     // static uint32_t hash_kswapd_high_wmark_hit_quickly = 0;
  19     // static uint32_t hash_kswapd_inodesteal = 0;
  20     // static uint32_t hash_kswapd_low_wmark_hit_quickly = 0;
  21     // static uint32_t hash_kswapd_skip_congestion_wait = 0;
  22     // static uint32_t hash_nr_active_anon = 0;
  23     // static uint32_t hash_nr_active_file = 0;
  24     // static uint32_t hash_nr_anon_pages = 0;
  25     // static uint32_t hash_nr_anon_transparent_hugepages = 0;
  26     // static uint32_t hash_nr_bounce = 0;
  27     // static uint32_t hash_nr_dirtied = 0;
  28     // static uint32_t hash_nr_dirty = 0;
  29     // static uint32_t hash_nr_dirty_background_threshold = 0;
  30     // static uint32_t hash_nr_dirty_threshold = 0;
  31     // static uint32_t hash_nr_file_pages = 0;
  32     // static uint32_t hash_nr_free_pages = 0;
  33     // static uint32_t hash_nr_inactive_anon = 0;
  34     // static uint32_t hash_nr_inactive_file = 0;
  35     // static uint32_t hash_nr_isolated_anon = 0;
  36     // static uint32_t hash_nr_isolated_file = 0;
  37     // static uint32_t hash_nr_kernel_stack = 0;
  38     // static uint32_t hash_nr_mapped = 0;
  39     // static uint32_t hash_nr_mlock = 0;
  40     // static uint32_t hash_nr_page_table_pages = 0;
  41     // static uint32_t hash_nr_shmem = 0;
  42     // static uint32_t hash_nr_slab_reclaimable = 0;
  43     // static uint32_t hash_nr_slab_unreclaimable = 0;
  44     // static uint32_t hash_nr_unevictable = 0;
  45     // static uint32_t hash_nr_unstable = 0;
  46     // static uint32_t hash_nr_vmscan_immediate_reclaim = 0;
  47     // static uint32_t hash_nr_vmscan_write = 0;
  48     // static uint32_t hash_nr_writeback = 0;
  49     // static uint32_t hash_nr_writeback_temp = 0;
  50     // static uint32_t hash_nr_written = 0;
  51     // static uint32_t hash_pageoutrun = 0;
  52     // static uint32_t hash_pgactivate = 0;
  53     // static uint32_t hash_pgalloc_dma = 0;
  54     // static uint32_t hash_pgalloc_dma32 = 0;
  55     // static uint32_t hash_pgalloc_movable = 0;
  56     // static uint32_t hash_pgalloc_normal = 0;
  57     // static uint32_t hash_pgdeactivate = 0;
  58     static uint32_t hash_pgfault = 0;
  59     // static uint32_t hash_pgfree = 0;
  60     // static uint32_t hash_pginodesteal = 0;
  61     static uint32_t hash_pgmajfault = 0;
  62     static uint32_t hash_pgpgin = 0;
  63     static uint32_t hash_pgpgout = 0;
  64     // static uint32_t hash_pgrefill_dma = 0;
  65     // static uint32_t hash_pgrefill_dma32 = 0;
  66     // static uint32_t hash_pgrefill_movable = 0;
  67     // static uint32_t hash_pgrefill_normal = 0;
  68     // static uint32_t hash_pgrotated = 0;
  69     // static uint32_t hash_pgscan_direct_dma = 0;
  70     // static uint32_t hash_pgscan_direct_dma32 = 0;
  71     // static uint32_t hash_pgscan_direct_movable = 0;
  72     // static uint32_t hash_pgscan_direct_normal = 0;
  73     // static uint32_t hash_pgscan_kswapd_dma = 0;
  74     // static uint32_t hash_pgscan_kswapd_dma32 = 0;
  75     // static uint32_t hash_pgscan_kswapd_movable = 0;
  76     // static uint32_t hash_pgscan_kswapd_normal = 0;
  77     // static uint32_t hash_pgsteal_direct_dma = 0;
  78     // static uint32_t hash_pgsteal_direct_dma32 = 0;
  79     // static uint32_t hash_pgsteal_direct_movable = 0;
  80     // static uint32_t hash_pgsteal_direct_normal = 0;
  81     // static uint32_t hash_pgsteal_kswapd_dma = 0;
  82     // static uint32_t hash_pgsteal_kswapd_dma32 = 0;
  83     // static uint32_t hash_pgsteal_kswapd_movable = 0;
  84     // static uint32_t hash_pgsteal_kswapd_normal = 0;
  85     static uint32_t hash_pswpin = 0;
  86     static uint32_t hash_pswpout = 0;
  87     // static uint32_t hash_slabs_scanned = 0;
  88     // static uint32_t hash_thp_collapse_alloc = 0;
  89     // static uint32_t hash_thp_collapse_alloc_failed = 0;
  90     // static uint32_t hash_thp_fault_alloc = 0;
  91     // static uint32_t hash_thp_fault_fallback = 0;
  92     // static uint32_t hash_thp_split = 0;
  93     // static uint32_t hash_unevictable_pgs_cleared = 0;
  94     // static uint32_t hash_unevictable_pgs_culled = 0;
  95     // static uint32_t hash_unevictable_pgs_mlocked = 0;
  96     // static uint32_t hash_unevictable_pgs_mlockfreed = 0;
  97     // static uint32_t hash_unevictable_pgs_munlocked = 0;
  98     // static uint32_t hash_unevictable_pgs_rescued = 0;
  99     // static uint32_t hash_unevictable_pgs_scanned = 0;
 100     // static uint32_t hash_unevictable_pgs_stranded = 0;
 101
 102     if(unlikely(do_swapio == -1)) {
 103         do_swapio = config_get_boolean_ondemand("plugin:proc:/proc/vmstat", "swap i/o", CONFIG_ONDEMAND_ONDEMAND);
 104         do_io = config_get_boolean("plugin:proc:/proc/vmstat", "disk i/o", 1);
 105         do_pgfaults = config_get_boolean("plugin:proc:/proc/vmstat", "memory page faults", 1);
 106
 107         // hash_allocstall = simple_hash("allocstall");
 108         // hash_compact_blocks_moved = simple_hash("compact_blocks_moved");
 109         // hash_compact_fail = simple_hash("compact_fail");
 110         // hash_compact_pagemigrate_failed = simple_hash("compact_pagemigrate_failed");
 111         // hash_compact_pages_moved = simple_hash("compact_pages_moved");
 112         // hash_compact_stall = simple_hash("compact_stall");
 113         // hash_compact_success = simple_hash("compact_success");
 114         // hash_htlb_buddy_alloc_fail = simple_hash("htlb_buddy_alloc_fail");
 115         // hash_htlb_buddy_alloc_success = simple_hash("htlb_buddy_alloc_success");
 116         // hash_kswapd_high_wmark_hit_quickly = simple_hash("kswapd_high_wmark_hit_quickly");
 117         // hash_kswapd_inodesteal = simple_hash("kswapd_inodesteal");
 118         // hash_kswapd_low_wmark_hit_quickly = simple_hash("kswapd_low_wmark_hit_quickly");
 119         // hash_kswapd_skip_congestion_wait = simple_hash("kswapd_skip_congestion_wait");
 120         // hash_nr_active_anon = simple_hash("nr_active_anon");
 121         // hash_nr_active_file = simple_hash("nr_active_file");
 122         // hash_nr_anon_pages = simple_hash("nr_anon_pages");
 123         // hash_nr_anon_transparent_hugepages = simple_hash("nr_anon_transparent_hugepages");
 124         // hash_nr_bounce = simple_hash("nr_bounce");
 125         // hash_nr_dirtied = simple_hash("nr_dirtied");
 126         // hash_nr_dirty = simple_hash("nr_dirty");
 127         // hash_nr_dirty_background_threshold = simple_hash("nr_dirty_background_threshold");
 128         // hash_nr_dirty_threshold = simple_hash("nr_dirty_threshold");
 129         // hash_nr_file_pages = simple_hash("nr_file_pages");
 130         // hash_nr_free_pages = simple_hash("nr_free_pages");
 131         // hash_nr_inactive_anon = simple_hash("nr_inactive_anon");
 132         // hash_nr_inactive_file = simple_hash("nr_inactive_file");
 133         // hash_nr_isolated_anon = simple_hash("nr_isolated_anon");
 134         // hash_nr_isolated_file = simple_hash("nr_isolated_file");
 135         // hash_nr_kernel_stack = simple_hash("nr_kernel_stack");
 136         // hash_nr_mapped = simple_hash("nr_mapped");
 137         // hash_nr_mlock = simple_hash("nr_mlock");
 138         // hash_nr_page_table_pages = simple_hash("nr_page_table_pages");
 139         // hash_nr_shmem = simple_hash("nr_shmem");
 140         // hash_nr_slab_reclaimable = simple_hash("nr_slab_reclaimable");
 141         // hash_nr_slab_unreclaimable = simple_hash("nr_slab_unreclaimable");
 142         // hash_nr_unevictable = simple_hash("nr_unevictable");
 143         // hash_nr_unstable = simple_hash("nr_unstable");
 144         // hash_nr_vmscan_immediate_reclaim = simple_hash("nr_vmscan_immediate_reclaim");
 145         // hash_nr_vmscan_write = simple_hash("nr_vmscan_write");
 146         // hash_nr_writeback = simple_hash("nr_writeback");
 147         // hash_nr_writeback_temp = simple_hash("nr_writeback_temp");
 148         // hash_nr_written = simple_hash("nr_written");
 149         // hash_pageoutrun = simple_hash("pageoutrun");
 150         // hash_pgactivate = simple_hash("pgactivate");
 151         // hash_pgalloc_dma = simple_hash("pgalloc_dma");
 152         // hash_pgalloc_dma32 = simple_hash("pgalloc_dma32");
 153         // hash_pgalloc_movable = simple_hash("pgalloc_movable");
 154         // hash_pgalloc_normal = simple_hash("pgalloc_normal");
 155         // hash_pgdeactivate = simple_hash("pgdeactivate");
 156         hash_pgfault = simple_hash("pgfault");
 157         // hash_pgfree = simple_hash("pgfree");
 158         // hash_pginodesteal = simple_hash("pginodesteal");
 159         hash_pgmajfault = simple_hash("pgmajfault");
 160         hash_pgpgin = simple_hash("pgpgin");
 161         hash_pgpgout = simple_hash("pgpgout");
 162         // hash_pgrefill_dma = simple_hash("pgrefill_dma");
 163         // hash_pgrefill_dma32 = simple_hash("pgrefill_dma32");
 164         // hash_pgrefill_movable = simple_hash("pgrefill_movable");
 165         // hash_pgrefill_normal = simple_hash("pgrefill_normal");
 166         // hash_pgrotated = simple_hash("pgrotated");
 167         // hash_pgscan_direct_dma = simple_hash("pgscan_direct_dma");
 168         // hash_pgscan_direct_dma32 = simple_hash("pgscan_direct_dma32");
 169         // hash_pgscan_direct_movable = simple_hash("pgscan_direct_movable");
 170         // hash_pgscan_direct_normal = simple_hash("pgscan_direct_normal");
 171         // hash_pgscan_kswapd_dma = simple_hash("pgscan_kswapd_dma");
 172         // hash_pgscan_kswapd_dma32 = simple_hash("pgscan_kswapd_dma32");
 173         // hash_pgscan_kswapd_movable = simple_hash("pgscan_kswapd_movable");
 174         // hash_pgscan_kswapd_normal = simple_hash("pgscan_kswapd_normal");
 175         // hash_pgsteal_direct_dma = simple_hash("pgsteal_direct_dma");
 176         // hash_pgsteal_direct_dma32 = simple_hash("pgsteal_direct_dma32");
 177         // hash_pgsteal_direct_movable = simple_hash("pgsteal_direct_movable");
 178         // hash_pgsteal_direct_normal = simple_hash("pgsteal_direct_normal");
 179         // hash_pgsteal_kswapd_dma = simple_hash("pgsteal_kswapd_dma");
 180         // hash_pgsteal_kswapd_dma32 = simple_hash("pgsteal_kswapd_dma32");
 181         // hash_pgsteal_kswapd_movable = simple_hash("pgsteal_kswapd_movable");
 182         // hash_pgsteal_kswapd_normal = simple_hash("pgsteal_kswapd_normal");
 183         hash_pswpin = simple_hash("pswpin");
 184         hash_pswpout = simple_hash("pswpout");
 185         // hash_slabs_scanned = simple_hash("slabs_scanned");
 186         // hash_thp_collapse_alloc = simple_hash("thp_collapse_alloc");
 187         // hash_thp_collapse_alloc_failed = simple_hash("thp_collapse_alloc_failed");
 188         // hash_thp_fault_alloc = simple_hash("thp_fault_alloc");
 189         // hash_thp_fault_fallback = simple_hash("thp_fault_fallback");
 190         // hash_thp_split = simple_hash("thp_split");
 191         // hash_unevictable_pgs_cleared = simple_hash("unevictable_pgs_cleared");
 192         // hash_unevictable_pgs_culled = simple_hash("unevictable_pgs_culled");
 193         // hash_unevictable_pgs_mlocked = simple_hash("unevictable_pgs_mlocked");
 194         // hash_unevictable_pgs_mlockfreed = simple_hash("unevictable_pgs_mlockfreed");
 195         // hash_unevictable_pgs_munlocked = simple_hash("unevictable_pgs_munlocked");
 196         // hash_unevictable_pgs_rescued = simple_hash("unevictable_pgs_rescued");
 197         // hash_unevictable_pgs_scanned = simple_hash("unevictable_pgs_scanned");
 198         // hash_unevictable_pgs_stranded = simple_hash("unevictable_pgs_stranded");
 199     }
 200
 201     if(unlikely(!ff)) {
 202         char filename[FILENAME_MAX + 1];
 203         snprintfz(filename, FILENAME_MAX, "%s%s", global_host_prefix, "/proc/vmstat");
 204         ff = procfile_open(config_get("plugin:proc:/proc/vmstat", "filename to monitor", filename), " \t:", PROCFILE_FLAG_DEFAULT);
 205         if(unlikely(!ff)) return 1;
 206     }
 207
 208     ff = procfile_readall(ff);
 209     if(unlikely(!ff)) return 0; // we return 0, so that we will retry to open it next time
 210
 211     uint32_t lines = procfile_lines(ff), l;
 212     uint32_t words;
 213
 214     // unsigned long long allocstall = 0ULL;
 215     // unsigned long long compact_blocks_moved = 0ULL;
 216     // unsigned long long compact_fail = 0ULL;
 217     // unsigned long long compact_pagemigrate_failed = 0ULL;
 218     // unsigned long long compact_pages_moved = 0ULL;
 219     // unsigned long long compact_stall = 0ULL;
 220     // unsigned long long compact_success = 0ULL;
 221     // unsigned long long htlb_buddy_alloc_fail = 0ULL;
 222     // unsigned long long htlb_buddy_alloc_success = 0ULL;
 223     // unsigned long long kswapd_high_wmark_hit_quickly = 0ULL;
 224     // unsigned long long kswapd_inodesteal = 0ULL;
 225     // unsigned long long kswapd_low_wmark_hit_quickly = 0ULL;
 226     // unsigned long long kswapd_skip_congestion_wait = 0ULL;
 227     // unsigned long long nr_active_anon = 0ULL;
 228     // unsigned long long nr_active_file = 0ULL;
 229     // unsigned long long nr_anon_pages = 0ULL;
 230     // unsigned long long nr_anon_transparent_hugepages = 0ULL;
 231     // unsigned long long nr_bounce = 0ULL;
 232     // unsigned long long nr_dirtied = 0ULL;
 233     // unsigned long long nr_dirty = 0ULL;
 234     // unsigned long long nr_dirty_background_threshold = 0ULL;
 235     // unsigned long long nr_dirty_threshold = 0ULL;
 236     // unsigned long long nr_file_pages = 0ULL;
 237     // unsigned long long nr_free_pages = 0ULL;
 238     // unsigned long long nr_inactive_anon = 0ULL;
 239     // unsigned long long nr_inactive_file = 0ULL;
 240     // unsigned long long nr_isolated_anon = 0ULL;
 241     // unsigned long long nr_isolated_file = 0ULL;
 242     // unsigned long long nr_kernel_stack = 0ULL;
 243     // unsigned long long nr_mapped = 0ULL;
 244     // unsigned long long nr_mlock = 0ULL;
 245     // unsigned long long nr_page_table_pages = 0ULL;
 246     // unsigned long long nr_shmem = 0ULL;
 247     // unsigned long long nr_slab_reclaimable = 0ULL;
 248     // unsigned long long nr_slab_unreclaimable = 0ULL;
 249     // unsigned long long nr_unevictable = 0ULL;
 250     // unsigned long long nr_unstable = 0ULL;
 251     // unsigned long long nr_vmscan_immediate_reclaim = 0ULL;
 252     // unsigned long long nr_vmscan_write = 0ULL;
 253     // unsigned long long nr_writeback = 0ULL;
 254     // unsigned long long nr_writeback_temp = 0ULL;
 255     // unsigned long long nr_written = 0ULL;
 256     // unsigned long long pageoutrun = 0ULL;
 257     // unsigned long long pgactivate = 0ULL;
 258     // unsigned long long pgalloc_dma = 0ULL;
 259     // unsigned long long pgalloc_dma32 = 0ULL;
 260     // unsigned long long pgalloc_movable = 0ULL;
 261     // unsigned long long pgalloc_normal = 0ULL;
 262     // unsigned long long pgdeactivate = 0ULL;
 263     unsigned long long pgfault = 0ULL;
 264     // unsigned long long pgfree = 0ULL;
 265     // unsigned long long pginodesteal = 0ULL;
 266     unsigned long long pgmajfault = 0ULL;
 267     unsigned long long pgpgin = 0ULL;
 268     unsigned long long pgpgout = 0ULL;
 269     // unsigned long long pgrefill_dma = 0ULL;
 270     // unsigned long long pgrefill_dma32 = 0ULL;
 271     // unsigned long long pgrefill_movable = 0ULL;
 272     // unsigned long long pgrefill_normal = 0ULL;
 273     // unsigned long long pgrotated = 0ULL;
 274     // unsigned long long pgscan_direct_dma = 0ULL;
 275     // unsigned long long pgscan_direct_dma32 = 0ULL;
 276     // unsigned long long pgscan_direct_movable = 0ULL;
 277     // unsigned long long pgscan_direct_normal = 0ULL;
 278     // unsigned long long pgscan_kswapd_dma = 0ULL;
 279     // unsigned long long pgscan_kswapd_dma32 = 0ULL;
 280     // unsigned long long pgscan_kswapd_movable = 0ULL;
 281     // unsigned long long pgscan_kswapd_normal = 0ULL;
 282     // unsigned long long pgsteal_direct_dma = 0ULL;
 283     // unsigned long long pgsteal_direct_dma32 = 0ULL;
 284     // unsigned long long pgsteal_direct_movable = 0ULL;
 285     // unsigned long long pgsteal_direct_normal = 0ULL;
 286     // unsigned long long pgsteal_kswapd_dma = 0ULL;
 287     // unsigned long long pgsteal_kswapd_dma32 = 0ULL;
 288     // unsigned long long pgsteal_kswapd_movable = 0ULL;
 289     // unsigned long long pgsteal_kswapd_normal = 0ULL;
 290     unsigned long long pswpin = 0ULL;
 291     unsigned long long pswpout = 0ULL;
 292     // unsigned long long slabs_scanned = 0ULL;
 293     // unsigned long long thp_collapse_alloc = 0ULL;
 294     // unsigned long long thp_collapse_alloc_failed = 0ULL;
 295     // unsigned long long thp_fault_alloc = 0ULL;
 296     // unsigned long long thp_fault_fallback = 0ULL;
 297     // unsigned long long thp_split = 0ULL;
 298     // unsigned long long unevictable_pgs_cleared = 0ULL;
 299     // unsigned long long unevictable_pgs_culled = 0ULL;
 300     // unsigned long long unevictable_pgs_mlocked = 0ULL;
 301     // unsigned long long unevictable_pgs_mlockfreed = 0ULL;
 302     // unsigned long long unevictable_pgs_munlocked = 0ULL;
 303     // unsigned long long unevictable_pgs_rescued = 0ULL;
 304     // unsigned long long unevictable_pgs_scanned = 0ULL;
 305     // unsigned long long unevictable_pgs_stranded = 0ULL;
 306
 307     for(l = 0; l < lines ;l++) {
 308         words = procfile_linewords(ff, l);
 309         if(unlikely(words < 2)) {
 310             if(unlikely(words)) error("Cannot read /proc/vmstat line %u. Expected 2 params, read %u.", l, words);
 311             continue;
 312         }
 313
 314         char *name = procfile_lineword(ff, l, 0);
 315         char * value = procfile_lineword(ff, l, 1);
 316         if(unlikely(!name || !*name || !value || !*value)) continue;
 317
 318         uint32_t hash = simple_hash(name);
 319
 320         if(unlikely(0)) ;
 321         // else if(unlikely(hash == hash_allocstall && strcmp(name, "allocstall") == 0)) allocstall = strtoull(value, NULL, 10);
 322         // else if(unlikely(hash == hash_compact_blocks_moved && strcmp(name, "compact_blocks_moved") == 0)) compact_blocks_moved = strtoull(value, NULL, 10);
 323         // else if(unlikely(hash == hash_compact_fail && strcmp(name, "compact_fail") == 0)) compact_fail = strtoull(value, NULL, 10);
 324         // else if(unlikely(hash == hash_compact_pagemigrate_failed && strcmp(name, "compact_pagemigrate_failed") == 0)) compact_pagemigrate_failed = strtoull(value, NULL, 10);
 325         // else if(unlikely(hash == hash_compact_pages_moved && strcmp(name, "compact_pages_moved") == 0)) compact_pages_moved = strtoull(value, NULL, 10);
 326         // else if(unlikely(hash == hash_compact_stall && strcmp(name, "compact_stall") == 0)) compact_stall = strtoull(value, NULL, 10);
 327         // else if(unlikely(hash == hash_compact_success && strcmp(name, "compact_success") == 0)) compact_success = strtoull(value, NULL, 10);
 328         // else if(unlikely(hash == hash_htlb_buddy_alloc_fail && strcmp(name, "htlb_buddy_alloc_fail") == 0)) htlb_buddy_alloc_fail = strtoull(value, NULL, 10);
 329         // else if(unlikely(hash == hash_htlb_buddy_alloc_success && strcmp(name, "htlb_buddy_alloc_success") == 0)) htlb_buddy_alloc_success = strtoull(value, NULL, 10);
 330         // else if(unlikely(hash == hash_kswapd_high_wmark_hit_quickly && strcmp(name, "kswapd_high_wmark_hit_quickly") == 0)) kswapd_high_wmark_hit_quickly = strtoull(value, NULL, 10);
 331         // else if(unlikely(hash == hash_kswapd_inodesteal && strcmp(name, "kswapd_inodesteal") == 0)) kswapd_inodesteal = strtoull(value, NULL, 10);
 332         // else if(unlikely(hash == hash_kswapd_low_wmark_hit_quickly && strcmp(name, "kswapd_low_wmark_hit_quickly") == 0)) kswapd_low_wmark_hit_quickly = strtoull(value, NULL, 10);
 333         // else if(unlikely(hash == hash_kswapd_skip_congestion_wait && strcmp(name, "kswapd_skip_congestion_wait") == 0)) kswapd_skip_congestion_wait = strtoull(value, NULL, 10);
 334         // else if(unlikely(hash == hash_nr_active_anon && strcmp(name, "nr_active_anon") == 0)) nr_active_anon = strtoull(value, NULL, 10);
 335         // else if(unlikely(hash == hash_nr_active_file && strcmp(name, "nr_active_file") == 0)) nr_active_file = strtoull(value, NULL, 10);
 336         // else if(unlikely(hash == hash_nr_anon_pages && strcmp(name, "nr_anon_pages") == 0)) nr_anon_pages = strtoull(value, NULL, 10);
 337         // else if(unlikely(hash == hash_nr_anon_transparent_hugepages && strcmp(name, "nr_anon_transparent_hugepages") == 0)) nr_anon_transparent_hugepages = strtoull(value, NULL, 10);
 338         // else if(unlikely(hash == hash_nr_bounce && strcmp(name, "nr_bounce") == 0)) nr_bounce = strtoull(value, NULL, 10);
 339         // else if(unlikely(hash == hash_nr_dirtied && strcmp(name, "nr_dirtied") == 0)) nr_dirtied = strtoull(value, NULL, 10);
 340         // else if(unlikely(hash == hash_nr_dirty && strcmp(name, "nr_dirty") == 0)) nr_dirty = strtoull(value, NULL, 10);
 341         // else if(unlikely(hash == hash_nr_dirty_background_threshold && strcmp(name, "nr_dirty_background_threshold") == 0)) nr_dirty_background_threshold = strtoull(value, NULL, 10);
 342         // else if(unlikely(hash == hash_nr_dirty_threshold && strcmp(name, "nr_dirty_threshold") == 0)) nr_dirty_threshold = strtoull(value, NULL, 10);
 343         // else if(unlikely(hash == hash_nr_file_pages && strcmp(name, "nr_file_pages") == 0)) nr_file_pages = strtoull(value, NULL, 10);
 344         // else if(unlikely(hash == hash_nr_free_pages && strcmp(name, "nr_free_pages") == 0)) nr_free_pages = strtoull(value, NULL, 10);
 345         // else if(unlikely(hash == hash_nr_inactive_anon && strcmp(name, "nr_inactive_anon") == 0)) nr_inactive_anon = strtoull(value, NULL, 10);
 346         // else if(unlikely(hash == hash_nr_inactive_file && strcmp(name, "nr_inactive_file") == 0)) nr_inactive_file = strtoull(value, NULL, 10);
 347         // else if(unlikely(hash == hash_nr_isolated_anon && strcmp(name, "nr_isolated_anon") == 0)) nr_isolated_anon = strtoull(value, NULL, 10);
 348         // else if(unlikely(hash == hash_nr_isolated_file && strcmp(name, "nr_isolated_file") == 0)) nr_isolated_file = strtoull(value, NULL, 10);
 349         // else if(unlikely(hash == hash_nr_kernel_stack && strcmp(name, "nr_kernel_stack") == 0)) nr_kernel_stack = strtoull(value, NULL, 10);
 350         // else if(unlikely(hash == hash_nr_mapped && strcmp(name, "nr_mapped") == 0)) nr_mapped = strtoull(value, NULL, 10);
 351         // else if(unlikely(hash == hash_nr_mlock && strcmp(name, "nr_mlock") == 0)) nr_mlock = strtoull(value, NULL, 10);
 352         // else if(unlikely(hash == hash_nr_page_table_pages && strcmp(name, "nr_page_table_pages") == 0)) nr_page_table_pages = strtoull(value, NULL, 10);
 353         // else if(unlikely(hash == hash_nr_shmem && strcmp(name, "nr_shmem") == 0)) nr_shmem = strtoull(value, NULL, 10);
 354         // else if(unlikely(hash == hash_nr_slab_reclaimable && strcmp(name, "nr_slab_reclaimable") == 0)) nr_slab_reclaimable = strtoull(value, NULL, 10);
 355         // else if(unlikely(hash == hash_nr_slab_unreclaimable && strcmp(name, "nr_slab_unreclaimable") == 0)) nr_slab_unreclaimable = strtoull(value, NULL, 10);
 356         // else if(unlikely(hash == hash_nr_unevictable && strcmp(name, "nr_unevictable") == 0)) nr_unevictable = strtoull(value, NULL, 10);
 357         // else if(unlikely(hash == hash_nr_unstable && strcmp(name, "nr_unstable") == 0)) nr_unstable = strtoull(value, NULL, 10);
 358         // else if(unlikely(hash == hash_nr_vmscan_immediate_reclaim && strcmp(name, "nr_vmscan_immediate_reclaim") == 0)) nr_vmscan_immediate_reclaim = strtoull(value, NULL, 10);
 359         // else if(unlikely(hash == hash_nr_vmscan_write && strcmp(name, "nr_vmscan_write") == 0)) nr_vmscan_write = strtoull(value, NULL, 10);
 360         // else if(unlikely(hash == hash_nr_writeback && strcmp(name, "nr_writeback") == 0)) nr_writeback = strtoull(value, NULL, 10);
 361         // else if(unlikely(hash == hash_nr_writeback_temp && strcmp(name, "nr_writeback_temp") == 0)) nr_writeback_temp = strtoull(value, NULL, 10);
 362         // else if(unlikely(hash == hash_nr_written && strcmp(name, "nr_written") == 0)) nr_written = strtoull(value, NULL, 10);
 363         // else if(unlikely(hash == hash_pageoutrun && strcmp(name, "pageoutrun") == 0)) pageoutrun = strtoull(value, NULL, 10);
 364         // else if(unlikely(hash == hash_pgactivate && strcmp(name, "pgactivate") == 0)) pgactivate = strtoull(value, NULL, 10);
 365         // else if(unlikely(hash == hash_pgalloc_dma && strcmp(name, "pgalloc_dma") == 0)) pgalloc_dma = strtoull(value, NULL, 10);
 366         // else if(unlikely(hash == hash_pgalloc_dma32 && strcmp(name, "pgalloc_dma32") == 0)) pgalloc_dma32 = strtoull(value, NULL, 10);
 367         // else if(unlikely(hash == hash_pgalloc_movable && strcmp(name, "pgalloc_movable") == 0)) pgalloc_movable = strtoull(value, NULL, 10);
 368         // else if(unlikely(hash == hash_pgalloc_normal && strcmp(name, "pgalloc_normal") == 0)) pgalloc_normal = strtoull(value, NULL, 10);
 369         // else if(unlikely(hash == hash_pgdeactivate && strcmp(name, "pgdeactivate") == 0)) pgdeactivate = strtoull(value, NULL, 10);
 370         else if(unlikely(hash == hash_pgfault && strcmp(name, "pgfault") == 0)) pgfault = strtoull(value, NULL, 10);
 371         // else if(unlikely(hash == hash_pgfree && strcmp(name, "pgfree") == 0)) pgfree = strtoull(value, NULL, 10);
 372         // else if(unlikely(hash == hash_pginodesteal && strcmp(name, "pginodesteal") == 0)) pginodesteal = strtoull(value, NULL, 10);
 373         else if(unlikely(hash == hash_pgmajfault && strcmp(name, "pgmajfault") == 0)) pgmajfault = strtoull(value, NULL, 10);
 374         else if(unlikely(hash == hash_pgpgin && strcmp(name, "pgpgin") == 0)) pgpgin = strtoull(value, NULL, 10);
 375         else if(unlikely(hash == hash_pgpgout && strcmp(name, "pgpgout") == 0)) pgpgout = strtoull(value, NULL, 10);
 376         // else if(unlikely(hash == hash_pgrefill_dma && strcmp(name, "pgrefill_dma") == 0)) pgrefill_dma = strtoull(value, NULL, 10);
 377         // else if(unlikely(hash == hash_pgrefill_dma32 && strcmp(name, "pgrefill_dma32") == 0)) pgrefill_dma32 = strtoull(value, NULL, 10);
 378         // else if(unlikely(hash == hash_pgrefill_movable && strcmp(name, "pgrefill_movable") == 0)) pgrefill_movable = strtoull(value, NULL, 10);
 379         // else if(unlikely(hash == hash_pgrefill_normal && strcmp(name, "pgrefill_normal") == 0)) pgrefill_normal = strtoull(value, NULL, 10);
 380         // else if(unlikely(hash == hash_pgrotated && strcmp(name, "pgrotated") == 0)) pgrotated = strtoull(value, NULL, 10);
 381         // else if(unlikely(hash == hash_pgscan_direct_dma && strcmp(name, "pgscan_direct_dma") == 0)) pgscan_direct_dma = strtoull(value, NULL, 10);
 382         // else if(unlikely(hash == hash_pgscan_direct_dma32 && strcmp(name, "pgscan_direct_dma32") == 0)) pgscan_direct_dma32 = strtoull(value, NULL, 10);
 383         // else if(unlikely(hash == hash_pgscan_direct_movable && strcmp(name, "pgscan_direct_movable") == 0)) pgscan_direct_movable = strtoull(value, NULL, 10);
 384         // else if(unlikely(hash == hash_pgscan_direct_normal && strcmp(name, "pgscan_direct_normal") == 0)) pgscan_direct_normal = strtoull(value, NULL, 10);
 385         // else if(unlikely(hash == hash_pgscan_kswapd_dma && strcmp(name, "pgscan_kswapd_dma") == 0)) pgscan_kswapd_dma = strtoull(value, NULL, 10);
 386         // else if(unlikely(hash == hash_pgscan_kswapd_dma32 && strcmp(name, "pgscan_kswapd_dma32") == 0)) pgscan_kswapd_dma32 = strtoull(value, NULL, 10);
 387         // else if(unlikely(hash == hash_pgscan_kswapd_movable && strcmp(name, "pgscan_kswapd_movable") == 0)) pgscan_kswapd_movable = strtoull(value, NULL, 10);
 388         // else if(unlikely(hash == hash_pgscan_kswapd_normal && strcmp(name, "pgscan_kswapd_normal") == 0)) pgscan_kswapd_normal = strtoull(value, NULL, 10);
 389         // else if(unlikely(hash == hash_pgsteal_direct_dma && strcmp(name, "pgsteal_direct_dma") == 0)) pgsteal_direct_dma = strtoull(value, NULL, 10);
 390         // else if(unlikely(hash == hash_pgsteal_direct_dma32 && strcmp(name, "pgsteal_direct_dma32") == 0)) pgsteal_direct_dma32 = strtoull(value, NULL, 10);
 391         // else if(unlikely(hash == hash_pgsteal_direct_movable && strcmp(name, "pgsteal_direct_movable") == 0)) pgsteal_direct_movable = strtoull(value, NULL, 10);
 392         // else if(unlikely(hash == hash_pgsteal_direct_normal && strcmp(name, "pgsteal_direct_normal") == 0)) pgsteal_direct_normal = strtoull(value, NULL, 10);
 393         // else if(unlikely(hash == hash_pgsteal_kswapd_dma && strcmp(name, "pgsteal_kswapd_dma") == 0)) pgsteal_kswapd_dma = strtoull(value, NULL, 10);
 394         // else if(unlikely(hash == hash_pgsteal_kswapd_dma32 && strcmp(name, "pgsteal_kswapd_dma32") == 0)) pgsteal_kswapd_dma32 = strtoull(value, NULL, 10);
 395         // else if(unlikely(hash == hash_pgsteal_kswapd_movable && strcmp(name, "pgsteal_kswapd_movable") == 0)) pgsteal_kswapd_movable = strtoull(value, NULL, 10);
 396         // else if(unlikely(hash == hash_pgsteal_kswapd_normal && strcmp(name, "pgsteal_kswapd_normal") == 0)) pgsteal_kswapd_normal = strtoull(value, NULL, 10);
 397         else if(unlikely(hash == hash_pswpin && strcmp(name, "pswpin") == 0)) pswpin = strtoull(value, NULL, 10);
 398         else if(unlikely(hash == hash_pswpout && strcmp(name, "pswpout") == 0)) pswpout = strtoull(value, NULL, 10);
 399         // else if(unlikely(hash == hash_slabs_scanned && strcmp(name, "slabs_scanned") == 0)) slabs_scanned = strtoull(value, NULL, 10);
 400         // else if(unlikely(hash == hash_thp_collapse_alloc && strcmp(name, "thp_collapse_alloc") == 0)) thp_collapse_alloc = strtoull(value, NULL, 10);
 401         // else if(unlikely(hash == hash_thp_collapse_alloc_failed && strcmp(name, "thp_collapse_alloc_failed") == 0)) thp_collapse_alloc_failed = strtoull(value, NULL, 10);
 402         // else if(unlikely(hash == hash_thp_fault_alloc && strcmp(name, "thp_fault_alloc") == 0)) thp_fault_alloc = strtoull(value, NULL, 10);
 403         // else if(unlikely(hash == hash_thp_fault_fallback && strcmp(name, "thp_fault_fallback") == 0)) thp_fault_fallback = strtoull(value, NULL, 10);
 404         // else if(unlikely(hash == hash_thp_split && strcmp(name, "thp_split") == 0)) thp_split = strtoull(value, NULL, 10);
 405         // else if(unlikely(hash == hash_unevictable_pgs_cleared && strcmp(name, "unevictable_pgs_cleared") == 0)) unevictable_pgs_cleared = strtoull(value, NULL, 10);
 406         // else if(unlikely(hash == hash_unevictable_pgs_culled && strcmp(name, "unevictable_pgs_culled") == 0)) unevictable_pgs_culled = strtoull(value, NULL, 10);
 407         // else if(unlikely(hash == hash_unevictable_pgs_mlocked && strcmp(name, "unevictable_pgs_mlocked") == 0)) unevictable_pgs_mlocked = strtoull(value, NULL, 10);
 408         // else if(unlikely(hash == hash_unevictable_pgs_mlockfreed && strcmp(name, "unevictable_pgs_mlockfreed") == 0)) unevictable_pgs_mlockfreed = strtoull(value, NULL, 10);
 409         // else if(unlikely(hash == hash_unevictable_pgs_munlocked && strcmp(name, "unevictable_pgs_munlocked") == 0)) unevictable_pgs_munlocked = strtoull(value, NULL, 10);
 410         // else if(unlikely(hash == hash_unevictable_pgs_rescued && strcmp(name, "unevictable_pgs_rescued") == 0)) unevictable_pgs_rescued = strtoull(value, NULL, 10);
 411         // else if(unlikely(hash == hash_unevictable_pgs_scanned && strcmp(name, "unevictable_pgs_scanned") == 0)) unevictable_pgs_scanned = strtoull(value, NULL, 10);
 412         // else if(unlikely(hash == hash_unevictable_pgs_stranded && strcmp(name, "unevictable_pgs_stranded") == 0)) unevictable_pgs_stranded = strtoull(value, NULL, 10);
 413     }
 414
 415     // --------------------------------------------------------------------
 416
 417     if(pswpin || pswpout || do_swapio == CONFIG_ONDEMAND_YES) {
 418         do_swapio = CONFIG_ONDEMAND_YES;
 419
 420         static RRDSET *st_swapio = NULL;
 421         if(unlikely(!st_swapio)) {
 422             st_swapio = rrdset_create("system", "swapio", NULL, "swap", NULL, "Swap I/O", "kilobytes/s", 250, update_every, RRDSET_TYPE_AREA);
 423
 424             rrddim_add(st_swapio, "in",  NULL, sysconf(_SC_PAGESIZE), 1024, RRDDIM_INCREMENTAL);
 425             rrddim_add(st_swapio, "out", NULL, -sysconf(_SC_PAGESIZE), 1024, RRDDIM_INCREMENTAL);
 426         }
 427         else rrdset_next(st_swapio);
 428
 429         rrddim_set(st_swapio, "in", pswpin);
 430         rrddim_set(st_swapio, "out", pswpout);
 431         rrdset_done(st_swapio);
 432     }
 433
 434     // --------------------------------------------------------------------
 435
 436     if(do_io) {
 437         static RRDSET *st_io = NULL;
 438         if(unlikely(!st_io)) {
 439             st_io = rrdset_create("system", "io", NULL, "disk", NULL, "Disk I/O", "kilobytes/s", 150, update_every, RRDSET_TYPE_AREA);
 440
 441             rrddim_add(st_io, "in",  NULL,  1, 1, RRDDIM_INCREMENTAL);
 442             rrddim_add(st_io, "out", NULL, -1, 1, RRDDIM_INCREMENTAL);
 443         }
 444         else rrdset_next(st_io);
 445
 446         rrddim_set(st_io, "in", pgpgin);
 447         rrddim_set(st_io, "out", pgpgout);
 448         rrdset_done(st_io);
 449     }
 450
 451     // --------------------------------------------------------------------
 452
 453     if(do_pgfaults) {
 454         static RRDSET *st_pgfaults = NULL;
 455         if(unlikely(!st_pgfaults)) {
 456             st_pgfaults = rrdset_create("mem", "pgfaults", NULL, "system", NULL, "Memory Page Faults", "page faults/s", 500, update_every, RRDSET_TYPE_LINE);
 457             st_pgfaults->isdetail = 1;
 458
 459             rrddim_add(st_pgfaults, "minor",  NULL,  1, 1, RRDDIM_INCREMENTAL);
 460             rrddim_add(st_pgfaults, "major", NULL, -1, 1, RRDDIM_INCREMENTAL);
 461         }
 462         else rrdset_next(st_pgfaults);
 463
 464         rrddim_set(st_pgfaults, "minor", pgfault);
 465         rrddim_set(st_pgfaults, "major", pgmajfault);
 466         rrdset_done(st_pgfaults);
 467     }
 468
 469     return 0;
 470 }
 471