]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - tools/vm/page-types.c
1 // SPDX-License-Identifier: GPL-2.0-only
3 * page-types: Tool for querying page flags
5 * Copyright (C) 2009 Intel corporation
7 * Authors: Wu Fengguang <fengguang.wu@intel.com>
10 #define _FILE_OFFSET_BITS 64
25 #include <sys/types.h>
26 #include <sys/errno.h>
27 #include <sys/fcntl.h>
28 #include <sys/mount.h>
29 #include <sys/statfs.h>
31 #include "../../include/uapi/linux/magic.h"
32 #include "../../include/uapi/linux/kernel-page-flags.h"
33 #include <api/fs/fs.h>
41 # define STR(x) _STR(x)
45 * pagemap kernel ABI bits
48 #define PM_ENTRY_BYTES 8
49 #define PM_PFRAME_BITS 55
50 #define PM_PFRAME_MASK ((1LL << PM_PFRAME_BITS) - 1)
51 #define PM_PFRAME(x) ((x) & PM_PFRAME_MASK)
52 #define MAX_SWAPFILES_SHIFT 5
53 #define PM_SWAP_OFFSET(x) (((x) & PM_PFRAME_MASK) >> MAX_SWAPFILES_SHIFT)
54 #define PM_SOFT_DIRTY (1ULL << 55)
55 #define PM_MMAP_EXCLUSIVE (1ULL << 56)
56 #define PM_FILE (1ULL << 61)
57 #define PM_SWAP (1ULL << 62)
58 #define PM_PRESENT (1ULL << 63)
65 #define PROC_KPAGEFLAGS "/proc/kpageflags"
66 #define PROC_KPAGECOUNT "/proc/kpagecount"
67 #define PROC_KPAGECGROUP "/proc/kpagecgroup"
69 #define SYS_KERNEL_MM_PAGE_IDLE "/sys/kernel/mm/page_idle/bitmap"
71 /* [32-] kernel hacking assistances */
72 #define KPF_RESERVED 32
73 #define KPF_MLOCKED 33
74 #define KPF_MAPPEDTODISK 34
75 #define KPF_PRIVATE 35
76 #define KPF_PRIVATE_2 36
77 #define KPF_OWNER_PRIVATE 37
79 #define KPF_UNCACHED 39
80 #define KPF_SOFTDIRTY 40
82 /* [48-] take some arbitrary free slots for expanding overloaded flags
83 * not part of kernel API
85 #define KPF_READAHEAD 48
86 #define KPF_SLOB_FREE 49
87 #define KPF_SLUB_FROZEN 50
88 #define KPF_SLUB_DEBUG 51
91 #define KPF_MMAP_EXCLUSIVE 63
93 #define KPF_ALL_BITS ((uint64_t)~0ULL)
94 #define KPF_HACKERS_BITS (0xffffULL << 32)
95 #define KPF_OVERLOADED_BITS (0xffffULL << 48)
96 #define BIT(name) (1ULL << KPF_##name)
97 #define BITS_COMPOUND (BIT(COMPOUND_HEAD) | BIT(COMPOUND_TAIL))
99 static const char * const page_flag_names
[] = {
100 [KPF_LOCKED
] = "L:locked",
101 [KPF_ERROR
] = "E:error",
102 [KPF_REFERENCED
] = "R:referenced",
103 [KPF_UPTODATE
] = "U:uptodate",
104 [KPF_DIRTY
] = "D:dirty",
106 [KPF_ACTIVE
] = "A:active",
107 [KPF_SLAB
] = "S:slab",
108 [KPF_WRITEBACK
] = "W:writeback",
109 [KPF_RECLAIM
] = "I:reclaim",
110 [KPF_BUDDY
] = "B:buddy",
112 [KPF_MMAP
] = "M:mmap",
113 [KPF_ANON
] = "a:anonymous",
114 [KPF_SWAPCACHE
] = "s:swapcache",
115 [KPF_SWAPBACKED
] = "b:swapbacked",
116 [KPF_COMPOUND_HEAD
] = "H:compound_head",
117 [KPF_COMPOUND_TAIL
] = "T:compound_tail",
118 [KPF_HUGE
] = "G:huge",
119 [KPF_UNEVICTABLE
] = "u:unevictable",
120 [KPF_HWPOISON
] = "X:hwpoison",
121 [KPF_NOPAGE
] = "n:nopage",
124 [KPF_OFFLINE
] = "o:offline",
125 [KPF_PGTABLE
] = "g:pgtable",
126 [KPF_ZERO_PAGE
] = "z:zero_page",
127 [KPF_IDLE
] = "i:idle_page",
129 [KPF_RESERVED
] = "r:reserved",
130 [KPF_MLOCKED
] = "m:mlocked",
131 [KPF_MAPPEDTODISK
] = "d:mappedtodisk",
132 [KPF_PRIVATE
] = "P:private",
133 [KPF_PRIVATE_2
] = "p:private_2",
134 [KPF_OWNER_PRIVATE
] = "O:owner_private",
135 [KPF_ARCH
] = "h:arch",
136 [KPF_UNCACHED
] = "c:uncached",
137 [KPF_SOFTDIRTY
] = "f:softdirty",
139 [KPF_READAHEAD
] = "I:readahead",
140 [KPF_SLOB_FREE
] = "P:slob_free",
141 [KPF_SLUB_FROZEN
] = "A:slub_frozen",
142 [KPF_SLUB_DEBUG
] = "E:slub_debug",
144 [KPF_FILE
] = "F:file",
145 [KPF_SWAP
] = "w:swap",
146 [KPF_MMAP_EXCLUSIVE
] = "1:mmap_exclusive",
154 static int opt_raw
; /* for kernel developers */
155 static int opt_list
; /* list pages (in ranges) */
156 static int opt_mark_idle
; /* set accessed bit */
157 static int opt_no_summary
; /* don't show summary */
158 static pid_t opt_pid
; /* process to walk */
159 const char *opt_file
; /* file or directory path */
160 static uint64_t opt_cgroup
; /* cgroup inode */
161 static int opt_list_cgroup
;/* list page cgroup */
162 static int opt_list_mapcnt
;/* list page map count */
163 static const char *opt_kpageflags
;/* kpageflags file to parse */
165 #define MAX_ADDR_RANGES 1024
166 static int nr_addr_ranges
;
167 static unsigned long opt_offset
[MAX_ADDR_RANGES
];
168 static unsigned long opt_size
[MAX_ADDR_RANGES
];
170 #define MAX_VMAS 10240
172 static unsigned long pg_start
[MAX_VMAS
];
173 static unsigned long pg_end
[MAX_VMAS
];
175 #define MAX_BIT_FILTERS 64
176 static int nr_bit_filters
;
177 static uint64_t opt_mask
[MAX_BIT_FILTERS
];
178 static uint64_t opt_bits
[MAX_BIT_FILTERS
];
180 static int page_size
;
182 static int pagemap_fd
;
183 static int kpageflags_fd
;
184 static int kpagecount_fd
= -1;
185 static int kpagecgroup_fd
= -1;
186 static int page_idle_fd
= -1;
188 static int opt_hwpoison
;
189 static int opt_unpoison
;
191 static const char *hwpoison_debug_fs
;
192 static int hwpoison_inject_fd
;
193 static int hwpoison_forget_fd
;
195 #define HASH_SHIFT 13
196 #define HASH_SIZE (1 << HASH_SHIFT)
197 #define HASH_MASK (HASH_SIZE - 1)
198 #define HASH_KEY(flags) (flags & HASH_MASK)
200 static unsigned long total_pages
;
201 static unsigned long nr_pages
[HASH_SIZE
];
202 static uint64_t page_flags
[HASH_SIZE
];
209 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
211 #define min_t(type, x, y) ({ \
214 __min1 < __min2 ? __min1 : __min2; })
216 #define max_t(type, x, y) ({ \
219 __max1 > __max2 ? __max1 : __max2; })
221 static unsigned long pages2mb(unsigned long pages
)
223 return (pages
* page_size
) >> 20;
226 static void fatal(const char *x
, ...)
231 vfprintf(stderr
, x
, ap
);
236 static int checked_open(const char *pathname
, int flags
)
238 int fd
= open(pathname
, flags
);
249 * pagemap/kpageflags routines
252 static unsigned long do_u64_read(int fd
, const char *name
,
259 if (index
> ULONG_MAX
/ 8)
260 fatal("index overflow: %lu\n", index
);
262 bytes
= pread(fd
, buf
, count
* 8, (off_t
)index
* 8);
268 fatal("partial read: %lu bytes\n", bytes
);
273 static unsigned long kpageflags_read(uint64_t *buf
,
277 return do_u64_read(kpageflags_fd
, opt_kpageflags
, buf
, index
, pages
);
280 static unsigned long kpagecgroup_read(uint64_t *buf
,
284 if (kpagecgroup_fd
< 0)
287 return do_u64_read(kpagecgroup_fd
, opt_kpageflags
, buf
, index
, pages
);
290 static unsigned long kpagecount_read(uint64_t *buf
,
294 return kpagecount_fd
< 0 ? pages
:
295 do_u64_read(kpagecount_fd
, PROC_KPAGECOUNT
,
299 static unsigned long pagemap_read(uint64_t *buf
,
303 return do_u64_read(pagemap_fd
, "/proc/pid/pagemap", buf
, index
, pages
);
306 static unsigned long pagemap_pfn(uint64_t val
)
310 if (val
& PM_PRESENT
)
311 pfn
= PM_PFRAME(val
);
318 static unsigned long pagemap_swap_offset(uint64_t val
)
320 return val
& PM_SWAP
? PM_SWAP_OFFSET(val
) : 0;
327 static char *page_flag_name(uint64_t flags
)
333 for (i
= 0, j
= 0; i
< ARRAY_SIZE(page_flag_names
); i
++) {
334 present
= (flags
>> i
) & 1;
335 if (!page_flag_names
[i
]) {
337 fatal("unknown flag bit %d\n", i
);
340 buf
[j
++] = present
? page_flag_names
[i
][0] : '_';
346 static char *page_flag_longname(uint64_t flags
)
348 static char buf
[1024];
351 for (i
= 0, n
= 0; i
< ARRAY_SIZE(page_flag_names
); i
++) {
352 if (!page_flag_names
[i
])
354 if ((flags
>> i
) & 1)
355 n
+= snprintf(buf
+ n
, sizeof(buf
) - n
, "%s,",
356 page_flag_names
[i
] + 2);
367 * page list and summary
370 static void show_page_range(unsigned long voffset
, unsigned long offset
,
371 unsigned long size
, uint64_t flags
,
372 uint64_t cgroup
, uint64_t mapcnt
)
374 static uint64_t flags0
;
375 static uint64_t cgroup0
;
376 static uint64_t mapcnt0
;
377 static unsigned long voff
;
378 static unsigned long index
;
379 static unsigned long count
;
381 if (flags
== flags0
&& cgroup
== cgroup0
&& mapcnt
== mapcnt0
&&
382 offset
== index
+ count
&& size
&& voffset
== voff
+ count
) {
389 printf("%lx\t", voff
);
391 printf("%lu\t", voff
);
393 printf("@%llu\t", (unsigned long long)cgroup0
);
395 printf("%lu\t", mapcnt0
);
396 printf("%lx\t%lx\t%s\n",
397 index
, count
, page_flag_name(flags0
));
408 static void flush_page_range(void)
410 show_page_range(0, 0, 0, 0, 0, 0);
413 static void show_page(unsigned long voffset
, unsigned long offset
,
414 uint64_t flags
, uint64_t cgroup
, uint64_t mapcnt
)
417 printf("%lx\t", voffset
);
419 printf("%lu\t", voffset
);
421 printf("@%llu\t", (unsigned long long)cgroup
);
423 printf("%lu\t", mapcnt
);
425 printf("%lx\t%s\n", offset
, page_flag_name(flags
));
428 static void show_summary(void)
432 printf(" flags\tpage-count MB"
433 " symbolic-flags\t\t\tlong-symbolic-flags\n");
435 for (i
= 0; i
< ARRAY_SIZE(nr_pages
); i
++) {
437 printf("0x%016llx\t%10lu %8lu %s\t%s\n",
438 (unsigned long long)page_flags
[i
],
440 pages2mb(nr_pages
[i
]),
441 page_flag_name(page_flags
[i
]),
442 page_flag_longname(page_flags
[i
]));
445 printf(" total\t%10lu %8lu\n",
446 total_pages
, pages2mb(total_pages
));
454 static int bit_mask_ok(uint64_t flags
)
458 for (i
= 0; i
< nr_bit_filters
; i
++) {
459 if (opt_bits
[i
] == KPF_ALL_BITS
) {
460 if ((flags
& opt_mask
[i
]) == 0)
463 if ((flags
& opt_mask
[i
]) != opt_bits
[i
])
471 static uint64_t expand_overloaded_flags(uint64_t flags
, uint64_t pme
)
473 /* SLOB/SLUB overload several page flags */
474 if (flags
& BIT(SLAB
)) {
475 if (flags
& BIT(PRIVATE
))
476 flags
^= BIT(PRIVATE
) | BIT(SLOB_FREE
);
477 if (flags
& BIT(ACTIVE
))
478 flags
^= BIT(ACTIVE
) | BIT(SLUB_FROZEN
);
479 if (flags
& BIT(ERROR
))
480 flags
^= BIT(ERROR
) | BIT(SLUB_DEBUG
);
483 /* PG_reclaim is overloaded as PG_readahead in the read path */
484 if ((flags
& (BIT(RECLAIM
) | BIT(WRITEBACK
))) == BIT(RECLAIM
))
485 flags
^= BIT(RECLAIM
) | BIT(READAHEAD
);
487 if (pme
& PM_SOFT_DIRTY
)
488 flags
|= BIT(SOFTDIRTY
);
493 if (pme
& PM_MMAP_EXCLUSIVE
)
494 flags
|= BIT(MMAP_EXCLUSIVE
);
499 static uint64_t well_known_flags(uint64_t flags
)
501 /* hide flags intended only for kernel hacker */
502 flags
&= ~KPF_HACKERS_BITS
;
504 /* hide non-hugeTLB compound pages */
505 if ((flags
& BITS_COMPOUND
) && !(flags
& BIT(HUGE
)))
506 flags
&= ~BITS_COMPOUND
;
511 static uint64_t kpageflags_flags(uint64_t flags
, uint64_t pme
)
514 flags
= expand_overloaded_flags(flags
, pme
);
516 flags
= well_known_flags(flags
);
525 static void prepare_hwpoison_fd(void)
527 char buf
[MAX_PATH
+ 1];
529 hwpoison_debug_fs
= debugfs__mount();
530 if (!hwpoison_debug_fs
) {
531 perror("mount debugfs");
535 if (opt_hwpoison
&& !hwpoison_inject_fd
) {
536 snprintf(buf
, MAX_PATH
, "%s/hwpoison/corrupt-pfn",
538 hwpoison_inject_fd
= checked_open(buf
, O_WRONLY
);
541 if (opt_unpoison
&& !hwpoison_forget_fd
) {
542 snprintf(buf
, MAX_PATH
, "%s/hwpoison/unpoison-pfn",
544 hwpoison_forget_fd
= checked_open(buf
, O_WRONLY
);
548 static int hwpoison_page(unsigned long offset
)
553 len
= sprintf(buf
, "0x%lx\n", offset
);
554 len
= write(hwpoison_inject_fd
, buf
, len
);
556 perror("hwpoison inject");
562 static int unpoison_page(unsigned long offset
)
567 len
= sprintf(buf
, "0x%lx\n", offset
);
568 len
= write(hwpoison_forget_fd
, buf
, len
);
570 perror("hwpoison forget");
576 static int mark_page_idle(unsigned long offset
)
578 static unsigned long off
;
582 if ((offset
/ 64 == off
/ 64) || buf
== 0) {
583 buf
|= 1UL << (offset
% 64);
588 len
= pwrite(page_idle_fd
, &buf
, 8, 8 * (off
/ 64));
590 perror("mark page idle");
594 buf
= 1UL << (offset
% 64);
604 static size_t hash_slot(uint64_t flags
)
606 size_t k
= HASH_KEY(flags
);
609 /* Explicitly reserve slot 0 for flags 0: the following logic
610 * cannot distinguish an unoccupied slot from slot (flags==0).
615 /* search through the remaining (HASH_SIZE-1) slots */
616 for (i
= 1; i
< ARRAY_SIZE(page_flags
); i
++, k
++) {
617 if (!k
|| k
>= ARRAY_SIZE(page_flags
))
619 if (page_flags
[k
] == 0) {
620 page_flags
[k
] = flags
;
623 if (page_flags
[k
] == flags
)
627 fatal("hash table full: bump up HASH_SHIFT?\n");
631 static void add_page(unsigned long voffset
, unsigned long offset
,
632 uint64_t flags
, uint64_t cgroup
, uint64_t mapcnt
,
635 flags
= kpageflags_flags(flags
, pme
);
637 if (!bit_mask_ok(flags
))
640 if (opt_cgroup
&& cgroup
!= (uint64_t)opt_cgroup
)
644 hwpoison_page(offset
);
646 unpoison_page(offset
);
649 mark_page_idle(offset
);
652 show_page_range(voffset
, offset
, 1, flags
, cgroup
, mapcnt
);
653 else if (opt_list
== 2)
654 show_page(voffset
, offset
, flags
, cgroup
, mapcnt
);
656 nr_pages
[hash_slot(flags
)]++;
660 #define KPAGEFLAGS_BATCH (64 << 10) /* 64k pages */
661 static void walk_pfn(unsigned long voffset
,
666 uint64_t buf
[KPAGEFLAGS_BATCH
];
667 uint64_t cgi
[KPAGEFLAGS_BATCH
];
668 uint64_t cnt
[KPAGEFLAGS_BATCH
];
674 * kpagecgroup_read() reads only if kpagecgroup were opened, but
675 * /proc/kpagecgroup might even not exist, so it's better to fill
676 * them with zeros here.
681 memset(cgi
, 0, sizeof cgi
);
684 batch
= min_t(unsigned long, count
, KPAGEFLAGS_BATCH
);
685 pages
= kpageflags_read(buf
, index
, batch
);
689 if (kpagecgroup_read(cgi
, index
, pages
) != pages
)
690 fatal("kpagecgroup returned fewer pages than expected");
692 if (kpagecount_read(cnt
, index
, pages
) != pages
)
693 fatal("kpagecount returned fewer pages than expected");
695 for (i
= 0; i
< pages
; i
++)
696 add_page(voffset
+ i
, index
+ i
,
697 buf
[i
], cgi
[i
], cnt
[i
], pme
);
704 static void walk_swap(unsigned long voffset
, uint64_t pme
)
706 uint64_t flags
= kpageflags_flags(0, pme
);
708 if (!bit_mask_ok(flags
))
715 show_page_range(voffset
, pagemap_swap_offset(pme
),
717 else if (opt_list
== 2)
718 show_page(voffset
, pagemap_swap_offset(pme
), flags
, 0, 0);
720 nr_pages
[hash_slot(flags
)]++;
724 #define PAGEMAP_BATCH (64 << 10)
725 static void walk_vma(unsigned long index
, unsigned long count
)
727 uint64_t buf
[PAGEMAP_BATCH
];
734 batch
= min_t(unsigned long, count
, PAGEMAP_BATCH
);
735 pages
= pagemap_read(buf
, index
, batch
);
739 for (i
= 0; i
< pages
; i
++) {
740 pfn
= pagemap_pfn(buf
[i
]);
742 walk_pfn(index
+ i
, pfn
, 1, buf
[i
]);
743 if (buf
[i
] & PM_SWAP
)
744 walk_swap(index
+ i
, buf
[i
]);
752 static void walk_task(unsigned long index
, unsigned long count
)
754 const unsigned long end
= index
+ count
;
758 while (index
< end
) {
760 while (pg_end
[i
] <= index
)
763 if (pg_start
[i
] >= end
)
766 start
= max_t(unsigned long, pg_start
[i
], index
);
767 index
= min_t(unsigned long, pg_end
[i
], end
);
769 assert(start
< index
);
770 walk_vma(start
, index
- start
);
774 static void add_addr_range(unsigned long offset
, unsigned long size
)
776 if (nr_addr_ranges
>= MAX_ADDR_RANGES
)
777 fatal("too many addr ranges\n");
779 opt_offset
[nr_addr_ranges
] = offset
;
780 opt_size
[nr_addr_ranges
] = min_t(unsigned long, size
, ULONG_MAX
-offset
);
784 static void walk_addr_ranges(void)
788 kpageflags_fd
= checked_open(opt_kpageflags
, O_RDONLY
);
791 add_addr_range(0, ULONG_MAX
);
793 for (i
= 0; i
< nr_addr_ranges
; i
++)
795 walk_pfn(opt_offset
[i
], opt_offset
[i
], opt_size
[i
], 0);
797 walk_task(opt_offset
[i
], opt_size
[i
]);
802 close(kpageflags_fd
);
810 static const char *page_flag_type(uint64_t flag
)
812 if (flag
& KPF_HACKERS_BITS
)
814 if (flag
& KPF_OVERLOADED_BITS
)
819 static void usage(void)
824 "page-types [options]\n"
825 " -r|--raw Raw mode, for kernel developers\n"
826 " -d|--describe flags Describe flags\n"
827 " -a|--addr addr-spec Walk a range of pages\n"
828 " -b|--bits bits-spec Walk pages with specified bits\n"
829 " -c|--cgroup path|@inode Walk pages within memory cgroup\n"
830 " -p|--pid pid Walk process address space\n"
831 " -f|--file filename Walk file address space\n"
832 " -i|--mark-idle Mark pages idle\n"
833 " -l|--list Show page details in ranges\n"
834 " -L|--list-each Show page details one by one\n"
835 " -C|--list-cgroup Show cgroup inode for pages\n"
836 " -M|--list-mapcnt Show page map count\n"
837 " -N|--no-summary Don't show summary info\n"
838 " -X|--hwpoison hwpoison pages\n"
839 " -x|--unpoison unpoison pages\n"
840 " -F|--kpageflags filename kpageflags file to parse\n"
841 " -h|--help Show this usage message\n"
843 " 0x10 bitfield format, e.g.\n"
844 " anon bit-name, e.g.\n"
845 " 0x10,anon comma-separated list, e.g.\n"
847 " N one page at offset N (unit: pages)\n"
848 " N+M pages range from N to N+M-1\n"
849 " N,M pages range from N to M-1\n"
850 " N, pages range from N to end\n"
851 " ,M pages range from 0 to M-1\n"
853 " bit1,bit2 (flags & (bit1|bit2)) != 0\n"
854 " bit1,bit2=bit1 (flags & (bit1|bit2)) == bit1\n"
855 " bit1,~bit2 (flags & (bit1|bit2)) == bit1\n"
856 " =bit1,bit2 flags == (bit1|bit2)\n"
860 for (i
= 0, j
= 0; i
< ARRAY_SIZE(page_flag_names
); i
++) {
861 if (!page_flag_names
[i
])
863 printf("%16s%s", page_flag_names
[i
] + 2,
864 page_flag_type(1ULL << i
));
871 "(r) raw mode bits (o) overloaded bits\n");
874 static unsigned long long parse_number(const char *str
)
876 unsigned long long n
;
878 n
= strtoll(str
, NULL
, 0);
880 if (n
== 0 && str
[0] != '0')
881 fatal("invalid name or number: %s\n", str
);
886 static void parse_pid(const char *str
)
891 opt_pid
= parse_number(str
);
893 sprintf(buf
, "/proc/%d/pagemap", opt_pid
);
894 pagemap_fd
= checked_open(buf
, O_RDONLY
);
896 sprintf(buf
, "/proc/%d/maps", opt_pid
);
897 file
= fopen(buf
, "r");
903 while (fgets(buf
, sizeof(buf
), file
) != NULL
) {
904 unsigned long vm_start
;
905 unsigned long vm_end
;
906 unsigned long long pgoff
;
912 n
= sscanf(buf
, "%lx-%lx %c%c%c%c %llx %x:%x %lu",
920 fprintf(stderr
, "unexpected line: %s\n", buf
);
923 pg_start
[nr_vmas
] = vm_start
/ page_size
;
924 pg_end
[nr_vmas
] = vm_end
/ page_size
;
925 if (++nr_vmas
>= MAX_VMAS
) {
926 fprintf(stderr
, "too many VMAs\n");
933 static void show_file(const char *name
, const struct stat
*st
)
935 unsigned long long size
= st
->st_size
;
936 char atime
[64], mtime
[64];
937 long now
= time(NULL
);
939 printf("%s\tInode: %u\tSize: %llu (%llu pages)\n",
940 name
, (unsigned)st
->st_ino
,
941 size
, (size
+ page_size
- 1) / page_size
);
943 strftime(atime
, sizeof(atime
), "%c", localtime(&st
->st_atime
));
944 strftime(mtime
, sizeof(mtime
), "%c", localtime(&st
->st_mtime
));
946 printf("Modify: %s (%ld seconds ago)\nAccess: %s (%ld seconds ago)\n",
947 mtime
, now
- st
->st_mtime
,
948 atime
, now
- st
->st_atime
);
951 static sigjmp_buf sigbus_jmp
;
953 static void * volatile sigbus_addr
;
955 static void sigbus_handler(int sig
, siginfo_t
*info
, void *ucontex
)
959 sigbus_addr
= info
? info
->si_addr
: NULL
;
960 siglongjmp(sigbus_jmp
, 1);
963 static struct sigaction sigbus_action
= {
964 .sa_sigaction
= sigbus_handler
,
965 .sa_flags
= SA_SIGINFO
,
968 static void walk_file(const char *name
, const struct stat
*st
)
970 uint8_t vec
[PAGEMAP_BATCH
];
971 uint64_t buf
[PAGEMAP_BATCH
], flags
;
974 unsigned long nr_pages
, pfn
, i
;
975 off_t off
, end
= st
->st_size
;
981 fd
= checked_open(name
, O_RDONLY
|O_NOATIME
|O_NOFOLLOW
);
983 for (off
= 0; off
< end
; off
+= len
) {
984 nr_pages
= (end
- off
+ page_size
- 1) / page_size
;
985 if (nr_pages
> PAGEMAP_BATCH
)
986 nr_pages
= PAGEMAP_BATCH
;
987 len
= nr_pages
* page_size
;
989 ptr
= mmap(NULL
, len
, PROT_READ
, MAP_SHARED
, fd
, off
);
990 if (ptr
== MAP_FAILED
)
991 fatal("mmap failed: %s", name
);
993 /* determine cached pages */
994 if (mincore(ptr
, len
, vec
))
995 fatal("mincore failed: %s", name
);
997 /* turn off readahead */
998 if (madvise(ptr
, len
, MADV_RANDOM
))
999 fatal("madvice failed: %s", name
);
1001 if (sigsetjmp(sigbus_jmp
, 1)) {
1002 end
= off
+ sigbus_addr
? sigbus_addr
- ptr
: 0;
1003 fprintf(stderr
, "got sigbus at offset %lld: %s\n",
1004 (long long)end
, name
);
1009 for (i
= 0; i
< nr_pages
; i
++) {
1011 (void)*(volatile int *)(ptr
+ i
* page_size
);
1015 /* turn off harvesting reference bits */
1016 if (madvise(ptr
, len
, MADV_SEQUENTIAL
))
1017 fatal("madvice failed: %s", name
);
1019 if (pagemap_read(buf
, (unsigned long)ptr
/ page_size
,
1020 nr_pages
) != nr_pages
)
1021 fatal("cannot read pagemap");
1025 for (i
= 0; i
< nr_pages
; i
++) {
1026 pfn
= pagemap_pfn(buf
[i
]);
1029 if (!kpageflags_read(&flags
, pfn
, 1))
1031 if (!kpagecgroup_read(&cgroup
, pfn
, 1))
1032 fatal("kpagecgroup_read failed");
1033 if (!kpagecount_read(&mapcnt
, pfn
, 1))
1034 fatal("kpagecount_read failed");
1035 if (first
&& opt_list
) {
1038 show_file(name
, st
);
1040 add_page(off
/ page_size
+ i
, pfn
,
1041 flags
, cgroup
, mapcnt
, buf
[i
]);
1048 int walk_tree(const char *name
, const struct stat
*st
, int type
, struct FTW
*f
)
1053 if (S_ISREG(st
->st_mode
))
1054 walk_file(name
, st
);
1057 fprintf(stderr
, "cannot read dir: %s\n", name
);
1063 static void walk_page_cache(void)
1067 kpageflags_fd
= checked_open(opt_kpageflags
, O_RDONLY
);
1068 pagemap_fd
= checked_open("/proc/self/pagemap", O_RDONLY
);
1069 sigaction(SIGBUS
, &sigbus_action
, NULL
);
1071 if (stat(opt_file
, &st
))
1072 fatal("stat failed: %s\n", opt_file
);
1074 if (S_ISREG(st
.st_mode
)) {
1075 walk_file(opt_file
, &st
);
1076 } else if (S_ISDIR(st
.st_mode
)) {
1077 /* do not follow symlinks and mountpoints */
1078 if (nftw(opt_file
, walk_tree
, 64, FTW_MOUNT
| FTW_PHYS
) < 0)
1079 fatal("nftw failed: %s\n", opt_file
);
1081 fatal("unhandled file type: %s\n", opt_file
);
1083 close(kpageflags_fd
);
1085 signal(SIGBUS
, SIG_DFL
);
1088 static void parse_file(const char *name
)
1093 static void parse_cgroup(const char *path
)
1095 if (path
[0] == '@') {
1096 opt_cgroup
= parse_number(path
+ 1);
1102 if (stat(path
, &st
))
1103 fatal("stat failed: %s: %m\n", path
);
1105 if (!S_ISDIR(st
.st_mode
))
1106 fatal("cgroup supposed to be a directory: %s\n", path
);
1108 opt_cgroup
= st
.st_ino
;
1111 static void parse_addr_range(const char *optarg
)
1113 unsigned long offset
;
1117 p
= strchr(optarg
, ',');
1119 p
= strchr(optarg
, '+');
1123 size
= parse_number(p
+ 1);
1125 offset
= parse_number(optarg
);
1129 size
= parse_number(p
+ 1);
1132 fatal("invalid range: %lu,%lu\n",
1138 offset
= parse_number(optarg
);
1142 add_addr_range(offset
, size
);
1145 static void add_bits_filter(uint64_t mask
, uint64_t bits
)
1147 if (nr_bit_filters
>= MAX_BIT_FILTERS
)
1148 fatal("too much bit filters\n");
1150 opt_mask
[nr_bit_filters
] = mask
;
1151 opt_bits
[nr_bit_filters
] = bits
;
1155 static uint64_t parse_flag_name(const char *str
, int len
)
1162 if (len
<= 8 && !strncmp(str
, "compound", len
))
1163 return BITS_COMPOUND
;
1165 for (i
= 0; i
< ARRAY_SIZE(page_flag_names
); i
++) {
1166 if (!page_flag_names
[i
])
1168 if (!strncmp(str
, page_flag_names
[i
] + 2, len
))
1172 return parse_number(str
);
1175 static uint64_t parse_flag_names(const char *str
, int all
)
1177 const char *p
= str
;
1181 if (*p
== ',' || *p
== '=' || *p
== '\0') {
1182 if ((*str
!= '~') || (*str
== '~' && all
&& *++str
))
1183 flags
|= parse_flag_name(str
, p
- str
);
1194 static void parse_bits_mask(const char *optarg
)
1200 p
= strchr(optarg
, '=');
1202 mask
= KPF_ALL_BITS
;
1203 bits
= parse_flag_names(p
+ 1, 0);
1205 mask
= parse_flag_names(optarg
, 0);
1206 bits
= parse_flag_names(p
+ 1, 0);
1207 } else if (strchr(optarg
, '~')) {
1208 mask
= parse_flag_names(optarg
, 1);
1209 bits
= parse_flag_names(optarg
, 0);
1211 mask
= parse_flag_names(optarg
, 0);
1212 bits
= KPF_ALL_BITS
;
1215 add_bits_filter(mask
, bits
);
1218 static void parse_kpageflags(const char *name
)
1220 opt_kpageflags
= name
;
1223 static void describe_flags(const char *optarg
)
1225 uint64_t flags
= parse_flag_names(optarg
, 0);
1227 printf("0x%016llx\t%s\t%s\n",
1228 (unsigned long long)flags
,
1229 page_flag_name(flags
),
1230 page_flag_longname(flags
));
1233 static const struct option opts
[] = {
1234 { "raw" , 0, NULL
, 'r' },
1235 { "pid" , 1, NULL
, 'p' },
1236 { "file" , 1, NULL
, 'f' },
1237 { "addr" , 1, NULL
, 'a' },
1238 { "bits" , 1, NULL
, 'b' },
1239 { "cgroup" , 1, NULL
, 'c' },
1240 { "describe" , 1, NULL
, 'd' },
1241 { "mark-idle" , 0, NULL
, 'i' },
1242 { "list" , 0, NULL
, 'l' },
1243 { "list-each" , 0, NULL
, 'L' },
1244 { "list-cgroup", 0, NULL
, 'C' },
1245 { "list-mapcnt", 0, NULL
, 'M' },
1246 { "no-summary", 0, NULL
, 'N' },
1247 { "hwpoison" , 0, NULL
, 'X' },
1248 { "unpoison" , 0, NULL
, 'x' },
1249 { "kpageflags", 0, NULL
, 'F' },
1250 { "help" , 0, NULL
, 'h' },
1251 { NULL
, 0, NULL
, 0 }
1254 int main(int argc
, char *argv
[])
1258 page_size
= getpagesize();
1260 while ((c
= getopt_long(argc
, argv
,
1261 "rp:f:a:b:d:c:CilLMNXxF:h",
1262 opts
, NULL
)) != -1) {
1274 parse_addr_range(optarg
);
1277 parse_bits_mask(optarg
);
1280 parse_cgroup(optarg
);
1283 opt_list_cgroup
= 1;
1286 describe_flags(optarg
);
1298 opt_list_mapcnt
= 1;
1305 prepare_hwpoison_fd();
1309 prepare_hwpoison_fd();
1312 parse_kpageflags(optarg
);
1323 if (!opt_kpageflags
)
1324 opt_kpageflags
= PROC_KPAGEFLAGS
;
1326 if (opt_cgroup
|| opt_list_cgroup
)
1327 kpagecgroup_fd
= checked_open(PROC_KPAGECGROUP
, O_RDONLY
);
1329 if (opt_list
&& opt_list_mapcnt
)
1330 kpagecount_fd
= checked_open(PROC_KPAGECOUNT
, O_RDONLY
);
1332 if (opt_mark_idle
&& opt_file
)
1333 page_idle_fd
= checked_open(SYS_KERNEL_MM_PAGE_IDLE
, O_RDWR
);
1335 if (opt_list
&& opt_pid
)
1336 printf("voffset\t");
1337 if (opt_list
&& opt_file
)
1338 printf("foffset\t");
1339 if (opt_list
&& opt_list_cgroup
)
1341 if (opt_list
&& opt_list_mapcnt
)
1342 printf("map-cnt\t");
1345 printf("offset\tlen\tflags\n");
1347 printf("offset\tflags\n");
1365 if (opt_list_mapcnt
)
1366 close(kpagecount_fd
);
1368 if (page_idle_fd
>= 0)
1369 close(page_idle_fd
);