[linux-2.6-block.git] / Documentation / vm / page-types.c

/*
 * page-types: Tool for querying page flags
 *
 * Copyright (C) 2009 Intel corporation
 *
 * Authors: Wu Fengguang <fengguang.wu@intel.com>
 *
 * Released under the General Public License (GPL).
 */

#define _LARGEFILE64_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <getopt.h>
#include <limits.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/fcntl.h>


/*
 * pagemap kernel ABI bits
 */

#define PM_ENTRY_BYTES      sizeof(uint64_t)
#define PM_STATUS_BITS      3
#define PM_STATUS_OFFSET    (64 - PM_STATUS_BITS)
#define PM_STATUS_MASK      (((1LL << PM_STATUS_BITS) - 1) << PM_STATUS_OFFSET)
#define PM_STATUS(nr)       (((nr) << PM_STATUS_OFFSET) & PM_STATUS_MASK)
#define PM_PSHIFT_BITS      6
#define PM_PSHIFT_OFFSET    (PM_STATUS_OFFSET - PM_PSHIFT_BITS)
#define PM_PSHIFT_MASK      (((1LL << PM_PSHIFT_BITS) - 1) << PM_PSHIFT_OFFSET)
#define PM_PSHIFT(x)        (((u64) (x) << PM_PSHIFT_OFFSET) & PM_PSHIFT_MASK)
#define PM_PFRAME_MASK      ((1LL << PM_PSHIFT_OFFSET) - 1)
#define PM_PFRAME(x)        ((x) & PM_PFRAME_MASK)

#define PM_PRESENT          PM_STATUS(4LL)
#define PM_SWAP             PM_STATUS(2LL)


/*
 * kernel page flags
 */

#define KPF_BYTES		8
#define PROC_KPAGEFLAGS		"/proc/kpageflags"

/* copied from kpageflags_read() */
#define KPF_LOCKED		0
#define KPF_ERROR		1
#define KPF_REFERENCED		2
#define KPF_UPTODATE		3
#define KPF_DIRTY		4
#define KPF_LRU			5
#define KPF_ACTIVE		6
#define KPF_SLAB		7
#define KPF_WRITEBACK		8
#define KPF_RECLAIM		9
#define KPF_BUDDY		10

/* [11-20] new additions in 2.6.31 */
#define KPF_MMAP		11
#define KPF_ANON		12
#define KPF_SWAPCACHE		13
#define KPF_SWAPBACKED		14
#define KPF_COMPOUND_HEAD	15
#define KPF_COMPOUND_TAIL	16
#define KPF_HUGE		17
#define KPF_UNEVICTABLE		18
#define KPF_HWPOISON		19
#define KPF_NOPAGE		20
#define KPF_KSM			21

/* [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

/* [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

#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))

static char *page_flag_names[] = {
	[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",
	[KPF_HWPOISON]		= "X:hwpoison",
	[KPF_NOPAGE]		= "n:nopage",
	[KPF_KSM]		= "x:ksm",

	[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",

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


/*
 * 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 */

#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];

#define MAX_VMAS	10240
static int		nr_vmas;
static unsigned long	pg_start[MAX_VMAS];
static unsigned long	pg_end[MAX_VMAS];
static unsigned long	voffset;

static int		pagemap_fd;

#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;

#define PAGES_BATCH	(64 << 10)	/* 64k pages */
static int		kpageflags_fd;

#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];
static uint64_t 	page_flags[HASH_SIZE];


/*
 * 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; })

#define max_t(type, x, y) ({			\
	type __max1 = (x);			\
	type __max2 = (y);			\
	__max1 > __max2 ? __max1 : __max2; })

static unsigned long pages2mb(unsigned long pages)
{
	return (pages * page_size) >> 20;
}

static void fatal(const char *x, ...)
{
	va_list ap;

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

int checked_open(const char *pathname, int flags)
{
	int fd = open(pathname, flags);

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

	return fd;
}


/*
 * page flag names
 */

static char *page_flag_name(uint64_t flags)
{
	static char buf[65];
	int present;
	int i, j;

	for (i = 0, j = 0; i < ARRAY_SIZE(page_flag_names); i++) {
		present = (flags >> i) & 1;
		if (!page_flag_names[i]) {
			if (present)
				fatal("unkown flag bit %d\n", i);
			continue;
		}
		buf[j++] = present ? page_flag_names[i][0] : '_';
	}

	return buf;
}

