page-types.c 28 KB
Newer Older
1 2 3
/*
 * page-types: Tool for querying page flags
 *
4 5 6 7 8 9 10 11 12 13 14 15 16
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should find a copy of v2 of the GNU General Public License somewhere on
 * your Linux system; if not, write to the Free Software Foundation, Inc., 59
 * Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
17
 * Copyright (C) 2009 Intel corporation
Wu Fengguang's avatar
Wu Fengguang committed
18 19
 *
 * Authors: Wu Fengguang <fengguang.wu@intel.com>
20 21
 */

22 23
#define _FILE_OFFSET_BITS 64
#define _GNU_SOURCE
24 25 26 27 28 29 30 31
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <getopt.h>
#include <limits.h>
32
#include <assert.h>
33 34
#include <ftw.h>
#include <time.h>
35 36
#include <setjmp.h>
#include <signal.h>
37 38 39
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
40 41
#include <sys/mount.h>
#include <sys/statfs.h>
42
#include <sys/mman.h>
43
#include "../../include/uapi/linux/magic.h"
44
#include "../../include/uapi/linux/kernel-page-flags.h"
45
#include <api/fs/fs.h>
46

47 48 49 50 51 52 53 54 55
#ifndef MAX_PATH
# define MAX_PATH 256
#endif

#ifndef STR
# define _STR(x) #x
# define STR(x) _STR(x)
#endif

56 57 58 59
/*
 * pagemap kernel ABI bits
 */

60 61 62 63
#define PM_ENTRY_BYTES		8
#define PM_PFRAME_BITS		55
#define PM_PFRAME_MASK		((1LL << PM_PFRAME_BITS) - 1)
#define PM_PFRAME(x)		((x) & PM_PFRAME_MASK)
64 65
#define MAX_SWAPFILES_SHIFT	5
#define PM_SWAP_OFFSET(x)	(((x) & PM_PFRAME_MASK) >> MAX_SWAPFILES_SHIFT)
66
#define PM_SOFT_DIRTY		(1ULL << 55)
67
#define PM_MMAP_EXCLUSIVE	(1ULL << 56)
68 69 70
#define PM_FILE			(1ULL << 61)
#define PM_SWAP			(1ULL << 62)
#define PM_PRESENT		(1ULL << 63)
71

72 73 74 75 76 77
/*
 * kernel page flags
 */

#define KPF_BYTES		8
#define PROC_KPAGEFLAGS		"/proc/kpageflags"
78
#define PROC_KPAGECGROUP	"/proc/kpagecgroup"
79 80 81 82 83 84 85 86 87 88

/* [32-] kernel hacking assistances */
#define KPF_RESERVED		32
#define KPF_MLOCKED		33
#define KPF_MAPPEDTODISK	34
#define KPF_PRIVATE		35
#define KPF_PRIVATE_2		36
#define KPF_OWNER_PRIVATE	37
#define KPF_ARCH		38
#define KPF_UNCACHED		39
89
#define KPF_SOFTDIRTY		40
90 91 92 93 94 95 96 97

/* [48-] take some arbitrary free slots for expanding overloaded flags
 * not part of kernel API
 */
#define KPF_READAHEAD		48
#define KPF_SLOB_FREE		49
#define KPF_SLUB_FROZEN		50
#define KPF_SLUB_DEBUG		51
98 99
#define KPF_FILE		61
#define KPF_SWAP		62
100
#define KPF_MMAP_EXCLUSIVE	63
101 102 103 104 105 106 107

#define KPF_ALL_BITS		((uint64_t)~0ULL)
#define KPF_HACKERS_BITS	(0xffffULL << 32)
#define KPF_OVERLOADED_BITS	(0xffffULL << 48)
#define BIT(name)		(1ULL << KPF_##name)
#define BITS_COMPOUND		(BIT(COMPOUND_HEAD) | BIT(COMPOUND_TAIL))

108
static const char * const page_flag_names[] = {
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
	[KPF_LOCKED]		= "L:locked",
	[KPF_ERROR]		= "E:error",
	[KPF_REFERENCED]	= "R:referenced",
	[KPF_UPTODATE]		= "U:uptodate",
	[KPF_DIRTY]		= "D:dirty",
	[KPF_LRU]		= "l:lru",
	[KPF_ACTIVE]		= "A:active",
	[KPF_SLAB]		= "S:slab",
	[KPF_WRITEBACK]		= "W:writeback",
	[KPF_RECLAIM]		= "I:reclaim",
	[KPF_BUDDY]		= "B:buddy",

	[KPF_MMAP]		= "M:mmap",
	[KPF_ANON]		= "a:anonymous",
	[KPF_SWAPCACHE]		= "s:swapcache",
	[KPF_SWAPBACKED]	= "b:swapbacked",
	[KPF_COMPOUND_HEAD]	= "H:compound_head",
	[KPF_COMPOUND_TAIL]	= "T:compound_tail",
	[KPF_HUGE]		= "G:huge",
	[KPF_UNEVICTABLE]	= "u:unevictable",
129
	[KPF_HWPOISON]		= "X:hwpoison",
130
	[KPF_NOPAGE]		= "n:nopage",
131
	[KPF_KSM]		= "x:ksm",
132
	[KPF_THP]		= "t:thp",
133
	[KPF_BALLOON]		= "o:balloon",
134
	[KPF_ZERO_PAGE]		= "z:zero_page",
135
	[KPF_IDLE]              = "i:idle_page",
136 137 138 139 140 141 142 143 144

	[KPF_RESERVED]		= "r:reserved",
	[KPF_MLOCKED]		= "m:mlocked",
	[KPF_MAPPEDTODISK]	= "d:mappedtodisk",
	[KPF_PRIVATE]		= "P:private",
	[KPF_PRIVATE_2]		= "p:private_2",
	[KPF_OWNER_PRIVATE]	= "O:owner_private",
	[KPF_ARCH]		= "h:arch",
	[KPF_UNCACHED]		= "c:uncached",
145
	[KPF_SOFTDIRTY]		= "f:softdirty",
146 147 148 149 150

	[KPF_READAHEAD]		= "I:readahead",
	[KPF_SLOB_FREE]		= "P:slob_free",
	[KPF_SLUB_FROZEN]	= "A:slub_frozen",
	[KPF_SLUB_DEBUG]	= "E:slub_debug",
151 152

	[KPF_FILE]		= "F:file",
153
	[KPF_SWAP]		= "w:swap",
154
	[KPF_MMAP_EXCLUSIVE]	= "1:mmap_exclusive",
155 156 157
};


