[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/session.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 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 perf_session *session __used)
{
	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)
{
	int err;
	struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);

	if (session == NULL)
		return -ENOMEM;

	register_idle_thread();
	register_perf_file_handler(&file_handler);

	err = perf_session__process_events(session, 0, &event__cwdlen, &event__cwd);
	perf_session__delete(session);
	return err;
}

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 = map_groups__find_function(kmaps, 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"
94c744b6	9	#include "util/session.h"
ba77c9e1 LZ	10
	11	#include "util/parse-options.h"
	12	#include "util/trace-event.h"
	13
	14	#include "util/debug.h"
	15	#include "util/data_map.h"
	16
	17	#include <linux/rbtree.h>
	18
	19	struct alloc_stat;
	20	typedef int (sort_fn_t)(struct alloc_stat , struct alloc_stat *);
	21
	22	static char const *input_name = "perf.data";
	23
ba77c9e1 LZ	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
d8f66248	315	static int process_sample_event(event_t event, struct perf_session session __used)
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	{
94c744b6 ACM	370	int err;
	371	struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
	372
	373	if (session == NULL)
	374	return -ENOMEM;
	375
ba77c9e1 LZ	376	register_idle_thread();
	377	register_perf_file_handler(&file_handler);
	378
94c744b6 ACM	379	err = perf_session__process_events(session, 0, &event__cwdlen, &event__cwd);
	380	perf_session__delete(session);
	381	return err;
ba77c9e1 LZ	382	}
	383
	384	static double fragmentation(unsigned long n_req, unsigned long n_alloc)
	385	{
	386	if (n_alloc == 0)
	387	return 0.0;
	388	else
	389	return 100.0 - (100.0 * n_req / n_alloc);
	390	}
	391
	392	static void __print_result(struct rb_root *root, int n_lines, int is_caller)
	393	{
	394	struct rb_node *next;
	395
079d3f65 LZ	396	printf("%.102s\n", graph_dotted_line);
	397	printf(" %-34s \|", is_caller ? "Callsite": "Alloc Ptr");
	398	printf(" Total_alloc/Per \| Total_req/Per \| Hit \| Ping-pong \| Frag\n");
	399	printf("%.102s\n", graph_dotted_line);
ba77c9e1 LZ	400
	401	next = rb_first(root);
	402
	403	while (next && n_lines--) {
1b145ae5 ACM	404	struct alloc_stat *data = rb_entry(next, struct alloc_stat,
	405	node);
	406	struct symbol *sym = NULL;
079d3f65	407	char buf[BUFSIZ];
1b145ae5 ACM	408	u64 addr;
	409
	410	if (is_caller) {
	411	addr = data->call_site;
7707b6b6	412	if (!raw_ip)
9958e1f0	413	sym = map_groups__find_function(kmaps, addr, NULL);
1b145ae5 ACM	414	} else
	415	addr = data->ptr;
	416
	417	if (sym != NULL)
079d3f65	418	snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
1b145ae5 ACM	419	addr - sym->start);
1b145ae5 ACM	420	else
079d3f65 LZ	421	snprintf(buf, sizeof(buf), "%#Lx", addr);
079d3f65 LZ	422	printf(" %-34s \|", buf);
ba77c9e1	423
079d3f65 LZ	424	printf(" %9llu/%-5lu \| %9llu/%-5lu \| %6lu \| %8lu \| %6.3f%%\n",
079d3f65 LZ	425	(unsigned long long)data->bytes_alloc,
ba77c9e1 LZ	426	(unsigned long)data->bytes_alloc / data->hit,
	427	(unsigned long long)data->bytes_req,
	428	(unsigned long)data->bytes_req / data->hit,
	429	(unsigned long)data->hit,
079d3f65	430	(unsigned long)data->pingpong,
ba77c9e1 LZ	431	fragmentation(data->bytes_req, data->bytes_alloc));
	432
	433	next = rb_next(next);
	434	}
	435
	436	if (n_lines == -1)
079d3f65	437	printf(" ... \| ... \| ... \| ... \| ... \| ... \n");
ba77c9e1	438
079d3f65	439	printf("%.102s\n", graph_dotted_line);
ba77c9e1 LZ	440	}
	441
	442	static void print_summary(void)
	443	{
	444	printf("\nSUMMARY\n=======\n");
	445	printf("Total bytes requested: %lu\n", total_requested);
	446	printf("Total bytes allocated: %lu\n", total_allocated);
	447	printf("Total bytes wasted on internal fragmentation: %lu\n",
	448	total_allocated - total_requested);
	449	printf("Internal fragmentation: %f%%\n",
	450	fragmentation(total_requested, total_allocated));
7d0d3945	451	printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
ba77c9e1 LZ	452	}
	453
	454	static void print_result(void)
	455	{
	456	if (caller_flag)
	457	__print_result(&root_caller_sorted, caller_lines, 1);
	458	if (alloc_flag)
	459	__print_result(&root_alloc_sorted, alloc_lines, 0);
	460	print_summary();
	461	}
	462