static char *page_flag_longname(uint64_t flags)
{
	static char buf[1024];
	int i, n;

	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
 */

static void show_page_range(unsigned long offset, uint64_t flags)
{
	static uint64_t      flags0;
	static unsigned long voff;
	static unsigned long index;
	static unsigned long count;

	if (flags == flags0 && offset == index + count &&
	    (!opt_pid || voffset == voff + count)) {
		count++;
		return;
	}

	if (count) {
		if (opt_pid)
			printf("%lx\t", voff);
		printf("%lx\t%lx\t%s\n",
				index, count, page_flag_name(flags0));
	}

	flags0 = flags;
	index  = offset;
	voff   = voffset;
	count  = 1;
}

static void show_page(unsigned long offset, uint64_t flags)
{
	if (opt_pid)
		printf("%lx\t", voffset);
	printf("%lx\t%s\n", offset, page_flag_name(flags));
}

static void show_summary(void)
{
	int i;

	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
 */

static int bit_mask_ok(uint64_t flags)
{
	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;
}

static uint64_t expand_overloaded_flags(uint64_t flags)
{
	/* 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);

	return flags;
}

static uint64_t well_known_flags(uint64_t flags)
{
	/* 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;
}


/*
 * page frame walker
 */

static int hash_slot(uint64_t flags)
{
	int k = HASH_KEY(flags);
	int i;

	/* 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);
}

static void add_page(unsigned long offset, uint64_t flags)
{
	flags = expand_overloaded_flags(flags);

	if (!opt_raw)
		flags = well_known_flags(flags);

	if (!bit_mask_ok(flags))
		return;

	if (opt_list == 1)
		show_page_range(offset, flags);
	else if (opt_list == 2)
		show_page(offset, flags);

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

static void walk_pfn(unsigned long index, unsigned long count)
{
	unsigned long batch;
	unsigned long n;
	unsigned long i;

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

	lseek(kpageflags_fd, index * KPF_BYTES, SEEK_SET);

	while (count) {
		uint64_t kpageflags_buf[KPF_BYTES * PAGES_BATCH];

		batch = min_t(unsigned long, count, PAGES_BATCH);
		n = read(kpageflags_fd, kpageflags_buf, batch * KPF_BYTES);
		if (n == 0)
			break;
		if (n < 0) {
			perror(PROC_KPAGEFLAGS);
			exit(EXIT_FAILURE);
		}

		if (n % KPF_BYTES != 0)
			fatal("partial read: %lu bytes\n", n);
		n = n / KPF_BYTES;

		for (i = 0; i < n; i++)
			add_page(index + i, kpageflags_buf[i]);

		index += batch;
		count -= batch;
	}
}


#define PAGEMAP_BATCH	4096
static unsigned long task_pfn(unsigned long pgoff)
{
	static uint64_t buf[PAGEMAP_BATCH];
	static unsigned long start;
	static long count;
	uint64_t pfn;

	if (pgoff < start || pgoff >= start + count) {
		if (lseek64(pagemap_fd,
			    (uint64_t)pgoff * PM_ENTRY_BYTES,
			    SEEK_SET) < 0) {
			perror("pagemap seek");
			exit(EXIT_FAILURE);
		}
		count = read(pagemap_fd, buf, sizeof(buf));
		if (count == 0)
			return 0;
		if (count < 0) {
			perror("pagemap read");
			exit(EXIT_FAILURE);
		}
		if (count % PM_ENTRY_BYTES) {
			fatal("pagemap read not aligned.\n");
			exit(EXIT_FAILURE);
		}
		count /= PM_ENTRY_BYTES;
		start = pgoff;
	}

	pfn = buf[pgoff - start];
	if (pfn & PM_PRESENT)
		pfn = PM_PFRAME(pfn);
	else
		pfn = 0;

	return pfn;
}

static void walk_task(unsigned long index, unsigned long count)
{
	int i = 0;
	const unsigned long end = index + count;

	while (index < end) {

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

		voffset = max_t(unsigned long, pg_start[i], index);
		index   = min_t(unsigned long, pg_end[i], end);

		assert(voffset < index);
		for (; voffset < index; voffset++) {
			unsigned long pfn = task_pfn(voffset);
			if (pfn)
				walk_pfn(pfn, 1);
		}
	}
}

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++;
}

static void walk_addr_ranges(void)
{
	int i;

	kpageflags_fd = checked_open(PROC_KPAGEFLAGS, O_RDONLY);

	if (!nr_addr_ranges)
		add_addr_range(0, ULONG_MAX);

	for (i = 0; i < nr_addr_ranges; i++)
		if (!opt_pid)
			walk_pfn(opt_offset[i], opt_size[i]);
		else
			walk_task(opt_offset[i], opt_size[i]);

	close(kpageflags_fd);
}


/*
 * user interface
 */

static const char *page_flag_type(uint64_t flag)
{
	if (flag & KPF_HACKERS_BITS)
		return "(r)";
	if (flag & KPF_OVERLOADED_BITS)
		return "(o)";
	return "   ";
}

static void usage(void)
{
	int i, j;

	printf(
"page-types [options]\n"
"            -r|--raw                  Raw mode, for kernel developers\n"
"            -a|--addr    addr-spec    Walk a range of pages\n"
"            -b|--bits    bits-spec    Walk pages with specified bits\n"
"            -p|--pid     pid          Walk process address space\n"
#if 0 /* planned features */
"            -f|--file    filename     Walk file address space\n"
#endif
"            -l|--list                 Show page details in ranges\n"
"            -L|--list-each            Show page details one by one\n"
"            -N|--no-summary           Don't show summay info\n"
"            -h|--help                 Show this usage message\n"
"addr-spec:\n"
"            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"
"bits-spec:\n"
"            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"
"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");
}

static unsigned long long parse_number(const char *str)
{
	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;
}

static void parse_pid(const char *str)
{
	FILE *file;
	char buf[5000];

	opt_pid = parse_number(str);

	sprintf(buf, "/proc/%d/pagemap", opt_pid);
	pagemap_fd = checked_open(buf, O_RDONLY);

	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);
}

static void parse_file(const char *name)
{
}

static void parse_addr_range(const char *optarg)
{
	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);
}

static void add_bits_filter(uint64_t mask, uint64_t bits)
{
	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++;
}

static uint64_t parse_flag_name(const char *str, int len)
{
	int i;

	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);
}

static uint64_t parse_flag_names(const char *str, int all)
{
	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;
}

static void parse_bits_mask(const char *optarg)
{
	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);
}