158
static const char * const debugfs_known_mountpoints[] = {
159 160 161 162 163
	"/sys/kernel/debug",
	"/debug",
	0,
};

164 165 166 167 168 169 170 171
/*
 * data structures
 */

static int		opt_raw;	/* for kernel developers */
static int		opt_list;	/* list pages (in ranges) */
static int		opt_no_summary;	/* don't show summary */
static pid_t		opt_pid;	/* process to walk */
172 173 174
const char *		opt_file;	/* file or directory path */
static uint64_t		opt_cgroup;	/* cgroup inode */
static int		opt_list_cgroup;/* list page cgroup */
175 176 177 178 179 180

#define MAX_ADDR_RANGES	1024
static int		nr_addr_ranges;
static unsigned long	opt_offset[MAX_ADDR_RANGES];
static unsigned long	opt_size[MAX_ADDR_RANGES];

181 182 183 184 185
#define MAX_VMAS	10240
static int		nr_vmas;
static unsigned long	pg_start[MAX_VMAS];
static unsigned long	pg_end[MAX_VMAS];

186 187 188 189 190 191 192
#define MAX_BIT_FILTERS	64
static int		nr_bit_filters;
static uint64_t		opt_mask[MAX_BIT_FILTERS];
static uint64_t		opt_bits[MAX_BIT_FILTERS];

static int		page_size;

193
static int		pagemap_fd;
194
static int		kpageflags_fd;
195
static int		kpagecgroup_fd = -1;
196

197 198 199
static int		opt_hwpoison;
static int		opt_unpoison;

200
static const char	*hwpoison_debug_fs;
201 202 203
static int		hwpoison_inject_fd;
static int		hwpoison_forget_fd;

204 205 206 207 208 209 210
#define HASH_SHIFT	13
#define HASH_SIZE	(1 << HASH_SHIFT)
#define HASH_MASK	(HASH_SIZE - 1)
#define HASH_KEY(flags)	(flags & HASH_MASK)

static unsigned long	total_pages;
static unsigned long	nr_pages[HASH_SIZE];
211
static uint64_t		page_flags[HASH_SIZE];
212 213 214 215 216 217 218 219 220 221 222 223 224


/*
 * helper functions
 */

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

#define min_t(type, x, y) ({			\
	type __min1 = (x);			\
	type __min2 = (y);			\
	__min1 < __min2 ? __min1 : __min2; })

225 226 227 228 229
#define max_t(type, x, y) ({			\
	type __max1 = (x);			\
	type __max2 = (y);			\
	__max1 > __max2 ? __max1 : __max2; })

230
static unsigned long pages2mb(unsigned long pages)
231 232 233 234
{
	return (pages * page_size) >> 20;
}

235
static void fatal(const char *x, ...)
236 237 238 239 240 241 242 243 244
{
	va_list ap;

	va_start(ap, x);
	vfprintf(stderr, x, ap);
	va_end(ap);
	exit(EXIT_FAILURE);
}

245
static int checked_open(const char *pathname, int flags)
246 247 248 249 250 251 252 253 254 255 256
{
	int fd = open(pathname, flags);

	if (fd < 0) {
		perror(pathname);
		exit(EXIT_FAILURE);
	}

	return fd;
}

257 258 259 260 261 262 263 264 265 266 267 268 269 270
/*
 * pagemap/kpageflags routines
 */

static unsigned long do_u64_read(int fd, char *name,
				 uint64_t *buf,
				 unsigned long index,
				 unsigned long count)
{
	long bytes;

	if (index > ULONG_MAX / 8)
		fatal("index overflow: %lu\n", index);

271
	bytes = pread(fd, buf, count * 8, (off_t)index * 8);
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
	if (bytes < 0) {
		perror(name);
		exit(EXIT_FAILURE);
	}
	if (bytes % 8)
		fatal("partial read: %lu bytes\n", bytes);

	return bytes / 8;
}

