[deliverable/linux.git] / tools / perf / builtin-kmem.c

#include "builtin.h"
#include "perf.h"

#include "util/util.h"
#include "util/cache.h"
#include "util/symbol.h"
#include "util/thread.h"
#include "util/header.h"

#include "util/parse-options.h"
#include "util/trace-event.h"

#include "util/debug.h"
#include "util/data_map.h"

#include <linux/rbtree.h>

struct alloc_stat;
typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);

static char const		*input_name = "perf.data";

static struct perf_header	*header;
static u64			sample_type;

static int			alloc_flag;
static int			caller_flag;

static int			alloc_lines = -1;
static int			caller_lines = -1;

static bool			raw_ip;

static char			default_sort_order[] = "frag,hit,bytes";

static int			*cpunode_map;
static int			max_cpu_num;

struct alloc_stat {
	u64	call_site;
	u64	ptr;
	u64	bytes_req;
	u64	bytes_alloc;
	u32	hit;
	u32	pingpong;

	short	alloc_cpu;

	struct rb_node node;
};

static struct rb_root root_alloc_stat;
static struct rb_root root_alloc_sorted;
static struct rb_root root_caller_stat;
static struct rb_root root_caller_sorted;

static unsigned long total_requested, total_allocated;
static unsigned long nr_allocs, nr_cross_allocs;

#define PATH_SYS_NODE	"/sys/devices/system/node"

static void init_cpunode_map(void)
{
	FILE *fp;
	int i;

	fp = fopen("/sys/devices/system/cpu/kernel_max", "r");
	if (!fp) {
		max_cpu_num = 4096;
		return;
	}

	if (fscanf(fp, "%d", &max_cpu_num) < 1)
		die("Failed to read 'kernel_max' from sysfs");
	max_cpu_num++;

	cpunode_map = calloc(max_cpu_num, sizeof(int));
	if (!cpunode_map)
		die("calloc");
	for (i = 0; i < max_cpu_num; i++)
		cpunode_map[i] = -1;
	fclose(fp);
}

static void setup_cpunode_map(void)
{
	struct dirent *dent1, *dent2;
	DIR *dir1, *dir2;
	unsigned int cpu, mem;
	char buf[PATH_MAX];

	init_cpunode_map();

	dir1 = opendir(PATH_SYS_NODE);
	if (!dir1)
		return;

	while (true) {
		dent1 = readdir(dir1);
		if (!dent1)
			break;

		if (sscanf(dent1->d_name, "node%u", &mem) < 1)
			continue;

		snprintf(buf, PATH_MAX, "%s/%s", PATH_SYS_NODE, dent1->d_name);
		dir2 = opendir(buf);
		if (!dir2)
			continue;
		while (true) {
			dent2 = readdir(dir2);
			if (!dent2)
				break;
			if (sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
				continue;
			cpunode_map[cpu] = mem;
		}
	}
}

static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
			      int bytes_req, int bytes_alloc, int cpu)
{
	struct rb_node **node = &root_alloc_stat.rb_node;
	struct rb_node *parent = NULL;
	struct alloc_stat *data = NULL;

	while (*node) {
		parent = *node;
		data = rb_entry(*node, struct alloc_stat, node);

		if (ptr > data->ptr)
			node = &(*node)->rb_right;
		else if (ptr < data->ptr)
			node = &(*node)->rb_left;
		else
			break;
	}

	if (data && data->ptr == ptr) {
		data->hit++;
		data->bytes_req += bytes_req;
		data->bytes_alloc += bytes_req;
	} else {
		data = malloc(sizeof(*data));
		if (!data)
			die("malloc");
		data->ptr = ptr;
		data->pingpong = 0;
		data->hit = 1;
		data->bytes_req = bytes_req;
		data->bytes_alloc = bytes_alloc;

		rb_link_node(&data->node, parent, node);
		rb_insert_color(&data->node, &root_alloc_stat);
	}
	data->call_site = call_site;
	data->alloc_cpu = cpu;
}

static void insert_caller_stat(unsigned long call_site,
			      int bytes_req, int bytes_alloc)
{
	struct rb_node **node = &root_caller_stat.rb_node;
	struct rb_node *parent = NULL;
	struct alloc_stat *data = NULL;

	while (*node) {
		parent = *node;
		data = rb_entry(*node, struct alloc_stat, node);

		if (call_site > data->call_site)
			node = &(*node)->rb_right;
		else if (call_site < data->call_site)
			node = &(*node)->rb_left;
		else
			break;
	}

	if (data && data->call_site == call_site) {
		data->hit++;
		data->bytes_req += bytes_req;
		data->bytes_alloc += bytes_req;
	} else {
		data = malloc(sizeof(*data));
		if (!data)
			die("malloc");
		data->call_site = call_site;
		data->pingpong = 0;
		data->hit = 1;
		data->bytes_req = bytes_req;
		data->bytes_alloc = bytes_alloc;

		rb_link_node(&data->node, parent, node);
		rb_insert_color(&data->node, &root_caller_stat);
	}
}

static void process_alloc_event(void *data,
				struct event *event,
				int cpu,
				u64 timestamp __used,
				struct thread *thread __used,
				int node)
{
	unsigned long call_site;
	unsigned long ptr;
	int bytes_req;
	int bytes_alloc;
	int node1, node2;

	ptr = raw_field_value(event, "ptr", data);
	call_site = raw_field_value(event, "call_site", data);
	bytes_req = raw_field_value(event, "bytes_req", data);
	bytes_alloc = raw_field_value(event, "bytes_alloc", data);

	insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
	insert_caller_stat(call_site, bytes_req, bytes_alloc);

	total_requested += bytes_req;
	total_allocated += bytes_alloc;

	if (node) {
		node1 = cpunode_map[cpu];
		node2 = raw_field_value(event, "node", data);
		if (node1 != node2)
			nr_cross_allocs++;
	}
	nr_allocs++;
}

static int ptr_cmp(struct alloc_stat *, struct alloc_stat *);
static int callsite_cmp(struct alloc_stat *, struct alloc_stat *);