29b3e152 LZ	463	struct sort_dimension {
	464	const char name[20];
	465	sort_fn_t cmp;
	466	struct list_head list;
	467	};
	468
	469	static LIST_HEAD(caller_sort);
	470	static LIST_HEAD(alloc_sort);
	471
ba77c9e1	472	static void sort_insert(struct rb_root root, struct alloc_stat data,
29b3e152	473	struct list_head *sort_list)
ba77c9e1 LZ	474	{
	475	struct rb_node **new = &(root->rb_node);
	476	struct rb_node *parent = NULL;
29b3e152	477	struct sort_dimension *sort;
ba77c9e1 LZ	478
	479	while (*new) {
	480	struct alloc_stat *this;
29b3e152	481	int cmp = 0;
ba77c9e1 LZ	482
	483	this = rb_entry(*new, struct alloc_stat, node);
	484	parent = *new;
	485
29b3e152 LZ	486	list_for_each_entry(sort, sort_list, list) {
	487	cmp = sort->cmp(data, this);
	488	if (cmp)
	489	break;
	490	}
ba77c9e1 LZ	491
	492	if (cmp > 0)
	493	new = &((*new)->rb_left);
	494	else
	495	new = &((*new)->rb_right);
	496	}
	497
	498	rb_link_node(&data->node, parent, new);
	499	rb_insert_color(&data->node, root);
	500	}
	501
	502	static void __sort_result(struct rb_root root, struct rb_root root_sorted,
29b3e152	503	struct list_head *sort_list)
ba77c9e1 LZ	504	{
	505	struct rb_node *node;
	506	struct alloc_stat *data;
	507
	508	for (;;) {
	509	node = rb_first(root);
	510	if (!node)
	511	break;
	512
	513	rb_erase(node, root);
	514	data = rb_entry(node, struct alloc_stat, node);
29b3e152	515	sort_insert(root_sorted, data, sort_list);
ba77c9e1 LZ	516	}
	517	}
	518
	519	static void sort_result(void)
	520	{
29b3e152 LZ	521	__sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
29b3e152 LZ	522	__sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
ba77c9e1 LZ	523	}
	524
	525	static int __cmd_kmem(void)
	526	{
	527	setup_pager();
	528	read_events();
	529	sort_result();
	530	print_result();
	531
	532	return 0;
	533	}
	534
	535	static const char * const kmem_usage[] = {
90b86a9f	536	"perf kmem [<options>] {record\|stat}",
ba77c9e1 LZ	537	NULL
	538	};
	539
ba77c9e1 LZ	540	static int ptr_cmp(struct alloc_stat l, struct alloc_stat r)
	541	{
	542	if (l->ptr < r->ptr)
	543	return -1;
	544	else if (l->ptr > r->ptr)
	545	return 1;
	546	return 0;
	547	}
	548
29b3e152 LZ	549	static struct sort_dimension ptr_sort_dimension = {
	550	.name = "ptr",
	551	.cmp = ptr_cmp,
	552	};
	553
ba77c9e1 LZ	554	static int callsite_cmp(struct alloc_stat l, struct alloc_stat r)
	555	{
	556	if (l->call_site < r->call_site)
	557	return -1;
	558	else if (l->call_site > r->call_site)
	559	return 1;
	560	return 0;
	561	}
	562
