builtin-kmem.c 16.9 KB
Newer Older
L
Li Zefan 已提交
1 2 3 4 5 6 7 8
#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"
9
#include "util/session.h"
L
Li Zefan 已提交
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

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

#include "util/debug.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 int			alloc_flag;
static int			caller_flag;

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

29 30
static bool			raw_ip;

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

33 34 35
static int			*cpunode_map;
static int			max_cpu_num;

L
Li Zefan 已提交
36
struct alloc_stat {
37 38
	u64	call_site;
	u64	ptr;
L
Li Zefan 已提交
39 40 41
	u64	bytes_req;
	u64	bytes_alloc;
	u32	hit;
42 43 44
	u32	pingpong;

	short	alloc_cpu;
L
Li Zefan 已提交
45 46 47 48 49 50 51 52 53 54

	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;
55
static unsigned long nr_allocs, nr_cross_allocs;
L
Li Zefan 已提交
56

57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
#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;
		}
	}
}

118 119
static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
			      int bytes_req, int bytes_alloc, int cpu)
L
Li Zefan 已提交
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
{
	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));
143 144
		if (!data)
			die("malloc");
L
Li Zefan 已提交
145
		data->ptr = ptr;
146
		data->pingpong = 0;
L
Li Zefan 已提交
147 148 149 150 151 152 153
		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);
	}
154 155
	data->call_site = call_site;
	data->alloc_cpu = cpu;
L
Li Zefan 已提交
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
}

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));
183 184
		if (!data)
			die("malloc");
L
Li Zefan 已提交
185
		data->call_site = call_site;
186
		data->pingpong = 0;
L
Li Zefan 已提交
187 188 189 190 191 192 193 194 195
		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);
	}
}

X
Xiao Guangrong 已提交
196
static void process_alloc_event(void *data,
L
Li Zefan 已提交
197
				struct event *event,
198
				int cpu,
L
Li Zefan 已提交
199 200
				u64 timestamp __used,
				struct thread *thread __used,
201
				int node)
L
Li Zefan 已提交
202 203 204 205 206
{
	unsigned long call_site;
	unsigned long ptr;
	int bytes_req;
	int bytes_alloc;
207
	int node1, node2;
L
Li Zefan 已提交
208

X
Xiao Guangrong 已提交
209 210 211 212
	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);
L
Li Zefan 已提交
213

214
	insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
L
Li Zefan 已提交
215 216 217 218
	insert_caller_stat(call_site, bytes_req, bytes_alloc);

	total_requested += bytes_req;
	total_allocated += bytes_alloc;
219 220 221

	if (node) {
		node1 = cpunode_map[cpu];
X
Xiao Guangrong 已提交
222
		node2 = raw_field_value(event, "node", data);
223 224 225 226
		if (node1 != node2)
			nr_cross_allocs++;
	}
	nr_allocs++;
L
Li Zefan 已提交
227 228
}

229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
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;
}

X
Xiao Guangrong 已提交
257
static void process_free_event(void *data,
258 259
			       struct event *event,
			       int cpu,
L
Li Zefan 已提交
260 261 262
			       u64 timestamp __used,
			       struct thread *thread __used)
{
263 264 265
	unsigned long ptr;
	struct alloc_stat *s_alloc, *s_caller;

X
Xiao Guangrong 已提交
266
	ptr = raw_field_value(event, "ptr", data);
267 268 269 270 271 272 273 274 275 276 277 278 279 280

	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;
L
Li Zefan 已提交
281 282 283
}

static void
X
Xiao Guangrong 已提交
284
process_raw_event(event_t *raw_event __used, void *data,
L
Li Zefan 已提交
285 286 287 288 289
		  int cpu, u64 timestamp, struct thread *thread)
{
	struct event *event;
	int type;

X
Xiao Guangrong 已提交
290
	type = trace_parse_common_type(data);
L
Li Zefan 已提交
291 292 293 294
	event = trace_find_event(type);

	if (!strcmp(event->name, "kmalloc") ||
	    !strcmp(event->name, "kmem_cache_alloc")) {
X
Xiao Guangrong 已提交
295
		process_alloc_event(data, event, cpu, timestamp, thread, 0);
L
Li Zefan 已提交
296 297 298 299 300
		return;
	}

	if (!strcmp(event->name, "kmalloc_node") ||
	    !strcmp(event->name, "kmem_cache_alloc_node")) {
X
Xiao Guangrong 已提交
301
		process_alloc_event(data, event, cpu, timestamp, thread, 1);
L
Li Zefan 已提交
302 303 304 305 306
		return;
	}

	if (!strcmp(event->name, "kfree") ||
	    !strcmp(event->name, "kmem_cache_free")) {
X
Xiao Guangrong 已提交
307
		process_free_event(data, event, cpu, timestamp, thread);
L
Li Zefan 已提交
308 309 310 311
		return;
	}
}