static struct alloc_stat *search_alloc_stat(unsigned long ptr,
					    unsigned long call_site,
					    struct rb_root *root,
					    sort_fn_t sort_fn)
{
	struct rb_node *node = root->rb_node;
	struct alloc_stat key = { .ptr = ptr, .call_site = call_site };

	while (node) {
		struct alloc_stat *data;
		int cmp;

		data = rb_entry(node, struct alloc_stat, node);

		cmp = sort_fn(&key, data);
		if (cmp < 0)
			node = node->rb_left;
		else if (cmp > 0)
			node = node->rb_right;
		else
			return data;
	}
	return NULL;
}

static void process_free_event(void *data,
			       struct event *event,
			       int cpu,
			       u64 timestamp __used,
			       struct thread *thread __used)
{
	unsigned long ptr;
	struct alloc_stat *s_alloc, *s_caller;

	ptr = raw_field_value(event, "ptr", data);

	s_alloc = search_alloc_stat(ptr, 0, &root_alloc_stat, ptr_cmp);
	if (!s_alloc)
		return;

	if (cpu != s_alloc->alloc_cpu) {
		s_alloc->pingpong++;

		s_caller = search_alloc_stat(0, s_alloc->call_site,
					     &root_caller_stat, callsite_cmp);
		assert(s_caller);
		s_caller->pingpong++;
	}
	s_alloc->alloc_cpu = -1;
}

static void
process_raw_event(event_t *raw_event __used, void *data,
		  int cpu, u64 timestamp, struct thread *thread)
{
	struct event *event;
	int type;

	type = trace_parse_common_type(data);
	event = trace_find_event(type);

	if (!strcmp(event->name, "kmalloc") ||
	    !strcmp(event->name, "kmem_cache_alloc")) {
		process_alloc_event(data, event, cpu, timestamp, thread, 0);
		return;
	}

	if (!strcmp(event->name, "kmalloc_node") ||
	    !strcmp(event->name, "kmem_cache_alloc_node")) {
		process_alloc_event(data, event, cpu, timestamp, thread, 1);
		return;
	}

	if (!strcmp(event->name, "kfree") ||
	    !strcmp(event->name, "kmem_cache_free")) {
		process_free_event(data, event, cpu, timestamp, thread);
		return;
	}
}

static int process_sample_event(event_t *event)
{
	struct sample_data data;
	struct thread *thread;

	memset(&data, 0, sizeof(data));
	data.time = -1;
	data.cpu = -1;
	data.period = 1;

	event__parse_sample(event, sample_type, &data);

	dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
		event->header.misc,
		data.pid, data.tid,
		(void *)(long)data.ip,
		(long long)data.period);

	thread = threads__findnew(event->ip.pid);
	if (thread == NULL) {
		pr_debug("problem processing %d event, skipping it.\n",
			 event->header.type);
		return -1;
	}

	dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);

	process_raw_event(event, data.raw_data, data.cpu,
			  data.time, thread);

	return 0;
}

static int sample_type_check(u64 type)
{
	sample_type = type;

	if (!(sample_type & PERF_SAMPLE_RAW)) {
		fprintf(stderr,
			"No trace sample to read. Did you call perf record "
			"without -R?");
		return -1;
	}

	return 0;
}

static struct perf_file_handler file_handler = {
	.process_sample_event	= process_sample_event,
	.process_comm_event	= event__process_comm,
	.sample_type_check	= sample_type_check,
};

static int read_events(void)
{
	register_idle_thread();
	register_perf_file_handler(&file_handler);

	return mmap_dispatch_perf_file(&header, input_name, 0, 0,
				       &event__cwdlen, &event__cwd);
}

static double fragmentation(unsigned long n_req, unsigned long n_alloc)
{
	if (n_alloc == 0)
		return 0.0;
	else
		return 100.0 - (100.0 * n_req / n_alloc);
}

static void __print_result(struct rb_root *root, int n_lines, int is_caller)
{
	struct rb_node *next;

	printf("%.102s\n", graph_dotted_line);
	printf(" %-34s |",  is_caller ? "Callsite": "Alloc Ptr");
	printf(" Total_alloc/Per | Total_req/Per   | Hit   | Ping-pong | Frag\n");
	printf("%.102s\n", graph_dotted_line);

	next = rb_first(root);

	while (next && n_lines--) {
		struct alloc_stat *data = rb_entry(next, struct alloc_stat,
						   node);
		struct symbol *sym = NULL;
		char buf[BUFSIZ];
		u64 addr;

		if (is_caller) {
			addr = data->call_site;
			if (!raw_ip)
				sym = thread__find_function(kthread, addr, NULL);
		} else
			addr = data->ptr;

		if (sym != NULL)
			snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
				 addr - sym->start);
		else
			snprintf(buf, sizeof(buf), "%#Lx", addr);
		printf(" %-34s |", buf);

		printf(" %9llu/%-5lu | %9llu/%-5lu | %6lu | %8lu | %6.3f%%\n",
		       (unsigned long long)data->bytes_alloc,
		       (unsigned long)data->bytes_alloc / data->hit,
		       (unsigned long long)data->bytes_req,
		       (unsigned long)data->bytes_req / data->hit,
		       (unsigned long)data->hit,
		       (unsigned long)data->pingpong,
		       fragmentation(data->bytes_req, data->bytes_alloc));

		next = rb_next(next);
	}

	if (n_lines == -1)
		printf(" ...                                | ...             | ...             | ...    | ...      | ...   \n");

	printf("%.102s\n", graph_dotted_line);
}

static void print_summary(void)
{
	printf("\nSUMMARY\n=======\n");
	printf("Total bytes requested: %lu\n", total_requested);
	printf("Total bytes allocated: %lu\n", total_allocated);
	printf("Total bytes wasted on internal fragmentation: %lu\n",
	       total_allocated - total_requested);
	printf("Internal fragmentation: %f%%\n",
	       fragmentation(total_requested, total_allocated));
	printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
}

static void print_result(void)
{
	if (caller_flag)
		__print_result(&root_caller_sorted, caller_lines, 1);
	if (alloc_flag)
		__print_result(&root_alloc_sorted, alloc_lines, 0);
	print_summary();
}