29b3e152 LZ	563	static struct sort_dimension callsite_sort_dimension = {
	564	.name = "callsite",
	565	.cmp = callsite_cmp,
	566	};
	567
f3ced7cd PE	568	static int hit_cmp(struct alloc_stat l, struct alloc_stat r)
	569	{
	570	if (l->hit < r->hit)
	571	return -1;
	572	else if (l->hit > r->hit)
	573	return 1;
	574	return 0;
	575	}
	576
29b3e152 LZ	577	static struct sort_dimension hit_sort_dimension = {
	578	.name = "hit",
	579	.cmp = hit_cmp,
	580	};
	581
ba77c9e1 LZ	582	static int bytes_cmp(struct alloc_stat l, struct alloc_stat r)
	583	{
	584	if (l->bytes_alloc < r->bytes_alloc)
	585	return -1;
	586	else if (l->bytes_alloc > r->bytes_alloc)
	587	return 1;
	588	return 0;
	589	}
	590
29b3e152 LZ	591	static struct sort_dimension bytes_sort_dimension = {
	592	.name = "bytes",
	593	.cmp = bytes_cmp,
	594	};
	595
f3ced7cd PE	596	static int frag_cmp(struct alloc_stat l, struct alloc_stat r)
	597	{
	598	double x, y;
	599
	600	x = fragmentation(l->bytes_req, l->bytes_alloc);
	601	y = fragmentation(r->bytes_req, r->bytes_alloc);
	602
	603	if (x < y)
	604	return -1;
	605	else if (x > y)
	606	return 1;
	607	return 0;
	608	}
	609
29b3e152 LZ	610	static struct sort_dimension frag_sort_dimension = {
	611	.name = "frag",
	612	.cmp = frag_cmp,
	613	};
	614
079d3f65 LZ	615	static int pingpong_cmp(struct alloc_stat l, struct alloc_stat r)
	616	{
	617	if (l->pingpong < r->pingpong)
	618	return -1;
	619	else if (l->pingpong > r->pingpong)
	620	return 1;
	621	return 0;
	622	}
	623
	624	static struct sort_dimension pingpong_sort_dimension = {
	625	.name = "pingpong",
	626	.cmp = pingpong_cmp,
	627	};
	628
29b3e152 LZ	629	static struct sort_dimension *avail_sorts[] = {
	630	&ptr_sort_dimension,
	631	&callsite_sort_dimension,
	632	&hit_sort_dimension,
	633	&bytes_sort_dimension,
	634	&frag_sort_dimension,
079d3f65	635	&pingpong_sort_dimension,
29b3e152 LZ	636	};
	637
	638	#define NUM_AVAIL_SORTS \
	639	(int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
	640
	641	static int sort_dimension__add(const char tok, struct list_head list)
	642	{
	643	struct sort_dimension *sort;
	644	int i;
	645
	646	for (i = 0; i < NUM_AVAIL_SORTS; i++) {
	647	if (!strcmp(avail_sorts[i]->name, tok)) {
	648	sort = malloc(sizeof(*sort));
	649	if (!sort)
	650	die("malloc");
	651	memcpy(sort, avail_sorts[i], sizeof(*sort));
	652	list_add_tail(&sort->list, list);
	653	return 0;
	654	}
	655	}
	656
	657	return -1;
	658	}
	659
	660	static int setup_sorting(struct list_head sort_list, const char arg)
	661	{
	662	char *tok;
	663	char *str = strdup(arg);
	664
	665	if (!str)
	666	die("strdup");
	667
	668	while (true) {
	669	tok = strsep(&str, ",");
	670	if (!tok)
	671	break;
	672	if (sort_dimension__add(tok, sort_list) < 0) {
	673	error("Unknown --sort key: '%s'", tok);
	674	return -1;
	675	}
	676	}
	677
	678	free(str);
	679	return 0;
	680	}
	681
ba77c9e1 LZ	682	static int parse_sort_opt(const struct option *opt __used,
	683	const char *arg, int unset __used)
	684	{
ba77c9e1 LZ	685	if (!arg)
	686	return -1;
	687
ba77c9e1	688	if (caller_flag > alloc_flag)
29b3e152	689	return setup_sorting(&caller_sort, arg);
ba77c9e1	690	else
29b3e152	691	return setup_sorting(&alloc_sort, arg);
ba77c9e1 LZ	692
	693	return 0;
	694	}
	695
90b86a9f	696	static int parse_caller_opt(const struct option *opt __used,
79312416	697	const char *arg __used, int unset __used)
ba77c9e1	698	{
90b86a9f LZ	699	caller_flag = (alloc_flag + 1);
	700	return 0;
	701	}
ba77c9e1	702
90b86a9f	703	static int parse_alloc_opt(const struct option *opt __used,
79312416	704	const char *arg __used, int unset __used)
90b86a9f LZ	705	{
90b86a9f LZ	706	alloc_flag = (caller_flag + 1);
ba77c9e1 LZ	707	return 0;
	708	}
	709
	710	static int parse_line_opt(const struct option *opt __used,
	711	const char *arg, int unset __used)
	712	{
	713	int lines;
	714
	715	if (!arg)
	716	return -1;
	717
	718	lines = strtoul(arg, NULL, 10);
	719
	720	if (caller_flag > alloc_flag)
	721	caller_lines = lines;
	722	else
	723	alloc_lines = lines;
	724
	725	return 0;
	726	}
	727
	728	static const struct option kmem_options[] = {
	729	OPT_STRING('i', "input", &input_name, "file",
	730	"input file name"),
90b86a9f LZ	731	OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
	732	"show per-callsite statistics",
	733	parse_caller_opt),
	734	OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
	735	"show per-allocation statistics",
	736	parse_alloc_opt),
