4 * Manages VM statistics
5 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
8 * Copyright (C) 2006 Silicon Graphics, Inc.,
9 * Christoph Lameter <christoph@lameter.com>
10 * Copyright (C) 2008-2014 Christoph Lameter
14 #include <linux/err.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/cpu.h>
18 #include <linux/cpumask.h>
19 #include <linux/vmstat.h>
20 #include <linux/proc_fs.h>
21 #include <linux/seq_file.h>
22 #include <linux/debugfs.h>
23 #include <linux/sched.h>
24 #include <linux/math64.h>
25 #include <linux/writeback.h>
26 #include <linux/compaction.h>
27 #include <linux/mm_inline.h>
28 #include <linux/page_ext.h>
29 #include <linux/page_owner.h>
33 #ifdef CONFIG_VM_EVENT_COUNTERS
34 DEFINE_PER_CPU(struct vm_event_state
, vm_event_states
) = {{0}};
35 EXPORT_PER_CPU_SYMBOL(vm_event_states
);
37 static void sum_vm_events(unsigned long *ret
)
42 memset(ret
, 0, NR_VM_EVENT_ITEMS
* sizeof(unsigned long));
44 for_each_online_cpu(cpu
) {
45 struct vm_event_state
*this = &per_cpu(vm_event_states
, cpu
);
47 for (i
= 0; i
< NR_VM_EVENT_ITEMS
; i
++)
48 ret
[i
] += this->event
[i
];
53 * Accumulate the vm event counters across all CPUs.
54 * The result is unavoidably approximate - it can change
55 * during and after execution of this function.
57 void all_vm_events(unsigned long *ret
)
63 EXPORT_SYMBOL_GPL(all_vm_events
);
66 * Fold the foreign cpu events into our own.
68 * This is adding to the events on one processor
69 * but keeps the global counts constant.
71 void vm_events_fold_cpu(int cpu
)
73 struct vm_event_state
*fold_state
= &per_cpu(vm_event_states
, cpu
);
76 for (i
= 0; i
< NR_VM_EVENT_ITEMS
; i
++) {
77 count_vm_events(i
, fold_state
->event
[i
]);
78 fold_state
->event
[i
] = 0;
82 #endif /* CONFIG_VM_EVENT_COUNTERS */
85 * Manage combined zone based / global counters
87 * vm_stat contains the global counters
89 atomic_long_t vm_stat
[NR_VM_ZONE_STAT_ITEMS
] __cacheline_aligned_in_smp
;
90 EXPORT_SYMBOL(vm_stat
);
94 int calculate_pressure_threshold(struct zone
*zone
)
97 int watermark_distance
;
100 * As vmstats are not up to date, there is drift between the estimated
101 * and real values. For high thresholds and a high number of CPUs, it
102 * is possible for the min watermark to be breached while the estimated
103 * value looks fine. The pressure threshold is a reduced value such
104 * that even the maximum amount of drift will not accidentally breach
107 watermark_distance
= low_wmark_pages(zone
) - min_wmark_pages(zone
);
108 threshold
= max(1, (int)(watermark_distance
/ num_online_cpus()));
111 * Maximum threshold is 125
113 threshold
= min(125, threshold
);
118 int calculate_normal_threshold(struct zone
*zone
)
121 int mem
; /* memory in 128 MB units */
124 * The threshold scales with the number of processors and the amount
125 * of memory per zone. More memory means that we can defer updates for
126 * longer, more processors could lead to more contention.
127 * fls() is used to have a cheap way of logarithmic scaling.
129 * Some sample thresholds:
131 * Threshold Processors (fls) Zonesize fls(mem+1)
132 * ------------------------------------------------------------------
149 * 125 1024 10 8-16 GB 8
150 * 125 1024 10 16-32 GB 9
153 mem
= zone
->managed_pages
>> (27 - PAGE_SHIFT
);
155 threshold
= 2 * fls(num_online_cpus()) * (1 + fls(mem
));
158 * Maximum threshold is 125
160 threshold
= min(125, threshold
);
166 * Refresh the thresholds for each zone.
168 void refresh_zone_stat_thresholds(void)
174 for_each_populated_zone(zone
) {
175 unsigned long max_drift
, tolerate_drift
;
177 threshold
= calculate_normal_threshold(zone
);
179 for_each_online_cpu(cpu
)
180 per_cpu_ptr(zone
->pageset
, cpu
)->stat_threshold
184 * Only set percpu_drift_mark if there is a danger that
185 * NR_FREE_PAGES reports the low watermark is ok when in fact
186 * the min watermark could be breached by an allocation
188 tolerate_drift
= low_wmark_pages(zone
) - min_wmark_pages(zone
);
189 max_drift
= num_online_cpus() * threshold
;
190 if (max_drift
> tolerate_drift
)
191 zone
->percpu_drift_mark
= high_wmark_pages(zone
) +
196 void set_pgdat_percpu_threshold(pg_data_t
*pgdat
,
197 int (*calculate_pressure
)(struct zone
*))
204 for (i
= 0; i
< pgdat
->nr_zones
; i
++) {
205 zone
= &pgdat
->node_zones
[i
];
206 if (!zone
->percpu_drift_mark
)
209 threshold
= (*calculate_pressure
)(zone
);
210 for_each_online_cpu(cpu
)
211 per_cpu_ptr(zone
->pageset
, cpu
)->stat_threshold
217 * For use when we know that interrupts are disabled,
218 * or when we know that preemption is disabled and that
219 * particular counter cannot be updated from interrupt context.
221 void __mod_zone_page_state(struct zone
*zone
, enum zone_stat_item item
,
224 struct per_cpu_pageset __percpu
*pcp
= zone
->pageset
;
225 s8 __percpu
*p
= pcp
->vm_stat_diff
+ item
;
229 x
= delta
+ __this_cpu_read(*p
);
231 t
= __this_cpu_read(pcp
->stat_threshold
);
233 if (unlikely(x
> t
|| x
< -t
)) {
234 zone_page_state_add(x
, zone
, item
);
237 __this_cpu_write(*p
, x
);
239 EXPORT_SYMBOL(__mod_zone_page_state
);
242 * Optimized increment and decrement functions.
244 * These are only for a single page and therefore can take a struct page *
245 * argument instead of struct zone *. This allows the inclusion of the code
246 * generated for page_zone(page) into the optimized functions.
248 * No overflow check is necessary and therefore the differential can be
249 * incremented or decremented in place which may allow the compilers to
250 * generate better code.
251 * The increment or decrement is known and therefore one boundary check can
254 * NOTE: These functions are very performance sensitive. Change only
257 * Some processors have inc/dec instructions that are atomic vs an interrupt.
258 * However, the code must first determine the differential location in a zone
259 * based on the processor number and then inc/dec the counter. There is no
260 * guarantee without disabling preemption that the processor will not change
261 * in between and therefore the atomicity vs. interrupt cannot be exploited
262 * in a useful way here.
264 void __inc_zone_state(struct zone
*zone
, enum zone_stat_item item
)
266 struct per_cpu_pageset __percpu
*pcp
= zone
->pageset
;
267 s8 __percpu
*p
= pcp
->vm_stat_diff
+ item
;
270 v
= __this_cpu_inc_return(*p
);
271 t
= __this_cpu_read(pcp
->stat_threshold
);
272 if (unlikely(v
> t
)) {
273 s8 overstep
= t
>> 1;
275 zone_page_state_add(v
+ overstep
, zone
, item
);
276 __this_cpu_write(*p
, -overstep
);
280 void __inc_zone_page_state(struct page
*page
, enum zone_stat_item item
)
282 __inc_zone_state(page_zone(page
), item
);
284 EXPORT_SYMBOL(__inc_zone_page_state
);
286 void __dec_zone_state(struct zone
*zone
, enum zone_stat_item item
)
288 struct per_cpu_pageset __percpu
*pcp
= zone
->pageset
;
289 s8 __percpu
*p
= pcp
->vm_stat_diff
+ item
;
292 v
= __this_cpu_dec_return(*p
);
293 t
= __this_cpu_read(pcp
->stat_threshold
);
294 if (unlikely(v
< - t
)) {
295 s8 overstep
= t
>> 1;
297 zone_page_state_add(v
- overstep
, zone
, item
);
298 __this_cpu_write(*p
, overstep
);
302 void __dec_zone_page_state(struct page
*page
, enum zone_stat_item item
)
304 __dec_zone_state(page_zone(page
), item
);
306 EXPORT_SYMBOL(__dec_zone_page_state
);
308 #ifdef CONFIG_HAVE_CMPXCHG_LOCAL
310 * If we have cmpxchg_local support then we do not need to incur the overhead
311 * that comes with local_irq_save/restore if we use this_cpu_cmpxchg.
313 * mod_state() modifies the zone counter state through atomic per cpu
316 * Overstep mode specifies how overstep should handled:
318 * 1 Overstepping half of threshold
319 * -1 Overstepping minus half of threshold
321 static inline void mod_state(struct zone
*zone
, enum zone_stat_item item
,
322 long delta
, int overstep_mode
)
324 struct per_cpu_pageset __percpu
*pcp
= zone
->pageset
;
325 s8 __percpu
*p
= pcp
->vm_stat_diff
+ item
;
329 z
= 0; /* overflow to zone counters */
332 * The fetching of the stat_threshold is racy. We may apply
333 * a counter threshold to the wrong the cpu if we get
334 * rescheduled while executing here. However, the next
335 * counter update will apply the threshold again and
336 * therefore bring the counter under the threshold again.
338 * Most of the time the thresholds are the same anyways
339 * for all cpus in a zone.
341 t
= this_cpu_read(pcp
->stat_threshold
);
343 o
= this_cpu_read(*p
);
346 if (n
> t
|| n
< -t
) {
347 int os
= overstep_mode
* (t
>> 1) ;
349 /* Overflow must be added to zone counters */
353 } while (this_cpu_cmpxchg(*p
, o
, n
) != o
);
356 zone_page_state_add(z
, zone
, item
);
359 void mod_zone_page_state(struct zone
*zone
, enum zone_stat_item item
,
362 mod_state(zone
, item
, delta
, 0);
364 EXPORT_SYMBOL(mod_zone_page_state
);
366 void inc_zone_state(struct zone
*zone
, enum zone_stat_item item
)
368 mod_state(zone
, item
, 1, 1);
371 void inc_zone_page_state(struct page
*page
, enum zone_stat_item item
)
373 mod_state(page_zone(page
), item
, 1, 1);
375 EXPORT_SYMBOL(inc_zone_page_state
);
377 void dec_zone_page_state(struct page
*page
, enum zone_stat_item item
)
379 mod_state(page_zone(page
), item
, -1, -1);
381 EXPORT_SYMBOL(dec_zone_page_state
);
384 * Use interrupt disable to serialize counter updates
386 void mod_zone_page_state(struct zone
*zone
, enum zone_stat_item item
,
391 local_irq_save(flags
);
392 __mod_zone_page_state(zone
, item
, delta
);
393 local_irq_restore(flags
);
395 EXPORT_SYMBOL(mod_zone_page_state
);
397 void inc_zone_state(struct zone
*zone
, enum zone_stat_item item
)
401 local_irq_save(flags
);
402 __inc_zone_state(zone
, item
);
403 local_irq_restore(flags
);
406 void inc_zone_page_state(struct page
*page
, enum zone_stat_item item
)
411 zone
= page_zone(page
);
412 local_irq_save(flags
);
413 __inc_zone_state(zone
, item
);
414 local_irq_restore(flags
);
416 EXPORT_SYMBOL(inc_zone_page_state
);
418 void dec_zone_page_state(struct page
*page
, enum zone_stat_item item
)
422 local_irq_save(flags
);
423 __dec_zone_page_state(page
, item
);
424 local_irq_restore(flags
);
426 EXPORT_SYMBOL(dec_zone_page_state
);
431 * Fold a differential into the global counters.
432 * Returns the number of counters updated.
434 static int fold_diff(int *diff
)
439 for (i
= 0; i
< NR_VM_ZONE_STAT_ITEMS
; i
++)
441 atomic_long_add(diff
[i
], &vm_stat
[i
]);
448 * Update the zone counters for the current cpu.
450 * Note that refresh_cpu_vm_stats strives to only access
451 * node local memory. The per cpu pagesets on remote zones are placed
452 * in the memory local to the processor using that pageset. So the
453 * loop over all zones will access a series of cachelines local to
456 * The call to zone_page_state_add updates the cachelines with the
457 * statistics in the remote zone struct as well as the global cachelines
458 * with the global counters. These could cause remote node cache line
459 * bouncing and will have to be only done when necessary.
461 * The function returns the number of global counters updated.
463 static int refresh_cpu_vm_stats(bool do_pagesets
)
467 int global_diff
[NR_VM_ZONE_STAT_ITEMS
] = { 0, };
470 for_each_populated_zone(zone
) {
471 struct per_cpu_pageset __percpu
*p
= zone
->pageset
;
473 for (i
= 0; i
< NR_VM_ZONE_STAT_ITEMS
; i
++) {
476 v
= this_cpu_xchg(p
->vm_stat_diff
[i
], 0);
479 atomic_long_add(v
, &zone
->vm_stat
[i
]);
482 /* 3 seconds idle till flush */
483 __this_cpu_write(p
->expire
, 3);
491 * Deal with draining the remote pageset of this
494 * Check if there are pages remaining in this pageset
495 * if not then there is nothing to expire.
497 if (!__this_cpu_read(p
->expire
) ||
498 !__this_cpu_read(p
->pcp
.count
))
502 * We never drain zones local to this processor.
504 if (zone_to_nid(zone
) == numa_node_id()) {
505 __this_cpu_write(p
->expire
, 0);
509 if (__this_cpu_dec_return(p
->expire
))
512 if (__this_cpu_read(p
->pcp
.count
)) {
513 drain_zone_pages(zone
, this_cpu_ptr(&p
->pcp
));
519 changes
+= fold_diff(global_diff
);
524 * Fold the data for an offline cpu into the global array.
525 * There cannot be any access by the offline cpu and therefore
526 * synchronization is simplified.
528 void cpu_vm_stats_fold(int cpu
)
532 int global_diff
[NR_VM_ZONE_STAT_ITEMS
] = { 0, };
534 for_each_populated_zone(zone
) {
535 struct per_cpu_pageset
*p
;
537 p
= per_cpu_ptr(zone
->pageset
, cpu
);
539 for (i
= 0; i
< NR_VM_ZONE_STAT_ITEMS
; i
++)
540 if (p
->vm_stat_diff
[i
]) {
543 v
= p
->vm_stat_diff
[i
];
544 p
->vm_stat_diff
[i
] = 0;
545 atomic_long_add(v
, &zone
->vm_stat
[i
]);
550 fold_diff(global_diff
);
554 * this is only called if !populated_zone(zone), which implies no other users of
555 * pset->vm_stat_diff[] exsist.
557 void drain_zonestat(struct zone
*zone
, struct per_cpu_pageset
*pset
)
561 for (i
= 0; i
< NR_VM_ZONE_STAT_ITEMS
; i
++)
562 if (pset
->vm_stat_diff
[i
]) {
563 int v
= pset
->vm_stat_diff
[i
];
564 pset
->vm_stat_diff
[i
] = 0;
565 atomic_long_add(v
, &zone
->vm_stat
[i
]);
566 atomic_long_add(v
, &vm_stat
[i
]);
573 * zonelist = the list of zones passed to the allocator
574 * z = the zone from which the allocation occurred.
576 * Must be called with interrupts disabled.
578 * When __GFP_OTHER_NODE is set assume the node of the preferred
579 * zone is the local node. This is useful for daemons who allocate
580 * memory on behalf of other processes.
582 void zone_statistics(struct zone
*preferred_zone
, struct zone
*z
, gfp_t flags
)
584 if (z
->zone_pgdat
== preferred_zone
->zone_pgdat
) {
585 __inc_zone_state(z
, NUMA_HIT
);
587 __inc_zone_state(z
, NUMA_MISS
);
588 __inc_zone_state(preferred_zone
, NUMA_FOREIGN
);
590 if (z
->node
== ((flags
& __GFP_OTHER_NODE
) ?
591 preferred_zone
->node
: numa_node_id()))
592 __inc_zone_state(z
, NUMA_LOCAL
);
594 __inc_zone_state(z
, NUMA_OTHER
);
598 * Determine the per node value of a stat item.
600 unsigned long node_page_state(int node
, enum zone_stat_item item
)
602 struct zone
*zones
= NODE_DATA(node
)->node_zones
;
604 unsigned long count
= 0;
606 for (i
= 0; i
< MAX_NR_ZONES
; i
++)
607 count
+= zone_page_state(zones
+ i
, item
);
614 #ifdef CONFIG_COMPACTION
616 struct contig_page_info
{
617 unsigned long free_pages
;
618 unsigned long free_blocks_total
;
619 unsigned long free_blocks_suitable
;
623 * Calculate the number of free pages in a zone, how many contiguous
624 * pages are free and how many are large enough to satisfy an allocation of
625 * the target size. Note that this function makes no attempt to estimate
626 * how many suitable free blocks there *might* be if MOVABLE pages were
627 * migrated. Calculating that is possible, but expensive and can be
628 * figured out from userspace
630 static void fill_contig_page_info(struct zone
*zone
,
631 unsigned int suitable_order
,
632 struct contig_page_info
*info
)
636 info
->free_pages
= 0;
637 info
->free_blocks_total
= 0;
638 info
->free_blocks_suitable
= 0;
640 for (order
= 0; order
< MAX_ORDER
; order
++) {
641 unsigned long blocks
;
643 /* Count number of free blocks */
644 blocks
= zone
->free_area
[order
].nr_free
;
645 info
->free_blocks_total
+= blocks
;
647 /* Count free base pages */
648 info
->free_pages
+= blocks
<< order
;
650 /* Count the suitable free blocks */
651 if (order
>= suitable_order
)
652 info
->free_blocks_suitable
+= blocks
<<
653 (order
- suitable_order
);
658 * A fragmentation index only makes sense if an allocation of a requested
659 * size would fail. If that is true, the fragmentation index indicates
660 * whether external fragmentation or a lack of memory was the problem.
661 * The value can be used to determine if page reclaim or compaction
664 static int __fragmentation_index(unsigned int order
, struct contig_page_info
*info
)
666 unsigned long requested
= 1UL << order
;
668 if (!info
->free_blocks_total
)
671 /* Fragmentation index only makes sense when a request would fail */
672 if (info
->free_blocks_suitable
)
676 * Index is between 0 and 1 so return within 3 decimal places
678 * 0 => allocation would fail due to lack of memory
679 * 1 => allocation would fail due to fragmentation
681 return 1000 - div_u64( (1000+(div_u64(info
->free_pages
* 1000ULL, requested
))), info
->free_blocks_total
);
684 /* Same as __fragmentation index but allocs contig_page_info on stack */
685 int fragmentation_index(struct zone
*zone
, unsigned int order
)
687 struct contig_page_info info
;
689 fill_contig_page_info(zone
, order
, &info
);
690 return __fragmentation_index(order
, &info
);
694 #if defined(CONFIG_PROC_FS) || defined(CONFIG_SYSFS) || defined(CONFIG_NUMA)
695 #ifdef CONFIG_ZONE_DMA
696 #define TEXT_FOR_DMA(xx) xx "_dma",
698 #define TEXT_FOR_DMA(xx)
701 #ifdef CONFIG_ZONE_DMA32
702 #define TEXT_FOR_DMA32(xx) xx "_dma32",
704 #define TEXT_FOR_DMA32(xx)
707 #ifdef CONFIG_HIGHMEM
708 #define TEXT_FOR_HIGHMEM(xx) xx "_high",
710 #define TEXT_FOR_HIGHMEM(xx)
713 #define TEXTS_FOR_ZONES(xx) TEXT_FOR_DMA(xx) TEXT_FOR_DMA32(xx) xx "_normal", \
714 TEXT_FOR_HIGHMEM(xx) xx "_movable",
716 const char * const vmstat_text
[] = {
717 /* enum zone_stat_item countes */
731 "nr_slab_reclaimable",
732 "nr_slab_unreclaimable",
733 "nr_page_table_pages",
738 "nr_vmscan_immediate_reclaim",
755 "workingset_refault",
756 "workingset_activate",
757 "workingset_nodereclaim",
758 "nr_anon_transparent_hugepages",
761 /* enum writeback_stat_item counters */
762 "nr_dirty_threshold",
763 "nr_dirty_background_threshold",
765 #ifdef CONFIG_VM_EVENT_COUNTERS
766 /* enum vm_event_item counters */
772 TEXTS_FOR_ZONES("pgalloc")
782 TEXTS_FOR_ZONES("pgrefill")
783 TEXTS_FOR_ZONES("pgsteal_kswapd")
784 TEXTS_FOR_ZONES("pgsteal_direct")
785 TEXTS_FOR_ZONES("pgscan_kswapd")
786 TEXTS_FOR_ZONES("pgscan_direct")
787 "pgscan_direct_throttle",
790 "zone_reclaim_failed",
795 "kswapd_low_wmark_hit_quickly",
796 "kswapd_high_wmark_hit_quickly",
805 #ifdef CONFIG_NUMA_BALANCING
807 "numa_huge_pte_updates",
809 "numa_hint_faults_local",
810 "numa_pages_migrated",
812 #ifdef CONFIG_MIGRATION
816 #ifdef CONFIG_COMPACTION
817 "compact_migrate_scanned",
818 "compact_free_scanned",
823 "compact_daemon_wake",
826 #ifdef CONFIG_HUGETLB_PAGE
827 "htlb_buddy_alloc_success",
828 "htlb_buddy_alloc_fail",
830 "unevictable_pgs_culled",
831 "unevictable_pgs_scanned",
832 "unevictable_pgs_rescued",
833 "unevictable_pgs_mlocked",
834 "unevictable_pgs_munlocked",
835 "unevictable_pgs_cleared",
836 "unevictable_pgs_stranded",
838 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
840 "thp_fault_fallback",
841 "thp_collapse_alloc",
842 "thp_collapse_alloc_failed",
844 "thp_split_page_failed",
845 "thp_deferred_split_page",
847 "thp_zero_page_alloc",
848 "thp_zero_page_alloc_failed",
850 #ifdef CONFIG_MEMORY_BALLOON
853 #ifdef CONFIG_BALLOON_COMPACTION
856 #endif /* CONFIG_MEMORY_BALLOON */
857 #ifdef CONFIG_DEBUG_TLBFLUSH
859 "nr_tlb_remote_flush",
860 "nr_tlb_remote_flush_received",
861 #endif /* CONFIG_SMP */
862 "nr_tlb_local_flush_all",
863 "nr_tlb_local_flush_one",
864 #endif /* CONFIG_DEBUG_TLBFLUSH */
866 #ifdef CONFIG_DEBUG_VM_VMACACHE
867 "vmacache_find_calls",
868 "vmacache_find_hits",
869 "vmacache_full_flushes",
871 #endif /* CONFIG_VM_EVENTS_COUNTERS */
873 #endif /* CONFIG_PROC_FS || CONFIG_SYSFS || CONFIG_NUMA */
876 #if (defined(CONFIG_DEBUG_FS) && defined(CONFIG_COMPACTION)) || \
877 defined(CONFIG_PROC_FS)
878 static void *frag_start(struct seq_file
*m
, loff_t
*pos
)
883 for (pgdat
= first_online_pgdat();
885 pgdat
= next_online_pgdat(pgdat
))
891 static void *frag_next(struct seq_file
*m
, void *arg
, loff_t
*pos
)
893 pg_data_t
*pgdat
= (pg_data_t
*)arg
;
896 return next_online_pgdat(pgdat
);
899 static void frag_stop(struct seq_file
*m
, void *arg
)
903 /* Walk all the zones in a node and print using a callback */
904 static void walk_zones_in_node(struct seq_file
*m
, pg_data_t
*pgdat
,
905 void (*print
)(struct seq_file
*m
, pg_data_t
*, struct zone
*))
908 struct zone
*node_zones
= pgdat
->node_zones
;
911 for (zone
= node_zones
; zone
- node_zones
< MAX_NR_ZONES
; ++zone
) {
912 if (!populated_zone(zone
))
915 spin_lock_irqsave(&zone
->lock
, flags
);
916 print(m
, pgdat
, zone
);
917 spin_unlock_irqrestore(&zone
->lock
, flags
);
922 #ifdef CONFIG_PROC_FS
923 static void frag_show_print(struct seq_file
*m
, pg_data_t
*pgdat
,
928 seq_printf(m
, "Node %d, zone %8s ", pgdat
->node_id
, zone
->name
);
929 for (order
= 0; order
< MAX_ORDER
; ++order
)
930 seq_printf(m
, "%6lu ", zone
->free_area
[order
].nr_free
);
935 * This walks the free areas for each zone.
937 static int frag_show(struct seq_file
*m
, void *arg
)
939 pg_data_t
*pgdat
= (pg_data_t
*)arg
;
940 walk_zones_in_node(m
, pgdat
, frag_show_print
);
944 static void pagetypeinfo_showfree_print(struct seq_file
*m
,
945 pg_data_t
*pgdat
, struct zone
*zone
)
949 for (mtype
= 0; mtype
< MIGRATE_TYPES
; mtype
++) {
950 seq_printf(m
, "Node %4d, zone %8s, type %12s ",
953 migratetype_names
[mtype
]);
954 for (order
= 0; order
< MAX_ORDER
; ++order
) {
955 unsigned long freecount
= 0;
956 struct free_area
*area
;
957 struct list_head
*curr
;
959 area
= &(zone
->free_area
[order
]);
961 list_for_each(curr
, &area
->free_list
[mtype
])
963 seq_printf(m
, "%6lu ", freecount
);
969 /* Print out the free pages at each order for each migatetype */
970 static int pagetypeinfo_showfree(struct seq_file
*m
, void *arg
)
973 pg_data_t
*pgdat
= (pg_data_t
*)arg
;
976 seq_printf(m
, "%-43s ", "Free pages count per migrate type at order");
977 for (order
= 0; order
< MAX_ORDER
; ++order
)
978 seq_printf(m
, "%6d ", order
);
981 walk_zones_in_node(m
, pgdat
, pagetypeinfo_showfree_print
);
986 static void pagetypeinfo_showblockcount_print(struct seq_file
*m
,
987 pg_data_t
*pgdat
, struct zone
*zone
)
991 unsigned long start_pfn
= zone
->zone_start_pfn
;
992 unsigned long end_pfn
= zone_end_pfn(zone
);
993 unsigned long count
[MIGRATE_TYPES
] = { 0, };
995 for (pfn
= start_pfn
; pfn
< end_pfn
; pfn
+= pageblock_nr_pages
) {
1001 page
= pfn_to_page(pfn
);
1003 /* Watch for unexpected holes punched in the memmap */
1004 if (!memmap_valid_within(pfn
, page
, zone
))
1007 if (page_zone(page
) != zone
)
1010 mtype
= get_pageblock_migratetype(page
);
1012 if (mtype
< MIGRATE_TYPES
)
1017 seq_printf(m
, "Node %d, zone %8s ", pgdat
->node_id
, zone
->name
);
1018 for (mtype
= 0; mtype
< MIGRATE_TYPES
; mtype
++)
1019 seq_printf(m
, "%12lu ", count
[mtype
]);
1023 /* Print out the free pages at each order for each migratetype */
1024 static int pagetypeinfo_showblockcount(struct seq_file
*m
, void *arg
)
1027 pg_data_t
*pgdat
= (pg_data_t
*)arg
;
1029 seq_printf(m
, "\n%-23s", "Number of blocks type ");
1030 for (mtype
= 0; mtype
< MIGRATE_TYPES
; mtype
++)
1031 seq_printf(m
, "%12s ", migratetype_names
[mtype
]);
1033 walk_zones_in_node(m
, pgdat
, pagetypeinfo_showblockcount_print
);
1038 #ifdef CONFIG_PAGE_OWNER
1039 static void pagetypeinfo_showmixedcount_print(struct seq_file
*m
,
1044 struct page_ext
*page_ext
;
1045 unsigned long pfn
= zone
->zone_start_pfn
, block_end_pfn
;
1046 unsigned long end_pfn
= pfn
+ zone
->spanned_pages
;
1047 unsigned long count
[MIGRATE_TYPES
] = { 0, };
1048 int pageblock_mt
, page_mt
;
1051 /* Scan block by block. First and last block may be incomplete */
1052 pfn
= zone
->zone_start_pfn
;
1055 * Walk the zone in pageblock_nr_pages steps. If a page block spans
1056 * a zone boundary, it will be double counted between zones. This does
1057 * not matter as the mixed block count will still be correct
1059 for (; pfn
< end_pfn
; ) {
1060 if (!pfn_valid(pfn
)) {
1061 pfn
= ALIGN(pfn
+ 1, MAX_ORDER_NR_PAGES
);
1065 block_end_pfn
= ALIGN(pfn
+ 1, pageblock_nr_pages
);
1066 block_end_pfn
= min(block_end_pfn
, end_pfn
);
1068 page
= pfn_to_page(pfn
);
1069 pageblock_mt
= get_pfnblock_migratetype(page
, pfn
);
1071 for (; pfn
< block_end_pfn
; pfn
++) {
1072 if (!pfn_valid_within(pfn
))
1075 page
= pfn_to_page(pfn
);
1077 if (page_zone(page
) != zone
)
1080 if (PageBuddy(page
)) {
1081 pfn
+= (1UL << page_order(page
)) - 1;
1085 if (PageReserved(page
))
1088 page_ext
= lookup_page_ext(page
);
1090 if (!test_bit(PAGE_EXT_OWNER
, &page_ext
->flags
))
1093 page_mt
= gfpflags_to_migratetype(page_ext
->gfp_mask
);
1094 if (pageblock_mt
!= page_mt
) {
1095 if (is_migrate_cma(pageblock_mt
))
1096 count
[MIGRATE_MOVABLE
]++;
1098 count
[pageblock_mt
]++;
1100 pfn
= block_end_pfn
;
1103 pfn
+= (1UL << page_ext
->order
) - 1;
1108 seq_printf(m
, "Node %d, zone %8s ", pgdat
->node_id
, zone
->name
);
1109 for (i
= 0; i
< MIGRATE_TYPES
; i
++)
1110 seq_printf(m
, "%12lu ", count
[i
]);
1113 #endif /* CONFIG_PAGE_OWNER */
1116 * Print out the number of pageblocks for each migratetype that contain pages
1117 * of other types. This gives an indication of how well fallbacks are being
1118 * contained by rmqueue_fallback(). It requires information from PAGE_OWNER
1119 * to determine what is going on
1121 static void pagetypeinfo_showmixedcount(struct seq_file
*m
, pg_data_t
*pgdat
)
1123 #ifdef CONFIG_PAGE_OWNER
1126 if (!static_branch_unlikely(&page_owner_inited
))
1129 drain_all_pages(NULL
);
1131 seq_printf(m
, "\n%-23s", "Number of mixed blocks ");
1132 for (mtype
= 0; mtype
< MIGRATE_TYPES
; mtype
++)
1133 seq_printf(m
, "%12s ", migratetype_names
[mtype
]);
1136 walk_zones_in_node(m
, pgdat
, pagetypeinfo_showmixedcount_print
);
1137 #endif /* CONFIG_PAGE_OWNER */
1141 * This prints out statistics in relation to grouping pages by mobility.
1142 * It is expensive to collect so do not constantly read the file.
1144 static int pagetypeinfo_show(struct seq_file
*m
, void *arg
)
1146 pg_data_t
*pgdat
= (pg_data_t
*)arg
;
1148 /* check memoryless node */
1149 if (!node_state(pgdat
->node_id
, N_MEMORY
))
1152 seq_printf(m
, "Page block order: %d\n", pageblock_order
);
1153 seq_printf(m
, "Pages per block: %lu\n", pageblock_nr_pages
);
1155 pagetypeinfo_showfree(m
, pgdat
);
1156 pagetypeinfo_showblockcount(m
, pgdat
);
1157 pagetypeinfo_showmixedcount(m
, pgdat
);
1162 static const struct seq_operations fragmentation_op
= {
1163 .start
= frag_start
,
1169 static int fragmentation_open(struct inode
*inode
, struct file
*file
)
1171 return seq_open(file
, &fragmentation_op
);
1174 static const struct file_operations fragmentation_file_operations
= {
1175 .open
= fragmentation_open
,
1177 .llseek
= seq_lseek
,
1178 .release
= seq_release
,
1181 static const struct seq_operations pagetypeinfo_op
= {
1182 .start
= frag_start
,
1185 .show
= pagetypeinfo_show
,
1188 static int pagetypeinfo_open(struct inode
*inode
, struct file
*file
)
1190 return seq_open(file
, &pagetypeinfo_op
);
1193 static const struct file_operations pagetypeinfo_file_ops
= {
1194 .open
= pagetypeinfo_open
,
1196 .llseek
= seq_lseek
,
1197 .release
= seq_release
,
1200 static void zoneinfo_show_print(struct seq_file
*m
, pg_data_t
*pgdat
,
1204 seq_printf(m
, "Node %d, zone %8s", pgdat
->node_id
, zone
->name
);
1214 zone_page_state(zone
, NR_FREE_PAGES
),
1215 min_wmark_pages(zone
),
1216 low_wmark_pages(zone
),
1217 high_wmark_pages(zone
),
1218 zone_page_state(zone
, NR_PAGES_SCANNED
),
1219 zone
->spanned_pages
,
1220 zone
->present_pages
,
1221 zone
->managed_pages
);
1223 for (i
= 0; i
< NR_VM_ZONE_STAT_ITEMS
; i
++)
1224 seq_printf(m
, "\n %-12s %lu", vmstat_text
[i
],
1225 zone_page_state(zone
, i
));
1228 "\n protection: (%ld",
1229 zone
->lowmem_reserve
[0]);
1230 for (i
= 1; i
< ARRAY_SIZE(zone
->lowmem_reserve
); i
++)
1231 seq_printf(m
, ", %ld", zone
->lowmem_reserve
[i
]);
1235 for_each_online_cpu(i
) {
1236 struct per_cpu_pageset
*pageset
;
1238 pageset
= per_cpu_ptr(zone
->pageset
, i
);
1247 pageset
->pcp
.batch
);
1249 seq_printf(m
, "\n vm stats threshold: %d",
1250 pageset
->stat_threshold
);
1254 "\n all_unreclaimable: %u"
1256 "\n inactive_ratio: %u",
1257 !zone_reclaimable(zone
),
1258 zone
->zone_start_pfn
,
1259 zone
->inactive_ratio
);
1264 * Output information about zones in @pgdat.
1266 static int zoneinfo_show(struct seq_file
*m
, void *arg
)
1268 pg_data_t
*pgdat
= (pg_data_t
*)arg
;
1269 walk_zones_in_node(m
, pgdat
, zoneinfo_show_print
);
1273 static const struct seq_operations zoneinfo_op
= {
1274 .start
= frag_start
, /* iterate over all zones. The same as in
1278 .show
= zoneinfo_show
,
1281 static int zoneinfo_open(struct inode
*inode
, struct file
*file
)
1283 return seq_open(file
, &zoneinfo_op
);
1286 static const struct file_operations proc_zoneinfo_file_operations
= {
1287 .open
= zoneinfo_open
,
1289 .llseek
= seq_lseek
,
1290 .release
= seq_release
,
1293 enum writeback_stat_item
{
1295 NR_DIRTY_BG_THRESHOLD
,
1296 NR_VM_WRITEBACK_STAT_ITEMS
,
1299 static void *vmstat_start(struct seq_file
*m
, loff_t
*pos
)
1302 int i
, stat_items_size
;
1304 if (*pos
>= ARRAY_SIZE(vmstat_text
))
1306 stat_items_size
= NR_VM_ZONE_STAT_ITEMS
* sizeof(unsigned long) +
1307 NR_VM_WRITEBACK_STAT_ITEMS
* sizeof(unsigned long);
1309 #ifdef CONFIG_VM_EVENT_COUNTERS
1310 stat_items_size
+= sizeof(struct vm_event_state
);
1313 v
= kmalloc(stat_items_size
, GFP_KERNEL
);
1316 return ERR_PTR(-ENOMEM
);
1317 for (i
= 0; i
< NR_VM_ZONE_STAT_ITEMS
; i
++)
1318 v
[i
] = global_page_state(i
);
1319 v
+= NR_VM_ZONE_STAT_ITEMS
;
1321 global_dirty_limits(v
+ NR_DIRTY_BG_THRESHOLD
,
1322 v
+ NR_DIRTY_THRESHOLD
);
1323 v
+= NR_VM_WRITEBACK_STAT_ITEMS
;
1325 #ifdef CONFIG_VM_EVENT_COUNTERS
1327 v
[PGPGIN
] /= 2; /* sectors -> kbytes */
1330 return (unsigned long *)m
->private + *pos
;
1333 static void *vmstat_next(struct seq_file
*m
, void *arg
, loff_t
*pos
)
1336 if (*pos
>= ARRAY_SIZE(vmstat_text
))
1338 return (unsigned long *)m
->private + *pos
;
1341 static int vmstat_show(struct seq_file
*m
, void *arg
)
1343 unsigned long *l
= arg
;
1344 unsigned long off
= l
- (unsigned long *)m
->private;
1346 seq_printf(m
, "%s %lu\n", vmstat_text
[off
], *l
);
1350 static void vmstat_stop(struct seq_file
*m
, void *arg
)
1356 static const struct seq_operations vmstat_op
= {
1357 .start
= vmstat_start
,
1358 .next
= vmstat_next
,
1359 .stop
= vmstat_stop
,
1360 .show
= vmstat_show
,
1363 static int vmstat_open(struct inode
*inode
, struct file
*file
)
1365 return seq_open(file
, &vmstat_op
);
1368 static const struct file_operations proc_vmstat_file_operations
= {
1369 .open
= vmstat_open
,
1371 .llseek
= seq_lseek
,
1372 .release
= seq_release
,
1374 #endif /* CONFIG_PROC_FS */
1377 static struct workqueue_struct
*vmstat_wq
;
1378 static DEFINE_PER_CPU(struct delayed_work
, vmstat_work
);
1379 int sysctl_stat_interval __read_mostly
= HZ
;
1380 static cpumask_var_t cpu_stat_off
;
1382 #ifdef CONFIG_PROC_FS
1383 static void refresh_vm_stats(struct work_struct
*work
)
1385 refresh_cpu_vm_stats(true);
1388 int vmstat_refresh(struct ctl_table
*table
, int write
,
1389 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
1396 * The regular update, every sysctl_stat_interval, may come later
1397 * than expected: leaving a significant amount in per_cpu buckets.
1398 * This is particularly misleading when checking a quantity of HUGE
1399 * pages, immediately after running a test. /proc/sys/vm/stat_refresh,
1400 * which can equally be echo'ed to or cat'ted from (by root),
1401 * can be used to update the stats just before reading them.
1403 * Oh, and since global_page_state() etc. are so careful to hide
1404 * transiently negative values, report an error here if any of
1405 * the stats is negative, so we know to go looking for imbalance.
1407 err
= schedule_on_each_cpu(refresh_vm_stats
);
1410 for (i
= 0; i
< NR_VM_ZONE_STAT_ITEMS
; i
++) {
1411 val
= atomic_long_read(&vm_stat
[i
]);
1414 case NR_ALLOC_BATCH
:
1415 case NR_PAGES_SCANNED
:
1417 * These are often seen to go negative in
1418 * recent kernels, but not to go permanently
1419 * negative. Whilst it would be nicer not to
1420 * have exceptions, rooting them out would be
1421 * another task, of rather low priority.
1425 pr_warn("%s: %s %ld\n",
1426 __func__
, vmstat_text
[i
], val
);
1440 #endif /* CONFIG_PROC_FS */
1442 static void vmstat_update(struct work_struct
*w
)
1444 if (refresh_cpu_vm_stats(true)) {
1446 * Counters were updated so we expect more updates
1447 * to occur in the future. Keep on running the
1448 * update worker thread.
1449 * If we were marked on cpu_stat_off clear the flag
1450 * so that vmstat_shepherd doesn't schedule us again.
1452 if (!cpumask_test_and_clear_cpu(smp_processor_id(),
1454 queue_delayed_work_on(smp_processor_id(), vmstat_wq
,
1455 this_cpu_ptr(&vmstat_work
),
1456 round_jiffies_relative(sysctl_stat_interval
));
1460 * We did not update any counters so the app may be in
1461 * a mode where it does not cause counter updates.
1462 * We may be uselessly running vmstat_update.
1463 * Defer the checking for differentials to the
1464 * shepherd thread on a different processor.
1466 cpumask_set_cpu(smp_processor_id(), cpu_stat_off
);
1471 * Switch off vmstat processing and then fold all the remaining differentials
1472 * until the diffs stay at zero. The function is used by NOHZ and can only be
1473 * invoked when tick processing is not active.
1476 * Check if the diffs for a certain cpu indicate that
1477 * an update is needed.
1479 static bool need_update(int cpu
)
1483 for_each_populated_zone(zone
) {
1484 struct per_cpu_pageset
*p
= per_cpu_ptr(zone
->pageset
, cpu
);
1486 BUILD_BUG_ON(sizeof(p
->vm_stat_diff
[0]) != 1);
1488 * The fast way of checking if there are any vmstat diffs.
1489 * This works because the diffs are byte sized items.
1491 if (memchr_inv(p
->vm_stat_diff
, 0, NR_VM_ZONE_STAT_ITEMS
))
1498 void quiet_vmstat(void)
1500 if (system_state
!= SYSTEM_RUNNING
)
1504 * If we are already in hands of the shepherd then there
1505 * is nothing for us to do here.
1507 if (cpumask_test_and_set_cpu(smp_processor_id(), cpu_stat_off
))
1510 if (!need_update(smp_processor_id()))
1514 * Just refresh counters and do not care about the pending delayed
1515 * vmstat_update. It doesn't fire that often to matter and canceling
1516 * it would be too expensive from this path.
1517 * vmstat_shepherd will take care about that for us.
1519 refresh_cpu_vm_stats(false);
1524 * Shepherd worker thread that checks the
1525 * differentials of processors that have their worker
1526 * threads for vm statistics updates disabled because of
1529 static void vmstat_shepherd(struct work_struct
*w
);
1531 static DECLARE_DEFERRABLE_WORK(shepherd
, vmstat_shepherd
);
1533 static void vmstat_shepherd(struct work_struct
*w
)
1538 /* Check processors whose vmstat worker threads have been disabled */
1539 for_each_cpu(cpu
, cpu_stat_off
) {
1540 struct delayed_work
*dw
= &per_cpu(vmstat_work
, cpu
);
1542 if (need_update(cpu
)) {
1543 if (cpumask_test_and_clear_cpu(cpu
, cpu_stat_off
))
1544 queue_delayed_work_on(cpu
, vmstat_wq
, dw
, 0);
1547 * Cancel the work if quiet_vmstat has put this
1548 * cpu on cpu_stat_off because the work item might
1549 * be still scheduled
1551 cancel_delayed_work(dw
);
1556 schedule_delayed_work(&shepherd
,
1557 round_jiffies_relative(sysctl_stat_interval
));
1560 static void __init
start_shepherd_timer(void)
1564 for_each_possible_cpu(cpu
)
1565 INIT_DEFERRABLE_WORK(per_cpu_ptr(&vmstat_work
, cpu
),
1568 if (!alloc_cpumask_var(&cpu_stat_off
, GFP_KERNEL
))
1570 cpumask_copy(cpu_stat_off
, cpu_online_mask
);
1572 vmstat_wq
= alloc_workqueue("vmstat", WQ_FREEZABLE
|WQ_MEM_RECLAIM
, 0);
1573 schedule_delayed_work(&shepherd
,
1574 round_jiffies_relative(sysctl_stat_interval
));
1577 static void vmstat_cpu_dead(int node
)
1582 for_each_online_cpu(cpu
)
1583 if (cpu_to_node(cpu
) == node
)
1586 node_clear_state(node
, N_CPU
);
1592 * Use the cpu notifier to insure that the thresholds are recalculated
1595 static int vmstat_cpuup_callback(struct notifier_block
*nfb
,
1596 unsigned long action
,
1599 long cpu
= (long)hcpu
;
1603 case CPU_ONLINE_FROZEN
:
1604 refresh_zone_stat_thresholds();
1605 node_set_state(cpu_to_node(cpu
), N_CPU
);
1606 cpumask_set_cpu(cpu
, cpu_stat_off
);
1608 case CPU_DOWN_PREPARE
:
1609 case CPU_DOWN_PREPARE_FROZEN
:
1610 cancel_delayed_work_sync(&per_cpu(vmstat_work
, cpu
));
1611 cpumask_clear_cpu(cpu
, cpu_stat_off
);
1613 case CPU_DOWN_FAILED
:
1614 case CPU_DOWN_FAILED_FROZEN
:
1615 cpumask_set_cpu(cpu
, cpu_stat_off
);
1618 case CPU_DEAD_FROZEN
:
1619 refresh_zone_stat_thresholds();
1620 vmstat_cpu_dead(cpu_to_node(cpu
));
1628 static struct notifier_block vmstat_notifier
=
1629 { &vmstat_cpuup_callback
, NULL
, 0 };
1632 static int __init
setup_vmstat(void)
1635 cpu_notifier_register_begin();
1636 __register_cpu_notifier(&vmstat_notifier
);
1638 start_shepherd_timer();
1639 cpu_notifier_register_done();
1641 #ifdef CONFIG_PROC_FS
1642 proc_create("buddyinfo", S_IRUGO
, NULL
, &fragmentation_file_operations
);
1643 proc_create("pagetypeinfo", S_IRUGO
, NULL
, &pagetypeinfo_file_ops
);
1644 proc_create("vmstat", S_IRUGO
, NULL
, &proc_vmstat_file_operations
);
1645 proc_create("zoneinfo", S_IRUGO
, NULL
, &proc_zoneinfo_file_operations
);
1649 module_init(setup_vmstat
)
1651 #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_COMPACTION)
1654 * Return an index indicating how much of the available free memory is
1655 * unusable for an allocation of the requested size.
1657 static int unusable_free_index(unsigned int order
,
1658 struct contig_page_info
*info
)
1660 /* No free memory is interpreted as all free memory is unusable */
1661 if (info
->free_pages
== 0)
1665 * Index should be a value between 0 and 1. Return a value to 3
1668 * 0 => no fragmentation
1669 * 1 => high fragmentation
1671 return div_u64((info
->free_pages
- (info
->free_blocks_suitable
<< order
)) * 1000ULL, info
->free_pages
);
1675 static void unusable_show_print(struct seq_file
*m
,
1676 pg_data_t
*pgdat
, struct zone
*zone
)
1680 struct contig_page_info info
;
1682 seq_printf(m
, "Node %d, zone %8s ",
1685 for (order
= 0; order
< MAX_ORDER
; ++order
) {
1686 fill_contig_page_info(zone
, order
, &info
);
1687 index
= unusable_free_index(order
, &info
);
1688 seq_printf(m
, "%d.%03d ", index
/ 1000, index
% 1000);
1695 * Display unusable free space index
1697 * The unusable free space index measures how much of the available free
1698 * memory cannot be used to satisfy an allocation of a given size and is a
1699 * value between 0 and 1. The higher the value, the more of free memory is
1700 * unusable and by implication, the worse the external fragmentation is. This
1701 * can be expressed as a percentage by multiplying by 100.
1703 static int unusable_show(struct seq_file
*m
, void *arg
)
1705 pg_data_t
*pgdat
= (pg_data_t
*)arg
;
1707 /* check memoryless node */
1708 if (!node_state(pgdat
->node_id
, N_MEMORY
))
1711 walk_zones_in_node(m
, pgdat
, unusable_show_print
);
1716 static const struct seq_operations unusable_op
= {
1717 .start
= frag_start
,
1720 .show
= unusable_show
,
1723 static int unusable_open(struct inode
*inode
, struct file
*file
)
1725 return seq_open(file
, &unusable_op
);
1728 static const struct file_operations unusable_file_ops
= {
1729 .open
= unusable_open
,
1731 .llseek
= seq_lseek
,
1732 .release
= seq_release
,
1735 static void extfrag_show_print(struct seq_file
*m
,
1736 pg_data_t
*pgdat
, struct zone
*zone
)
1741 /* Alloc on stack as interrupts are disabled for zone walk */
1742 struct contig_page_info info
;
1744 seq_printf(m
, "Node %d, zone %8s ",
1747 for (order
= 0; order
< MAX_ORDER
; ++order
) {
1748 fill_contig_page_info(zone
, order
, &info
);
1749 index
= __fragmentation_index(order
, &info
);
1750 seq_printf(m
, "%d.%03d ", index
/ 1000, index
% 1000);
1757 * Display fragmentation index for orders that allocations would fail for
1759 static int extfrag_show(struct seq_file
*m
, void *arg
)
1761 pg_data_t
*pgdat
= (pg_data_t
*)arg
;
1763 walk_zones_in_node(m
, pgdat
, extfrag_show_print
);
1768 static const struct seq_operations extfrag_op
= {
1769 .start
= frag_start
,
1772 .show
= extfrag_show
,
1775 static int extfrag_open(struct inode
*inode
, struct file
*file
)
1777 return seq_open(file
, &extfrag_op
);
1780 static const struct file_operations extfrag_file_ops
= {
1781 .open
= extfrag_open
,
1783 .llseek
= seq_lseek
,
1784 .release
= seq_release
,
1787 static int __init
extfrag_debug_init(void)
1789 struct dentry
*extfrag_debug_root
;
1791 extfrag_debug_root
= debugfs_create_dir("extfrag", NULL
);
1792 if (!extfrag_debug_root
)
1795 if (!debugfs_create_file("unusable_index", 0444,
1796 extfrag_debug_root
, NULL
, &unusable_file_ops
))
1799 if (!debugfs_create_file("extfrag_index", 0444,
1800 extfrag_debug_root
, NULL
, &extfrag_file_ops
))
1805 debugfs_remove_recursive(extfrag_debug_root
);
1809 module_init(extfrag_debug_init
);