static unsigned long kpageflags_read(uint64_t *buf,
				     unsigned long index,
				     unsigned long pages)
{
	return do_u64_read(kpageflags_fd, PROC_KPAGEFLAGS, buf, index, pages);
}

289 290 291 292 293 294 295 296 297 298
static unsigned long kpagecgroup_read(uint64_t *buf,
				      unsigned long index,
				      unsigned long pages)
{
	if (kpagecgroup_fd < 0)
		return pages;

	return do_u64_read(kpagecgroup_fd, PROC_KPAGEFLAGS, buf, index, pages);
}

299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
static unsigned long pagemap_read(uint64_t *buf,
				  unsigned long index,
				  unsigned long pages)
{
	return do_u64_read(pagemap_fd, "/proc/pid/pagemap", buf, index, pages);
}

static unsigned long pagemap_pfn(uint64_t val)
{
	unsigned long pfn;

	if (val & PM_PRESENT)
		pfn = PM_PFRAME(val);
	else
		pfn = 0;

	return pfn;
}

318 319 320 321
static unsigned long pagemap_swap_offset(uint64_t val)
{
	return val & PM_SWAP ? PM_SWAP_OFFSET(val) : 0;
}
322 323 324 325 326

/*
 * page flag names
 */

327
static char *page_flag_name(uint64_t flags)
328 329 330
{
	static char buf[65];
	int present;
331
	size_t i, j;
332 333 334 335 336

	for (i = 0, j = 0; i < ARRAY_SIZE(page_flag_names); i++) {
		present = (flags >> i) & 1;
		if (!page_flag_names[i]) {
			if (present)
337
				fatal("unknown flag bit %d\n", i);
338 339 340 341 342 343 344 345
			continue;
		}
		buf[j++] = present ? page_flag_names[i][0] : '_';
	}

	return buf;
}

346
static char *page_flag_longname(uint64_t flags)
347 348
{
	static char buf[1024];
349
	size_t i, n;
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369

	for (i = 0, n = 0; i < ARRAY_SIZE(page_flag_names); i++) {
		if (!page_flag_names[i])
			continue;
		if ((flags >> i) & 1)
			n += snprintf(buf + n, sizeof(buf) - n, "%s,",
					page_flag_names[i] + 2);
	}
	if (n)
		n--;
	buf[n] = '\0';

	return buf;
}


/*
 * page list and summary
 */

370
static void show_page_range(unsigned long voffset, unsigned long offset,
371
			    unsigned long size, uint64_t flags, uint64_t cgroup)
372 373
{
	static uint64_t      flags0;
374
	static uint64_t	     cgroup0;
375
	static unsigned long voff;
376 377 378
	static unsigned long index;
	static unsigned long count;

379
	if (flags == flags0 && cgroup == cgroup0 && offset == index + count &&
380 381
	    size && voffset == voff + count) {
		count += size;
382 383 384
		return;
	}

385 386 387
	if (count) {
		if (opt_pid)
			printf("%lx\t", voff);
388 389
		if (opt_file)
			printf("%lu\t", voff);
390 391
		if (opt_list_cgroup)
			printf("@%llu\t", (unsigned long long)cgroup0);
392
		printf("%lx\t%lx\t%s\n",
393
				index, count, page_flag_name(flags0));
394
	}
395 396

	flags0 = flags;
397
	cgroup0= cgroup;
398
	index  = offset;
399
	voff   = voffset;
400 401 402 403 404
	count  = size;
}

static void flush_page_range(void)
{
405
	show_page_range(0, 0, 0, 0, 0);
406 407
}

408 409
static void show_page(unsigned long voffset, unsigned long offset,
		      uint64_t flags, uint64_t cgroup)
410
{
411 412
	if (opt_pid)
		printf("%lx\t", voffset);
413 414
	if (opt_file)
		printf("%lu\t", voffset);
415 416
	if (opt_list_cgroup)
		printf("@%llu\t", (unsigned long long)cgroup);
417
	printf("%lx\t%s\n", offset, page_flag_name(flags));
418 419
}

420
static void show_summary(void)
421
{
422
	size_t i;
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445

	printf("             flags\tpage-count       MB"
		"  symbolic-flags\t\t\tlong-symbolic-flags\n");

	for (i = 0; i < ARRAY_SIZE(nr_pages); i++) {
		if (nr_pages[i])
			printf("0x%016llx\t%10lu %8lu  %s\t%s\n",
				(unsigned long long)page_flags[i],
				nr_pages[i],
				pages2mb(nr_pages[i]),
				page_flag_name(page_flags[i]),
				page_flag_longname(page_flags[i]));
	}

	printf("             total\t%10lu %8lu\n",
			total_pages, pages2mb(total_pages));
}


/*
 * page flag filters
 */

446
static int bit_mask_ok(uint64_t flags)
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
{
	int i;

	for (i = 0; i < nr_bit_filters; i++) {
		if (opt_bits[i] == KPF_ALL_BITS) {
			if ((flags & opt_mask[i]) == 0)
				return 0;
		} else {
			if ((flags & opt_mask[i]) != opt_bits[i])
				return 0;
		}
	}

	return 1;
}