static struct option opts[] = {
	{ "raw"       , 0, NULL, 'r' },
	{ "pid"       , 1, NULL, 'p' },
	{ "file"      , 1, NULL, 'f' },
	{ "addr"      , 1, NULL, 'a' },
	{ "bits"      , 1, NULL, 'b' },
	{ "list"      , 0, NULL, 'l' },
	{ "list-each" , 0, NULL, 'L' },
	{ "no-summary", 0, NULL, 'N' },
	{ "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,
				"rp:f:a:b:lLNh", opts, NULL)) != -1) {
		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;
		case 'l':
			opt_list = 1;
			break;
		case 'L':
			opt_list = 2;
			break;
		case 'N':
			opt_no_summary = 1;
			break;
		case 'h':
			usage();
			exit(0);
		default:
			usage();
			exit(1);
		}
	}

	if (opt_list && opt_pid)
		printf("voffset\t");
	if (opt_list == 1)
		printf("offset\tlen\tflags\n");
	if (opt_list == 2)
		printf("offset\tflags\n");

	walk_addr_ranges();

	if (opt_list == 1)
		show_page_range(0, 0);  /* drain the buffer */

	if (opt_no_summary)
		return 0;

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

	show_summary();

	return 0;
}
Commit	Line	Data
35efa5e9 WF	1	/*
	2	* page-types: Tool for querying page flags
	3	*
	4	* Copyright (C) 2009 Intel corporation
0c57effe WF	5	*
	6	* Authors: Wu Fengguang <fengguang.wu@intel.com>
	7	*
	8	* Released under the General Public License (GPL).
35efa5e9 WF	9	*/
35efa5e9 WF	10
0b4b2ad5	11	#define _LARGEFILE64_SOURCE
35efa5e9 WF	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <unistd.h>
	15	#include <stdint.h>
	16	#include <stdarg.h>
	17	#include <string.h>
	18	#include <getopt.h>
	19	#include <limits.h>
0b4b2ad5	20	#include <assert.h>
35efa5e9 WF	21	#include <sys/types.h>
	22	#include <sys/errno.h>
	23	#include <sys/fcntl.h>
	24
	25
0b4b2ad5 WF	26	/*
	27	* pagemap kernel ABI bits
	28	*/
	29
	30	#define PM_ENTRY_BYTES sizeof(uint64_t)
	31	#define PM_STATUS_BITS 3
	32	#define PM_STATUS_OFFSET (64 - PM_STATUS_BITS)
	33	#define PM_STATUS_MASK (((1LL << PM_STATUS_BITS) - 1) << PM_STATUS_OFFSET)
	34	#define PM_STATUS(nr) (((nr) << PM_STATUS_OFFSET) & PM_STATUS_MASK)
	35	#define PM_PSHIFT_BITS 6
	36	#define PM_PSHIFT_OFFSET (PM_STATUS_OFFSET - PM_PSHIFT_BITS)
	37	#define PM_PSHIFT_MASK (((1LL << PM_PSHIFT_BITS) - 1) << PM_PSHIFT_OFFSET)
	38	#define PM_PSHIFT(x) (((u64) (x) << PM_PSHIFT_OFFSET) & PM_PSHIFT_MASK)
	39	#define PM_PFRAME_MASK ((1LL << PM_PSHIFT_OFFSET) - 1)
	40	#define PM_PFRAME(x) ((x) & PM_PFRAME_MASK)
	41
	42	#define PM_PRESENT PM_STATUS(4LL)
	43	#define PM_SWAP PM_STATUS(2LL)
	44
	45
35efa5e9 WF	46	/*
	47	* kernel page flags
	48	*/
	49
	50	#define KPF_BYTES 8
	51	#define PROC_KPAGEFLAGS "/proc/kpageflags"
	52
	53	/* copied from kpageflags_read() */
	54	#define KPF_LOCKED 0
	55	#define KPF_ERROR 1
	56	#define KPF_REFERENCED 2
	57	#define KPF_UPTODATE 3
	58	#define KPF_DIRTY 4
	59	#define KPF_LRU 5
	60	#define KPF_ACTIVE 6
	61	#define KPF_SLAB 7
	62	#define KPF_WRITEBACK 8
	63	#define KPF_RECLAIM 9
	64	#define KPF_BUDDY 10
	65
	66	/* [11-20] new additions in 2.6.31 */
	67	#define KPF_MMAP 11
	68	#define KPF_ANON 12
	69	#define KPF_SWAPCACHE 13
	70	#define KPF_SWAPBACKED 14
	71	#define KPF_COMPOUND_HEAD 15
	72	#define KPF_COMPOUND_TAIL 16
	73	#define KPF_HUGE 17
	74	#define KPF_UNEVICTABLE 18