struct sort_dimension {
	const char		name[20];
	sort_fn_t		cmp;
	struct list_head	list;
};

static LIST_HEAD(caller_sort);
static LIST_HEAD(alloc_sort);

static void sort_insert(struct rb_root *root, struct alloc_stat *data,
			struct list_head *sort_list)
{
	struct rb_node **new = &(root->rb_node);
	struct rb_node *parent = NULL;
	struct sort_dimension *sort;

	while (*new) {
		struct alloc_stat *this;
		int cmp = 0;

		this = rb_entry(*new, struct alloc_stat, node);
		parent = *new;

		list_for_each_entry(sort, sort_list, list) {
			cmp = sort->cmp(data, this);
			if (cmp)
				break;
		}

		if (cmp > 0)
			new = &((*new)->rb_left);
		else
			new = &((*new)->rb_right);
	}

	rb_link_node(&data->node, parent, new);
	rb_insert_color(&data->node, root);
}

static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
			  struct list_head *sort_list)
{
	struct rb_node *node;
	struct alloc_stat *data;

	for (;;) {
		node = rb_first(root);
		if (!node)
			break;

		rb_erase(node, root);
		data = rb_entry(node, struct alloc_stat, node);
		sort_insert(root_sorted, data, sort_list);
	}
}

static void sort_result(void)
{
	__sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
	__sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
}

static int __cmd_kmem(void)
{
	setup_pager();
	read_events();
	sort_result();
	print_result();

	return 0;
}

static const char * const kmem_usage[] = {
	"perf kmem [<options>] {record|stat}",
	NULL
};

static int ptr_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	if (l->ptr < r->ptr)
		return -1;
	else if (l->ptr > r->ptr)
		return 1;
	return 0;
}

static struct sort_dimension ptr_sort_dimension = {
	.name	= "ptr",
	.cmp	= ptr_cmp,
};

static int callsite_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	if (l->call_site < r->call_site)
		return -1;
	else if (l->call_site > r->call_site)
		return 1;
	return 0;
}

static struct sort_dimension callsite_sort_dimension = {
	.name	= "callsite",
	.cmp	= callsite_cmp,
};

static int hit_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	if (l->hit < r->hit)
		return -1;
	else if (l->hit > r->hit)
		return 1;
	return 0;
}

static struct sort_dimension hit_sort_dimension = {
	.name	= "hit",
	.cmp	= hit_cmp,
};

static int bytes_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	if (l->bytes_alloc < r->bytes_alloc)
		return -1;
	else if (l->bytes_alloc > r->bytes_alloc)
		return 1;
	return 0;
}

static struct sort_dimension bytes_sort_dimension = {
	.name	= "bytes",
	.cmp	= bytes_cmp,
};

static int frag_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	double x, y;

	x = fragmentation(l->bytes_req, l->bytes_alloc);
	y = fragmentation(r->bytes_req, r->bytes_alloc);

	if (x < y)
		return -1;
	else if (x > y)
		return 1;
	return 0;
}

static struct sort_dimension frag_sort_dimension = {
	.name	= "frag",
	.cmp	= frag_cmp,
};

static int pingpong_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	if (l->pingpong < r->pingpong)
		return -1;
	else if (l->pingpong > r->pingpong)
		return 1;
	return 0;
}

static struct sort_dimension pingpong_sort_dimension = {
	.name	= "pingpong",
	.cmp	= pingpong_cmp,
};

static struct sort_dimension *avail_sorts[] = {
	&ptr_sort_dimension,
	&callsite_sort_dimension,
	&hit_sort_dimension,
	&bytes_sort_dimension,
	&frag_sort_dimension,
	&pingpong_sort_dimension,
};

#define NUM_AVAIL_SORTS	\
	(int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))

static int sort_dimension__add(const char *tok, struct list_head *list)
{
	struct sort_dimension *sort;
	int i;

	for (i = 0; i < NUM_AVAIL_SORTS; i++) {
		if (!strcmp(avail_sorts[i]->name, tok)) {
			sort = malloc(sizeof(*sort));
			if (!sort)
				die("malloc");
			memcpy(sort, avail_sorts[i], sizeof(*sort));
			list_add_tail(&sort->list, list);
			return 0;
		}
	}

	return -1;
}

static int setup_sorting(struct list_head *sort_list, const char *arg)
{
	char *tok;
	char *str = strdup(arg);

	if (!str)
		die("strdup");

	while (true) {
		tok = strsep(&str, ",");
		if (!tok)
			break;
		if (sort_dimension__add(tok, sort_list) < 0) {
			error("Unknown --sort key: '%s'", tok);
			return -1;
		}
	}

	free(str);
	return 0;
}

static int parse_sort_opt(const struct option *opt __used,
			  const char *arg, int unset __used)
{
	if (!arg)
		return -1;

	if (caller_flag > alloc_flag)
		return setup_sorting(&caller_sort, arg);
	else
		return setup_sorting(&alloc_sort, arg);

	return 0;
}

static int parse_caller_opt(const struct option *opt __used,
			  const char *arg __used, int unset __used)
{
	caller_flag = (alloc_flag + 1);
	return 0;
}

static int parse_alloc_opt(const struct option *opt __used,
			  const char *arg __used, int unset __used)
{
	alloc_flag = (caller_flag + 1);
	return 0;
}

static int parse_line_opt(const struct option *opt __used,
			  const char *arg, int unset __used)
{
	int lines;

	if (!arg)
		return -1;

	lines = strtoul(arg, NULL, 10);

	if (caller_flag > alloc_flag)
		caller_lines = lines;
	else
		alloc_lines = lines;

	return 0;
}

static const struct option kmem_options[] = {
	OPT_STRING('i', "input", &input_name, "file",
		   "input file name"),
	OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
			   "show per-callsite statistics",
			   parse_caller_opt),
	OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
			   "show per-allocation statistics",
			   parse_alloc_opt),
	OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
		     "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
		     parse_sort_opt),
	OPT_CALLBACK('l', "line", NULL, "num",
		     "show n lines",
		     parse_line_opt),
	OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
	OPT_END()
};

