1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/debugfs.h>
3 #include <linux/mm.h>
4 #include <linux/slab.h>
5 #include <linux/uaccess.h>
6 #include <linux/memblock.h>
7 #include <linux/stacktrace.h>
8 #include <linux/page_owner.h>
9 #include <linux/jump_label.h>
10 #include <linux/migrate.h>
11 #include <linux/stackdepot.h>
12 #include <linux/seq_file.h>
13 #include <linux/sched/clock.h>
14
15 #include "internal.h"
16
17 /*
18 * TODO: teach PAGE_OWNER_STACK_DEPTH (__dump_page_owner and save_stack)
19 * to use off stack temporal storage
20 */
21 #define PAGE_OWNER_STACK_DEPTH (16)
22
23 struct page_owner {
24 unsigned short order;
25 short last_migrate_reason;
26 gfp_t gfp_mask;
27 depot_stack_handle_t handle;
28 depot_stack_handle_t free_handle;
29 u64 ts_nsec;
30 u64 free_ts_nsec;
31 pid_t pid;
32 };
33
34 bool page_owner_enabled;
35 DEFINE_STATIC_KEY_FALSE(page_owner_inited);
36
37 static depot_stack_handle_t dummy_handle;
38 static depot_stack_handle_t failure_handle;
39 static depot_stack_handle_t early_handle;
40
41 static void init_early_allocated_pages(void);
42
early_page_owner_param(char * buf)43 static int __init early_page_owner_param(char *buf)
44 {
45 if (!buf)
46 return -EINVAL;
47
48 if (strcmp(buf, "on") == 0)
49 page_owner_enabled = true;
50
51 return 0;
52 }
53 early_param("page_owner", early_page_owner_param);
54
need_page_owner(void)55 static bool need_page_owner(void)
56 {
57 return page_owner_enabled;
58 }
59
create_dummy_stack(void)60 static __always_inline depot_stack_handle_t create_dummy_stack(void)
61 {
62 unsigned long entries[4];
63 unsigned int nr_entries;
64
65 nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 0);
66 return stack_depot_save(entries, nr_entries, GFP_KERNEL);
67 }
68
register_dummy_stack(void)69 static noinline void register_dummy_stack(void)
70 {
71 dummy_handle = create_dummy_stack();
72 }
73
register_failure_stack(void)74 static noinline void register_failure_stack(void)
75 {
76 failure_handle = create_dummy_stack();
77 }
78
register_early_stack(void)79 static noinline void register_early_stack(void)
80 {
81 early_handle = create_dummy_stack();
82 }
83
init_page_owner(void)84 static void init_page_owner(void)
85 {
86 if (!page_owner_enabled)
87 return;
88
89 register_dummy_stack();
90 register_failure_stack();
91 register_early_stack();
92 static_branch_enable(&page_owner_inited);
93 init_early_allocated_pages();
94 }
95
96 struct page_ext_operations page_owner_ops = {
97 .size = sizeof(struct page_owner),
98 .need = need_page_owner,
99 .init = init_page_owner,
100 };
101
get_page_owner(struct page_ext * page_ext)102 struct page_owner *get_page_owner(struct page_ext *page_ext)
103 {
104 return (void *)page_ext + page_owner_ops.offset;
105 }
106 EXPORT_SYMBOL_GPL(get_page_owner);
107
get_page_owner_handle(struct page_ext * page_ext,unsigned long pfn)108 depot_stack_handle_t get_page_owner_handle(struct page_ext *page_ext, unsigned long pfn)
109 {
110 struct page_owner *page_owner;
111 depot_stack_handle_t handle;
112
113 if (!page_owner_enabled)
114 return 0;
115
116 page_owner = get_page_owner(page_ext);
117
118 /* skip handle for tail pages of higher order allocations */
119 if (!IS_ALIGNED(pfn, 1 << page_owner->order))
120 return 0;
121
122 handle = READ_ONCE(page_owner->handle);
123 return handle;
124 }
125 EXPORT_SYMBOL_GPL(get_page_owner_handle);
126
check_recursive_alloc(unsigned long * entries,unsigned int nr_entries,unsigned long ip)127 static inline bool check_recursive_alloc(unsigned long *entries,
128 unsigned int nr_entries,
129 unsigned long ip)
130 {
131 unsigned int i;
132
133 for (i = 0; i < nr_entries; i++) {
134 if (entries[i] == ip)
135 return true;
136 }
137 return false;
138 }
139
save_stack(gfp_t flags)140 static noinline depot_stack_handle_t save_stack(gfp_t flags)
141 {
142 unsigned long entries[PAGE_OWNER_STACK_DEPTH];
143 depot_stack_handle_t handle;
144 unsigned int nr_entries;
145
146 nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 2);
147
148 /*
149 * We need to check recursion here because our request to
150 * stackdepot could trigger memory allocation to save new
151 * entry. New memory allocation would reach here and call
152 * stack_depot_save_entries() again if we don't catch it. There is
153 * still not enough memory in stackdepot so it would try to
154 * allocate memory again and loop forever.
155 */
156 if (check_recursive_alloc(entries, nr_entries, _RET_IP_))
157 return dummy_handle;
158
159 handle = stack_depot_save(entries, nr_entries, flags);
160 if (!handle)
161 handle = failure_handle;
162
163 return handle;
164 }
165
__reset_page_owner(struct page * page,unsigned int order)166 void __reset_page_owner(struct page *page, unsigned int order)
167 {
168 int i;
169 struct page_ext *page_ext;
170 depot_stack_handle_t handle = 0;
171 struct page_owner *page_owner;
172 u64 free_ts_nsec = local_clock();
173
174 handle = save_stack(GFP_NOWAIT | __GFP_NOWARN);
175
176 page_ext = page_ext_get(page);
177 if (unlikely(!page_ext))
178 return;
179 for (i = 0; i < (1 << order); i++) {
180 __clear_bit(PAGE_EXT_OWNER_ALLOCATED, &page_ext->flags);
181 page_owner = get_page_owner(page_ext);
182 page_owner->free_handle = handle;
183 page_owner->free_ts_nsec = free_ts_nsec;
184 page_ext = page_ext_next(page_ext);
185 }
186 page_ext_put(page_ext);
187 }
188
__set_page_owner_handle(struct page * page,struct page_ext * page_ext,depot_stack_handle_t handle,unsigned int order,gfp_t gfp_mask)189 static inline void __set_page_owner_handle(struct page *page,
190 struct page_ext *page_ext, depot_stack_handle_t handle,
191 unsigned int order, gfp_t gfp_mask)
192 {
193 struct page_owner *page_owner;
194 int i;
195
196 for (i = 0; i < (1 << order); i++) {
197 page_owner = get_page_owner(page_ext);
198 page_owner->handle = handle;
199 page_owner->order = order;
200 page_owner->gfp_mask = gfp_mask;
201 page_owner->last_migrate_reason = -1;
202 page_owner->pid = current->pid;
203 page_owner->ts_nsec = local_clock();
204 __set_bit(PAGE_EXT_OWNER, &page_ext->flags);
205 __set_bit(PAGE_EXT_OWNER_ALLOCATED, &page_ext->flags);
206
207 page_ext = page_ext_next(page_ext);
208 }
209 }
210
__set_page_owner(struct page * page,unsigned int order,gfp_t gfp_mask)211 noinline void __set_page_owner(struct page *page, unsigned int order,
212 gfp_t gfp_mask)
213 {
214 struct page_ext *page_ext;
215 depot_stack_handle_t handle;
216
217 handle = save_stack(gfp_mask);
218
219 page_ext = page_ext_get(page);
220 if (unlikely(!page_ext))
221 return;
222 __set_page_owner_handle(page, page_ext, handle, order, gfp_mask);
223 page_ext_put(page_ext);
224 }
225
__set_page_owner_migrate_reason(struct page * page,int reason)226 void __set_page_owner_migrate_reason(struct page *page, int reason)
227 {
228 struct page_ext *page_ext = page_ext_get(page);
229 struct page_owner *page_owner;
230
231 if (unlikely(!page_ext))
232 return;
233
234 page_owner = get_page_owner(page_ext);
235 page_owner->last_migrate_reason = reason;
236 page_ext_put(page_ext);
237 }
238
__split_page_owner(struct page * page,unsigned int nr)239 void __split_page_owner(struct page *page, unsigned int nr)
240 {
241 int i;
242 struct page_ext *page_ext = page_ext_get(page);
243 struct page_owner *page_owner;
244
245 if (unlikely(!page_ext))
246 return;
247
248 for (i = 0; i < nr; i++) {
249 page_owner = get_page_owner(page_ext);
250 page_owner->order = 0;
251 page_ext = page_ext_next(page_ext);
252 }
253 page_ext_put(page_ext);
254 }
255
__copy_page_owner(struct page * oldpage,struct page * newpage)256 void __copy_page_owner(struct page *oldpage, struct page *newpage)
257 {
258 struct page_ext *old_ext;
259 struct page_ext *new_ext;
260 struct page_owner *old_page_owner, *new_page_owner;
261
262 old_ext = page_ext_get(oldpage);
263 if (unlikely(!old_ext))
264 return;
265
266 new_ext = page_ext_get(newpage);
267 if (unlikely(!new_ext)) {
268 page_ext_put(old_ext);
269 return;
270 }
271
272 old_page_owner = get_page_owner(old_ext);
273 new_page_owner = get_page_owner(new_ext);
274 new_page_owner->order = old_page_owner->order;
275 new_page_owner->gfp_mask = old_page_owner->gfp_mask;
276 new_page_owner->last_migrate_reason =
277 old_page_owner->last_migrate_reason;
278 new_page_owner->handle = old_page_owner->handle;
279 new_page_owner->pid = old_page_owner->pid;
280 new_page_owner->ts_nsec = old_page_owner->ts_nsec;
281 new_page_owner->free_ts_nsec = old_page_owner->ts_nsec;
282
283 /*
284 * We don't clear the bit on the oldpage as it's going to be freed
285 * after migration. Until then, the info can be useful in case of
286 * a bug, and the overal stats will be off a bit only temporarily.
287 * Also, migrate_misplaced_transhuge_page() can still fail the
288 * migration and then we want the oldpage to retain the info. But
289 * in that case we also don't need to explicitly clear the info from
290 * the new page, which will be freed.
291 */
292 __set_bit(PAGE_EXT_OWNER, &new_ext->flags);
293 __set_bit(PAGE_EXT_OWNER_ALLOCATED, &new_ext->flags);
294 page_ext_put(new_ext);
295 page_ext_put(old_ext);
296 }
297
pagetypeinfo_showmixedcount_print(struct seq_file * m,pg_data_t * pgdat,struct zone * zone)298 void pagetypeinfo_showmixedcount_print(struct seq_file *m,
299 pg_data_t *pgdat, struct zone *zone)
300 {
301 struct page *page;
302 struct page_ext *page_ext;
303 struct page_owner *page_owner;
304 unsigned long pfn = zone->zone_start_pfn, block_end_pfn;
305 unsigned long end_pfn = pfn + zone->spanned_pages;
306 unsigned long count[MIGRATE_TYPES] = { 0, };
307 int pageblock_mt, page_mt;
308 int i;
309
310 /* Scan block by block. First and last block may be incomplete */
311 pfn = zone->zone_start_pfn;
312
313 /*
314 * Walk the zone in pageblock_nr_pages steps. If a page block spans
315 * a zone boundary, it will be double counted between zones. This does
316 * not matter as the mixed block count will still be correct
317 */
318 for (; pfn < end_pfn; ) {
319 page = pfn_to_online_page(pfn);
320 if (!page) {
321 pfn = ALIGN(pfn + 1, MAX_ORDER_NR_PAGES);
322 continue;
323 }
324
325 block_end_pfn = ALIGN(pfn + 1, pageblock_nr_pages);
326 block_end_pfn = min(block_end_pfn, end_pfn);
327
328 pageblock_mt = get_pageblock_migratetype(page);
329
330 for (; pfn < block_end_pfn; pfn++) {
331 if (!pfn_valid_within(pfn))
332 continue;
333
334 /* The pageblock is online, no need to recheck. */
335 page = pfn_to_page(pfn);
336
337 if (page_zone(page) != zone)
338 continue;
339
340 if (PageBuddy(page)) {
341 unsigned long freepage_order;
342
343 freepage_order = buddy_order_unsafe(page);
344 if (freepage_order < MAX_ORDER)
345 pfn += (1UL << freepage_order) - 1;
346 continue;
347 }
348
349 if (PageReserved(page))
350 continue;
351
352 page_ext = page_ext_get(page);
353 if (unlikely(!page_ext))
354 continue;
355
356 if (!test_bit(PAGE_EXT_OWNER_ALLOCATED, &page_ext->flags))
357 goto ext_put_continue;
358
359 page_owner = get_page_owner(page_ext);
360 page_mt = gfp_migratetype(page_owner->gfp_mask);
361 if (pageblock_mt != page_mt) {
362 if (is_migrate_cma(pageblock_mt))
363 count[MIGRATE_MOVABLE]++;
364 else
365 count[pageblock_mt]++;
366
367 pfn = block_end_pfn;
368 page_ext_put(page_ext);
369 break;
370 }
371 pfn += (1UL << page_owner->order) - 1;
372 ext_put_continue:
373 page_ext_put(page_ext);
374 }
375 }
376
377 /* Print counts */
378 seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
379 for (i = 0; i < MIGRATE_TYPES; i++)
380 seq_printf(m, "%12lu ", count[i]);
381 seq_putc(m, '\n');
382 }
383
384 static ssize_t
print_page_owner(char __user * buf,size_t count,unsigned long pfn,struct page * page,struct page_owner * page_owner,depot_stack_handle_t handle)385 print_page_owner(char __user *buf, size_t count, unsigned long pfn,
386 struct page *page, struct page_owner *page_owner,
387 depot_stack_handle_t handle)
388 {
389 int ret, pageblock_mt, page_mt;
390 unsigned long *entries;
391 unsigned int nr_entries;
392 char *kbuf;
393
394 count = min_t(size_t, count, PAGE_SIZE);
395 kbuf = kmalloc(count, GFP_KERNEL);
396 if (!kbuf)
397 return -ENOMEM;
398
399 ret = snprintf(kbuf, count,
400 "Page allocated via order %u, mask %#x(%pGg), pid %d, ts %llu ns, free_ts %llu ns\n",
401 page_owner->order, page_owner->gfp_mask,
402 &page_owner->gfp_mask, page_owner->pid,
403 page_owner->ts_nsec, page_owner->free_ts_nsec);
404
405 if (ret >= count)
406 goto err;
407
408 /* Print information relevant to grouping pages by mobility */
409 pageblock_mt = get_pageblock_migratetype(page);
410 page_mt = gfp_migratetype(page_owner->gfp_mask);
411 ret += snprintf(kbuf + ret, count - ret,
412 "PFN %lu type %s Block %lu type %s Flags %#lx(%pGp)\n",
413 pfn,
414 migratetype_names[page_mt],
415 pfn >> pageblock_order,
416 migratetype_names[pageblock_mt],
417 page->flags, &page->flags);
418
419 if (ret >= count)
420 goto err;
421
422 nr_entries = stack_depot_fetch(handle, &entries);
423 ret += stack_trace_snprint(kbuf + ret, count - ret, entries, nr_entries, 0);
424 if (ret >= count)
425 goto err;
426
427 if (page_owner->last_migrate_reason != -1) {
428 ret += snprintf(kbuf + ret, count - ret,
429 "Page has been migrated, last migrate reason: %s\n",
430 migrate_reason_names[page_owner->last_migrate_reason]);
431 if (ret >= count)
432 goto err;
433 }
434
435 ret += snprintf(kbuf + ret, count - ret, "\n");
436 if (ret >= count)
437 goto err;
438
439 if (copy_to_user(buf, kbuf, ret))
440 ret = -EFAULT;
441
442 kfree(kbuf);
443 return ret;
444
445 err:
446 kfree(kbuf);
447 return -ENOMEM;
448 }
449
__dump_page_owner(struct page * page)450 void __dump_page_owner(struct page *page)
451 {
452 struct page_ext *page_ext = page_ext_get((void *)page);
453 struct page_owner *page_owner;
454 depot_stack_handle_t handle;
455 unsigned long *entries;
456 unsigned int nr_entries;
457 gfp_t gfp_mask;
458 int mt;
459
460 if (unlikely(!page_ext)) {
461 pr_alert("There is not page extension available.\n");
462 return;
463 }
464
465 page_owner = get_page_owner(page_ext);
466 gfp_mask = page_owner->gfp_mask;
467 mt = gfp_migratetype(gfp_mask);
468
469 if (!test_bit(PAGE_EXT_OWNER, &page_ext->flags)) {
470 pr_alert("page_owner info is not present (never set?)\n");
471 page_ext_put(page_ext);
472 return;
473 }
474
475 if (test_bit(PAGE_EXT_OWNER_ALLOCATED, &page_ext->flags))
476 pr_alert("page_owner tracks the page as allocated\n");
477 else
478 pr_alert("page_owner tracks the page as freed\n");
479
480 pr_alert("page last allocated via order %u, migratetype %s, gfp_mask %#x(%pGg), pid %d, ts %llu, free_ts %llu\n",
481 page_owner->order, migratetype_names[mt], gfp_mask, &gfp_mask,
482 page_owner->pid, page_owner->ts_nsec, page_owner->free_ts_nsec);
483
484 handle = READ_ONCE(page_owner->handle);
485 if (!handle) {
486 pr_alert("page_owner allocation stack trace missing\n");
487 } else {
488 nr_entries = stack_depot_fetch(handle, &entries);
489 stack_trace_print(entries, nr_entries, 0);
490 }
491
492 handle = READ_ONCE(page_owner->free_handle);
493 if (!handle) {
494 pr_alert("page_owner free stack trace missing\n");
495 } else {
496 nr_entries = stack_depot_fetch(handle, &entries);
497 pr_alert("page last free stack trace:\n");
498 stack_trace_print(entries, nr_entries, 0);
499 }
500
501 if (page_owner->last_migrate_reason != -1)
502 pr_alert("page has been migrated, last migrate reason: %s\n",
503 migrate_reason_names[page_owner->last_migrate_reason]);
504 page_ext_put(page_ext);
505 }
506
507 static ssize_t
read_page_owner(struct file * file,char __user * buf,size_t count,loff_t * ppos)508 read_page_owner(struct file *file, char __user *buf, size_t count, loff_t *ppos)
509 {
510 unsigned long pfn;
511 struct page *page;
512 struct page_ext *page_ext;
513 struct page_owner *page_owner;
514 depot_stack_handle_t handle;
515
516 if (!static_branch_unlikely(&page_owner_inited))
517 return -EINVAL;
518
519 page = NULL;
520 pfn = min_low_pfn + *ppos;
521
522 /* Find a valid PFN or the start of a MAX_ORDER_NR_PAGES area */
523 while (!pfn_valid(pfn) && (pfn & (MAX_ORDER_NR_PAGES - 1)) != 0)
524 pfn++;
525
526 drain_all_pages(NULL);
527
528 /* Find an allocated page */
529 for (; pfn < max_pfn; pfn++) {
530 /*
531 * This temporary page_owner is required so
532 * that we can avoid the context switches while holding
533 * the rcu lock and copying the page owner information to
534 * user through copy_to_user() or GFP_KERNEL allocations.
535 */
536 struct page_owner page_owner_tmp;
537
538 /*
539 * If the new page is in a new MAX_ORDER_NR_PAGES area,
540 * validate the area as existing, skip it if not
541 */
542 if ((pfn & (MAX_ORDER_NR_PAGES - 1)) == 0 && !pfn_valid(pfn)) {
543 pfn += MAX_ORDER_NR_PAGES - 1;
544 continue;
545 }
546
547 /* Check for holes within a MAX_ORDER area */
548 if (!pfn_valid_within(pfn))
549 continue;
550
551 page = pfn_to_page(pfn);
552 if (PageBuddy(page)) {
553 unsigned long freepage_order = buddy_order_unsafe(page);
554
555 if (freepage_order < MAX_ORDER)
556 pfn += (1UL << freepage_order) - 1;
557 continue;
558 }
559
560 page_ext = page_ext_get(page);
561 if (unlikely(!page_ext))
562 continue;
563
564 /*
565 * Some pages could be missed by concurrent allocation or free,
566 * because we don't hold the zone lock.
567 */
568 if (!test_bit(PAGE_EXT_OWNER, &page_ext->flags))
569 goto ext_put_continue;
570
571 /*
572 * Although we do have the info about past allocation of free
573 * pages, it's not relevant for current memory usage.
574 */
575 if (!test_bit(PAGE_EXT_OWNER_ALLOCATED, &page_ext->flags))
576 goto ext_put_continue;
577
578 page_owner = get_page_owner(page_ext);
579
580 /*
581 * Don't print "tail" pages of high-order allocations as that
582 * would inflate the stats.
583 */
584 if (!IS_ALIGNED(pfn, 1 << page_owner->order))
585 goto ext_put_continue;
586
587 /*
588 * Access to page_ext->handle isn't synchronous so we should
589 * be careful to access it.
590 */
591 handle = READ_ONCE(page_owner->handle);
592 if (!handle)
593 goto ext_put_continue;
594
595 /* Record the next PFN to read in the file offset */
596 *ppos = (pfn - min_low_pfn) + 1;
597
598 page_owner_tmp = *page_owner;
599 page_ext_put(page_ext);
600 return print_page_owner(buf, count, pfn, page,
601 &page_owner_tmp, handle);
602 ext_put_continue:
603 page_ext_put(page_ext);
604 }
605
606 return 0;
607 }
608
init_pages_in_zone(pg_data_t * pgdat,struct zone * zone)609 static void init_pages_in_zone(pg_data_t *pgdat, struct zone *zone)
610 {
611 unsigned long pfn = zone->zone_start_pfn;
612 unsigned long end_pfn = zone_end_pfn(zone);
613 unsigned long count = 0;
614
615 /*
616 * Walk the zone in pageblock_nr_pages steps. If a page block spans
617 * a zone boundary, it will be double counted between zones. This does
618 * not matter as the mixed block count will still be correct
619 */
620 for (; pfn < end_pfn; ) {
621 unsigned long block_end_pfn;
622
623 if (!pfn_valid(pfn)) {
624 pfn = ALIGN(pfn + 1, MAX_ORDER_NR_PAGES);
625 continue;
626 }
627
628 block_end_pfn = ALIGN(pfn + 1, pageblock_nr_pages);
629 block_end_pfn = min(block_end_pfn, end_pfn);
630
631 for (; pfn < block_end_pfn; pfn++) {
632 struct page *page;
633 struct page_ext *page_ext;
634
635 if (!pfn_valid_within(pfn))
636 continue;
637
638 page = pfn_to_page(pfn);
639
640 if (page_zone(page) != zone)
641 continue;
642
643 /*
644 * To avoid having to grab zone->lock, be a little
645 * careful when reading buddy page order. The only
646 * danger is that we skip too much and potentially miss
647 * some early allocated pages, which is better than
648 * heavy lock contention.
649 */
650 if (PageBuddy(page)) {
651 unsigned long order = buddy_order_unsafe(page);
652
653 if (order > 0 && order < MAX_ORDER)
654 pfn += (1UL << order) - 1;
655 continue;
656 }
657
658 if (PageReserved(page))
659 continue;
660
661 page_ext = page_ext_get(page);
662 if (unlikely(!page_ext))
663 continue;
664
665 /* Maybe overlapping zone */
666 if (test_bit(PAGE_EXT_OWNER, &page_ext->flags))
667 goto ext_put_continue;
668
669 /* Found early allocated page */
670 __set_page_owner_handle(page, page_ext, early_handle,
671 0, 0);
672 count++;
673 ext_put_continue:
674 page_ext_put(page_ext);
675 }
676 cond_resched();
677 }
678
679 pr_info("Node %d, zone %8s: page owner found early allocated %lu pages\n",
680 pgdat->node_id, zone->name, count);
681 }
682
init_zones_in_node(pg_data_t * pgdat)683 static void init_zones_in_node(pg_data_t *pgdat)
684 {
685 struct zone *zone;
686 struct zone *node_zones = pgdat->node_zones;
687
688 for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
689 if (!populated_zone(zone))
690 continue;
691
692 init_pages_in_zone(pgdat, zone);
693 }
694 }
695
init_early_allocated_pages(void)696 static void init_early_allocated_pages(void)
697 {
698 pg_data_t *pgdat;
699
700 for_each_online_pgdat(pgdat)
701 init_zones_in_node(pgdat);
702 }
703
704 static const struct file_operations proc_page_owner_operations = {
705 .read = read_page_owner,
706 };
707
pageowner_init(void)708 static int __init pageowner_init(void)
709 {
710 if (!static_branch_unlikely(&page_owner_inited)) {
711 pr_info("page_owner is disabled\n");
712 return 0;
713 }
714
715 debugfs_create_file("page_owner", 0400, NULL, NULL,
716 &proc_page_owner_operations);
717
718 return 0;
719 }
720 late_initcall(pageowner_init)
721