29b3e152	737	OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
079d3f65	738	"sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
ba77c9e1 LZ	739	parse_sort_opt),
ba77c9e1 LZ	740	OPT_CALLBACK('l', "line", NULL, "num",
90b86a9f	741	"show n lines",
ba77c9e1	742	parse_line_opt),
7707b6b6	743	OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
ba77c9e1 LZ	744	OPT_END()
	745	};
	746
	747	static const char *record_args[] = {
	748	"record",
	749	"-a",
	750	"-R",
	751	"-M",
	752	"-f",
	753	"-c", "1",
	754	"-e", "kmem:kmalloc",
	755	"-e", "kmem:kmalloc_node",
	756	"-e", "kmem:kfree",
	757	"-e", "kmem:kmem_cache_alloc",
	758	"-e", "kmem:kmem_cache_alloc_node",
	759	"-e", "kmem:kmem_cache_free",
	760	};
	761
	762	static int __cmd_record(int argc, const char **argv)
	763	{
	764	unsigned int rec_argc, i, j;
	765	const char **rec_argv;
	766
	767	rec_argc = ARRAY_SIZE(record_args) + argc - 1;
	768	rec_argv = calloc(rec_argc + 1, sizeof(char *));
	769
	770	for (i = 0; i < ARRAY_SIZE(record_args); i++)
	771	rec_argv[i] = strdup(record_args[i]);
	772
	773	for (j = 1; j < (unsigned int)argc; j++, i++)
	774	rec_argv[i] = argv[j];
	775
	776	return cmd_record(i, rec_argv, NULL);
	777	}
	778
	779	int cmd_kmem(int argc, const char *argv, const char prefix __used)
	780	{
	781	symbol__init(0);
	782
	783	argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
	784
90b86a9f	785	if (!argc)
ba77c9e1 LZ	786	usage_with_options(kmem_usage, kmem_options);
ba77c9e1 LZ	787
90b86a9f LZ	788	if (!strncmp(argv[0], "rec", 3)) {
	789	return __cmd_record(argc, argv);
	790	} else if (!strcmp(argv[0], "stat")) {
	791	setup_cpunode_map();
	792
	793	if (list_empty(&caller_sort))
	794	setup_sorting(&caller_sort, default_sort_order);
	795	if (list_empty(&alloc_sort))
	796	setup_sorting(&alloc_sort, default_sort_order);
ba77c9e1	797
90b86a9f LZ	798	return __cmd_kmem();
90b86a9f LZ	799	}
7d0d3945	800
90b86a9f	801	return 0;
ba77c9e1 LZ	802	}
ba77c9e1 LZ	803