static const char *record_args[] = {
	"record",
	"-a",
	"-R",
	"-M",
	"-f",
	"-c", "1",
	"-e", "kmem:kmalloc",
	"-e", "kmem:kmalloc_node",
	"-e", "kmem:kfree",
	"-e", "kmem:kmem_cache_alloc",
	"-e", "kmem:kmem_cache_alloc_node",
	"-e", "kmem:kmem_cache_free",
};

static int __cmd_record(int argc, const char **argv)
{
	unsigned int rec_argc, i, j;
	const char **rec_argv;

	rec_argc = ARRAY_SIZE(record_args) + argc - 1;
	rec_argv = calloc(rec_argc + 1, sizeof(char *));

	for (i = 0; i < ARRAY_SIZE(record_args); i++)
		rec_argv[i] = strdup(record_args[i]);

	for (j = 1; j < (unsigned int)argc; j++, i++)
		rec_argv[i] = argv[j];

	return cmd_record(i, rec_argv, NULL);
}

int cmd_kmem(int argc, const char **argv, const char *prefix __used)
{
	symbol__init(0);

	argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);

	if (!argc)
		usage_with_options(kmem_usage, kmem_options);

	if (!strncmp(argv[0], "rec", 3)) {
		return __cmd_record(argc, argv);
	} else if (!strcmp(argv[0], "stat")) {
		setup_cpunode_map();

		if (list_empty(&caller_sort))
			setup_sorting(&caller_sort, default_sort_order);
		if (list_empty(&alloc_sort))
			setup_sorting(&alloc_sort, default_sort_order);

		return __cmd_kmem();
	}

	return 0;
}
Commit	Line	Data
ba77c9e1 LZ	1	#include "builtin.h"
	2	#include "perf.h"
	3
	4	#include "util/util.h"
	5	#include "util/cache.h"
	6	#include "util/symbol.h"
	7	#include "util/thread.h"
	8	#include "util/header.h"
	9
	10	#include "util/parse-options.h"
	11	#include "util/trace-event.h"
	12
	13	#include "util/debug.h"
	14	#include "util/data_map.h"
	15
	16	#include <linux/rbtree.h>
	17
	18	struct alloc_stat;
	19	typedef int (sort_fn_t)(struct alloc_stat , struct alloc_stat *);
	20
	21	static char const *input_name = "perf.data";
	22
	23	static struct perf_header *header;
	24	static u64 sample_type;
	25
	26	static int alloc_flag;
	27	static int caller_flag;
	28
ba77c9e1 LZ	29	static int alloc_lines = -1;
	30	static int caller_lines = -1;
	31
7707b6b6 LZ	32	static bool raw_ip;
7707b6b6 LZ	33
29b3e152 LZ	34	static char default_sort_order[] = "frag,hit,bytes";
29b3e152 LZ	35
7d0d3945 LZ	36	static int *cpunode_map;
	37	static int max_cpu_num;
	38
ba77c9e1	39	struct alloc_stat {
079d3f65 LZ	40	u64 call_site;
079d3f65 LZ	41	u64 ptr;
ba77c9e1 LZ	42	u64 bytes_req;
	43	u64 bytes_alloc;
	44	u32 hit;
079d3f65 LZ	45	u32 pingpong;
	46
	47	short alloc_cpu;
ba77c9e1 LZ	48
	49	struct rb_node node;
	50	};
	51
	52	static struct rb_root root_alloc_stat;
	53	static struct rb_root root_alloc_sorted;
	54	static struct rb_root root_caller_stat;
	55	static struct rb_root root_caller_sorted;
	56
	57	static unsigned long total_requested, total_allocated;
7d0d3945	58	static unsigned long nr_allocs, nr_cross_allocs;
ba77c9e1	59
7d0d3945 LZ	60	#define PATH_SYS_NODE "/sys/devices/system/node"
	61
	62	static void init_cpunode_map(void)
	63	{
	64	FILE *fp;
	65	int i;
	66
	67	fp = fopen("/sys/devices/system/cpu/kernel_max", "r");
	68	if (!fp) {
	69	max_cpu_num = 4096;
	70	return;
	71	}
	72
	73	if (fscanf(fp, "%d", &max_cpu_num) < 1)
	74	die("Failed to read 'kernel_max' from sysfs");
	75	max_cpu_num++;
	76
	77	cpunode_map = calloc(max_cpu_num, sizeof(int));
	78	if (!cpunode_map)
	79	die("calloc");
	80	for (i = 0; i < max_cpu_num; i++)
	81	cpunode_map[i] = -1;
	82	fclose(fp);
	83	}
	84
	85	static void setup_cpunode_map(void)
	86	{
	87	struct dirent dent1, dent2;
	88	DIR dir1, dir2;
	89	unsigned int cpu, mem;
	90	char buf[PATH_MAX];
	91
	92	init_cpunode_map();
	93
	94	dir1 = opendir(PATH_SYS_NODE);
	95	if (!dir1)
	96	return;
	97
	98	while (true) {
	99	dent1 = readdir(dir1);
	100	if (!dent1)
	101	break;
	102
	103	if (sscanf(dent1->d_name, "node%u", &mem) < 1)
	104	continue;
	105
	106	snprintf(buf, PATH_MAX, "%s/%s", PATH_SYS_NODE, dent1->d_name);
	107	dir2 = opendir(buf);
	108	if (!dir2)
	109	continue;
	110	while (true) {
	111	dent2 = readdir(dir2);
	112	if (!dent2)
	113	break;
	114	if (sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
	115	continue;
	116	cpunode_map[cpu] = mem;
	117	}
	118	}
	119	}
	120
079d3f65 LZ	121	static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
079d3f65 LZ	122	int bytes_req, int bytes_alloc, int cpu)
ba77c9e1 LZ	123	{
	124	struct rb_node **node = &root_alloc_stat.rb_node;
	125	struct rb_node *parent = NULL;
	126	struct alloc_stat *data = NULL;
	127
ba77c9e1 LZ	128	while (*node) {
	129	parent = *node;
	130	data = rb_entry(*node, struct alloc_stat, node);
	131
	132	if (ptr > data->ptr)
	133	node = &(*node)->rb_right;
	134	else if (ptr < data->ptr)
	135	node = &(*node)->rb_left;
	136	else
	137	break;
	138	}
	139
	140	if (data && data->ptr == ptr) {
	141	data->hit++;
	142	data->bytes_req += bytes_req;
	143	data->bytes_alloc += bytes_req;
	144	} else {
	145	data = malloc(sizeof(*data));
079d3f65 LZ	146	if (!data)
079d3f65 LZ	147	die("malloc");
ba77c9e1	148	data->ptr = ptr;
079d3f65	149	data->pingpong = 0;
ba77c9e1 LZ	150	data->hit = 1;
	151	data->bytes_req = bytes_req;
	152	data->bytes_alloc = bytes_alloc;
	153
	154	rb_link_node(&data->node, parent, node);
	155	rb_insert_color(&data->node, &root_alloc_stat);
	156	}
079d3f65 LZ	157	data->call_site = call_site;
079d3f65 LZ	158	data->alloc_cpu = cpu;
ba77c9e1 LZ	159	}
	160
	161	static void insert_caller_stat(unsigned long call_site,
	162	int bytes_req, int bytes_alloc)
	163	{
	164	struct rb_node **node = &root_caller_stat.rb_node;
	165	struct rb_node *parent = NULL;
	166	struct alloc_stat *data = NULL;
	167
ba77c9e1 LZ	168	while (*node) {
	169	parent = *node;
	170	data = rb_entry(*node, struct alloc_stat, node);
	171
	172	if (call_site > data->call_site)
	173	node = &(*node)->rb_right;
	174	else if (call_site < data->call_site)
	175	node = &(*node)->rb_left;
	176	else
	177	break;
	178	}
	179
	180	if (data && data->call_site == call_site) {
	181	data->hit++;
	182	data->bytes_req += bytes_req;
	183	data->bytes_alloc += bytes_req;
	184	} else {
	185	data = malloc(sizeof(*data));
079d3f65 LZ	186	if (!data)
079d3f65 LZ	187	die("malloc");
ba77c9e1	188	data->call_site = call_site;
079d3f65	189	data->pingpong = 0;
ba77c9e1 LZ	190	data->hit = 1;
	191	data->bytes_req = bytes_req;
	192	data->bytes_alloc = bytes_alloc;
	193
	194	rb_link_node(&data->node, parent, node);
	195	rb_insert_color(&data->node, &root_caller_stat);
	196	}
	197	}
	198