253fb02d	75	#define KPF_HWPOISON 19
35efa5e9	76	#define KPF_NOPAGE 20
a1bbb5ec	77	#define KPF_KSM 21
35efa5e9 WF	78
	79	/* [32-] kernel hacking assistances */
	80	#define KPF_RESERVED 32
	81	#define KPF_MLOCKED 33
	82	#define KPF_MAPPEDTODISK 34
	83	#define KPF_PRIVATE 35
	84	#define KPF_PRIVATE_2 36
	85	#define KPF_OWNER_PRIVATE 37
	86	#define KPF_ARCH 38
	87	#define KPF_UNCACHED 39
	88
	89	/* [48-] take some arbitrary free slots for expanding overloaded flags
	90	* not part of kernel API
	91	*/
	92	#define KPF_READAHEAD 48
	93	#define KPF_SLOB_FREE 49
	94	#define KPF_SLUB_FROZEN 50
	95	#define KPF_SLUB_DEBUG 51
	96
	97	#define KPF_ALL_BITS ((uint64_t)~0ULL)
	98	#define KPF_HACKERS_BITS (0xffffULL << 32)
	99	#define KPF_OVERLOADED_BITS (0xffffULL << 48)
	100	#define BIT(name) (1ULL << KPF_##name)
	101	#define BITS_COMPOUND (BIT(COMPOUND_HEAD) \| BIT(COMPOUND_TAIL))
	102
	103	static char *page_flag_names[] = {
	104	[KPF_LOCKED] = "L:locked",
	105	[KPF_ERROR] = "E:error",
	106	[KPF_REFERENCED] = "R:referenced",
	107	[KPF_UPTODATE] = "U:uptodate",
	108	[KPF_DIRTY] = "D:dirty",
	109	[KPF_LRU] = "l:lru",
	110	[KPF_ACTIVE] = "A:active",
	111	[KPF_SLAB] = "S:slab",
	112	[KPF_WRITEBACK] = "W:writeback",
	113	[KPF_RECLAIM] = "I:reclaim",
	114	[KPF_BUDDY] = "B:buddy",
	115
	116	[KPF_MMAP] = "M:mmap",
	117	[KPF_ANON] = "a:anonymous",
	118	[KPF_SWAPCACHE] = "s:swapcache",
	119	[KPF_SWAPBACKED] = "b:swapbacked",
	120	[KPF_COMPOUND_HEAD] = "H:compound_head",
	121	[KPF_COMPOUND_TAIL] = "T:compound_tail",
	122	[KPF_HUGE] = "G:huge",
	123	[KPF_UNEVICTABLE] = "u:unevictable",
253fb02d	124	[KPF_HWPOISON] = "X:hwpoison",
35efa5e9	125	[KPF_NOPAGE] = "n:nopage",
a1bbb5ec	126	[KPF_KSM] = "x:ksm",
35efa5e9 WF	127
	128	[KPF_RESERVED] = "r:reserved",
	129	[KPF_MLOCKED] = "m:mlocked",
	130	[KPF_MAPPEDTODISK] = "d:mappedtodisk",
	131	[KPF_PRIVATE] = "P:private",
	132	[KPF_PRIVATE_2] = "p:private_2",
	133	[KPF_OWNER_PRIVATE] = "O:owner_private",
	134	[KPF_ARCH] = "h:arch",
	135	[KPF_UNCACHED] = "c:uncached",
	136
	137	[KPF_READAHEAD] = "I:readahead",
	138	[KPF_SLOB_FREE] = "P:slob_free",
	139	[KPF_SLUB_FROZEN] = "A:slub_frozen",
	140	[KPF_SLUB_DEBUG] = "E:slub_debug",
	141	};
	142
	143
	144	/*
	145	* data structures
	146	*/
	147
	148	static int opt_raw; /* for kernel developers */
	149	static int opt_list; /* list pages (in ranges) */
	150	static int opt_no_summary; /* don't show summary */
	151	static pid_t opt_pid; /* process to walk */
	152
	153	#define MAX_ADDR_RANGES 1024
	154	static int nr_addr_ranges;
	155	static unsigned long opt_offset[MAX_ADDR_RANGES];
	156	static unsigned long opt_size[MAX_ADDR_RANGES];
	157
0b4b2ad5 WF	158	#define MAX_VMAS 10240
	159	static int nr_vmas;
	160	static unsigned long pg_start[MAX_VMAS];
	161	static unsigned long pg_end[MAX_VMAS];
	162	static unsigned long voffset;
	163
	164	static int pagemap_fd;
	165
35efa5e9 WF	166	#define MAX_BIT_FILTERS 64
	167	static int nr_bit_filters;
	168	static uint64_t opt_mask[MAX_BIT_FILTERS];
	169	static uint64_t opt_bits[MAX_BIT_FILTERS];
	170
	171	static int page_size;
	172
	173	#define PAGES_BATCH (64 << 10) /* 64k pages */
	174	static int kpageflags_fd;
35efa5e9 WF	175
	176	#define HASH_SHIFT 13
	177	#define HASH_SIZE (1 << HASH_SHIFT)
	178	#define HASH_MASK (HASH_SIZE - 1)
	179	#define HASH_KEY(flags) (flags & HASH_MASK)
	180
	181	static unsigned long total_pages;
	182	static unsigned long nr_pages[HASH_SIZE];
	183	static uint64_t page_flags[HASH_SIZE];
	184
	185
	186	/*
	187	* helper functions
	188	*/
	189
	190	#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
	191
	192	#define min_t(type, x, y) ({ \
	193	type __min1 = (x); \
	194	type __min2 = (y); \
	195	__min1 < __min2 ? __min1 : __min2; })
	196
0b4b2ad5 WF	197	#define max_t(type, x, y) ({ \
	198	type __max1 = (x); \
	199	type __max2 = (y); \
	200	__max1 > __max2 ? __max1 : __max2; })
	201
b7ed698c	202	static unsigned long pages2mb(unsigned long pages)
35efa5e9 WF	203	{
	204	return (pages * page_size) >> 20;
	205	}
	206
b7ed698c	207	static void fatal(const char *x, ...)
35efa5e9 WF	208	{
	209	va_list ap;
	210
	211	va_start(ap, x);
	212	vfprintf(stderr, x, ap);
	213	va_end(ap);
	214	exit(EXIT_FAILURE);
	215	}
	216
31bbf66e WF	217	int checked_open(const char *pathname, int flags)
	218	{
	219	int fd = open(pathname, flags);
	220
	221	if (fd < 0) {
	222	perror(pathname);
	223	exit(EXIT_FAILURE);
	224	}
	225
	226	return fd;
	227	}
	228
35efa5e9 WF	229
	230	/*
	231	* page flag names
	232	*/
	233