463
static uint64_t expand_overloaded_flags(uint64_t flags, uint64_t pme)
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
{
	/* SLOB/SLUB overload several page flags */
	if (flags & BIT(SLAB)) {
		if (flags & BIT(PRIVATE))
			flags ^= BIT(PRIVATE) | BIT(SLOB_FREE);
		if (flags & BIT(ACTIVE))
			flags ^= BIT(ACTIVE) | BIT(SLUB_FROZEN);
		if (flags & BIT(ERROR))
			flags ^= BIT(ERROR) | BIT(SLUB_DEBUG);
	}

	/* PG_reclaim is overloaded as PG_readahead in the read path */
	if ((flags & (BIT(RECLAIM) | BIT(WRITEBACK))) == BIT(RECLAIM))
		flags ^= BIT(RECLAIM) | BIT(READAHEAD);

479 480
	if (pme & PM_SOFT_DIRTY)
		flags |= BIT(SOFTDIRTY);
481 482
	if (pme & PM_FILE)
		flags |= BIT(FILE);
483 484
	if (pme & PM_SWAP)
		flags |= BIT(SWAP);
485 486
	if (pme & PM_MMAP_EXCLUSIVE)
		flags |= BIT(MMAP_EXCLUSIVE);
487

488 489 490
	return flags;
}

491
static uint64_t well_known_flags(uint64_t flags)
492 493 494 495 496 497 498 499 500 501 502
{
	/* hide flags intended only for kernel hacker */
	flags &= ~KPF_HACKERS_BITS;

	/* hide non-hugeTLB compound pages */
	if ((flags & BITS_COMPOUND) && !(flags & BIT(HUGE)))
		flags &= ~BITS_COMPOUND;

	return flags;
}

503
static uint64_t kpageflags_flags(uint64_t flags, uint64_t pme)
504
{
505 506 507
	if (opt_raw)
		flags = expand_overloaded_flags(flags, pme);
	else
508 509 510 511 512
		flags = well_known_flags(flags);

	return flags;
}

513 514 515 516 517 518
/*
 * page actions
 */

static void prepare_hwpoison_fd(void)
{
519 520
	char buf[MAX_PATH + 1];

521
	hwpoison_debug_fs = debugfs__mount();
522 523 524 525
	if (!hwpoison_debug_fs) {
		perror("mount debugfs");
		exit(EXIT_FAILURE);
	}
526 527

	if (opt_hwpoison && !hwpoison_inject_fd) {
528 529
		snprintf(buf, MAX_PATH, "%s/hwpoison/corrupt-pfn",
			hwpoison_debug_fs);
530 531 532 533
		hwpoison_inject_fd = checked_open(buf, O_WRONLY);
	}

	if (opt_unpoison && !hwpoison_forget_fd) {
534 535
		snprintf(buf, MAX_PATH, "%s/hwpoison/unpoison-pfn",
			hwpoison_debug_fs);
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
		hwpoison_forget_fd = checked_open(buf, O_WRONLY);
	}
}

static int hwpoison_page(unsigned long offset)
{
	char buf[100];
	int len;

	len = sprintf(buf, "0x%lx\n", offset);
	len = write(hwpoison_inject_fd, buf, len);
	if (len < 0) {
		perror("hwpoison inject");
		return len;
	}
	return 0;
}

static int unpoison_page(unsigned long offset)
{
	char buf[100];
	int len;

	len = sprintf(buf, "0x%lx\n", offset);
	len = write(hwpoison_forget_fd, buf, len);
	if (len < 0) {
		perror("hwpoison forget");
		return len;
	}
	return 0;
}

568 569 570 571
/*
 * page frame walker
 */

572
static size_t hash_slot(uint64_t flags)
573
{
574 575
	size_t k = HASH_KEY(flags);
	size_t i;
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598

	/* Explicitly reserve slot 0 for flags 0: the following logic
	 * cannot distinguish an unoccupied slot from slot (flags==0).
	 */
	if (flags == 0)
		return 0;

	/* search through the remaining (HASH_SIZE-1) slots */
	for (i = 1; i < ARRAY_SIZE(page_flags); i++, k++) {
		if (!k || k >= ARRAY_SIZE(page_flags))
			k = 1;
		if (page_flags[k] == 0) {
			page_flags[k] = flags;
			return k;
		}
		if (page_flags[k] == flags)
			return k;
	}

	fatal("hash table full: bump up HASH_SHIFT?\n");
	exit(EXIT_FAILURE);
}

599 600
static void add_page(unsigned long voffset, unsigned long offset,
		     uint64_t flags, uint64_t cgroup, uint64_t pme)
601
{
602
	flags = kpageflags_flags(flags, pme);
603 604 605 606

	if (!bit_mask_ok(flags))
		return;

607 608 609
	if (opt_cgroup && cgroup != (uint64_t)opt_cgroup)
		return;

610 611 612 613 614
	if (opt_hwpoison)
		hwpoison_page(offset);
	if (opt_unpoison)
		unpoison_page(offset);

615
	if (opt_list == 1)
616
		show_page_range(voffset, offset, 1, flags, cgroup);
617
	else if (opt_list == 2)
618
		show_page(voffset, offset, flags, cgroup);
619 620 621 622 623

	nr_pages[hash_slot(flags)]++;
	total_pages++;
}

624
#define KPAGEFLAGS_BATCH	(64 << 10)	/* 64k pages */
625 626
static void walk_pfn(unsigned long voffset,
		     unsigned long index,
627 628
		     unsigned long count,
		     uint64_t pme)