312
static int process_sample_event(event_t *event, struct perf_session *session)
L
Li Zefan 已提交
313
{
314 315
	struct sample_data data;
	struct thread *thread;
L
Li Zefan 已提交
316

317 318 319 320
	memset(&data, 0, sizeof(data));
	data.time = -1;
	data.cpu = -1;
	data.period = 1;
L
Li Zefan 已提交
321

322
	event__parse_sample(event, session->sample_type, &data);
L
Li Zefan 已提交
323

324
	dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
L
Li Zefan 已提交
325
		event->header.misc,
326 327 328
		data.pid, data.tid,
		(void *)(long)data.ip,
		(long long)data.period);
L
Li Zefan 已提交
329

330
	thread = perf_session__findnew(session, event->ip.pid);
L
Li Zefan 已提交
331 332 333 334 335 336 337 338
	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);

X
Xiao Guangrong 已提交
339
	process_raw_event(event, data.raw_data, data.cpu,
340
			  data.time, thread);
L
Li Zefan 已提交
341 342 343 344

	return 0;
}

345
static struct perf_event_ops event_ops = {
L
Li Zefan 已提交
346
	.process_sample_event	= process_sample_event,
347
	.process_comm_event	= event__process_comm,
L
Li Zefan 已提交
348 349 350 351 352 353 354 355 356 357
};

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

358 359
static void __print_result(struct rb_root *root, struct perf_session *session,
			   int n_lines, int is_caller)
L
Li Zefan 已提交
360 361 362
{
	struct rb_node *next;

363 364 365 366
	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);
L
Li Zefan 已提交
367 368 369 370

	next = rb_first(root);

	while (next && n_lines--) {
371 372 373
		struct alloc_stat *data = rb_entry(next, struct alloc_stat,
						   node);
		struct symbol *sym = NULL;
374
		char buf[BUFSIZ];
375 376 377 378
		u64 addr;

		if (is_caller) {
			addr = data->call_site;
379
			if (!raw_ip)
380
				sym = map_groups__find_function(&session->kmaps, session, addr, NULL);
381 382 383 384
		} else
			addr = data->ptr;

		if (sym != NULL)
385
			snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
386 387
				 addr - sym->start);
		else
388 389
			snprintf(buf, sizeof(buf), "%#Lx", addr);
		printf(" %-34s |", buf);
L
Li Zefan 已提交
390

391 392
		printf(" %9llu/%-5lu | %9llu/%-5lu | %6lu | %8lu | %6.3f%%\n",
		       (unsigned long long)data->bytes_alloc,
L
Li Zefan 已提交
393 394 395 396
		       (unsigned long)data->bytes_alloc / data->hit,
		       (unsigned long long)data->bytes_req,
		       (unsigned long)data->bytes_req / data->hit,
		       (unsigned long)data->hit,
397
		       (unsigned long)data->pingpong,
L
Li Zefan 已提交
398 399 400 401 402 403
		       fragmentation(data->bytes_req, data->bytes_alloc));

		next = rb_next(next);
	}

	if (n_lines == -1)
404
		printf(" ...                                | ...             | ...             | ...    | ...      | ...   \n");
L
Li Zefan 已提交
405

406
	printf("%.102s\n", graph_dotted_line);
L
Li Zefan 已提交
407 408 409 410 411 412 413 414 415 416 417
}

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));
418
	printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
L
Li Zefan 已提交
419 420
}

421
static void print_result(struct perf_session *session)
L
Li Zefan 已提交
422 423
{
	if (caller_flag)
424
		__print_result(&root_caller_sorted, session, caller_lines, 1);
L
Li Zefan 已提交
425
	if (alloc_flag)
426
		__print_result(&root_alloc_sorted, session, alloc_lines, 0);
L
Li Zefan 已提交
427 428 429
	print_summary();
}

430 431 432 433 434 435 436 437 438
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);

L
Li Zefan 已提交
439
static void sort_insert(struct rb_root *root, struct alloc_stat *data,
440
			struct list_head *sort_list)