b7ed698c	234	static char *page_flag_name(uint64_t flags)
35efa5e9 WF	235	{
	236	static char buf[65];
	237	int present;
	238	int i, j;
	239
	240	for (i = 0, j = 0; i < ARRAY_SIZE(page_flag_names); i++) {
	241	present = (flags >> i) & 1;
	242	if (!page_flag_names[i]) {
	243	if (present)
	244	fatal("unkown flag bit %d\n", i);
	245	continue;
	246	}
	247	buf[j++] = present ? page_flag_names[i][0] : '_';
	248	}
	249
	250	return buf;
	251	}
	252
b7ed698c	253	static char *page_flag_longname(uint64_t flags)
35efa5e9 WF	254	{
	255	static char buf[1024];
	256	int i, n;
	257
	258	for (i = 0, n = 0; i < ARRAY_SIZE(page_flag_names); i++) {
	259	if (!page_flag_names[i])
	260	continue;
	261	if ((flags >> i) & 1)
	262	n += snprintf(buf + n, sizeof(buf) - n, "%s,",
	263	page_flag_names[i] + 2);
	264	}
	265	if (n)
	266	n--;
	267	buf[n] = '\0';
	268
	269	return buf;
	270	}
	271
	272
	273	/*
	274	* page list and summary
	275	*/
	276
b7ed698c	277	static void show_page_range(unsigned long offset, uint64_t flags)
35efa5e9 WF	278	{
35efa5e9 WF	279	static uint64_t flags0;
0b4b2ad5	280	static unsigned long voff;
35efa5e9 WF	281	static unsigned long index;
	282	static unsigned long count;
	283
0b4b2ad5 WF	284	if (flags == flags0 && offset == index + count &&
0b4b2ad5 WF	285	(!opt_pid \|\| voffset == voff + count)) {
35efa5e9 WF	286	count++;
	287	return;
	288	}
	289
0b4b2ad5 WF	290	if (count) {
	291	if (opt_pid)
	292	printf("%lx\t", voff);
	293	printf("%lx\t%lx\t%s\n",
35efa5e9	294	index, count, page_flag_name(flags0));
0b4b2ad5	295	}
35efa5e9 WF	296
	297	flags0 = flags;
	298	index = offset;
0b4b2ad5	299	voff = voffset;
35efa5e9 WF	300	count = 1;
	301	}
	302
b7ed698c	303	static void show_page(unsigned long offset, uint64_t flags)
35efa5e9	304	{
0b4b2ad5 WF	305	if (opt_pid)
	306	printf("%lx\t", voffset);
	307	printf("%lx\t%s\n", offset, page_flag_name(flags));
35efa5e9 WF	308	}
35efa5e9 WF	309
b7ed698c	310	static void show_summary(void)
35efa5e9 WF	311	{
	312	int i;
	313
	314	printf(" flags\tpage-count MB"
	315	" symbolic-flags\t\t\tlong-symbolic-flags\n");
	316
	317	for (i = 0; i < ARRAY_SIZE(nr_pages); i++) {
	318	if (nr_pages[i])
	319	printf("0x%016llx\t%10lu %8lu %s\t%s\n",
	320	(unsigned long long)page_flags[i],
	321	nr_pages[i],
	322	pages2mb(nr_pages[i]),
	323	page_flag_name(page_flags[i]),
	324	page_flag_longname(page_flags[i]));
	325	}
	326
	327	printf(" total\t%10lu %8lu\n",
	328	total_pages, pages2mb(total_pages));
	329	}
	330
	331
	332	/*
	333	* page flag filters
	334	*/
	335
b7ed698c	336	static int bit_mask_ok(uint64_t flags)
35efa5e9 WF	337	{
	338	int i;
	339
	340	for (i = 0; i < nr_bit_filters; i++) {
	341	if (opt_bits[i] == KPF_ALL_BITS) {
	342	if ((flags & opt_mask[i]) == 0)
	343	return 0;
	344	} else {
	345	if ((flags & opt_mask[i]) != opt_bits[i])
	346	return 0;
	347	}
	348	}
	349
	350	return 1;
	351	}
	352
b7ed698c	353	static uint64_t expand_overloaded_flags(uint64_t flags)
35efa5e9 WF	354	{
	355	/* SLOB/SLUB overload several page flags */
	356	if (flags & BIT(SLAB)) {
	357	if (flags & BIT(PRIVATE))
	358	flags ^= BIT(PRIVATE) \| BIT(SLOB_FREE);
	359	if (flags & BIT(ACTIVE))
	360	flags ^= BIT(ACTIVE) \| BIT(SLUB_FROZEN);
	361	if (flags & BIT(ERROR))
	362	flags ^= BIT(ERROR) \| BIT(SLUB_DEBUG);
	363	}
	364
	365	/* PG_reclaim is overloaded as PG_readahead in the read path */
	366	if ((flags & (BIT(RECLAIM) \| BIT(WRITEBACK))) == BIT(RECLAIM))
	367	flags ^= BIT(RECLAIM) \| BIT(READAHEAD);
	368
	369	return flags;
	370	}
	371
b7ed698c	372	static uint64_t well_known_flags(uint64_t flags)
35efa5e9 WF	373	{
	374	/* hide flags intended only for kernel hacker */
	375	flags &= ~KPF_HACKERS_BITS;
	376
	377	/* hide non-hugeTLB compound pages */
	378	if ((flags & BITS_COMPOUND) && !(flags & BIT(HUGE)))
	379	flags &= ~BITS_COMPOUND;
	380
	381	return flags;
	382	}
	383
	384
	385	/*
	386	* page frame walker
	387	*/
	388