629
{
630
	uint64_t buf[KPAGEFLAGS_BATCH];
631
	uint64_t cgi[KPAGEFLAGS_BATCH];
632
	unsigned long batch;
633
	unsigned long pages;
634 635
	unsigned long i;

636 637 638 639 640 641 642 643 644
	/*
	 * kpagecgroup_read() reads only if kpagecgroup were opened, but
	 * /proc/kpagecgroup might even not exist, so it's better to fill
	 * them with zeros here.
	 */
	if (count == 1)
		cgi[0] = 0;
	else
		memset(cgi, 0, sizeof cgi);
645

646
	while (count) {
647 648 649
		batch = min_t(unsigned long, count, KPAGEFLAGS_BATCH);
		pages = kpageflags_read(buf, index, batch);
		if (pages == 0)
650 651
			break;

652 653 654
		if (kpagecgroup_read(cgi, index, pages) != pages)
			fatal("kpagecgroup returned fewer pages than expected");

655
		for (i = 0; i < pages; i++)
656
			add_page(voffset + i, index + i, buf[i], cgi[i], pme);
657

658 659
		index += pages;
		count -= pages;
660 661 662
	}
}

663 664 665 666 667 668 669
static void walk_swap(unsigned long voffset, uint64_t pme)
{
	uint64_t flags = kpageflags_flags(0, pme);

	if (!bit_mask_ok(flags))
		return;

670 671 672
	if (opt_cgroup)
		return;

673
	if (opt_list == 1)
674
		show_page_range(voffset, pagemap_swap_offset(pme), 1, flags, 0);
675
	else if (opt_list == 2)
676
		show_page(voffset, pagemap_swap_offset(pme), flags, 0);
677 678 679 680 681

	nr_pages[hash_slot(flags)]++;
	total_pages++;
}

682 683
#define PAGEMAP_BATCH	(64 << 10)
static void walk_vma(unsigned long index, unsigned long count)
684
{
685 686 687 688 689
	uint64_t buf[PAGEMAP_BATCH];
	unsigned long batch;
	unsigned long pages;
	unsigned long pfn;
	unsigned long i;
690

691 692 693 694 695
	while (count) {
		batch = min_t(unsigned long, count, PAGEMAP_BATCH);
		pages = pagemap_read(buf, index, batch);
		if (pages == 0)
			break;
696

697 698 699
		for (i = 0; i < pages; i++) {
			pfn = pagemap_pfn(buf[i]);
			if (pfn)
700
				walk_pfn(index + i, pfn, 1, buf[i]);
701 702
			if (buf[i] & PM_SWAP)
				walk_swap(index + i, buf[i]);
703 704 705 706 707
		}

		index += pages;
		count -= pages;
	}
708 709 710 711 712
}

static void walk_task(unsigned long index, unsigned long count)
{
	const unsigned long end = index + count;
713 714
	unsigned long start;
	int i = 0;
715 716 717 718 719 720 721 722 723

	while (index < end) {

		while (pg_end[i] <= index)
			if (++i >= nr_vmas)
				return;
		if (pg_start[i] >= end)
			return;

724 725
		start = max_t(unsigned long, pg_start[i], index);
		index = min_t(unsigned long, pg_end[i], end);
726

727 728
		assert(start < index);
		walk_vma(start, index - start);
729 730 731 732 733 734 735 736 737 738 739 740 741
	}
}

static void add_addr_range(unsigned long offset, unsigned long size)
{
	if (nr_addr_ranges >= MAX_ADDR_RANGES)
		fatal("too many addr ranges\n");

	opt_offset[nr_addr_ranges] = offset;
	opt_size[nr_addr_ranges] = min_t(unsigned long, size, ULONG_MAX-offset);
	nr_addr_ranges++;
}

742
static void walk_addr_ranges(void)
743 744 745
{
	int i;

746
	kpageflags_fd = checked_open(PROC_KPAGEFLAGS, O_RDONLY);
747 748

	if (!nr_addr_ranges)
749
		add_addr_range(0, ULONG_MAX);
750 751

	for (i = 0; i < nr_addr_ranges; i++)
752
		if (!opt_pid)
753
			walk_pfn(opt_offset[i], opt_offset[i], opt_size[i], 0);
754 755
		else
			walk_task(opt_offset[i], opt_size[i]);
756 757 758 759 760 761 762 763 764

	close(kpageflags_fd);
}


/*
 * user interface
 */

765
static const char *page_flag_type(uint64_t flag)
766 767 768 769 770 771 772 773
{
	if (flag & KPF_HACKERS_BITS)
		return "(r)";
	if (flag & KPF_OVERLOADED_BITS)
		return "(o)";
	return "   ";
}

