vmstat.c 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473
  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. #include <linux/fs.h>
  12. #include <linux/mm.h>
  13. #include <linux/err.h>
  14. #include <linux/module.h>
  15. #include <linux/slab.h>
  16. #include <linux/cpu.h>
  17. #include <linux/vmstat.h>
  18. #include <linux/sched.h>
  19. #include <linux/math64.h>
  20. #include <linux/writeback.h>
  21. #include <linux/compaction.h>
  22. #include <linux/mm_inline.h>
  23. #include "internal.h"
  24. #ifdef CONFIG_VM_EVENT_COUNTERS
  25. DEFINE_PER_CPU(struct vm_event_state, vm_event_states) = {{0}};
  26. EXPORT_PER_CPU_SYMBOL(vm_event_states);
  27. static void sum_vm_events(unsigned long *ret)
  28. {
  29. int cpu;
  30. int i;
  31. memset(ret, 0, NR_VM_EVENT_ITEMS * sizeof(unsigned long));
  32. for_each_online_cpu(cpu) {
  33. struct vm_event_state *this = &per_cpu(vm_event_states, cpu);
  34. for (i = 0; i < NR_VM_EVENT_ITEMS; i++)
  35. ret[i] += this->event[i];
  36. }
  37. }
  38. /*
  39. * Accumulate the vm event counters across all CPUs.
  40. * The result is unavoidably approximate - it can change
  41. * during and after execution of this function.
  42. */
  43. void all_vm_events(unsigned long *ret)
  44. {
  45. get_online_cpus();
  46. sum_vm_events(ret);
  47. put_online_cpus();
  48. }
  49. EXPORT_SYMBOL_GPL(all_vm_events);
  50. /*
  51. * Fold the foreign cpu events into our own.
  52. *
  53. * This is adding to the events on one processor
  54. * but keeps the global counts constant.
  55. */
  56. void vm_events_fold_cpu(int cpu)
  57. {
  58. struct vm_event_state *fold_state = &per_cpu(vm_event_states, cpu);
  59. int i;
  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_VM_EVENT_COUNTERS */
  66. /*
  67. * Manage combined zone based / global counters
  68. *
  69. * vm_stat contains the global counters
  70. */
  71. atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS] __cacheline_aligned_in_smp;
  72. EXPORT_SYMBOL(vm_stat);
  73. #ifdef CONFIG_SMP
  74. int calculate_pressure_threshold(struct zone *zone)
  75. {
  76. int threshold;
  77. int watermark_distance;
  78. /*
  79. * As vmstats are not up to date, there is drift between the estimated
  80. * and real values. For high thresholds and a high number of CPUs, it
  81. * is possible for the min watermark to be breached while the estimated
  82. * value looks fine. The pressure threshold is a reduced value such
  83. * that even the maximum amount of drift will not accidentally breach
  84. * the min watermark
  85. */
  86. watermark_distance = low_wmark_pages(zone) - min_wmark_pages(zone);
  87. threshold = max(1, (int)(watermark_distance / num_online_cpus()));
  88. /*
  89. * Maximum threshold is 125
  90. */
  91. threshold = min(125, threshold);
  92. return threshold;
  93. }
  94. int calculate_normal_threshold(struct zone *zone)
  95. {
  96. int threshold;
  97. int mem; /* memory in 128 MB units */
  98. /*
  99. * The threshold scales with the number of processors and the amount
  100. * of memory per zone. More memory means that we can defer updates for
  101. * longer, more processors could lead to more contention.
  102. * fls() is used to have a cheap way of logarithmic scaling.
  103. *
  104. * Some sample thresholds:
  105. *
  106. * Threshold Processors (fls) Zonesize fls(mem+1)
  107. * ------------------------------------------------------------------
  108. * 8 1 1 0.9-1 GB 4
  109. * 16 2 2 0.9-1 GB 4
  110. * 20 2 2 1-2 GB 5
  111. * 24 2 2 2-4 GB 6
  112. * 28 2 2 4-8 GB 7
  113. * 32 2 2 8-16 GB 8
  114. * 4 2 2 <128M 1
  115. * 30 4 3 2-4 GB 5
  116. * 48 4 3 8-16 GB 8
  117. * 32 8 4 1-2 GB 4
  118. * 32 8 4 0.9-1GB 4
  119. * 10 16 5 <128M 1
  120. * 40 16 5 900M 4
  121. * 70 64 7 2-4 GB 5
  122. * 84 64 7 4-8 GB 6
  123. * 108 512 9 4-8 GB 6
  124. * 125 1024 10 8-16 GB 8
  125. * 125 1024 10 16-32 GB 9
  126. */
  127. mem = zone->managed_pages >> (27 - PAGE_SHIFT);
  128. threshold = 2 * fls(num_online_cpus()) * (1 + fls(mem));
  129. /*
  130. * Maximum threshold is 125
  131. */
  132. threshold = min(125, threshold);
  133. return threshold;
  134. }
  135. /*
  136. * Refresh the thresholds for each zone.
  137. */
  138. void refresh_zone_stat_thresholds(void)
  139. {
  140. struct zone *zone;
  141. int cpu;
  142. int threshold;
  143. for_each_populated_zone(zone) {
  144. unsigned long max_drift, tolerate_drift;
  145. threshold = calculate_normal_threshold(zone);
  146. for_each_online_cpu(cpu)
  147. per_cpu_ptr(zone->pageset, cpu)->stat_threshold
  148. = threshold;
  149. /*
  150. * Only set percpu_drift_mark if there is a danger that
  151. * NR_FREE_PAGES reports the low watermark is ok when in fact
  152. * the min watermark could be breached by an allocation
  153. */
  154. tolerate_drift = low_wmark_pages(zone) - min_wmark_pages(zone);
  155. max_drift = num_online_cpus() * threshold;
  156. if (max_drift > tolerate_drift)
  157. zone->percpu_drift_mark = high_wmark_pages(zone) +
  158. max_drift;
  159. }
  160. }
  161. void set_pgdat_percpu_threshold(pg_data_t *pgdat,
  162. int (*calculate_pressure)(struct zone *))
  163. {
  164. struct zone *zone;
  165. int cpu;
  166. int threshold;
  167. int i;
  168. for (i = 0; i < pgdat->nr_zones; i++) {
  169. zone = &pgdat->node_zones[i];
  170. if (!zone->percpu_drift_mark)
  171. continue;
  172. threshold = (*calculate_pressure)(zone);
  173. for_each_possible_cpu(cpu)
  174. per_cpu_ptr(zone->pageset, cpu)->stat_threshold
  175. = threshold;
  176. }
  177. }
  178. /*
  179. * For use when we know that interrupts are disabled.
  180. */
  181. void __mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
  182. int delta)
  183. {
  184. struct per_cpu_pageset __percpu *pcp = zone->pageset;
  185. s8 __percpu *p = pcp->vm_stat_diff + item;
  186. long x;
  187. long t;
  188. x = delta + __this_cpu_read(*p);
  189. t = __this_cpu_read(pcp->stat_threshold);
  190. if (unlikely(x > t || x < -t)) {
  191. zone_page_state_add(x, zone, item);
  192. x = 0;
  193. }
  194. __this_cpu_write(*p, x);
  195. }
  196. EXPORT_SYMBOL(__mod_zone_page_state);
  197. /*
  198. * Optimized increment and decrement functions.
  199. *
  200. * These are only for a single page and therefore can take a struct page *
  201. * argument instead of struct zone *. This allows the inclusion of the code
  202. * generated for page_zone(page) into the optimized functions.
  203. *
  204. * No overflow check is necessary and therefore the differential can be
  205. * incremented or decremented in place which may allow the compilers to
  206. * generate better code.
  207. * The increment or decrement is known and therefore one boundary check can
  208. * be omitted.
  209. *
  210. * NOTE: These functions are very performance sensitive. Change only
  211. * with care.
  212. *
  213. * Some processors have inc/dec instructions that are atomic vs an interrupt.
  214. * However, the code must first determine the differential location in a zone
  215. * based on the processor number and then inc/dec the counter. There is no
  216. * guarantee without disabling preemption that the processor will not change
  217. * in between and therefore the atomicity vs. interrupt cannot be exploited
  218. * in a useful way here.
  219. */
  220. void __inc_zone_state(struct zone *zone, enum zone_stat_item item)
  221. {
  222. struct per_cpu_pageset __percpu *pcp = zone->pageset;
  223. s8 __percpu *p = pcp->vm_stat_diff + item;
  224. s8 v, t;
  225. v = __this_cpu_inc_return(*p);
  226. t = __this_cpu_read(pcp->stat_threshold);
  227. if (unlikely(v > t)) {
  228. s8 overstep = t >> 1;
  229. zone_page_state_add(v + overstep, zone, item);
  230. __this_cpu_write(*p, -overstep);
  231. }
  232. }
  233. void __inc_zone_page_state(struct page *page, enum zone_stat_item item)
  234. {
  235. __inc_zone_state(page_zone(page), item);
  236. }
  237. EXPORT_SYMBOL(__inc_zone_page_state);
  238. void __dec_zone_state(struct zone *zone, enum zone_stat_item item)
  239. {
  240. struct per_cpu_pageset __percpu *pcp = zone->pageset;
  241. s8 __percpu *p = pcp->vm_stat_diff + item;
  242. s8 v, t;
  243. v = __this_cpu_dec_return(*p);
  244. t = __this_cpu_read(pcp->stat_threshold);
  245. if (unlikely(v < - t)) {
  246. s8 overstep = t >> 1;
  247. zone_page_state_add(v - overstep, zone, item);
  248. __this_cpu_write(*p, overstep);
  249. }
  250. }
  251. void __dec_zone_page_state(struct page *page, enum zone_stat_item item)
  252. {
  253. __dec_zone_state(page_zone(page), item);
  254. }
  255. EXPORT_SYMBOL(__dec_zone_page_state);
  256. #ifdef CONFIG_HAVE_CMPXCHG_LOCAL
  257. /*
  258. * If we have cmpxchg_local support then we do not need to incur the overhead
  259. * that comes with local_irq_save/restore if we use this_cpu_cmpxchg.
  260. *
  261. * mod_state() modifies the zone counter state through atomic per cpu
  262. * operations.
  263. *
  264. * Overstep mode specifies how overstep should handled:
  265. * 0 No overstepping
  266. * 1 Overstepping half of threshold
  267. * -1 Overstepping minus half of threshold
  268. */
  269. static inline void mod_state(struct zone *zone,
  270. enum zone_stat_item item, int delta, int overstep_mode)
  271. {
  272. struct per_cpu_pageset __percpu *pcp = zone->pageset;
  273. s8 __percpu *p = pcp->vm_stat_diff + item;
  274. long o, n, t, z;
  275. do {
  276. z = 0; /* overflow to zone counters */
  277. /*
  278. * The fetching of the stat_threshold is racy. We may apply
  279. * a counter threshold to the wrong the cpu if we get
  280. * rescheduled while executing here. However, the next
  281. * counter update will apply the threshold again and
  282. * therefore bring the counter under the threshold again.
  283. *
  284. * Most of the time the thresholds are the same anyways
  285. * for all cpus in a zone.
  286. */
  287. t = this_cpu_read(pcp->stat_threshold);
  288. o = this_cpu_read(*p);
  289. n = delta + o;
  290. if (n > t || n < -t) {
  291. int os = overstep_mode * (t >> 1) ;
  292. /* Overflow must be added to zone counters */
  293. z = n + os;
  294. n = -os;
  295. }
  296. } while (this_cpu_cmpxchg(*p, o, n) != o);
  297. if (z)
  298. zone_page_state_add(z, zone, item);
  299. }
  300. void mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
  301. int delta)
  302. {
  303. mod_state(zone, item, delta, 0);
  304. }
  305. EXPORT_SYMBOL(mod_zone_page_state);
  306. void inc_zone_state(struct zone *zone, enum zone_stat_item item)
  307. {
  308. mod_state(zone, item, 1, 1);
  309. }
  310. void inc_zone_page_state(struct page *page, enum zone_stat_item item)
  311. {
  312. mod_state(page_zone(page), item, 1, 1);
  313. }
  314. EXPORT_SYMBOL(inc_zone_page_state);
  315. void dec_zone_page_state(struct page *page, enum zone_stat_item item)
  316. {
  317. mod_state(page_zone(page), item, -1, -1);
  318. }
  319. EXPORT_SYMBOL(dec_zone_page_state);
  320. #else
  321. /*
  322. * Use interrupt disable to serialize counter updates
  323. */
  324. void mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
  325. int delta)
  326. {
  327. unsigned long flags;
  328. local_irq_save(flags);
  329. __mod_zone_page_state(zone, item, delta);
  330. local_irq_restore(flags);
  331. }
  332. EXPORT_SYMBOL(mod_zone_page_state);
  333. void inc_zone_state(struct zone *zone, enum zone_stat_item item)
  334. {
  335. unsigned long flags;
  336. local_irq_save(flags);
  337. __inc_zone_state(zone, item);
  338. local_irq_restore(flags);
  339. }
  340. void inc_zone_page_state(struct page *page, enum zone_stat_item item)
  341. {
  342. unsigned long flags;
  343. struct zone *zone;
  344. zone = page_zone(page);
  345. local_irq_save(flags);
  346. __inc_zone_state(zone, item);
  347. local_irq_restore(flags);
  348. }
  349. EXPORT_SYMBOL(inc_zone_page_state);
  350. void dec_zone_page_state(struct page *page, enum zone_stat_item item)
  351. {
  352. unsigned long flags;
  353. local_irq_save(flags);
  354. __dec_zone_page_state(page, item);
  355. local_irq_restore(flags);
  356. }
  357. EXPORT_SYMBOL(dec_zone_page_state);
  358. #endif
  359. static inline void fold_diff(int *diff)
  360. {
  361. int i;
  362. for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
  363. if (diff[i])
  364. atomic_long_add(diff[i], &vm_stat[i]);
  365. }
  366. /*
  367. * Update the zone counters for the current cpu.
  368. *
  369. * Note that refresh_cpu_vm_stats strives to only access
  370. * node local memory. The per cpu pagesets on remote zones are placed
  371. * in the memory local to the processor using that pageset. So the
  372. * loop over all zones will access a series of cachelines local to
  373. * the processor.
  374. *
  375. * The call to zone_page_state_add updates the cachelines with the
  376. * statistics in the remote zone struct as well as the global cachelines
  377. * with the global counters. These could cause remote node cache line
  378. * bouncing and will have to be only done when necessary.
  379. */
  380. static void refresh_cpu_vm_stats(void)
  381. {
  382. struct zone *zone;
  383. int i;
  384. int global_diff[NR_VM_ZONE_STAT_ITEMS] = { 0, };
  385. for_each_populated_zone(zone) {
  386. struct per_cpu_pageset __percpu *p = zone->pageset;
  387. for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++) {
  388. int v;
  389. v = this_cpu_xchg(p->vm_stat_diff[i], 0);
  390. if (v) {
  391. atomic_long_add(v, &zone->vm_stat[i]);
  392. global_diff[i] += v;
  393. #ifdef CONFIG_NUMA
  394. /* 3 seconds idle till flush */
  395. __this_cpu_write(p->expire, 3);
  396. #endif
  397. }
  398. }
  399. cond_resched();
  400. #ifdef CONFIG_NUMA
  401. /*
  402. * Deal with draining the remote pageset of this
  403. * processor
  404. *
  405. * Check if there are pages remaining in this pageset
  406. * if not then there is nothing to expire.
  407. */
  408. if (!__this_cpu_read(p->expire) ||
  409. !__this_cpu_read(p->pcp.count))
  410. continue;
  411. /*
  412. * We never drain zones local to this processor.
  413. */
  414. if (zone_to_nid(zone) == numa_node_id()) {
  415. __this_cpu_write(p->expire, 0);
  416. continue;
  417. }
  418. if (__this_cpu_dec_return(p->expire))
  419. continue;
  420. if (__this_cpu_read(p->pcp.count))
  421. drain_zone_pages(zone, __this_cpu_ptr(&p->pcp));
  422. #endif
  423. }
  424. fold_diff(global_diff);
  425. }
  426. /*
  427. * Fold the data for an offline cpu into the global array.
  428. * There cannot be any access by the offline cpu and therefore
  429. * synchronization is simplified.
  430. */
  431. void cpu_vm_stats_fold(int cpu)
  432. {
  433. struct zone *zone;
  434. int i;
  435. int global_diff[NR_VM_ZONE_STAT_ITEMS] = { 0, };
  436. for_each_populated_zone(zone) {
  437. struct per_cpu_pageset *p;
  438. p = per_cpu_ptr(zone->pageset, cpu);
  439. for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
  440. if (p->vm_stat_diff[i]) {
  441. int v;
  442. v = p->vm_stat_diff[i];
  443. p->vm_stat_diff[i] = 0;
  444. atomic_long_add(v, &zone->vm_stat[i]);
  445. global_diff[i] += v;
  446. }
  447. }
  448. fold_diff(global_diff);
  449. }
  450. /*
  451. * this is only called if !populated_zone(zone), which implies no other users of
  452. * pset->vm_stat_diff[] exsist.
  453. */
  454. void drain_zonestat(struct zone *zone, struct per_cpu_pageset *pset)
  455. {
  456. int i;
  457. for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
  458. if (pset->vm_stat_diff[i]) {
  459. int v = pset->vm_stat_diff[i];
  460. pset->vm_stat_diff[i] = 0;
  461. atomic_long_add(v, &zone->vm_stat[i]);
  462. atomic_long_add(v, &vm_stat[i]);
  463. }
  464. }
  465. #endif
  466. #ifdef CONFIG_NUMA
  467. /*
  468. * zonelist = the list of zones passed to the allocator
  469. * z = the zone from which the allocation occurred.
  470. *
  471. * Must be called with interrupts disabled.
  472. *
  473. * When __GFP_OTHER_NODE is set assume the node of the preferred
  474. * zone is the local node. This is useful for daemons who allocate
  475. * memory on behalf of other processes.
  476. */
  477. void zone_statistics(struct zone *preferred_zone, struct zone *z, gfp_t flags)
  478. {
  479. if (z->zone_pgdat == preferred_zone->zone_pgdat) {
  480. __inc_zone_state(z, NUMA_HIT);
  481. } else {
  482. __inc_zone_state(z, NUMA_MISS);
  483. __inc_zone_state(preferred_zone, NUMA_FOREIGN);
  484. }
  485. if (z->node == ((flags & __GFP_OTHER_NODE) ?
  486. preferred_zone->node : numa_node_id()))
  487. __inc_zone_state(z, NUMA_LOCAL);
  488. else
  489. __inc_zone_state(z, NUMA_OTHER);
  490. }
  491. #endif
  492. #ifdef CONFIG_COMPACTION
  493. struct contig_page_info {
  494. unsigned long free_pages;
  495. unsigned long free_blocks_total;
  496. unsigned long free_blocks_suitable;
  497. };
  498. /*
  499. * Calculate the number of free pages in a zone, how many contiguous
  500. * pages are free and how many are large enough to satisfy an allocation of
  501. * the target size. Note that this function makes no attempt to estimate
  502. * how many suitable free blocks there *might* be if MOVABLE pages were
  503. * migrated. Calculating that is possible, but expensive and can be
  504. * figured out from userspace
  505. */
  506. static void fill_contig_page_info(struct zone *zone,
  507. unsigned int suitable_order,
  508. struct contig_page_info *info)
  509. {
  510. unsigned int order;
  511. info->free_pages = 0;
  512. info->free_blocks_total = 0;
  513. info->free_blocks_suitable = 0;
  514. for (order = 0; order < MAX_ORDER; order++) {
  515. unsigned long blocks;
  516. /* Count number of free blocks */
  517. blocks = zone->free_area[order].nr_free;
  518. info->free_blocks_total += blocks;
  519. /* Count free base pages */
  520. info->free_pages += blocks << order;
  521. /* Count the suitable free blocks */
  522. if (order >= suitable_order)
  523. info->free_blocks_suitable += blocks <<
  524. (order - suitable_order);
  525. }
  526. }
  527. /*
  528. * A fragmentation index only makes sense if an allocation of a requested
  529. * size would fail. If that is true, the fragmentation index indicates
  530. * whether external fragmentation or a lack of memory was the problem.
  531. * The value can be used to determine if page reclaim or compaction
  532. * should be used
  533. */
  534. static int __fragmentation_index(unsigned int order, struct contig_page_info *info)
  535. {
  536. unsigned long requested = 1UL << order;
  537. if (!info->free_blocks_total)
  538. return 0;
  539. /* Fragmentation index only makes sense when a request would fail */
  540. if (info->free_blocks_suitable)
  541. return -1000;
  542. /*
  543. * Index is between 0 and 1 so return within 3 decimal places
  544. *
  545. * 0 => allocation would fail due to lack of memory
  546. * 1 => allocation would fail due to fragmentation
  547. */
  548. return 1000 - div_u64( (1000+(div_u64(info->free_pages * 1000ULL, requested))), info->free_blocks_total);
  549. }
  550. /* Same as __fragmentation index but allocs contig_page_info on stack */
  551. int fragmentation_index(struct zone *zone, unsigned int order)
  552. {
  553. struct contig_page_info info;
  554. fill_contig_page_info(zone, order, &info);
  555. return __fragmentation_index(order, &info);
  556. }
  557. #endif
  558. #if defined(CONFIG_PROC_FS) || defined(CONFIG_COMPACTION)
  559. #include <linux/proc_fs.h>
  560. #include <linux/seq_file.h>
  561. static char * const migratetype_names[MIGRATE_TYPES] = {
  562. "Unmovable",
  563. "Reclaimable",
  564. "Movable",
  565. "Reserve",
  566. #ifdef CONFIG_CMA
  567. "CMA",
  568. #endif
  569. #ifdef CONFIG_MEMORY_ISOLATION
  570. "Isolate",
  571. #endif
  572. };
  573. static void *frag_start(struct seq_file *m, loff_t *pos)
  574. {
  575. pg_data_t *pgdat;
  576. loff_t node = *pos;
  577. for (pgdat = first_online_pgdat();
  578. pgdat && node;
  579. pgdat = next_online_pgdat(pgdat))
  580. --node;
  581. return pgdat;
  582. }
  583. static void *frag_next(struct seq_file *m, void *arg, loff_t *pos)
  584. {
  585. pg_data_t *pgdat = (pg_data_t *)arg;
  586. (*pos)++;
  587. return next_online_pgdat(pgdat);
  588. }
  589. static void frag_stop(struct seq_file *m, void *arg)
  590. {
  591. }
  592. /* Walk all the zones in a node and print using a callback */
  593. static void walk_zones_in_node(struct seq_file *m, pg_data_t *pgdat,
  594. void (*print)(struct seq_file *m, pg_data_t *, struct zone *))
  595. {
  596. struct zone *zone;
  597. struct zone *node_zones = pgdat->node_zones;
  598. unsigned long flags;
  599. for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
  600. if (!populated_zone(zone))
  601. continue;
  602. spin_lock_irqsave(&zone->lock, flags);
  603. print(m, pgdat, zone);
  604. spin_unlock_irqrestore(&zone->lock, flags);
  605. }
  606. }
  607. #endif
  608. #if defined(CONFIG_PROC_FS) || defined(CONFIG_SYSFS) || defined(CONFIG_NUMA)
  609. #ifdef CONFIG_ZONE_DMA
  610. #define TEXT_FOR_DMA(xx) xx "_dma",
  611. #else
  612. #define TEXT_FOR_DMA(xx)
  613. #endif
  614. #ifdef CONFIG_ZONE_DMA32
  615. #define TEXT_FOR_DMA32(xx) xx "_dma32",
  616. #else
  617. #define TEXT_FOR_DMA32(xx)
  618. #endif
  619. #ifdef CONFIG_HIGHMEM
  620. #define TEXT_FOR_HIGHMEM(xx) xx "_high",
  621. #else
  622. #define TEXT_FOR_HIGHMEM(xx)
  623. #endif
  624. #define TEXTS_FOR_ZONES(xx) TEXT_FOR_DMA(xx) TEXT_FOR_DMA32(xx) xx "_normal", \
  625. TEXT_FOR_HIGHMEM(xx) xx "_movable",
  626. const char * const vmstat_text[] = {
  627. /* Zoned VM counters */
  628. "nr_free_pages",
  629. "nr_alloc_batch",
  630. "nr_inactive_anon",
  631. "nr_active_anon",
  632. "nr_inactive_file",
  633. "nr_active_file",
  634. "nr_unevictable",
  635. "nr_mlock",
  636. "nr_anon_pages",
  637. "nr_mapped",
  638. "nr_file_pages",
  639. "nr_dirty",
  640. "nr_writeback",
  641. "nr_slab_reclaimable",
  642. "nr_slab_unreclaimable",
  643. "nr_page_table_pages",
  644. "nr_kernel_stack",
  645. "nr_unstable",
  646. "nr_bounce",
  647. "nr_vmscan_write",
  648. "nr_vmscan_immediate_reclaim",
  649. "nr_writeback_temp",
  650. "nr_isolated_anon",
  651. "nr_isolated_file",
  652. "nr_shmem",
  653. "nr_dirtied",
  654. "nr_written",
  655. #ifdef CONFIG_NUMA
  656. "numa_hit",
  657. "numa_miss",
  658. "numa_foreign",
  659. "numa_interleave",
  660. "numa_local",
  661. "numa_other",
  662. #endif
  663. "nr_anon_transparent_hugepages",
  664. "nr_free_cma",
  665. "nr_dirty_threshold",
  666. "nr_dirty_background_threshold",
  667. #ifdef CONFIG_VM_EVENT_COUNTERS
  668. "pgpgin",
  669. "pgpgout",
  670. "pswpin",
  671. "pswpout",
  672. TEXTS_FOR_ZONES("pgalloc")
  673. "pgfree",
  674. "pgactivate",
  675. "pgdeactivate",
  676. "pgfault",
  677. "pgmajfault",
  678. TEXTS_FOR_ZONES("pgrefill")
  679. TEXTS_FOR_ZONES("pgsteal_kswapd")
  680. TEXTS_FOR_ZONES("pgsteal_direct")
  681. TEXTS_FOR_ZONES("pgscan_kswapd")
  682. TEXTS_FOR_ZONES("pgscan_direct")
  683. "pgscan_direct_throttle",
  684. #ifdef CONFIG_NUMA
  685. "zone_reclaim_failed",
  686. #endif
  687. "pginodesteal",
  688. "slabs_scanned",
  689. "kswapd_inodesteal",
  690. "kswapd_low_wmark_hit_quickly",
  691. "kswapd_high_wmark_hit_quickly",
  692. "pageoutrun",
  693. "allocstall",
  694. "pgrotated",
  695. #ifdef CONFIG_NUMA_BALANCING
  696. "numa_pte_updates",
  697. "numa_huge_pte_updates",
  698. "numa_hint_faults",
  699. "numa_hint_faults_local",
  700. "numa_pages_migrated",
  701. #endif
  702. #ifdef CONFIG_MIGRATION
  703. "pgmigrate_success",
  704. "pgmigrate_fail",
  705. #endif
  706. #ifdef CONFIG_COMPACTION
  707. "compact_migrate_scanned",
  708. "compact_free_scanned",
  709. "compact_isolated",
  710. "compact_stall",
  711. "compact_fail",
  712. "compact_success",
  713. #endif
  714. #ifdef CONFIG_HUGETLB_PAGE
  715. "htlb_buddy_alloc_success",
  716. "htlb_buddy_alloc_fail",
  717. #endif
  718. "unevictable_pgs_culled",
  719. "unevictable_pgs_scanned",
  720. "unevictable_pgs_rescued",
  721. "unevictable_pgs_mlocked",
  722. "unevictable_pgs_munlocked",
  723. "unevictable_pgs_cleared",
  724. "unevictable_pgs_stranded",
  725. #ifdef CONFIG_TRANSPARENT_HUGEPAGE
  726. "thp_fault_alloc",
  727. "thp_fault_fallback",
  728. "thp_collapse_alloc",
  729. "thp_collapse_alloc_failed",
  730. "thp_split",
  731. "thp_zero_page_alloc",
  732. "thp_zero_page_alloc_failed",
  733. #endif
  734. #ifdef CONFIG_SMP
  735. "nr_tlb_remote_flush",
  736. "nr_tlb_remote_flush_received",
  737. #endif
  738. "nr_tlb_local_flush_all",
  739. "nr_tlb_local_flush_one",
  740. #endif /* CONFIG_VM_EVENTS_COUNTERS */
  741. };
  742. #endif /* CONFIG_PROC_FS || CONFIG_SYSFS || CONFIG_NUMA */
  743. #ifdef CONFIG_PROC_FS
  744. static void frag_show_print(struct seq_file *m, pg_data_t *pgdat,
  745. struct zone *zone)
  746. {
  747. int order;
  748. seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
  749. for (order = 0; order < MAX_ORDER; ++order)
  750. seq_printf(m, "%6lu ", zone->free_area[order].nr_free);
  751. seq_putc(m, '\n');
  752. }
  753. /*
  754. * This walks the free areas for each zone.
  755. */
  756. static int frag_show(struct seq_file *m, void *arg)
  757. {
  758. pg_data_t *pgdat = (pg_data_t *)arg;
  759. walk_zones_in_node(m, pgdat, frag_show_print);
  760. return 0;
  761. }
  762. static void pagetypeinfo_showfree_print(struct seq_file *m,
  763. pg_data_t *pgdat, struct zone *zone)
  764. {
  765. int order, mtype;
  766. for (mtype = 0; mtype < MIGRATE_TYPES; mtype++) {
  767. seq_printf(m, "Node %4d, zone %8s, type %12s ",
  768. pgdat->node_id,
  769. zone->name,
  770. migratetype_names[mtype]);
  771. for (order = 0; order < MAX_ORDER; ++order) {
  772. unsigned long freecount = 0;
  773. struct free_area *area;
  774. struct list_head *curr;
  775. area = &(zone->free_area[order]);
  776. list_for_each(curr, &area->free_list[mtype])
  777. freecount++;
  778. seq_printf(m, "%6lu ", freecount);
  779. }
  780. seq_putc(m, '\n');
  781. }
  782. }
  783. /* Print out the free pages at each order for each migatetype */
  784. static int pagetypeinfo_showfree(struct seq_file *m, void *arg)
  785. {
  786. int order;
  787. pg_data_t *pgdat = (pg_data_t *)arg;
  788. /* Print header */
  789. seq_printf(m, "%-43s ", "Free pages count per migrate type at order");
  790. for (order = 0; order < MAX_ORDER; ++order)
  791. seq_printf(m, "%6d ", order);
  792. seq_putc(m, '\n');
  793. walk_zones_in_node(m, pgdat, pagetypeinfo_showfree_print);
  794. return 0;
  795. }
  796. static void pagetypeinfo_showblockcount_print(struct seq_file *m,
  797. pg_data_t *pgdat, struct zone *zone)
  798. {
  799. int mtype;
  800. unsigned long pfn;
  801. unsigned long start_pfn = zone->zone_start_pfn;
  802. unsigned long end_pfn = zone_end_pfn(zone);
  803. unsigned long count[MIGRATE_TYPES] = { 0, };
  804. for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages) {
  805. struct page *page;
  806. if (!pfn_valid(pfn))
  807. continue;
  808. page = pfn_to_page(pfn);
  809. /* Watch for unexpected holes punched in the memmap */
  810. if (!memmap_valid_within(pfn, page, zone))
  811. continue;
  812. mtype = get_pageblock_migratetype(page);
  813. if (mtype < MIGRATE_TYPES)
  814. count[mtype]++;
  815. }
  816. /* Print counts */
  817. seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
  818. for (mtype = 0; mtype < MIGRATE_TYPES; mtype++)
  819. seq_printf(m, "%12lu ", count[mtype]);
  820. seq_putc(m, '\n');
  821. }
  822. /* Print out the free pages at each order for each migratetype */
  823. static int pagetypeinfo_showblockcount(struct seq_file *m, void *arg)
  824. {
  825. int mtype;
  826. pg_data_t *pgdat = (pg_data_t *)arg;
  827. seq_printf(m, "\n%-23s", "Number of blocks type ");
  828. for (mtype = 0; mtype < MIGRATE_TYPES; mtype++)
  829. seq_printf(m, "%12s ", migratetype_names[mtype]);
  830. seq_putc(m, '\n');
  831. walk_zones_in_node(m, pgdat, pagetypeinfo_showblockcount_print);
  832. return 0;
  833. }
  834. /*
  835. * This prints out statistics in relation to grouping pages by mobility.
  836. * It is expensive to collect so do not constantly read the file.
  837. */
  838. static int pagetypeinfo_show(struct seq_file *m, void *arg)
  839. {
  840. pg_data_t *pgdat = (pg_data_t *)arg;
  841. /* check memoryless node */
  842. if (!node_state(pgdat->node_id, N_MEMORY))
  843. return 0;
  844. seq_printf(m, "Page block order: %d\n", pageblock_order);
  845. seq_printf(m, "Pages per block: %lu\n", pageblock_nr_pages);
  846. seq_putc(m, '\n');
  847. pagetypeinfo_showfree(m, pgdat);
  848. pagetypeinfo_showblockcount(m, pgdat);
  849. return 0;
  850. }
  851. static const struct seq_operations fragmentation_op = {
  852. .start = frag_start,
  853. .next = frag_next,
  854. .stop = frag_stop,
  855. .show = frag_show,
  856. };
  857. static int fragmentation_open(struct inode *inode, struct file *file)
  858. {
  859. return seq_open(file, &fragmentation_op);
  860. }
  861. static const struct file_operations fragmentation_file_operations = {
  862. .open = fragmentation_open,
  863. .read = seq_read,
  864. .llseek = seq_lseek,
  865. .release = seq_release,
  866. };
  867. static const struct seq_operations pagetypeinfo_op = {
  868. .start = frag_start,
  869. .next = frag_next,
  870. .stop = frag_stop,
  871. .show = pagetypeinfo_show,
  872. };
  873. static int pagetypeinfo_open(struct inode *inode, struct file *file)
  874. {
  875. return seq_open(file, &pagetypeinfo_op);
  876. }
  877. static const struct file_operations pagetypeinfo_file_ops = {
  878. .open = pagetypeinfo_open,
  879. .read = seq_read,
  880. .llseek = seq_lseek,
  881. .release = seq_release,
  882. };
  883. static void zoneinfo_show_print(struct seq_file *m, pg_data_t *pgdat,
  884. struct zone *zone)
  885. {
  886. int i;
  887. seq_printf(m, "Node %d, zone %8s", pgdat->node_id, zone->name);
  888. seq_printf(m,
  889. "\n pages free %lu"
  890. "\n min %lu"
  891. "\n low %lu"
  892. "\n high %lu"
  893. "\n scanned %lu"
  894. "\n spanned %lu"
  895. "\n present %lu"
  896. "\n managed %lu",
  897. zone_page_state(zone, NR_FREE_PAGES),
  898. min_wmark_pages(zone),
  899. low_wmark_pages(zone),
  900. high_wmark_pages(zone),
  901. zone->pages_scanned,
  902. zone->spanned_pages,
  903. zone->present_pages,
  904. zone->managed_pages);
  905. for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
  906. seq_printf(m, "\n %-12s %lu", vmstat_text[i],
  907. zone_page_state(zone, i));
  908. seq_printf(m,
  909. "\n protection: (%lu",
  910. zone->lowmem_reserve[0]);
  911. for (i = 1; i < ARRAY_SIZE(zone->lowmem_reserve); i++)
  912. seq_printf(m, ", %lu", zone->lowmem_reserve[i]);
  913. seq_printf(m,
  914. ")"
  915. "\n pagesets");
  916. for_each_online_cpu(i) {
  917. struct per_cpu_pageset *pageset;
  918. pageset = per_cpu_ptr(zone->pageset, i);
  919. seq_printf(m,
  920. "\n cpu: %i"
  921. "\n count: %i"
  922. "\n high: %i"
  923. "\n batch: %i",
  924. i,
  925. pageset->pcp.count,
  926. pageset->pcp.high,
  927. pageset->pcp.batch);
  928. #ifdef CONFIG_SMP
  929. seq_printf(m, "\n vm stats threshold: %d",
  930. pageset->stat_threshold);
  931. #endif
  932. }
  933. seq_printf(m,
  934. "\n all_unreclaimable: %u"
  935. "\n start_pfn: %lu"
  936. "\n inactive_ratio: %u",
  937. !zone_reclaimable(zone),
  938. zone->zone_start_pfn,
  939. zone->inactive_ratio);
  940. seq_putc(m, '\n');
  941. }
  942. /*
  943. * Output information about zones in @pgdat.
  944. */
  945. static int zoneinfo_show(struct seq_file *m, void *arg)
  946. {
  947. pg_data_t *pgdat = (pg_data_t *)arg;
  948. walk_zones_in_node(m, pgdat, zoneinfo_show_print);
  949. return 0;
  950. }
  951. static const struct seq_operations zoneinfo_op = {
  952. .start = frag_start, /* iterate over all zones. The same as in
  953. * fragmentation. */
  954. .next = frag_next,
  955. .stop = frag_stop,
  956. .show = zoneinfo_show,
  957. };
  958. static int zoneinfo_open(struct inode *inode, struct file *file)
  959. {
  960. return seq_open(file, &zoneinfo_op);
  961. }
  962. static const struct file_operations proc_zoneinfo_file_operations = {
  963. .open = zoneinfo_open,
  964. .read = seq_read,
  965. .llseek = seq_lseek,
  966. .release = seq_release,
  967. };
  968. enum writeback_stat_item {
  969. NR_DIRTY_THRESHOLD,
  970. NR_DIRTY_BG_THRESHOLD,
  971. NR_VM_WRITEBACK_STAT_ITEMS,
  972. };
  973. static void *vmstat_start(struct seq_file *m, loff_t *pos)
  974. {
  975. unsigned long *v;
  976. int i, stat_items_size;
  977. if (*pos >= ARRAY_SIZE(vmstat_text))
  978. return NULL;
  979. stat_items_size = NR_VM_ZONE_STAT_ITEMS * sizeof(unsigned long) +
  980. NR_VM_WRITEBACK_STAT_ITEMS * sizeof(unsigned long);
  981. #ifdef CONFIG_VM_EVENT_COUNTERS
  982. stat_items_size += sizeof(struct vm_event_state);
  983. #endif
  984. v = kmalloc(stat_items_size, GFP_KERNEL);
  985. m->private = v;
  986. if (!v)
  987. return ERR_PTR(-ENOMEM);
  988. for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
  989. v[i] = global_page_state(i);
  990. v += NR_VM_ZONE_STAT_ITEMS;
  991. global_dirty_limits(v + NR_DIRTY_BG_THRESHOLD,
  992. v + NR_DIRTY_THRESHOLD);
  993. v += NR_VM_WRITEBACK_STAT_ITEMS;
  994. #ifdef CONFIG_VM_EVENT_COUNTERS
  995. all_vm_events(v);
  996. v[PGPGIN] /= 2; /* sectors -> kbytes */
  997. v[PGPGOUT] /= 2;
  998. #endif
  999. return (unsigned long *)m->private + *pos;
  1000. }
  1001. static void *vmstat_next(struct seq_file *m, void *arg, loff_t *pos)
  1002. {
  1003. (*pos)++;
  1004. if (*pos >= ARRAY_SIZE(vmstat_text))
  1005. return NULL;
  1006. return (unsigned long *)m->private + *pos;
  1007. }
  1008. static int vmstat_show(struct seq_file *m, void *arg)
  1009. {
  1010. unsigned long *l = arg;
  1011. unsigned long off = l - (unsigned long *)m->private;
  1012. seq_printf(m, "%s %lu\n", vmstat_text[off], *l);
  1013. return 0;
  1014. }
  1015. static void vmstat_stop(struct seq_file *m, void *arg)
  1016. {
  1017. kfree(m->private);
  1018. m->private = NULL;
  1019. }
  1020. static const struct seq_operations vmstat_op = {
  1021. .start = vmstat_start,
  1022. .next = vmstat_next,
  1023. .stop = vmstat_stop,
  1024. .show = vmstat_show,
  1025. };
  1026. static int vmstat_open(struct inode *inode, struct file *file)
  1027. {
  1028. return seq_open(file, &vmstat_op);
  1029. }
  1030. static const struct file_operations proc_vmstat_file_operations = {
  1031. .open = vmstat_open,
  1032. .read = seq_read,
  1033. .llseek = seq_lseek,
  1034. .release = seq_release,
  1035. };
  1036. #endif /* CONFIG_PROC_FS */
  1037. #ifdef CONFIG_SMP
  1038. static DEFINE_PER_CPU(struct delayed_work, vmstat_work);
  1039. int sysctl_stat_interval __read_mostly = HZ;
  1040. static void vmstat_update(struct work_struct *w)
  1041. {
  1042. refresh_cpu_vm_stats();
  1043. schedule_delayed_work(&__get_cpu_var(vmstat_work),
  1044. round_jiffies_relative(sysctl_stat_interval));
  1045. }
  1046. static void start_cpu_timer(int cpu)
  1047. {
  1048. struct delayed_work *work = &per_cpu(vmstat_work, cpu);
  1049. INIT_DEFERRABLE_WORK(work, vmstat_update);
  1050. schedule_delayed_work_on(cpu, work, __round_jiffies_relative(HZ, cpu));
  1051. }
  1052. static void vmstat_cpu_dead(int node)
  1053. {
  1054. int cpu;
  1055. get_online_cpus();
  1056. for_each_online_cpu(cpu)
  1057. if (cpu_to_node(cpu) == node)
  1058. goto end;
  1059. node_clear_state(node, N_CPU);
  1060. end:
  1061. put_online_cpus();
  1062. }
  1063. /*
  1064. * Use the cpu notifier to insure that the thresholds are recalculated
  1065. * when necessary.
  1066. */
  1067. static int vmstat_cpuup_callback(struct notifier_block *nfb,
  1068. unsigned long action,
  1069. void *hcpu)
  1070. {
  1071. long cpu = (long)hcpu;
  1072. switch (action) {
  1073. case CPU_ONLINE:
  1074. case CPU_ONLINE_FROZEN:
  1075. refresh_zone_stat_thresholds();
  1076. start_cpu_timer(cpu);
  1077. node_set_state(cpu_to_node(cpu), N_CPU);
  1078. break;
  1079. case CPU_DOWN_PREPARE:
  1080. case CPU_DOWN_PREPARE_FROZEN:
  1081. cancel_delayed_work_sync(&per_cpu(vmstat_work, cpu));
  1082. per_cpu(vmstat_work, cpu).work.func = NULL;
  1083. break;
  1084. case CPU_DOWN_FAILED:
  1085. case CPU_DOWN_FAILED_FROZEN:
  1086. start_cpu_timer(cpu);
  1087. break;
  1088. case CPU_DEAD:
  1089. case CPU_DEAD_FROZEN:
  1090. refresh_zone_stat_thresholds();
  1091. vmstat_cpu_dead(cpu_to_node(cpu));
  1092. break;
  1093. default:
  1094. break;
  1095. }
  1096. return NOTIFY_OK;
  1097. }
  1098. static struct notifier_block vmstat_notifier =
  1099. { &vmstat_cpuup_callback, NULL, 0 };
  1100. #endif
  1101. static int __init setup_vmstat(void)
  1102. {
  1103. #ifdef CONFIG_SMP
  1104. int cpu;
  1105. register_cpu_notifier(&vmstat_notifier);
  1106. get_online_cpus();
  1107. for_each_online_cpu(cpu) {
  1108. start_cpu_timer(cpu);
  1109. node_set_state(cpu_to_node(cpu), N_CPU);
  1110. }
  1111. put_online_cpus();
  1112. #endif
  1113. #ifdef CONFIG_PROC_FS
  1114. proc_create("buddyinfo", S_IRUGO, NULL, &fragmentation_file_operations);
  1115. proc_create("pagetypeinfo", S_IRUGO, NULL, &pagetypeinfo_file_ops);
  1116. proc_create("vmstat", S_IRUGO, NULL, &proc_vmstat_file_operations);
  1117. proc_create("zoneinfo", S_IRUGO, NULL, &proc_zoneinfo_file_operations);
  1118. #endif
  1119. return 0;
  1120. }
  1121. module_init(setup_vmstat)
  1122. #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_COMPACTION)
  1123. #include <linux/debugfs.h>
  1124. /*
  1125. * Return an index indicating how much of the available free memory is
  1126. * unusable for an allocation of the requested size.
  1127. */
  1128. static int unusable_free_index(unsigned int order,
  1129. struct contig_page_info *info)
  1130. {
  1131. /* No free memory is interpreted as all free memory is unusable */
  1132. if (info->free_pages == 0)
  1133. return 1000;
  1134. /*
  1135. * Index should be a value between 0 and 1. Return a value to 3
  1136. * decimal places.
  1137. *
  1138. * 0 => no fragmentation
  1139. * 1 => high fragmentation
  1140. */
  1141. return div_u64((info->free_pages - (info->free_blocks_suitable << order)) * 1000ULL, info->free_pages);
  1142. }
  1143. static void unusable_show_print(struct seq_file *m,
  1144. pg_data_t *pgdat, struct zone *zone)
  1145. {
  1146. unsigned int order;
  1147. int index;
  1148. struct contig_page_info info;
  1149. seq_printf(m, "Node %d, zone %8s ",
  1150. pgdat->node_id,
  1151. zone->name);
  1152. for (order = 0; order < MAX_ORDER; ++order) {
  1153. fill_contig_page_info(zone, order, &info);
  1154. index = unusable_free_index(order, &info);
  1155. seq_printf(m, "%d.%03d ", index / 1000, index % 1000);
  1156. }
  1157. seq_putc(m, '\n');
  1158. }
  1159. /*
  1160. * Display unusable free space index
  1161. *
  1162. * The unusable free space index measures how much of the available free
  1163. * memory cannot be used to satisfy an allocation of a given size and is a
  1164. * value between 0 and 1. The higher the value, the more of free memory is
  1165. * unusable and by implication, the worse the external fragmentation is. This
  1166. * can be expressed as a percentage by multiplying by 100.
  1167. */
  1168. static int unusable_show(struct seq_file *m, void *arg)
  1169. {
  1170. pg_data_t *pgdat = (pg_data_t *)arg;
  1171. /* check memoryless node */
  1172. if (!node_state(pgdat->node_id, N_MEMORY))
  1173. return 0;
  1174. walk_zones_in_node(m, pgdat, unusable_show_print);
  1175. return 0;
  1176. }
  1177. static const struct seq_operations unusable_op = {
  1178. .start = frag_start,
  1179. .next = frag_next,
  1180. .stop = frag_stop,
  1181. .show = unusable_show,
  1182. };
  1183. static int unusable_open(struct inode *inode, struct file *file)
  1184. {
  1185. return seq_open(file, &unusable_op);
  1186. }
  1187. static const struct file_operations unusable_file_ops = {
  1188. .open = unusable_open,
  1189. .read = seq_read,
  1190. .llseek = seq_lseek,
  1191. .release = seq_release,
  1192. };
  1193. static void extfrag_show_print(struct seq_file *m,
  1194. pg_data_t *pgdat, struct zone *zone)
  1195. {
  1196. unsigned int order;
  1197. int index;
  1198. /* Alloc on stack as interrupts are disabled for zone walk */
  1199. struct contig_page_info info;
  1200. seq_printf(m, "Node %d, zone %8s ",
  1201. pgdat->node_id,
  1202. zone->name);
  1203. for (order = 0; order < MAX_ORDER; ++order) {
  1204. fill_contig_page_info(zone, order, &info);
  1205. index = __fragmentation_index(order, &info);
  1206. seq_printf(m, "%d.%03d ", index / 1000, index % 1000);
  1207. }
  1208. seq_putc(m, '\n');
  1209. }
  1210. /*
  1211. * Display fragmentation index for orders that allocations would fail for
  1212. */
  1213. static int extfrag_show(struct seq_file *m, void *arg)
  1214. {
  1215. pg_data_t *pgdat = (pg_data_t *)arg;
  1216. walk_zones_in_node(m, pgdat, extfrag_show_print);
  1217. return 0;
  1218. }
  1219. static const struct seq_operations extfrag_op = {
  1220. .start = frag_start,
  1221. .next = frag_next,
  1222. .stop = frag_stop,
  1223. .show = extfrag_show,
  1224. };
  1225. static int extfrag_open(struct inode *inode, struct file *file)
  1226. {
  1227. return seq_open(file, &extfrag_op);
  1228. }
  1229. static const struct file_operations extfrag_file_ops = {
  1230. .open = extfrag_open,
  1231. .read = seq_read,
  1232. .llseek = seq_lseek,
  1233. .release = seq_release,
  1234. };
  1235. static int __init extfrag_debug_init(void)
  1236. {
  1237. struct dentry *extfrag_debug_root;
  1238. extfrag_debug_root = debugfs_create_dir("extfrag", NULL);
  1239. if (!extfrag_debug_root)
  1240. return -ENOMEM;
  1241. if (!debugfs_create_file("unusable_index", 0444,
  1242. extfrag_debug_root, NULL, &unusable_file_ops))
  1243. goto fail;
  1244. if (!debugfs_create_file("extfrag_index", 0444,
  1245. extfrag_debug_root, NULL, &extfrag_file_ops))
  1246. goto fail;
  1247. return 0;
  1248. fail:
  1249. debugfs_remove_recursive(extfrag_debug_root);
  1250. return -ENOMEM;
  1251. }
  1252. module_init(extfrag_debug_init);
  1253. #endif