b7ed698c	389	static int hash_slot(uint64_t flags)
35efa5e9 WF	390	{
	391	int k = HASH_KEY(flags);
	392	int i;
	393
	394	/* Explicitly reserve slot 0 for flags 0: the following logic
	395	* cannot distinguish an unoccupied slot from slot (flags==0).
	396	*/
	397	if (flags == 0)
	398	return 0;
	399
	400	/* search through the remaining (HASH_SIZE-1) slots */
	401	for (i = 1; i < ARRAY_SIZE(page_flags); i++, k++) {
	402	if (!k \|\| k >= ARRAY_SIZE(page_flags))
	403	k = 1;
	404	if (page_flags[k] == 0) {
	405	page_flags[k] = flags;
	406	return k;
	407	}
	408	if (page_flags[k] == flags)
	409	return k;
	410	}
	411
	412	fatal("hash table full: bump up HASH_SHIFT?\n");
	413	exit(EXIT_FAILURE);
	414	}
	415
b7ed698c	416	static void add_page(unsigned long offset, uint64_t flags)
35efa5e9 WF	417	{
	418	flags = expand_overloaded_flags(flags);
	419
	420	if (!opt_raw)
	421	flags = well_known_flags(flags);
	422
	423	if (!bit_mask_ok(flags))
	424	return;
	425
	426	if (opt_list == 1)
	427	show_page_range(offset, flags);
	428	else if (opt_list == 2)
	429	show_page(offset, flags);
	430
	431	nr_pages[hash_slot(flags)]++;
	432	total_pages++;
	433	}
	434
b7ed698c	435	static void walk_pfn(unsigned long index, unsigned long count)
35efa5e9 WF	436	{
	437	unsigned long batch;
	438	unsigned long n;
	439	unsigned long i;
	440
	441	if (index > ULONG_MAX / KPF_BYTES)
	442	fatal("index overflow: %lu\n", index);
	443
	444	lseek(kpageflags_fd, index * KPF_BYTES, SEEK_SET);
	445
	446	while (count) {
0b4b2ad5 WF	447	uint64_t kpageflags_buf[KPF_BYTES * PAGES_BATCH];
0b4b2ad5 WF	448
35efa5e9 WF	449	batch = min_t(unsigned long, count, PAGES_BATCH);
	450	n = read(kpageflags_fd, kpageflags_buf, batch * KPF_BYTES);
	451	if (n == 0)
	452	break;
	453	if (n < 0) {
	454	perror(PROC_KPAGEFLAGS);
	455	exit(EXIT_FAILURE);
	456	}
	457
	458	if (n % KPF_BYTES != 0)
	459	fatal("partial read: %lu bytes\n", n);
	460	n = n / KPF_BYTES;
	461
	462	for (i = 0; i < n; i++)
	463	add_page(index + i, kpageflags_buf[i]);
	464
	465	index += batch;
	466	count -= batch;
	467	}
	468	}
	469
0b4b2ad5 WF	470
	471	#define PAGEMAP_BATCH 4096
	472	static unsigned long task_pfn(unsigned long pgoff)
	473	{
	474	static uint64_t buf[PAGEMAP_BATCH];
	475	static unsigned long start;
	476	static long count;
	477	uint64_t pfn;
	478
	479	if (pgoff < start \|\| pgoff >= start + count) {
	480	if (lseek64(pagemap_fd,
	481	(uint64_t)pgoff * PM_ENTRY_BYTES,
	482	SEEK_SET) < 0) {
	483	perror("pagemap seek");
	484	exit(EXIT_FAILURE);
	485	}
	486	count = read(pagemap_fd, buf, sizeof(buf));
	487	if (count == 0)
	488	return 0;
	489	if (count < 0) {
	490	perror("pagemap read");
	491	exit(EXIT_FAILURE);
	492	}
	493	if (count % PM_ENTRY_BYTES) {
	494	fatal("pagemap read not aligned.\n");
	495	exit(EXIT_FAILURE);
	496	}
	497	count /= PM_ENTRY_BYTES;
	498	start = pgoff;
	499	}
	500
	501	pfn = buf[pgoff - start];
	502	if (pfn & PM_PRESENT)
	503	pfn = PM_PFRAME(pfn);
	504	else
	505	pfn = 0;
	506
	507	return pfn;
	508	}
	509
	510	static void walk_task(unsigned long index, unsigned long count)
	511	{
	512	int i = 0;
	513	const unsigned long end = index + count;
	514
	515	while (index < end) {
	516
	517	while (pg_end[i] <= index)
	518	if (++i >= nr_vmas)
	519	return;
	520	if (pg_start[i] >= end)
	521	return;
	522
	523	voffset = max_t(unsigned long, pg_start[i], index);
	524	index = min_t(unsigned long, pg_end[i], end);
	525
	526	assert(voffset < index);
	527	for (; voffset < index; voffset++) {
	528	unsigned long pfn = task_pfn(voffset);
	529	if (pfn)
	530	walk_pfn(pfn, 1);
	531	}
	532	}
	533	}