f48f669d	199	static void process_alloc_event(void *data,
ba77c9e1	200	struct event *event,
7d0d3945	201	int cpu,
ba77c9e1 LZ	202	u64 timestamp __used,
ba77c9e1 LZ	203	struct thread *thread __used,
7d0d3945	204	int node)
ba77c9e1 LZ	205	{
	206	unsigned long call_site;
	207	unsigned long ptr;
	208	int bytes_req;
	209	int bytes_alloc;
7d0d3945	210	int node1, node2;
ba77c9e1	211
f48f669d XG	212	ptr = raw_field_value(event, "ptr", data);
	213	call_site = raw_field_value(event, "call_site", data);
	214	bytes_req = raw_field_value(event, "bytes_req", data);
	215	bytes_alloc = raw_field_value(event, "bytes_alloc", data);
ba77c9e1	216
079d3f65	217	insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
ba77c9e1 LZ	218	insert_caller_stat(call_site, bytes_req, bytes_alloc);
	219
	220	total_requested += bytes_req;
	221	total_allocated += bytes_alloc;
7d0d3945 LZ	222
	223	if (node) {
	224	node1 = cpunode_map[cpu];
f48f669d	225	node2 = raw_field_value(event, "node", data);
7d0d3945 LZ	226	if (node1 != node2)
	227	nr_cross_allocs++;
	228	}
	229	nr_allocs++;
ba77c9e1 LZ	230	}
ba77c9e1 LZ	231
079d3f65 LZ	232	static int ptr_cmp(struct alloc_stat , struct alloc_stat );
	233	static int callsite_cmp(struct alloc_stat , struct alloc_stat );
	234
	235	static struct alloc_stat *search_alloc_stat(unsigned long ptr,
	236	unsigned long call_site,
	237	struct rb_root *root,
	238	sort_fn_t sort_fn)
	239	{
	240	struct rb_node *node = root->rb_node;
	241	struct alloc_stat key = { .ptr = ptr, .call_site = call_site };
	242
	243	while (node) {
	244	struct alloc_stat *data;
	245	int cmp;
	246
	247	data = rb_entry(node, struct alloc_stat, node);
	248
	249	cmp = sort_fn(&key, data);
	250	if (cmp < 0)
	251	node = node->rb_left;
	252	else if (cmp > 0)
	253	node = node->rb_right;
	254	else
	255	return data;
	256	}
	257	return NULL;
	258	}
	259
f48f669d	260	static void process_free_event(void *data,
079d3f65 LZ	261	struct event *event,
079d3f65 LZ	262	int cpu,
ba77c9e1 LZ	263	u64 timestamp __used,
	264	struct thread *thread __used)
	265	{
079d3f65 LZ	266	unsigned long ptr;
	267	struct alloc_stat s_alloc, s_caller;
	268
f48f669d	269	ptr = raw_field_value(event, "ptr", data);
079d3f65 LZ	270
	271	s_alloc = search_alloc_stat(ptr, 0, &root_alloc_stat, ptr_cmp);
	272	if (!s_alloc)
	273	return;
	274
	275	if (cpu != s_alloc->alloc_cpu) {
	276	s_alloc->pingpong++;
	277
	278	s_caller = search_alloc_stat(0, s_alloc->call_site,
	279	&root_caller_stat, callsite_cmp);
	280	assert(s_caller);
	281	s_caller->pingpong++;
	282	}
	283	s_alloc->alloc_cpu = -1;
ba77c9e1 LZ	284	}
	285
	286	static void