774
static void usage(void)
775
{
776
	size_t i, j;
777 778 779

	printf(
"page-types [options]\n"
780
"            -r|--raw                   Raw mode, for kernel developers\n"
781
"            -d|--describe flags        Describe flags\n"
782 783
"            -a|--addr    addr-spec     Walk a range of pages\n"
"            -b|--bits    bits-spec     Walk pages with specified bits\n"
784
"            -c|--cgroup  path|@inode   Walk pages within memory cgroup\n"
785 786 787 788
"            -p|--pid     pid           Walk process address space\n"
"            -f|--file    filename      Walk file address space\n"
"            -l|--list                  Show page details in ranges\n"
"            -L|--list-each             Show page details one by one\n"
789
"            -C|--list-cgroup           Show cgroup inode for pages\n"
790
"            -N|--no-summary            Don't show summary info\n"
791 792 793
"            -X|--hwpoison              hwpoison pages\n"
"            -x|--unpoison              unpoison pages\n"
"            -h|--help                  Show this usage message\n"
794
"flags:\n"
795 796 797
"            0x10                       bitfield format, e.g.\n"
"            anon                       bit-name, e.g.\n"
"            0x10,anon                  comma-separated list, e.g.\n"
798
"addr-spec:\n"
799 800 801 802 803
"            N                          one page at offset N (unit: pages)\n"
"            N+M                        pages range from N to N+M-1\n"
"            N,M                        pages range from N to M-1\n"
"            N,                         pages range from N to end\n"
"            ,M                         pages range from 0 to M-1\n"
804
"bits-spec:\n"
805 806 807 808
"            bit1,bit2                  (flags & (bit1|bit2)) != 0\n"
"            bit1,bit2=bit1             (flags & (bit1|bit2)) == bit1\n"
"            bit1,~bit2                 (flags & (bit1|bit2)) == bit1\n"
"            =bit1,bit2                 flags == (bit1|bit2)\n"
809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825
"bit-names:\n"
	);

	for (i = 0, j = 0; i < ARRAY_SIZE(page_flag_names); i++) {
		if (!page_flag_names[i])
			continue;
		printf("%16s%s", page_flag_names[i] + 2,
				 page_flag_type(1ULL << i));
		if (++j > 3) {
			j = 0;
			putchar('\n');
		}
	}
	printf("\n                                   "
		"(r) raw mode bits  (o) overloaded bits\n");
}

826
static unsigned long long parse_number(const char *str)
827 828 829 830 831 832 833 834 835 836 837
{
	unsigned long long n;

	n = strtoll(str, NULL, 0);

	if (n == 0 && str[0] != '0')
		fatal("invalid name or number: %s\n", str);

	return n;
}

838
static void parse_pid(const char *str)
839
{
840 841 842
	FILE *file;
	char buf[5000];

843 844
	opt_pid = parse_number(str);

845
	sprintf(buf, "/proc/%d/pagemap", opt_pid);
846
	pagemap_fd = checked_open(buf, O_RDONLY);
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882

	sprintf(buf, "/proc/%d/maps", opt_pid);
	file = fopen(buf, "r");
	if (!file) {
		perror(buf);
		exit(EXIT_FAILURE);
	}

	while (fgets(buf, sizeof(buf), file) != NULL) {
		unsigned long vm_start;
		unsigned long vm_end;
		unsigned long long pgoff;
		int major, minor;
		char r, w, x, s;
		unsigned long ino;
		int n;

		n = sscanf(buf, "%lx-%lx %c%c%c%c %llx %x:%x %lu",
			   &vm_start,
			   &vm_end,
			   &r, &w, &x, &s,
			   &pgoff,
			   &major, &minor,
			   &ino);
		if (n < 10) {
			fprintf(stderr, "unexpected line: %s\n", buf);
			continue;
		}
		pg_start[nr_vmas] = vm_start / page_size;
		pg_end[nr_vmas] = vm_end / page_size;
		if (++nr_vmas >= MAX_VMAS) {
			fprintf(stderr, "too many VMAs\n");
			break;
		}
	}
	fclose(file);
883 884
}

885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
static void show_file(const char *name, const struct stat *st)
{
	unsigned long long size = st->st_size;
	char atime[64], mtime[64];
	long now = time(NULL);

	printf("%s\tInode: %u\tSize: %llu (%llu pages)\n",
			name, (unsigned)st->st_ino,
			size, (size + page_size - 1) / page_size);

	strftime(atime, sizeof(atime), "%c", localtime(&st->st_atime));
	strftime(mtime, sizeof(mtime), "%c", localtime(&st->st_mtime));

	printf("Modify: %s (%ld seconds ago)\nAccess: %s (%ld seconds ago)\n",
			mtime, now - st->st_mtime,
			atime, now - st->st_atime);
}

903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
static sigjmp_buf sigbus_jmp;

static void * volatile sigbus_addr;

static void sigbus_handler(int sig, siginfo_t *info, void *ucontex)
{
	(void)sig;
	(void)ucontex;
	sigbus_addr = info ? info->si_addr : NULL;
	siglongjmp(sigbus_jmp, 1);
}

static struct sigaction sigbus_action = {
	.sa_sigaction = sigbus_handler,
	.sa_flags = SA_SIGINFO,
};

