page_owner.c 17 KB

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