f48f669d	287	process_raw_event(event_t raw_event __used, void data,
ba77c9e1 LZ	288	int cpu, u64 timestamp, struct thread *thread)
ba77c9e1 LZ	289	{
ba77c9e1 LZ	290	struct event *event;
	291	int type;
	292
f48f669d	293	type = trace_parse_common_type(data);
ba77c9e1 LZ	294	event = trace_find_event(type);
	295
	296	if (!strcmp(event->name, "kmalloc") \|\|
	297	!strcmp(event->name, "kmem_cache_alloc")) {
f48f669d	298	process_alloc_event(data, event, cpu, timestamp, thread, 0);
ba77c9e1 LZ	299	return;
	300	}
	301
	302	if (!strcmp(event->name, "kmalloc_node") \|\|
	303	!strcmp(event->name, "kmem_cache_alloc_node")) {
f48f669d	304	process_alloc_event(data, event, cpu, timestamp, thread, 1);
ba77c9e1 LZ	305	return;
	306	}
	307
	308	if (!strcmp(event->name, "kfree") \|\|
	309	!strcmp(event->name, "kmem_cache_free")) {
f48f669d	310	process_free_event(data, event, cpu, timestamp, thread);
ba77c9e1 LZ	311	return;
	312	}
	313	}
	314
62daacb5	315	static int process_sample_event(event_t *event)
ba77c9e1	316	{
180f95e2 OH	317	struct sample_data data;
180f95e2 OH	318	struct thread *thread;
ba77c9e1	319
180f95e2 OH	320	memset(&data, 0, sizeof(data));
	321	data.time = -1;
	322	data.cpu = -1;
	323	data.period = 1;
ba77c9e1	324
180f95e2	325	event__parse_sample(event, sample_type, &data);
ba77c9e1	326
62daacb5	327	dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
ba77c9e1	328	event->header.misc,
180f95e2 OH	329	data.pid, data.tid,
	330	(void *)(long)data.ip,
	331	(long long)data.period);
ba77c9e1	332
180f95e2	333	thread = threads__findnew(event->ip.pid);
ba77c9e1 LZ	334	if (thread == NULL) {
	335	pr_debug("problem processing %d event, skipping it.\n",
	336	event->header.type);
	337	return -1;
	338	}
	339
	340	dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
	341
f48f669d	342	process_raw_event(event, data.raw_data, data.cpu,
d8bd9e0a	343	data.time, thread);
ba77c9e1 LZ	344
	345	return 0;
	346	}
	347
	348	static int sample_type_check(u64 type)
	349	{
	350	sample_type = type;
	351
	352	if (!(sample_type & PERF_SAMPLE_RAW)) {
	353	fprintf(stderr,
	354	"No trace sample to read. Did you call perf record "
	355	"without -R?");
	356	return -1;
	357	}
	358
	359	return 0;
	360	}
	361
	362	static struct perf_file_handler file_handler = {
	363	.process_sample_event = process_sample_event,
62daacb5	364	.process_comm_event = event__process_comm,
ba77c9e1 LZ	365	.sample_type_check = sample_type_check,
	366	};
	367
	368	static int read_events(void)
	369	{
	370	register_idle_thread();
	371	register_perf_file_handler(&file_handler);
	372
b32d133a	373	return mmap_dispatch_perf_file(&header, input_name, 0, 0,
62daacb5	374	&event__cwdlen, &event__cwd);
ba77c9e1 LZ	375	}
	376
	377	static double fragmentation(unsigned long n_req, unsigned long n_alloc)
	378	{
	379	if (n_alloc == 0)
	380	return 0.0;
	381	else
	382	return 100.0 - (100.0 * n_req / n_alloc);
	383	}
	384
	385	static void __print_result(struct rb_root *root, int n_lines, int is_caller)
	386	{
	387	struct rb_node *next;
	388
079d3f65 LZ	389	printf("%.102s\n", graph_dotted_line);
	390	printf(" %-34s \|", is_caller ? "Callsite": "Alloc Ptr");
	391	printf(" Total_alloc/Per \| Total_req/Per \| Hit \| Ping-pong \| Frag\n");
	392	printf("%.102s\n", graph_dotted_line);
ba77c9e1 LZ	393
	394	next = rb_first(root);
	395
	396	while (next && n_lines--) {
1b145ae5 ACM	397	struct alloc_stat *data = rb_entry(next, struct alloc_stat,
	398	node);
	399	struct symbol *sym = NULL;
079d3f65	400	char buf[BUFSIZ];
1b145ae5 ACM	401	u64 addr;
	402
	403	if (is_caller) {
	404	addr = data->call_site;
7707b6b6	405	if (!raw_ip)
1ed091c4	406	sym = thread__find_function(kthread, addr, NULL);
1b145ae5 ACM	407	} else
	408	addr = data->ptr;
	409
	410	if (sym != NULL)
079d3f65	411	snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
1b145ae5 ACM	412	addr - sym->start);
1b145ae5 ACM	413	else
079d3f65 LZ	414	snprintf(buf, sizeof(buf), "%#Lx", addr);
079d3f65 LZ	415	printf(" %-34s \|", buf);
ba77c9e1	416
079d3f65 LZ	417	printf(" %9llu/%-5lu \| %9llu/%-5lu \| %6lu \| %8lu \| %6.3f%%\n",
079d3f65 LZ	418	(unsigned long long)data->bytes_alloc,
ba77c9e1 LZ	419	(unsigned long)data->bytes_alloc / data->hit,
	420	(unsigned long long)data->bytes_req,
	421	(unsigned long)data->bytes_req / data->hit,
	422	(unsigned long)data->hit,
079d3f65	423	(unsigned long)data->pingpong,
ba77c9e1 LZ	424	fragmentation(data->bytes_req, data->bytes_alloc));
	425
	426	next = rb_next(next);
	427	}
	428
	429	if (n_lines == -1)