920 921 922 923
static void walk_file(const char *name, const struct stat *st)
{
	uint8_t vec[PAGEMAP_BATCH];
	uint64_t buf[PAGEMAP_BATCH], flags;
924
	uint64_t cgroup = 0;
925
	unsigned long nr_pages, pfn, i;
926
	off_t off, end = st->st_size;
927 928 929 930 931 932 933
	int fd;
	ssize_t len;
	void *ptr;
	int first = 1;

	fd = checked_open(name, O_RDONLY|O_NOATIME|O_NOFOLLOW);

934 935
	for (off = 0; off < end; off += len) {
		nr_pages = (end - off + page_size - 1) / page_size;
936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
		if (nr_pages > PAGEMAP_BATCH)
			nr_pages = PAGEMAP_BATCH;
		len = nr_pages * page_size;

		ptr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, off);
		if (ptr == MAP_FAILED)
			fatal("mmap failed: %s", name);

		/* determine cached pages */
		if (mincore(ptr, len, vec))
			fatal("mincore failed: %s", name);

		/* turn off readahead */
		if (madvise(ptr, len, MADV_RANDOM))
			fatal("madvice failed: %s", name);

952 953 954 955 956 957 958
		if (sigsetjmp(sigbus_jmp, 1)) {
			end = off + sigbus_addr ? sigbus_addr - ptr : 0;
			fprintf(stderr, "got sigbus at offset %lld: %s\n",
					(long long)end, name);
			goto got_sigbus;
		}

959 960 961 962 963
		/* populate ptes */
		for (i = 0; i < nr_pages ; i++) {
			if (vec[i] & 1)
				(void)*(volatile int *)(ptr + i * page_size);
		}
964
got_sigbus:
965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981

		/* turn off harvesting reference bits */
		if (madvise(ptr, len, MADV_SEQUENTIAL))
			fatal("madvice failed: %s", name);

		if (pagemap_read(buf, (unsigned long)ptr / page_size,
					nr_pages) != nr_pages)
			fatal("cannot read pagemap");

		munmap(ptr, len);

		for (i = 0; i < nr_pages; i++) {
			pfn = pagemap_pfn(buf[i]);
			if (!pfn)
				continue;
			if (!kpageflags_read(&flags, pfn, 1))
				continue;
982 983
			if (!kpagecgroup_read(&cgroup, pfn, 1))
				fatal("kpagecgroup_read failed");
984 985 986 987 988
			if (first && opt_list) {
				first = 0;
				flush_page_range();
				show_file(name, st);
			}
989 990
			add_page(off / page_size + i, pfn,
				 flags, cgroup, buf[i]);
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
		}
	}

	close(fd);
}

int walk_tree(const char *name, const struct stat *st, int type, struct FTW *f)
{
	(void)f;
	switch (type) {
	case FTW_F:
		if (S_ISREG(st->st_mode))
			walk_file(name, st);
		break;
	case FTW_DNR:
		fprintf(stderr, "cannot read dir: %s\n", name);
		break;
	}
	return 0;
}

static void walk_page_cache(void)
{
	struct stat st;

	kpageflags_fd = checked_open(PROC_KPAGEFLAGS, O_RDONLY);
	pagemap_fd = checked_open("/proc/self/pagemap", O_RDONLY);
1018
	sigaction(SIGBUS, &sigbus_action, NULL);
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033

	if (stat(opt_file, &st))
		fatal("stat failed: %s\n", opt_file);

	if (S_ISREG(st.st_mode)) {
		walk_file(opt_file, &st);
	} else if (S_ISDIR(st.st_mode)) {
		/* do not follow symlinks and mountpoints */
		if (nftw(opt_file, walk_tree, 64, FTW_MOUNT | FTW_PHYS) < 0)
			fatal("nftw failed: %s\n", opt_file);
	} else
		fatal("unhandled file type: %s\n", opt_file);

	close(kpageflags_fd);
	close(pagemap_fd);
1034
	signal(SIGBUS, SIG_DFL);
1035 1036
}

1037
static void parse_file(const char *name)
1038
{
1039
	opt_file = name;
1040 1041
}

1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
static void parse_cgroup(const char *path)
{
	if (path[0] == '@') {
		opt_cgroup = parse_number(path + 1);
		return;
	}

	struct stat st;

	if (stat(path, &st))
		fatal("stat failed: %s: %m\n", path);

	if (!S_ISDIR(st.st_mode))
		fatal("cgroup supposed to be a directory: %s\n", path);

	opt_cgroup = st.st_ino;
}

1060
static void parse_addr_range(const char *optarg)
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
{
	unsigned long offset;
	unsigned long size;
	char *p;

	p = strchr(optarg, ',');
	if (!p)
		p = strchr(optarg, '+');

	if (p == optarg) {
		offset = 0;
		size   = parse_number(p + 1);
	} else if (p) {
		offset = parse_number(optarg);
		if (p[1] == '\0')
			size = ULONG_MAX;
		else {
			size = parse_number(p + 1);
			if (*p == ',') {
				if (size < offset)
					fatal("invalid range: %lu,%lu\n",
							offset, size);
				size -= offset;
			}
		}
	} else {
		offset = parse_number(optarg);
		size   = 1;
	}

	add_addr_range(offset, size);
}

1094
static void add_bits_filter(uint64_t mask, uint64_t bits)
1095 1096 1097 1098 1099 1100 1101 1102 1103
{
	if (nr_bit_filters >= MAX_BIT_FILTERS)
		fatal("too much bit filters\n");

	opt_mask[nr_bit_filters] = mask;
	opt_bits[nr_bit_filters] = bits;
	nr_bit_filters++;
}

