vmstat.c revision 468fd62ed9090ccbe872489df5d0d099510df4b5
1/* 2 * linux/mm/vmstat.c 3 * 4 * Manages VM statistics 5 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds 6 * 7 * zoned VM statistics 8 * Copyright (C) 2006 Silicon Graphics, Inc., 9 * Christoph Lameter <christoph@lameter.com> 10 */ 11 12#include <linux/mm.h> 13#include <linux/err.h> 14#include <linux/module.h> 15#include <linux/cpu.h> 16#include <linux/sched.h> 17 18#ifdef CONFIG_VM_EVENT_COUNTERS 19DEFINE_PER_CPU(struct vm_event_state, vm_event_states) = {{0}}; 20EXPORT_PER_CPU_SYMBOL(vm_event_states); 21 22static void sum_vm_events(unsigned long *ret, cpumask_t *cpumask) 23{ 24 int cpu; 25 int i; 26 27 memset(ret, 0, NR_VM_EVENT_ITEMS * sizeof(unsigned long)); 28 29 for_each_cpu_mask(cpu, *cpumask) { 30 struct vm_event_state *this = &per_cpu(vm_event_states, cpu); 31 32 for (i = 0; i < NR_VM_EVENT_ITEMS; i++) 33 ret[i] += this->event[i]; 34 } 35} 36 37/* 38 * Accumulate the vm event counters across all CPUs. 39 * The result is unavoidably approximate - it can change 40 * during and after execution of this function. 41*/ 42void all_vm_events(unsigned long *ret) 43{ 44 sum_vm_events(ret, &cpu_online_map); 45} 46EXPORT_SYMBOL_GPL(all_vm_events); 47 48#ifdef CONFIG_HOTPLUG 49/* 50 * Fold the foreign cpu events into our own. 51 * 52 * This is adding to the events on one processor 53 * but keeps the global counts constant. 54 */ 55void vm_events_fold_cpu(int cpu) 56{ 57 struct vm_event_state *fold_state = &per_cpu(vm_event_states, cpu); 58 int i; 59 60 for (i = 0; i < NR_VM_EVENT_ITEMS; i++) { 61 count_vm_events(i, fold_state->event[i]); 62 fold_state->event[i] = 0; 63 } 64} 65#endif /* CONFIG_HOTPLUG */ 66 67#endif /* CONFIG_VM_EVENT_COUNTERS */ 68 69/* 70 * Manage combined zone based / global counters 71 * 72 * vm_stat contains the global counters 73 */ 74atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS]; 75EXPORT_SYMBOL(vm_stat); 76 77#ifdef CONFIG_SMP 78 79static int calculate_threshold(struct zone *zone) 80{ 81 int threshold; 82 int mem; /* memory in 128 MB units */ 83 84 /* 85 * The threshold scales with the number of processors and the amount 86 * of memory per zone. More memory means that we can defer updates for 87 * longer, more processors could lead to more contention. 88 * fls() is used to have a cheap way of logarithmic scaling. 89 * 90 * Some sample thresholds: 91 * 92 * Threshold Processors (fls) Zonesize fls(mem+1) 93 * ------------------------------------------------------------------ 94 * 8 1 1 0.9-1 GB 4 95 * 16 2 2 0.9-1 GB 4 96 * 20 2 2 1-2 GB 5 97 * 24 2 2 2-4 GB 6 98 * 28 2 2 4-8 GB 7 99 * 32 2 2 8-16 GB 8 100 * 4 2 2 <128M 1 101 * 30 4 3 2-4 GB 5 102 * 48 4 3 8-16 GB 8 103 * 32 8 4 1-2 GB 4 104 * 32 8 4 0.9-1GB 4 105 * 10 16 5 <128M 1 106 * 40 16 5 900M 4 107 * 70 64 7 2-4 GB 5 108 * 84 64 7 4-8 GB 6 109 * 108 512 9 4-8 GB 6 110 * 125 1024 10 8-16 GB 8 111 * 125 1024 10 16-32 GB 9 112 */ 113 114 mem = zone->present_pages >> (27 - PAGE_SHIFT); 115 116 threshold = 2 * fls(num_online_cpus()) * (1 + fls(mem)); 117 118 /* 119 * Maximum threshold is 125 120 */ 121 threshold = min(125, threshold); 122 123 return threshold; 124} 125 126/* 127 * Refresh the thresholds for each zone. 128 */ 129static void refresh_zone_stat_thresholds(void) 130{ 131 struct zone *zone; 132 int cpu; 133 int threshold; 134 135 for_each_zone(zone) { 136 137 if (!zone->present_pages) 138 continue; 139 140 threshold = calculate_threshold(zone); 141 142 for_each_online_cpu(cpu) 143 zone_pcp(zone, cpu)->stat_threshold = threshold; 144 } 145} 146 147/* 148 * For use when we know that interrupts are disabled. 149 */ 150void __mod_zone_page_state(struct zone *zone, enum zone_stat_item item, 151 int delta) 152{ 153 struct per_cpu_pageset *pcp = zone_pcp(zone, smp_processor_id()); 154 s8 *p = pcp->vm_stat_diff + item; 155 long x; 156 157 x = delta + *p; 158 159 if (unlikely(x > pcp->stat_threshold || x < -pcp->stat_threshold)) { 160 zone_page_state_add(x, zone, item); 161 x = 0; 162 } 163 *p = x; 164} 165EXPORT_SYMBOL(__mod_zone_page_state); 166 167/* 168 * For an unknown interrupt state 169 */ 170void mod_zone_page_state(struct zone *zone, enum zone_stat_item item, 171 int delta) 172{ 173 unsigned long flags; 174 175 local_irq_save(flags); 176 __mod_zone_page_state(zone, item, delta); 177 local_irq_restore(flags); 178} 179EXPORT_SYMBOL(mod_zone_page_state); 180 181/* 182 * Optimized increment and decrement functions. 183 * 184 * These are only for a single page and therefore can take a struct page * 185 * argument instead of struct zone *. This allows the inclusion of the code 186 * generated for page_zone(page) into the optimized functions. 187 * 188 * No overflow check is necessary and therefore the differential can be 189 * incremented or decremented in place which may allow the compilers to 190 * generate better code. 191 * The increment or decrement is known and therefore one boundary check can 192 * be omitted. 193 * 194 * NOTE: These functions are very performance sensitive. Change only 195 * with care. 196 * 197 * Some processors have inc/dec instructions that are atomic vs an interrupt. 198 * However, the code must first determine the differential location in a zone 199 * based on the processor number and then inc/dec the counter. There is no 200 * guarantee without disabling preemption that the processor will not change 201 * in between and therefore the atomicity vs. interrupt cannot be exploited 202 * in a useful way here. 203 */ 204void __inc_zone_state(struct zone *zone, enum zone_stat_item item) 205{ 206 struct per_cpu_pageset *pcp = zone_pcp(zone, smp_processor_id()); 207 s8 *p = pcp->vm_stat_diff + item; 208 209 (*p)++; 210 211 if (unlikely(*p > pcp->stat_threshold)) { 212 int overstep = pcp->stat_threshold / 2; 213 214 zone_page_state_add(*p + overstep, zone, item); 215 *p = -overstep; 216 } 217} 218 219void __inc_zone_page_state(struct page *page, enum zone_stat_item item) 220{ 221 __inc_zone_state(page_zone(page), item); 222} 223EXPORT_SYMBOL(__inc_zone_page_state); 224 225void __dec_zone_state(struct zone *zone, enum zone_stat_item item) 226{ 227 struct per_cpu_pageset *pcp = zone_pcp(zone, smp_processor_id()); 228 s8 *p = pcp->vm_stat_diff + item; 229 230 (*p)--; 231 232 if (unlikely(*p < - pcp->stat_threshold)) { 233 int overstep = pcp->stat_threshold / 2; 234 235 zone_page_state_add(*p - overstep, zone, item); 236 *p = overstep; 237 } 238} 239 240void __dec_zone_page_state(struct page *page, enum zone_stat_item item) 241{ 242 __dec_zone_state(page_zone(page), item); 243} 244EXPORT_SYMBOL(__dec_zone_page_state); 245 246void inc_zone_state(struct zone *zone, enum zone_stat_item item) 247{ 248 unsigned long flags; 249 250 local_irq_save(flags); 251 __inc_zone_state(zone, item); 252 local_irq_restore(flags); 253} 254 255void inc_zone_page_state(struct page *page, enum zone_stat_item item) 256{ 257 unsigned long flags; 258 struct zone *zone; 259 260 zone = page_zone(page); 261 local_irq_save(flags); 262 __inc_zone_state(zone, item); 263 local_irq_restore(flags); 264} 265EXPORT_SYMBOL(inc_zone_page_state); 266 267void dec_zone_page_state(struct page *page, enum zone_stat_item item) 268{ 269 unsigned long flags; 270 271 local_irq_save(flags); 272 __dec_zone_page_state(page, item); 273 local_irq_restore(flags); 274} 275EXPORT_SYMBOL(dec_zone_page_state); 276 277/* 278 * Update the zone counters for one cpu. 279 * 280 * The cpu specified must be either the current cpu or a processor that 281 * is not online. If it is the current cpu then the execution thread must 282 * be pinned to the current cpu. 283 * 284 * Note that refresh_cpu_vm_stats strives to only access 285 * node local memory. The per cpu pagesets on remote zones are placed 286 * in the memory local to the processor using that pageset. So the 287 * loop over all zones will access a series of cachelines local to 288 * the processor. 289 * 290 * The call to zone_page_state_add updates the cachelines with the 291 * statistics in the remote zone struct as well as the global cachelines 292 * with the global counters. These could cause remote node cache line 293 * bouncing and will have to be only done when necessary. 294 */ 295void refresh_cpu_vm_stats(int cpu) 296{ 297 struct zone *zone; 298 int i; 299 int global_diff[NR_VM_ZONE_STAT_ITEMS] = { 0, }; 300 301 for_each_zone(zone) { 302 struct per_cpu_pageset *p; 303 304 if (!populated_zone(zone)) 305 continue; 306 307 p = zone_pcp(zone, cpu); 308 309 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++) 310 if (p->vm_stat_diff[i]) { 311 unsigned long flags; 312 int v; 313 314 local_irq_save(flags); 315 v = p->vm_stat_diff[i]; 316 p->vm_stat_diff[i] = 0; 317 local_irq_restore(flags); 318 atomic_long_add(v, &zone->vm_stat[i]); 319 global_diff[i] += v; 320#ifdef CONFIG_NUMA 321 /* 3 seconds idle till flush */ 322 p->expire = 3; 323#endif 324 } 325 cond_resched(); 326#ifdef CONFIG_NUMA 327 /* 328 * Deal with draining the remote pageset of this 329 * processor 330 * 331 * Check if there are pages remaining in this pageset 332 * if not then there is nothing to expire. 333 */ 334 if (!p->expire || !p->pcp.count) 335 continue; 336 337 /* 338 * We never drain zones local to this processor. 339 */ 340 if (zone_to_nid(zone) == numa_node_id()) { 341 p->expire = 0; 342 continue; 343 } 344 345 p->expire--; 346 if (p->expire) 347 continue; 348 349 if (p->pcp.count) 350 drain_zone_pages(zone, &p->pcp); 351#endif 352 } 353 354 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++) 355 if (global_diff[i]) 356 atomic_long_add(global_diff[i], &vm_stat[i]); 357} 358 359#endif 360 361#ifdef CONFIG_NUMA 362/* 363 * zonelist = the list of zones passed to the allocator 364 * z = the zone from which the allocation occurred. 365 * 366 * Must be called with interrupts disabled. 367 */ 368void zone_statistics(struct zone *preferred_zone, struct zone *z) 369{ 370 if (z->zone_pgdat == preferred_zone->zone_pgdat) { 371 __inc_zone_state(z, NUMA_HIT); 372 } else { 373 __inc_zone_state(z, NUMA_MISS); 374 __inc_zone_state(preferred_zone, NUMA_FOREIGN); 375 } 376 if (z->node == numa_node_id()) 377 __inc_zone_state(z, NUMA_LOCAL); 378 else 379 __inc_zone_state(z, NUMA_OTHER); 380} 381#endif 382 383#ifdef CONFIG_PROC_FS 384 385#include <linux/seq_file.h> 386 387static char * const migratetype_names[MIGRATE_TYPES] = { 388 "Unmovable", 389 "Reclaimable", 390 "Movable", 391 "Reserve", 392 "Isolate", 393}; 394 395static void *frag_start(struct seq_file *m, loff_t *pos) 396{ 397 pg_data_t *pgdat; 398 loff_t node = *pos; 399 for (pgdat = first_online_pgdat(); 400 pgdat && node; 401 pgdat = next_online_pgdat(pgdat)) 402 --node; 403 404 return pgdat; 405} 406 407static void *frag_next(struct seq_file *m, void *arg, loff_t *pos) 408{ 409 pg_data_t *pgdat = (pg_data_t *)arg; 410 411 (*pos)++; 412 return next_online_pgdat(pgdat); 413} 414 415static void frag_stop(struct seq_file *m, void *arg) 416{ 417} 418 419/* Walk all the zones in a node and print using a callback */ 420static void walk_zones_in_node(struct seq_file *m, pg_data_t *pgdat, 421 void (*print)(struct seq_file *m, pg_data_t *, struct zone *)) 422{ 423 struct zone *zone; 424 struct zone *node_zones = pgdat->node_zones; 425 unsigned long flags; 426 427 for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) { 428 if (!populated_zone(zone)) 429 continue; 430 431 spin_lock_irqsave(&zone->lock, flags); 432 print(m, pgdat, zone); 433 spin_unlock_irqrestore(&zone->lock, flags); 434 } 435} 436 437static void frag_show_print(struct seq_file *m, pg_data_t *pgdat, 438 struct zone *zone) 439{ 440 int order; 441 442 seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name); 443 for (order = 0; order < MAX_ORDER; ++order) 444 seq_printf(m, "%6lu ", zone->free_area[order].nr_free); 445 seq_putc(m, '\n'); 446} 447 448/* 449 * This walks the free areas for each zone. 450 */ 451static int frag_show(struct seq_file *m, void *arg) 452{ 453 pg_data_t *pgdat = (pg_data_t *)arg; 454 walk_zones_in_node(m, pgdat, frag_show_print); 455 return 0; 456} 457 458static void pagetypeinfo_showfree_print(struct seq_file *m, 459 pg_data_t *pgdat, struct zone *zone) 460{ 461 int order, mtype; 462 463 for (mtype = 0; mtype < MIGRATE_TYPES; mtype++) { 464 seq_printf(m, "Node %4d, zone %8s, type %12s ", 465 pgdat->node_id, 466 zone->name, 467 migratetype_names[mtype]); 468 for (order = 0; order < MAX_ORDER; ++order) { 469 unsigned long freecount = 0; 470 struct free_area *area; 471 struct list_head *curr; 472 473 area = &(zone->free_area[order]); 474 475 list_for_each(curr, &area->free_list[mtype]) 476 freecount++; 477 seq_printf(m, "%6lu ", freecount); 478 } 479 seq_putc(m, '\n'); 480 } 481} 482 483/* Print out the free pages at each order for each migatetype */ 484static int pagetypeinfo_showfree(struct seq_file *m, void *arg) 485{ 486 int order; 487 pg_data_t *pgdat = (pg_data_t *)arg; 488 489 /* Print header */ 490 seq_printf(m, "%-43s ", "Free pages count per migrate type at order"); 491 for (order = 0; order < MAX_ORDER; ++order) 492 seq_printf(m, "%6d ", order); 493 seq_putc(m, '\n'); 494 495 walk_zones_in_node(m, pgdat, pagetypeinfo_showfree_print); 496 497 return 0; 498} 499 500static void pagetypeinfo_showblockcount_print(struct seq_file *m, 501 pg_data_t *pgdat, struct zone *zone) 502{ 503 int mtype; 504 unsigned long pfn; 505 unsigned long start_pfn = zone->zone_start_pfn; 506 unsigned long end_pfn = start_pfn + zone->spanned_pages; 507 unsigned long count[MIGRATE_TYPES] = { 0, }; 508 509 for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages) { 510 struct page *page; 511 512 if (!pfn_valid(pfn)) 513 continue; 514 515 page = pfn_to_page(pfn); 516 mtype = get_pageblock_migratetype(page); 517 518 count[mtype]++; 519 } 520 521 /* Print counts */ 522 seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name); 523 for (mtype = 0; mtype < MIGRATE_TYPES; mtype++) 524 seq_printf(m, "%12lu ", count[mtype]); 525 seq_putc(m, '\n'); 526} 527 528/* Print out the free pages at each order for each migratetype */ 529static int pagetypeinfo_showblockcount(struct seq_file *m, void *arg) 530{ 531 int mtype; 532 pg_data_t *pgdat = (pg_data_t *)arg; 533 534 seq_printf(m, "\n%-23s", "Number of blocks type "); 535 for (mtype = 0; mtype < MIGRATE_TYPES; mtype++) 536 seq_printf(m, "%12s ", migratetype_names[mtype]); 537 seq_putc(m, '\n'); 538 walk_zones_in_node(m, pgdat, pagetypeinfo_showblockcount_print); 539 540 return 0; 541} 542 543/* 544 * This prints out statistics in relation to grouping pages by mobility. 545 * It is expensive to collect so do not constantly read the file. 546 */ 547static int pagetypeinfo_show(struct seq_file *m, void *arg) 548{ 549 pg_data_t *pgdat = (pg_data_t *)arg; 550 551 seq_printf(m, "Page block order: %d\n", pageblock_order); 552 seq_printf(m, "Pages per block: %lu\n", pageblock_nr_pages); 553 seq_putc(m, '\n'); 554 pagetypeinfo_showfree(m, pgdat); 555 pagetypeinfo_showblockcount(m, pgdat); 556 557 return 0; 558} 559 560const struct seq_operations fragmentation_op = { 561 .start = frag_start, 562 .next = frag_next, 563 .stop = frag_stop, 564 .show = frag_show, 565}; 566 567const struct seq_operations pagetypeinfo_op = { 568 .start = frag_start, 569 .next = frag_next, 570 .stop = frag_stop, 571 .show = pagetypeinfo_show, 572}; 573 574#ifdef CONFIG_ZONE_DMA 575#define TEXT_FOR_DMA(xx) xx "_dma", 576#else 577#define TEXT_FOR_DMA(xx) 578#endif 579 580#ifdef CONFIG_ZONE_DMA32 581#define TEXT_FOR_DMA32(xx) xx "_dma32", 582#else 583#define TEXT_FOR_DMA32(xx) 584#endif 585 586#ifdef CONFIG_HIGHMEM 587#define TEXT_FOR_HIGHMEM(xx) xx "_high", 588#else 589#define TEXT_FOR_HIGHMEM(xx) 590#endif 591 592#define TEXTS_FOR_ZONES(xx) TEXT_FOR_DMA(xx) TEXT_FOR_DMA32(xx) xx "_normal", \ 593 TEXT_FOR_HIGHMEM(xx) xx "_movable", 594 595static const char * const vmstat_text[] = { 596 /* Zoned VM counters */ 597 "nr_free_pages", 598 "nr_inactive", 599 "nr_active", 600 "nr_anon_pages", 601 "nr_mapped", 602 "nr_file_pages", 603 "nr_dirty", 604 "nr_writeback", 605 "nr_slab_reclaimable", 606 "nr_slab_unreclaimable", 607 "nr_page_table_pages", 608 "nr_unstable", 609 "nr_bounce", 610 "nr_vmscan_write", 611 612#ifdef CONFIG_NUMA 613 "numa_hit", 614 "numa_miss", 615 "numa_foreign", 616 "numa_interleave", 617 "numa_local", 618 "numa_other", 619#endif 620 621#ifdef CONFIG_VM_EVENT_COUNTERS 622 "pgpgin", 623 "pgpgout", 624 "pswpin", 625 "pswpout", 626 627 TEXTS_FOR_ZONES("pgalloc") 628 629 "pgfree", 630 "pgactivate", 631 "pgdeactivate", 632 633 "pgfault", 634 "pgmajfault", 635 636 TEXTS_FOR_ZONES("pgrefill") 637 TEXTS_FOR_ZONES("pgsteal") 638 TEXTS_FOR_ZONES("pgscan_kswapd") 639 TEXTS_FOR_ZONES("pgscan_direct") 640 641 "pginodesteal", 642 "slabs_scanned", 643 "kswapd_steal", 644 "kswapd_inodesteal", 645 "pageoutrun", 646 "allocstall", 647 648 "pgrotated", 649#ifdef CONFIG_HUGETLB_PAGE 650 "htlb_buddy_alloc_success", 651 "htlb_buddy_alloc_fail", 652#endif 653#endif 654}; 655 656static void zoneinfo_show_print(struct seq_file *m, pg_data_t *pgdat, 657 struct zone *zone) 658{ 659 int i; 660 seq_printf(m, "Node %d, zone %8s", pgdat->node_id, zone->name); 661 seq_printf(m, 662 "\n pages free %lu" 663 "\n min %lu" 664 "\n low %lu" 665 "\n high %lu" 666 "\n scanned %lu (a: %lu i: %lu)" 667 "\n spanned %lu" 668 "\n present %lu", 669 zone_page_state(zone, NR_FREE_PAGES), 670 zone->pages_min, 671 zone->pages_low, 672 zone->pages_high, 673 zone->pages_scanned, 674 zone->nr_scan_active, zone->nr_scan_inactive, 675 zone->spanned_pages, 676 zone->present_pages); 677 678 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++) 679 seq_printf(m, "\n %-12s %lu", vmstat_text[i], 680 zone_page_state(zone, i)); 681 682 seq_printf(m, 683 "\n protection: (%lu", 684 zone->lowmem_reserve[0]); 685 for (i = 1; i < ARRAY_SIZE(zone->lowmem_reserve); i++) 686 seq_printf(m, ", %lu", zone->lowmem_reserve[i]); 687 seq_printf(m, 688 ")" 689 "\n pagesets"); 690 for_each_online_cpu(i) { 691 struct per_cpu_pageset *pageset; 692 693 pageset = zone_pcp(zone, i); 694 seq_printf(m, 695 "\n cpu: %i" 696 "\n count: %i" 697 "\n high: %i" 698 "\n batch: %i", 699 i, 700 pageset->pcp.count, 701 pageset->pcp.high, 702 pageset->pcp.batch); 703#ifdef CONFIG_SMP 704 seq_printf(m, "\n vm stats threshold: %d", 705 pageset->stat_threshold); 706#endif 707 } 708 seq_printf(m, 709 "\n all_unreclaimable: %u" 710 "\n prev_priority: %i" 711 "\n start_pfn: %lu", 712 zone_is_all_unreclaimable(zone), 713 zone->prev_priority, 714 zone->zone_start_pfn); 715 seq_putc(m, '\n'); 716} 717 718/* 719 * Output information about zones in @pgdat. 720 */ 721static int zoneinfo_show(struct seq_file *m, void *arg) 722{ 723 pg_data_t *pgdat = (pg_data_t *)arg; 724 walk_zones_in_node(m, pgdat, zoneinfo_show_print); 725 return 0; 726} 727 728const struct seq_operations zoneinfo_op = { 729 .start = frag_start, /* iterate over all zones. The same as in 730 * fragmentation. */ 731 .next = frag_next, 732 .stop = frag_stop, 733 .show = zoneinfo_show, 734}; 735 736static void *vmstat_start(struct seq_file *m, loff_t *pos) 737{ 738 unsigned long *v; 739#ifdef CONFIG_VM_EVENT_COUNTERS 740 unsigned long *e; 741#endif 742 int i; 743 744 if (*pos >= ARRAY_SIZE(vmstat_text)) 745 return NULL; 746 747#ifdef CONFIG_VM_EVENT_COUNTERS 748 v = kmalloc(NR_VM_ZONE_STAT_ITEMS * sizeof(unsigned long) 749 + sizeof(struct vm_event_state), GFP_KERNEL); 750#else 751 v = kmalloc(NR_VM_ZONE_STAT_ITEMS * sizeof(unsigned long), 752 GFP_KERNEL); 753#endif 754 m->private = v; 755 if (!v) 756 return ERR_PTR(-ENOMEM); 757 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++) 758 v[i] = global_page_state(i); 759#ifdef CONFIG_VM_EVENT_COUNTERS 760 e = v + NR_VM_ZONE_STAT_ITEMS; 761 all_vm_events(e); 762 e[PGPGIN] /= 2; /* sectors -> kbytes */ 763 e[PGPGOUT] /= 2; 764#endif 765 return v + *pos; 766} 767 768static void *vmstat_next(struct seq_file *m, void *arg, loff_t *pos) 769{ 770 (*pos)++; 771 if (*pos >= ARRAY_SIZE(vmstat_text)) 772 return NULL; 773 return (unsigned long *)m->private + *pos; 774} 775 776static int vmstat_show(struct seq_file *m, void *arg) 777{ 778 unsigned long *l = arg; 779 unsigned long off = l - (unsigned long *)m->private; 780 781 seq_printf(m, "%s %lu\n", vmstat_text[off], *l); 782 return 0; 783} 784 785static void vmstat_stop(struct seq_file *m, void *arg) 786{ 787 kfree(m->private); 788 m->private = NULL; 789} 790 791const struct seq_operations vmstat_op = { 792 .start = vmstat_start, 793 .next = vmstat_next, 794 .stop = vmstat_stop, 795 .show = vmstat_show, 796}; 797 798#endif /* CONFIG_PROC_FS */ 799 800#ifdef CONFIG_SMP 801static DEFINE_PER_CPU(struct delayed_work, vmstat_work); 802int sysctl_stat_interval __read_mostly = HZ; 803 804static void vmstat_update(struct work_struct *w) 805{ 806 refresh_cpu_vm_stats(smp_processor_id()); 807 schedule_delayed_work(&__get_cpu_var(vmstat_work), 808 sysctl_stat_interval); 809} 810 811static void __cpuinit start_cpu_timer(int cpu) 812{ 813 struct delayed_work *vmstat_work = &per_cpu(vmstat_work, cpu); 814 815 INIT_DELAYED_WORK_DEFERRABLE(vmstat_work, vmstat_update); 816 schedule_delayed_work_on(cpu, vmstat_work, HZ + cpu); 817} 818 819/* 820 * Use the cpu notifier to insure that the thresholds are recalculated 821 * when necessary. 822 */ 823static int __cpuinit vmstat_cpuup_callback(struct notifier_block *nfb, 824 unsigned long action, 825 void *hcpu) 826{ 827 long cpu = (long)hcpu; 828 829 switch (action) { 830 case CPU_ONLINE: 831 case CPU_ONLINE_FROZEN: 832 start_cpu_timer(cpu); 833 break; 834 case CPU_DOWN_PREPARE: 835 case CPU_DOWN_PREPARE_FROZEN: 836 cancel_rearming_delayed_work(&per_cpu(vmstat_work, cpu)); 837 per_cpu(vmstat_work, cpu).work.func = NULL; 838 break; 839 case CPU_DOWN_FAILED: 840 case CPU_DOWN_FAILED_FROZEN: 841 start_cpu_timer(cpu); 842 break; 843 case CPU_DEAD: 844 case CPU_DEAD_FROZEN: 845 refresh_zone_stat_thresholds(); 846 break; 847 default: 848 break; 849 } 850 return NOTIFY_OK; 851} 852 853static struct notifier_block __cpuinitdata vmstat_notifier = 854 { &vmstat_cpuup_callback, NULL, 0 }; 855 856static int __init setup_vmstat(void) 857{ 858 int cpu; 859 860 refresh_zone_stat_thresholds(); 861 register_cpu_notifier(&vmstat_notifier); 862 863 for_each_online_cpu(cpu) 864 start_cpu_timer(cpu); 865 return 0; 866} 867module_init(setup_vmstat) 868#endif 869