079d3f65	430	printf(" ... \| ... \| ... \| ... \| ... \| ... \n");
ba77c9e1	431
079d3f65	432	printf("%.102s\n", graph_dotted_line);
ba77c9e1 LZ	433	}
	434
	435	static void print_summary(void)
	436	{
	437	printf("\nSUMMARY\n=======\n");
	438	printf("Total bytes requested: %lu\n", total_requested);
	439	printf("Total bytes allocated: %lu\n", total_allocated);
	440	printf("Total bytes wasted on internal fragmentation: %lu\n",
	441	total_allocated - total_requested);
	442	printf("Internal fragmentation: %f%%\n",
	443	fragmentation(total_requested, total_allocated));
7d0d3945	444	printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
ba77c9e1 LZ	445	}
	446
	447	static void print_result(void)
	448	{
	449	if (caller_flag)
	450	__print_result(&root_caller_sorted, caller_lines, 1);
	451	if (alloc_flag)
	452	__print_result(&root_alloc_sorted, alloc_lines, 0);
	453	print_summary();
	454	}
	455
29b3e152 LZ	456	struct sort_dimension {
	457	const char name[20];
	458	sort_fn_t cmp;
	459	struct list_head list;
	460	};
	461
	462	static LIST_HEAD(caller_sort);
	463	static LIST_HEAD(alloc_sort);
	464
ba77c9e1	465	static void sort_insert(struct rb_root root, struct alloc_stat data,
29b3e152	466	struct list_head *sort_list)
ba77c9e1 LZ	467	{
	468	struct rb_node **new = &(root->rb_node);
	469	struct rb_node *parent = NULL;
29b3e152	470	struct sort_dimension *sort;
ba77c9e1 LZ	471
	472	while (*new) {
	473	struct alloc_stat *this;
29b3e152	474	int cmp = 0;
ba77c9e1 LZ	475
	476	this = rb_entry(*new, struct alloc_stat, node);
	477	parent = *new;
	478
29b3e152 LZ	479	list_for_each_entry(sort, sort_list, list) {
	480	cmp = sort->cmp(data, this);
	481	if (cmp)
	482	break;
	483	}
ba77c9e1 LZ	484
	485	if (cmp > 0)
	486	new = &((*new)->rb_left);
	487	else
	488	new = &((*new)->rb_right);
	489	}
	490
	491	rb_link_node(&data->node, parent, new);
	492	rb_insert_color(&data->node, root);
	493	}
	494
	495	static void __sort_result(struct rb_root root, struct rb_root root_sorted,
29b3e152	496	struct list_head *sort_list)
ba77c9e1 LZ	497	{
	498	struct rb_node *node;
	499	struct alloc_stat *data;
	500
	501	for (;;) {
	502	node = rb_first(root);
	503	if (!node)
	504	break;
	505
	506	rb_erase(node, root);
	507	data = rb_entry(node, struct alloc_stat, node);
29b3e152	508	sort_insert(root_sorted, data, sort_list);
ba77c9e1 LZ	509	}
	510	}
	511
	512	static void sort_result(void)
	513	{
29b3e152 LZ	514	__sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
29b3e152 LZ	515	__sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
ba77c9e1 LZ	516	}
	517
	518	static int __cmd_kmem(void)
	519	{
	520	setup_pager();
	521	read_events();
	522	sort_result();
	523	print_result();
	524
	525	return 0;
	526	}
	527
	528	static const char * const kmem_usage[] = {
90b86a9f	529	"perf kmem [<options>] {record\|stat}",
ba77c9e1 LZ	530	NULL
	531	};
	532
ba77c9e1 LZ	533	static int ptr_cmp(struct alloc_stat l, struct alloc_stat r)
	534	{
	535	if (l->ptr < r->ptr)
	536	return -1;
	537	else if (l->ptr > r->ptr)
	538	return 1;
	539	return 0;
	540	}
	541
29b3e152 LZ	542	static struct sort_dimension ptr_sort_dimension = {
	543	.name = "ptr",
	544	.cmp = ptr_cmp,
	545	};
	546
ba77c9e1 LZ	547	static int callsite_cmp(struct alloc_stat l, struct alloc_stat r)
	548	{
	549	if (l->call_site < r->call_site)
	550	return -1;
	551	else if (l->call_site > r->call_site)
	552	return 1;
	553	return 0;
	554	}
	555
29b3e152 LZ	556	static struct sort_dimension callsite_sort_dimension = {
	557	.name = "callsite",
	558	.cmp = callsite_cmp,
	559	};
	560
f3ced7cd PE	561	static int hit_cmp(struct alloc_stat l, struct alloc_stat r)
	562	{
	563	if (l->hit < r->hit)
	564	return -1;
	565	else if (l->hit > r->hit)
	566	return 1;
	567	return 0;
	568	}
	569
29b3e152 LZ	570	static struct sort_dimension hit_sort_dimension = {
	571	.name = "hit",
	572	.cmp = hit_cmp,
	573	};
	574
ba77c9e1 LZ	575	static int bytes_cmp(struct alloc_stat l, struct alloc_stat r)
	576	{
	577	if (l->bytes_alloc < r->bytes_alloc)
	578	return -1;
	579	else if (l->bytes_alloc > r->bytes_alloc)
	580	return 1;
	581	return 0;
	582	}
	583
29b3e152 LZ	584	static struct sort_dimension bytes_sort_dimension = {
	585	.name = "bytes",
	586	.cmp = bytes_cmp,
	587	};
	588
f3ced7cd PE	589	static int frag_cmp(struct alloc_stat l, struct alloc_stat r)
	590	{
	591	double x, y;
	592
	593	x = fragmentation(l->bytes_req, l->bytes_alloc);
	594	y = fragmentation(r->bytes_req, r->bytes_alloc);
	595
	596	if (x < y)
	597	return -1;
	598	else if (x > y)
	599	return 1;
	600	return 0;
	601	}
	602
29b3e152 LZ	603	static struct sort_dimension frag_sort_dimension = {
	604	.name = "frag",
	605	.cmp = frag_cmp,
	606	};
	607
079d3f65 LZ	608	static int pingpong_cmp(struct alloc_stat l, struct alloc_stat r)
	609	{
	610	if (l->pingpong < r->pingpong)
	611	return -1;
	612	else if (l->pingpong > r->pingpong)
	613	return 1;
	614	return 0;
	615	}
	616
	617	static struct sort_dimension pingpong_sort_dimension = {
	618	.name = "pingpong",
	619	.cmp = pingpong_cmp,
	620	};
	621
