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 19 DEFINE_PER_CPU(struct vm_event_state, vm_event_states) = {{0}}; 20 EXPORT_PER_CPU_SYMBOL(vm_event_states); 21 22 static 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 */ 42 void all_vm_events(unsigned long *ret) 43 { 44 sum_vm_events(ret, &cpu_online_map); 45 } 46 EXPORT_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 */ 55 void 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 */ 74 atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS]; 75 EXPORT_SYMBOL(vm_stat); 76 77 #ifdef CONFIG_SMP 78 79 static 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 */ 129 static 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 */ 150 void __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 } 165 EXPORT_SYMBOL(__mod_zone_page_state); 166 167 /* 168 * For an unknown interrupt state 169 */ 170 void 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 } 179 EXPORT_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 */ 204 void __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 219 void __inc_zone_page_state(struct page *page, enum zone_stat_item item) 220 { 221 __inc_zone_state(page_zone(page), item); 222 } 223 EXPORT_SYMBOL(__inc_zone_page_state); 224 225 void __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 240 void __dec_zone_page_state(struct page *page, enum zone_stat_item item) 241 { 242 __dec_zone_state(page_zone(page), item); 243 } 244 EXPORT_SYMBOL(__dec_zone_page_state); 245 246 void 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 255 void 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 } 265 EXPORT_SYMBOL(inc_zone_page_state); 266 267 void 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 } 275 EXPORT_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 */ 295 void 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 */ 368 void 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 387 static char * const migratetype_names[MIGRATE_TYPES] = { 388 "Unmovable", 389 "Reclaimable", 390 "Movable", 391 "Reserve", 392 "Isolate", 393 }; 394 395 static 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 407 static 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 415 static 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 */ 420 static 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 437 static 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 */ 451 static 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 458 static 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 */ 484 static 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 500 static 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 */ 529 static 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 */ 547 static int pagetypeinfo_show(struct seq_file *m, void *arg) 548 { 549 pg_data_t *pgdat = (pg_data_t *)arg; 550 551 /* check memoryless node */ 552 if (!node_state(pgdat->node_id, N_HIGH_MEMORY)) 553 return 0; 554 555 seq_printf(m, "Page block order: %d\n", pageblock_order); 556 seq_printf(m, "Pages per block: %lu\n", pageblock_nr_pages); 557 seq_putc(m, '\n'); 558 pagetypeinfo_showfree(m, pgdat); 559 pagetypeinfo_showblockcount(m, pgdat); 560 561 return 0; 562 } 563 564 const struct seq_operations fragmentation_op = { 565 .start = frag_start, 566 .next = frag_next, 567 .stop = frag_stop, 568 .show = frag_show, 569 }; 570 571 const struct seq_operations pagetypeinfo_op = { 572 .start = frag_start, 573 .next = frag_next, 574 .stop = frag_stop, 575 .show = pagetypeinfo_show, 576 }; 577 578 #ifdef CONFIG_ZONE_DMA 579 #define TEXT_FOR_DMA(xx) xx "_dma", 580 #else 581 #define TEXT_FOR_DMA(xx) 582 #endif 583 584 #ifdef CONFIG_ZONE_DMA32 585 #define TEXT_FOR_DMA32(xx) xx "_dma32", 586 #else 587 #define TEXT_FOR_DMA32(xx) 588 #endif 589 590 #ifdef CONFIG_HIGHMEM 591 #define TEXT_FOR_HIGHMEM(xx) xx "_high", 592 #else 593 #define TEXT_FOR_HIGHMEM(xx) 594 #endif 595 596 #define TEXTS_FOR_ZONES(xx) TEXT_FOR_DMA(xx) TEXT_FOR_DMA32(xx) xx "_normal", \ 597 TEXT_FOR_HIGHMEM(xx) xx "_movable", 598 599 static const char * const vmstat_text[] = { 600 /* Zoned VM counters */ 601 "nr_free_pages", 602 "nr_inactive", 603 "nr_active", 604 "nr_anon_pages", 605 "nr_mapped", 606 "nr_file_pages", 607 "nr_dirty", 608 "nr_writeback", 609 "nr_slab_reclaimable", 610 "nr_slab_unreclaimable", 611 "nr_page_table_pages", 612 "nr_unstable", 613 "nr_bounce", 614 "nr_vmscan_write", 615 "nr_writeback_temp", 616 617 #ifdef CONFIG_NUMA 618 "numa_hit", 619 "numa_miss", 620 "numa_foreign", 621 "numa_interleave", 622 "numa_local", 623 "numa_other", 624 #endif 625 626 #ifdef CONFIG_VM_EVENT_COUNTERS 627 "pgpgin", 628 "pgpgout", 629 "pswpin", 630 "pswpout", 631 632 TEXTS_FOR_ZONES("pgalloc") 633 634 "pgfree", 635 "pgactivate", 636 "pgdeactivate", 637 638 "pgfault", 639 "pgmajfault", 640 641 TEXTS_FOR_ZONES("pgrefill") 642 TEXTS_FOR_ZONES("pgsteal") 643 TEXTS_FOR_ZONES("pgscan_kswapd") 644 TEXTS_FOR_ZONES("pgscan_direct") 645 646 "pginodesteal", 647 "slabs_scanned", 648 "kswapd_steal", 649 "kswapd_inodesteal", 650 "pageoutrun", 651 "allocstall", 652 653 "pgrotated", 654 #ifdef CONFIG_HUGETLB_PAGE 655 "htlb_buddy_alloc_success", 656 "htlb_buddy_alloc_fail", 657 #endif 658 #endif 659 }; 660 661 static void zoneinfo_show_print(struct seq_file *m, pg_data_t *pgdat, 662 struct zone *zone) 663 { 664 int i; 665 seq_printf(m, "Node %d, zone %8s", pgdat->node_id, zone->name); 666 seq_printf(m, 667 "\n pages free %lu" 668 "\n min %lu" 669 "\n low %lu" 670 "\n high %lu" 671 "\n scanned %lu (a: %lu i: %lu)" 672 "\n spanned %lu" 673 "\n present %lu", 674 zone_page_state(zone, NR_FREE_PAGES), 675 zone->pages_min, 676 zone->pages_low, 677 zone->pages_high, 678 zone->pages_scanned, 679 zone->nr_scan_active, zone->nr_scan_inactive, 680 zone->spanned_pages, 681 zone->present_pages); 682 683 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++) 684 seq_printf(m, "\n %-12s %lu", vmstat_text[i], 685 zone_page_state(zone, i)); 686 687 seq_printf(m, 688 "\n protection: (%lu", 689 zone->lowmem_reserve[0]); 690 for (i = 1; i < ARRAY_SIZE(zone->lowmem_reserve); i++) 691 seq_printf(m, ", %lu", zone->lowmem_reserve[i]); 692 seq_printf(m, 693 ")" 694 "\n pagesets"); 695 for_each_online_cpu(i) { 696 struct per_cpu_pageset *pageset; 697 698 pageset = zone_pcp(zone, i); 699 seq_printf(m, 700 "\n cpu: %i" 701 "\n count: %i" 702 "\n high: %i" 703 "\n batch: %i", 704 i, 705 pageset->pcp.count, 706 pageset->pcp.high, 707 pageset->pcp.batch); 708 #ifdef CONFIG_SMP 709 seq_printf(m, "\n vm stats threshold: %d", 710 pageset->stat_threshold); 711 #endif 712 } 713 seq_printf(m, 714 "\n all_unreclaimable: %u" 715 "\n prev_priority: %i" 716 "\n start_pfn: %lu", 717 zone_is_all_unreclaimable(zone), 718 zone->prev_priority, 719 zone->zone_start_pfn); 720 seq_putc(m, '\n'); 721 } 722 723 /* 724 * Output information about zones in @pgdat. 725 */ 726 static int zoneinfo_show(struct seq_file *m, void *arg) 727 { 728 pg_data_t *pgdat = (pg_data_t *)arg; 729 walk_zones_in_node(m, pgdat, zoneinfo_show_print); 730 return 0; 731 } 732 733 const struct seq_operations zoneinfo_op = { 734 .start = frag_start, /* iterate over all zones. The same as in 735 * fragmentation. */ 736 .next = frag_next, 737 .stop = frag_stop, 738 .show = zoneinfo_show, 739 }; 740 741 static void *vmstat_start(struct seq_file *m, loff_t *pos) 742 { 743 unsigned long *v; 744 #ifdef CONFIG_VM_EVENT_COUNTERS 745 unsigned long *e; 746 #endif 747 int i; 748 749 if (*pos >= ARRAY_SIZE(vmstat_text)) 750 return NULL; 751 752 #ifdef CONFIG_VM_EVENT_COUNTERS 753 v = kmalloc(NR_VM_ZONE_STAT_ITEMS * sizeof(unsigned long) 754 + sizeof(struct vm_event_state), GFP_KERNEL); 755 #else 756 v = kmalloc(NR_VM_ZONE_STAT_ITEMS * sizeof(unsigned long), 757 GFP_KERNEL); 758 #endif 759 m->private = v; 760 if (!v) 761 return ERR_PTR(-ENOMEM); 762 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++) 763 v[i] = global_page_state(i); 764 #ifdef CONFIG_VM_EVENT_COUNTERS 765 e = v + NR_VM_ZONE_STAT_ITEMS; 766 all_vm_events(e); 767 e[PGPGIN] /= 2; /* sectors -> kbytes */ 768 e[PGPGOUT] /= 2; 769 #endif 770 return v + *pos; 771 } 772 773 static void *vmstat_next(struct seq_file *m, void *arg, loff_t *pos) 774 { 775 (*pos)++; 776 if (*pos >= ARRAY_SIZE(vmstat_text)) 777 return NULL; 778 return (unsigned long *)m->private + *pos; 779 } 780 781 static int vmstat_show(struct seq_file *m, void *arg) 782 { 783 unsigned long *l = arg; 784 unsigned long off = l - (unsigned long *)m->private; 785 786 seq_printf(m, "%s %lu\n", vmstat_text[off], *l); 787 return 0; 788 } 789 790 static void vmstat_stop(struct seq_file *m, void *arg) 791 { 792 kfree(m->private); 793 m->private = NULL; 794 } 795 796 const struct seq_operations vmstat_op = { 797 .start = vmstat_start, 798 .next = vmstat_next, 799 .stop = vmstat_stop, 800 .show = vmstat_show, 801 }; 802 803 #endif /* CONFIG_PROC_FS */ 804 805 #ifdef CONFIG_SMP 806 static DEFINE_PER_CPU(struct delayed_work, vmstat_work); 807 int sysctl_stat_interval __read_mostly = HZ; 808 809 static void vmstat_update(struct work_struct *w) 810 { 811 refresh_cpu_vm_stats(smp_processor_id()); 812 schedule_delayed_work(&__get_cpu_var(vmstat_work), 813 sysctl_stat_interval); 814 } 815 816 static void __cpuinit start_cpu_timer(int cpu) 817 { 818 struct delayed_work *vmstat_work = &per_cpu(vmstat_work, cpu); 819 820 INIT_DELAYED_WORK_DEFERRABLE(vmstat_work, vmstat_update); 821 schedule_delayed_work_on(cpu, vmstat_work, HZ + cpu); 822 } 823 824 /* 825 * Use the cpu notifier to insure that the thresholds are recalculated 826 * when necessary. 827 */ 828 static int __cpuinit vmstat_cpuup_callback(struct notifier_block *nfb, 829 unsigned long action, 830 void *hcpu) 831 { 832 long cpu = (long)hcpu; 833 834 switch (action) { 835 case CPU_ONLINE: 836 case CPU_ONLINE_FROZEN: 837 start_cpu_timer(cpu); 838 break; 839 case CPU_DOWN_PREPARE: 840 case CPU_DOWN_PREPARE_FROZEN: 841 cancel_rearming_delayed_work(&per_cpu(vmstat_work, cpu)); 842 per_cpu(vmstat_work, cpu).work.func = NULL; 843 break; 844 case CPU_DOWN_FAILED: 845 case CPU_DOWN_FAILED_FROZEN: 846 start_cpu_timer(cpu); 847 break; 848 case CPU_DEAD: 849 case CPU_DEAD_FROZEN: 850 refresh_zone_stat_thresholds(); 851 break; 852 default: 853 break; 854 } 855 return NOTIFY_OK; 856 } 857 858 static struct notifier_block __cpuinitdata vmstat_notifier = 859 { &vmstat_cpuup_callback, NULL, 0 }; 860 861 static int __init setup_vmstat(void) 862 { 863 int cpu; 864 865 refresh_zone_stat_thresholds(); 866 register_cpu_notifier(&vmstat_notifier); 867 868 for_each_online_cpu(cpu) 869 start_cpu_timer(cpu); 870 return 0; 871 } 872 module_init(setup_vmstat) 873 #endif 874