1104
static uint64_t parse_flag_name(const char *str, int len)
1105
{
1106
	size_t i;
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123

	if (!*str || !len)
		return 0;

	if (len <= 8 && !strncmp(str, "compound", len))
		return BITS_COMPOUND;

	for (i = 0; i < ARRAY_SIZE(page_flag_names); i++) {
		if (!page_flag_names[i])
			continue;
		if (!strncmp(str, page_flag_names[i] + 2, len))
			return 1ULL << i;
	}

	return parse_number(str);
}

1124
static uint64_t parse_flag_names(const char *str, int all)
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
{
	const char *p    = str;
	uint64_t   flags = 0;

	while (1) {
		if (*p == ',' || *p == '=' || *p == '\0') {
			if ((*str != '~') || (*str == '~' && all && *++str))
				flags |= parse_flag_name(str, p - str);
			if (*p != ',')
				break;
			str = p + 1;
		}
		p++;
	}

	return flags;
}

1143
static void parse_bits_mask(const char *optarg)
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
{
	uint64_t mask;
	uint64_t bits;
	const char *p;

	p = strchr(optarg, '=');
	if (p == optarg) {
		mask = KPF_ALL_BITS;
		bits = parse_flag_names(p + 1, 0);
	} else if (p) {
		mask = parse_flag_names(optarg, 0);
		bits = parse_flag_names(p + 1, 0);
	} else if (strchr(optarg, '~')) {
		mask = parse_flag_names(optarg, 1);
		bits = parse_flag_names(optarg, 0);
	} else {
		mask = parse_flag_names(optarg, 0);
		bits = KPF_ALL_BITS;
	}

	add_bits_filter(mask, bits);
}

1167 1168 1169 1170 1171 1172 1173 1174 1175
static void describe_flags(const char *optarg)
{
	uint64_t flags = parse_flag_names(optarg, 0);

	printf("0x%016llx\t%s\t%s\n",
		(unsigned long long)flags,
		page_flag_name(flags),
		page_flag_longname(flags));
}
1176

1177
static const struct option opts[] = {
1178 1179 1180 1181 1182
	{ "raw"       , 0, NULL, 'r' },
	{ "pid"       , 1, NULL, 'p' },
	{ "file"      , 1, NULL, 'f' },
	{ "addr"      , 1, NULL, 'a' },
	{ "bits"      , 1, NULL, 'b' },
1183
	{ "cgroup"    , 1, NULL, 'c' },
1184
	{ "describe"  , 1, NULL, 'd' },
1185 1186
	{ "list"      , 0, NULL, 'l' },
	{ "list-each" , 0, NULL, 'L' },
1187
	{ "list-cgroup", 0, NULL, 'C' },
1188
	{ "no-summary", 0, NULL, 'N' },
1189 1190
	{ "hwpoison"  , 0, NULL, 'X' },
	{ "unpoison"  , 0, NULL, 'x' },
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
	{ "help"      , 0, NULL, 'h' },
	{ NULL        , 0, NULL, 0 }
};

int main(int argc, char *argv[])
{
	int c;

	page_size = getpagesize();

	while ((c = getopt_long(argc, argv,
1202
				"rp:f:a:b:d:c:ClLNXxh", opts, NULL)) != -1) {
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
		switch (c) {
		case 'r':
			opt_raw = 1;
			break;
		case 'p':
			parse_pid(optarg);
			break;
		case 'f':
			parse_file(optarg);
			break;
		case 'a':
			parse_addr_range(optarg);
			break;
		case 'b':
			parse_bits_mask(optarg);
			break;
1219 1220 1221 1222 1223 1224
		case 'c':
			parse_cgroup(optarg);
			break;
		case 'C':
			opt_list_cgroup = 1;
			break;
1225 1226
		case 'd':
			describe_flags(optarg);
1227
			exit(0);
1228 1229 1230 1231 1232 1233 1234 1235 1236
		case 'l':
			opt_list = 1;
			break;
		case 'L':
			opt_list = 2;
			break;
		case 'N':
			opt_no_summary = 1;
			break;
1237 1238 1239 1240 1241 1242 1243 1244
		case 'X':
			opt_hwpoison = 1;
			prepare_hwpoison_fd();
			break;
		case 'x':
			opt_unpoison = 1;
			prepare_hwpoison_fd();
			break;
1245 1246 1247 1248 1249 1250 1251 1252 1253
		case 'h':
			usage();
			exit(0);
		default:
			usage();
			exit(1);
		}
	}

1254 1255 1256
	if (opt_cgroup || opt_list_cgroup)
		kpagecgroup_fd = checked_open(PROC_KPAGECGROUP, O_RDONLY);

1257 1258
	if (opt_list && opt_pid)
		printf("voffset\t");
1259 1260
	if (opt_list && opt_file)
		printf("foffset\t");
1261 1262
	if (opt_list && opt_list_cgroup)
		printf("cgroup\t");
1263
	if (opt_list == 1)
1264
		printf("offset\tlen\tflags\n");
1265 1266 1267
	if (opt_list == 2)
		printf("offset\tflags\n");

1268 1269 1270 1271
	if (opt_file)
		walk_page_cache();
	else
		walk_addr_ranges();
1272 1273

	if (opt_list == 1)
1274
		flush_page_range();
1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285

	if (opt_no_summary)
		return 0;

	if (opt_list)
		printf("\n\n");

	show_summary();

	return 0;
}