29b3e152 LZ	622	static struct sort_dimension *avail_sorts[] = {
	623	&ptr_sort_dimension,
	624	&callsite_sort_dimension,
	625	&hit_sort_dimension,
	626	&bytes_sort_dimension,
	627	&frag_sort_dimension,
079d3f65	628	&pingpong_sort_dimension,
29b3e152 LZ	629	};
	630
	631	#define NUM_AVAIL_SORTS \
	632	(int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
	633
	634	static int sort_dimension__add(const char tok, struct list_head list)
	635	{
	636	struct sort_dimension *sort;
	637	int i;
	638
	639	for (i = 0; i < NUM_AVAIL_SORTS; i++) {
	640	if (!strcmp(avail_sorts[i]->name, tok)) {
	641	sort = malloc(sizeof(*sort));
	642	if (!sort)
	643	die("malloc");
	644	memcpy(sort, avail_sorts[i], sizeof(*sort));
	645	list_add_tail(&sort->list, list);
	646	return 0;
	647	}
	648	}
	649
	650	return -1;
	651	}
	652
	653	static int setup_sorting(struct list_head sort_list, const char arg)
	654	{
	655	char *tok;
	656	char *str = strdup(arg);
	657
	658	if (!str)
	659	die("strdup");
	660
	661	while (true) {
	662	tok = strsep(&str, ",");
	663	if (!tok)
	664	break;
	665	if (sort_dimension__add(tok, sort_list) < 0) {
	666	error("Unknown --sort key: '%s'", tok);
	667	return -1;
	668	}
	669	}
	670
	671	free(str);
	672	return 0;
	673	}
	674
ba77c9e1 LZ	675	static int parse_sort_opt(const struct option *opt __used,
	676	const char *arg, int unset __used)
	677	{
ba77c9e1 LZ	678	if (!arg)
	679	return -1;
	680
ba77c9e1	681	if (caller_flag > alloc_flag)
29b3e152	682	return setup_sorting(&caller_sort, arg);
ba77c9e1	683	else
29b3e152	684	return setup_sorting(&alloc_sort, arg);
ba77c9e1 LZ	685
	686	return 0;
	687	}
	688
90b86a9f	689	static int parse_caller_opt(const struct option *opt __used,
79312416	690	const char *arg __used, int unset __used)
ba77c9e1	691	{
90b86a9f LZ	692	caller_flag = (alloc_flag + 1);
	693	return 0;
	694	}
ba77c9e1	695
90b86a9f	696	static int parse_alloc_opt(const struct option *opt __used,
79312416	697	const char *arg __used, int unset __used)
90b86a9f LZ	698	{
90b86a9f LZ	699	alloc_flag = (caller_flag + 1);
ba77c9e1 LZ	700	return 0;
	701	}
	702
	703	static int parse_line_opt(const struct option *opt __used,
	704	const char *arg, int unset __used)
	705	{
	706	int lines;
	707
	708	if (!arg)
	709	return -1;
	710
	711	lines = strtoul(arg, NULL, 10);
	712
	713	if (caller_flag > alloc_flag)
	714	caller_lines = lines;
	715	else
	716	alloc_lines = lines;
	717
	718	return 0;
	719	}
	720
	721	static const struct option kmem_options[] = {
	722	OPT_STRING('i', "input", &input_name, "file",
	723	"input file name"),
90b86a9f LZ	724	OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
	725	"show per-callsite statistics",
	726	parse_caller_opt),
	727	OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
	728	"show per-allocation statistics",
	729	parse_alloc_opt),
29b3e152	730	OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
079d3f65	731	"sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
ba77c9e1 LZ	732	parse_sort_opt),
ba77c9e1 LZ	733	OPT_CALLBACK('l', "line", NULL, "num",
90b86a9f	734	"show n lines",
ba77c9e1	735	parse_line_opt),
7707b6b6	736	OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
ba77c9e1 LZ	737	OPT_END()
	738	};
	739
	740	static const char *record_args[] = {
	741	"record",
	742	"-a",
	743	"-R",
	744	"-M",
	745	"-f",
	746	"-c", "1",
	747	"-e", "kmem:kmalloc",
	748	"-e", "kmem:kmalloc_node",
	749	"-e", "kmem:kfree",
	750	"-e", "kmem:kmem_cache_alloc",
	751	"-e", "kmem:kmem_cache_alloc_node",
	752	"-e", "kmem:kmem_cache_free",
	753	};
	754
	755	static int __cmd_record(int argc, const char **argv)
	756	{
	757	unsigned int rec_argc, i, j;
	758	const char **rec_argv;
	759
	760	rec_argc = ARRAY_SIZE(record_args) + argc - 1;
	761	rec_argv = calloc(rec_argc + 1, sizeof(char *));
	762
	763	for (i = 0; i < ARRAY_SIZE(record_args); i++)
	764	rec_argv[i] = strdup(record_args[i]);
	765
	766	for (j = 1; j < (unsigned int)argc; j++, i++)
	767	rec_argv[i] = argv[j];
	768
	769	return cmd_record(i, rec_argv, NULL);
	770	}
	771
	772	int cmd_kmem(int argc, const char *argv, const char prefix __used)
	773	{
	774	symbol__init(0);
	775
	776	argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
	777
90b86a9f	778	if (!argc)
ba77c9e1 LZ	779	usage_with_options(kmem_usage, kmem_options);
ba77c9e1 LZ	780
90b86a9f LZ	781	if (!strncmp(argv[0], "rec", 3)) {
	782	return __cmd_record(argc, argv);
	783	} else if (!strcmp(argv[0], "stat")) {
	784	setup_cpunode_map();
	785
	786	if (list_empty(&caller_sort))
	787	setup_sorting(&caller_sort, default_sort_order);
	788	if (list_empty(&alloc_sort))
	789	setup_sorting(&alloc_sort, default_sort_order);
ba77c9e1	790
90b86a9f LZ	791	return __cmd_kmem();
90b86a9f LZ	792	}
7d0d3945	793
90b86a9f	794	return 0;
ba77c9e1 LZ	795	}
ba77c9e1 LZ	796