L
Li Zefan 已提交
441 442 443
{
	struct rb_node **new = &(root->rb_node);
	struct rb_node *parent = NULL;
444
	struct sort_dimension *sort;
L
Li Zefan 已提交
445 446 447

	while (*new) {
		struct alloc_stat *this;
448
		int cmp = 0;
L
Li Zefan 已提交
449 450 451 452

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

453 454 455 456 457
		list_for_each_entry(sort, sort_list, list) {
			cmp = sort->cmp(data, this);
			if (cmp)
				break;
		}
L
Li Zefan 已提交
458 459 460 461 462 463 464 465 466 467 468 469

		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,
470
			  struct list_head *sort_list)
L
Li Zefan 已提交
471 472 473 474 475 476 477 478 479 480 481
{
	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);
482
		sort_insert(root_sorted, data, sort_list);
L
Li Zefan 已提交
483 484 485 486 487
	}
}

static void sort_result(void)
{
488 489
	__sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
	__sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
L
Li Zefan 已提交
490 491 492 493
}

static int __cmd_kmem(void)
{
494
	int err = -EINVAL;
495
	struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
496 497 498
	if (session == NULL)
		return -ENOMEM;

499 500 501
	if (!perf_session__has_traces(session, "kmem record"))
		goto out_delete;

L
Li Zefan 已提交
502
	setup_pager();
503 504 505
	err = perf_session__process_events(session, &event_ops);
	if (err != 0)
		goto out_delete;
L
Li Zefan 已提交
506
	sort_result();
507 508 509 510
	print_result(session);
out_delete:
	perf_session__delete(session);
	return err;
L
Li Zefan 已提交
511 512 513
}

static const char * const kmem_usage[] = {
514
	"perf kmem [<options>] {record|stat}",
L
Li Zefan 已提交
515 516 517 518 519 520 521 522 523 524 525 526
	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;
}

527 528 529 530 531
static struct sort_dimension ptr_sort_dimension = {
	.name	= "ptr",
	.cmp	= ptr_cmp,
};

L
Li Zefan 已提交
532 533 534 535 536 537 538 539 540
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;
}

541 542 543 544 545
static struct sort_dimension callsite_sort_dimension = {
	.name	= "callsite",
	.cmp	= callsite_cmp,
};

546 547 548 549 550 551 552 553 554
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;
}

555 556 557 558 559
static struct sort_dimension hit_sort_dimension = {
	.name	= "hit",
	.cmp	= hit_cmp,
};

L
Li Zefan 已提交
560 561 562 563 564 565 566 567 568
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;
}

569 570 571 572 573
static struct sort_dimension bytes_sort_dimension = {
	.name	= "bytes",
	.cmp	= bytes_cmp,
};

574 575 576 577 578 579 580 581 582 583 584 585 586 587
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;
}

588 589 590 591 592
static struct sort_dimension frag_sort_dimension = {
	.name	= "frag",
	.cmp	= frag_cmp,
};

593 594 595 596 597 598 599 600 601 602 603 604 605 606
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,
};

607 608 609 610 611 612
static struct sort_dimension *avail_sorts[] = {
	&ptr_sort_dimension,
	&callsite_sort_dimension,
	&hit_sort_dimension,
	&bytes_sort_dimension,
	&frag_sort_dimension,
613
	&pingpong_sort_dimension,
614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
};

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

L
Li Zefan 已提交
660 661 662 663 664 665 666
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)
667
		return setup_sorting(&caller_sort, arg);
L
Li Zefan 已提交
668
	else
669
		return setup_sorting(&alloc_sort, arg);
L
Li Zefan 已提交
670 671 672 673

	return 0;
}

674
static int parse_caller_opt(const struct option *opt __used,
675
			  const char *arg __used, int unset __used)
L
Li Zefan 已提交
676
{
677 678 679
	caller_flag = (alloc_flag + 1);
	return 0;
}
L
Li Zefan 已提交
680

681
static int parse_alloc_opt(const struct option *opt __used,
682
			  const char *arg __used, int unset __used)
683 684
{
	alloc_flag = (caller_flag + 1);
L
Li Zefan 已提交
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
	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"),
709 710 711 712 713 714
	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),
715
	OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
716
		     "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
L
Li Zefan 已提交
717 718
		     parse_sort_opt),
	OPT_CALLBACK('l', "line", NULL, "num",
719
		     "show n lines",
L
Li Zefan 已提交
720
		     parse_line_opt),
721
	OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
L
Li Zefan 已提交
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
	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)
{
	argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);

761
	if (!argc)
L
Li Zefan 已提交
762 763
		usage_with_options(kmem_usage, kmem_options);

764 765
	symbol__init();

766 767 768 769 770 771 772 773 774
	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);
L
Li Zefan 已提交
775

776 777
		return __cmd_kmem();
	}
778

779
	return 0;
L
Li Zefan 已提交
780 781
}