534
535	static void add_addr_range(unsigned long offset, unsigned long size)
536	{
537	if (nr_addr_ranges >= MAX_ADDR_RANGES)
538	fatal("too many addr ranges\n");
539
540	opt_offset[nr_addr_ranges] = offset;
541	opt_size[nr_addr_ranges] = min_t(unsigned long, size, ULONG_MAX-offset);
542	nr_addr_ranges++;
543	}
544
b7ed698c	545	static void walk_addr_ranges(void)
35efa5e9 WF	546	{
	547	int i;
	548
31bbf66e	549	kpageflags_fd = checked_open(PROC_KPAGEFLAGS, O_RDONLY);
35efa5e9 WF	550
35efa5e9 WF	551	if (!nr_addr_ranges)
0b4b2ad5	552	add_addr_range(0, ULONG_MAX);
35efa5e9 WF	553
35efa5e9 WF	554	for (i = 0; i < nr_addr_ranges; i++)
0b4b2ad5 WF	555	if (!opt_pid)
	556	walk_pfn(opt_offset[i], opt_size[i]);
	557	else
	558	walk_task(opt_offset[i], opt_size[i]);
35efa5e9 WF	559
	560	close(kpageflags_fd);
	561	}
	562
	563
	564	/*
	565	* user interface
	566	*/
	567
b7ed698c	568	static const char *page_flag_type(uint64_t flag)
35efa5e9 WF	569	{
	570	if (flag & KPF_HACKERS_BITS)
	571	return "(r)";
	572	if (flag & KPF_OVERLOADED_BITS)
	573	return "(o)";
	574	return " ";
	575	}
	576
b7ed698c	577	static void usage(void)
35efa5e9 WF	578	{
	579	int i, j;
	580
	581	printf(
	582	"page-types [options]\n"
	583	" -r\|--raw Raw mode, for kernel developers\n"
	584	" -a\|--addr addr-spec Walk a range of pages\n"
	585	" -b\|--bits bits-spec Walk pages with specified bits\n"
35efa5e9	586	" -p\|--pid pid Walk process address space\n"
0b4b2ad5	587	#if 0 /* planned features */
35efa5e9 WF	588	" -f\|--file filename Walk file address space\n"
	589	#endif
	590	" -l\|--list Show page details in ranges\n"
	591	" -L\|--list-each Show page details one by one\n"
	592	" -N\|--no-summary Don't show summay info\n"
	593	" -h\|--help Show this usage message\n"
	594	"addr-spec:\n"
	595	" N one page at offset N (unit: pages)\n"
	596	" N+M pages range from N to N+M-1\n"
	597	" N,M pages range from N to M-1\n"
	598	" N, pages range from N to end\n"
0b4b2ad5	599	" ,M pages range from 0 to M-1\n"
35efa5e9 WF	600	"bits-spec:\n"
	601	" bit1,bit2 (flags & (bit1\|bit2)) != 0\n"
	602	" bit1,bit2=bit1 (flags & (bit1\|bit2)) == bit1\n"
	603	" bit1,~bit2 (flags & (bit1\|bit2)) == bit1\n"
	604	" =bit1,bit2 flags == (bit1\|bit2)\n"
	605	"bit-names:\n"
	606	);
	607
	608	for (i = 0, j = 0; i < ARRAY_SIZE(page_flag_names); i++) {
	609	if (!page_flag_names[i])
	610	continue;
	611	printf("%16s%s", page_flag_names[i] + 2,
	612	page_flag_type(1ULL << i));
	613	if (++j > 3) {
	614	j = 0;
	615	putchar('\n');
	616	}
	617	}
	618	printf("\n "
	619	"(r) raw mode bits (o) overloaded bits\n");
	620	}
	621
b7ed698c	622	static unsigned long long parse_number(const char *str)
35efa5e9 WF	623	{
	624	unsigned long long n;
	625
	626	n = strtoll(str, NULL, 0);
	627
	628	if (n == 0 && str[0] != '0')
	629	fatal("invalid name or number: %s\n", str);
	630
	631	return n;
	632	}
	633
b7ed698c	634	static void parse_pid(const char *str)
35efa5e9	635	{
0b4b2ad5 WF	636	FILE *file;
	637	char buf[5000];
	638
35efa5e9	639	opt_pid = parse_number(str);
35efa5e9	640
0b4b2ad5	641	sprintf(buf, "/proc/%d/pagemap", opt_pid);
31bbf66e	642	pagemap_fd = checked_open(buf, O_RDONLY);
0b4b2ad5 WF	643
	644	sprintf(buf, "/proc/%d/maps", opt_pid);
	645	file = fopen(buf, "r");
	646	if (!file) {
	647	perror(buf);
	648	exit(EXIT_FAILURE);
	649	}
	650
	651	while (fgets(buf, sizeof(buf), file) != NULL) {
	652	unsigned long vm_start;
	653	unsigned long vm_end;
	654	unsigned long long pgoff;
	655	int major, minor;
	656	char r, w, x, s;
	657	unsigned long ino;
	658	int n;
	659
	660	n = sscanf(buf, "%lx-%lx %c%c%c%c %llx %x:%x %lu",
	661	&vm_start,
	662	&vm_end,
	663	&r, &w, &x, &s,
	664	&pgoff,
	665	&major, &minor,
	666	&ino);
	667	if (n < 10) {
	668	fprintf(stderr, "unexpected line: %s\n", buf);
	669	continue;
	670	}
	671	pg_start[nr_vmas] = vm_start / page_size;
	672	pg_end[nr_vmas] = vm_end / page_size;
	673	if (++nr_vmas >= MAX_VMAS) {
	674	fprintf(stderr, "too many VMAs\n");
	675	break;
	676	}
	677	}
	678	fclose(file);
35efa5e9 WF	679	}
35efa5e9 WF	680
0b4b2ad5	681	static void parse_file(const char *name)
35efa5e9	682	{
35efa5e9 WF	683	}
35efa5e9 WF	684
b7ed698c	685	static void parse_addr_range(const char *optarg)
35efa5e9 WF	686	{
	687	unsigned long offset;
	688	unsigned long size;
	689	char *p;
	690
	691	p = strchr(optarg, ',');
	692	if (!p)
	693	p = strchr(optarg, '+');
	694
	695	if (p == optarg) {
	696	offset = 0;
	697	size = parse_number(p + 1);
	698	} else if (p) {
	699	offset = parse_number(optarg);
	700	if (p[1] == '\0')
	701	size = ULONG_MAX;
	702	else {
	703	size = parse_number(p + 1);
	704	if (*p == ',') {
	705	if (size < offset)
	706	fatal("invalid range: %lu,%lu\n",
	707	offset, size);
	708	size -= offset;
	709	}
	710	}
	711	} else {
	712	offset = parse_number(optarg);
	713	size = 1;
	714	}
	715
	716	add_addr_range(offset, size);
	717	}
	718
b7ed698c	719	static void add_bits_filter(uint64_t mask, uint64_t bits)
35efa5e9 WF	720	{
	721	if (nr_bit_filters >= MAX_BIT_FILTERS)
	722	fatal("too much bit filters\n");
	723
	724	opt_mask[nr_bit_filters] = mask;
	725	opt_bits[nr_bit_filters] = bits;
	726	nr_bit_filters++;
	727	}
	728
b7ed698c	729	static uint64_t parse_flag_name(const char *str, int len)
35efa5e9 WF	730	{
	731	int i;
	732
	733	if (!*str \|\| !len)
	734	return 0;
	735
	736	if (len <= 8 && !strncmp(str, "compound", len))
	737	return BITS_COMPOUND;
	738
	739	for (i = 0; i < ARRAY_SIZE(page_flag_names); i++) {
	740	if (!page_flag_names[i])
	741	continue;
	742	if (!strncmp(str, page_flag_names[i] + 2, len))
	743	return 1ULL << i;
	744	}
	745
	746	return parse_number(str);
	747	}
	748
b7ed698c	749	static uint64_t parse_flag_names(const char *str, int all)
35efa5e9 WF	750	{
	751	const char *p = str;
	752	uint64_t flags = 0;
	753
	754	while (1) {
	755	if (p == ',' \|\| p == '=' \|\| *p == '\0') {
	756	if ((str != '~') \|\| (str == '~' && all && *++str))
	757	flags \|= parse_flag_name(str, p - str);
	758	if (*p != ',')
	759	break;
	760	str = p + 1;
	761	}
	762	p++;
	763	}
	764
	765	return flags;
	766	}
	767
b7ed698c	768	static void parse_bits_mask(const char *optarg)
35efa5e9 WF	769	{
	770	uint64_t mask;
	771	uint64_t bits;
	772	const char *p;
	773
	774	p = strchr(optarg, '=');
	775	if (p == optarg) {
	776	mask = KPF_ALL_BITS;
	777	bits = parse_flag_names(p + 1, 0);
	778	} else if (p) {
	779	mask = parse_flag_names(optarg, 0);
	780	bits = parse_flag_names(p + 1, 0);
	781	} else if (strchr(optarg, '~')) {
	782	mask = parse_flag_names(optarg, 1);
	783	bits = parse_flag_names(optarg, 0);
	784	} else {
	785	mask = parse_flag_names(optarg, 0);
	786	bits = KPF_ALL_BITS;
	787	}
	788
	789	add_bits_filter(mask, bits);
	790	}
	791
	792
b7ed698c	793	static struct option opts[] = {
35efa5e9 WF	794	{ "raw" , 0, NULL, 'r' },
	795	{ "pid" , 1, NULL, 'p' },
	796	{ "file" , 1, NULL, 'f' },
	797	{ "addr" , 1, NULL, 'a' },
	798	{ "bits" , 1, NULL, 'b' },
	799	{ "list" , 0, NULL, 'l' },
	800	{ "list-each" , 0, NULL, 'L' },
	801	{ "no-summary", 0, NULL, 'N' },
	802	{ "help" , 0, NULL, 'h' },
	803	{ NULL , 0, NULL, 0 }
	804	};
	805
	806	int main(int argc, char *argv[])
	807	{
	808	int c;
	809
	810	page_size = getpagesize();
	811
	812	while ((c = getopt_long(argc, argv,
	813	"rp:f:a:b:lLNh", opts, NULL)) != -1) {
	814	switch (c) {
	815	case 'r':
	816	opt_raw = 1;
	817	break;
	818	case 'p':
	819	parse_pid(optarg);
	820	break;
	821	case 'f':
	822	parse_file(optarg);
	823	break;
	824	case 'a':
	825	parse_addr_range(optarg);
	826	break;
	827	case 'b':
	828	parse_bits_mask(optarg);
	829	break;
	830	case 'l':
	831	opt_list = 1;
	832	break;
	833	case 'L':
	834	opt_list = 2;
	835	break;
	836	case 'N':
	837	opt_no_summary = 1;
	838	break;
	839	case 'h':
	840	usage();
	841	exit(0);
	842	default:
	843	usage();
	844	exit(1);
	845	}
	846	}
	847
0b4b2ad5 WF	848	if (opt_list && opt_pid)
0b4b2ad5 WF	849	printf("voffset\t");
35efa5e9	850	if (opt_list == 1)
0b4b2ad5	851	printf("offset\tlen\tflags\n");
35efa5e9 WF	852	if (opt_list == 2)
	853	printf("offset\tflags\n");
	854
	855	walk_addr_ranges();
	856
	857	if (opt_list == 1)
	858	show_page_range(0, 0); /* drain the buffer */
	859
	860	if (opt_no_summary)
	861	return 0;
	862
	863	if (opt_list)
	864	printf("\n\n");
	865
	866	show_summary();
	867
	868	return 0;
	869	}