builtin-kmem.c 17.1 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 int sample_type_check(struct perf_session *session)
L
Li Zefan 已提交
346
{
347
	if (!(session->sample_type & PERF_SAMPLE_RAW)) {
L
Li Zefan 已提交
348 349 350 351 352 353 354 355 356
		fprintf(stderr,
			"No trace sample to read. Did you call perf record "
			"without -R?");
		return -1;
	}

	return 0;
}

357
static struct perf_event_ops event_ops = {
L
Li Zefan 已提交
358
	.process_sample_event	= process_sample_event,
359
	.process_comm_event	= event__process_comm,
L
Li Zefan 已提交
360 361 362 363 364 365 366 367 368 369 370
	.sample_type_check	= sample_type_check,
};

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

371 372
static void __print_result(struct rb_root *root, struct perf_session *session,
			   int n_lines, int is_caller)
L
Li Zefan 已提交
373 374 375
{
	struct rb_node *next;

376 377 378 379
	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 已提交
380 381 382 383

	next = rb_first(root);

	while (next && n_lines--) {
384 385 386
		struct alloc_stat *data = rb_entry(next, struct alloc_stat,
						   node);
		struct symbol *sym = NULL;
387
		char buf[BUFSIZ];
388 389 390 391
		u64 addr;

		if (is_caller) {
			addr = data->call_site;
392
			if (!raw_ip)
393
				sym = map_groups__find_function(&session->kmaps, session, addr, NULL);
394 395 396 397
		} else
			addr = data->ptr;

		if (sym != NULL)
398
			snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
399 400
				 addr - sym->start);
		else
401 402
			snprintf(buf, sizeof(buf), "%#Lx", addr);
		printf(" %-34s |", buf);
L
Li Zefan 已提交
403

404 405
		printf(" %9llu/%-5lu | %9llu/%-5lu | %6lu | %8lu | %6.3f%%\n",
		       (unsigned long long)data->bytes_alloc,
L
Li Zefan 已提交
406 407 408 409
		       (unsigned long)data->bytes_alloc / data->hit,
		       (unsigned long long)data->bytes_req,
		       (unsigned long)data->bytes_req / data->hit,
		       (unsigned long)data->hit,
410
		       (unsigned long)data->pingpong,
L
Li Zefan 已提交
411 412 413 414 415 416
		       fragmentation(data->bytes_req, data->bytes_alloc));

		next = rb_next(next);
	}

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

419
	printf("%.102s\n", graph_dotted_line);
L
Li Zefan 已提交
420 421 422 423 424 425 426 427 428 429 430
}

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

434
static void print_result(struct perf_session *session)
L
Li Zefan 已提交
435 436
{
	if (caller_flag)
437
		__print_result(&root_caller_sorted, session, caller_lines, 1);
L
Li Zefan 已提交
438
	if (alloc_flag)
439
		__print_result(&root_alloc_sorted, session, alloc_lines, 0);
L
Li Zefan 已提交
440 441 442
	print_summary();
}

443 444 445 446 447 448 449 450 451
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 已提交
452
static void sort_insert(struct rb_root *root, struct alloc_stat *data,
453
			struct list_head *sort_list)
L
Li Zefan 已提交
454 455 456
{
	struct rb_node **new = &(root->rb_node);
	struct rb_node *parent = NULL;
457
	struct sort_dimension *sort;
L
Li Zefan 已提交
458 459 460

	while (*new) {
		struct alloc_stat *this;
461
		int cmp = 0;
L
Li Zefan 已提交
462 463 464 465

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

466 467 468 469 470
		list_for_each_entry(sort, sort_list, list) {
			cmp = sort->cmp(data, this);
			if (cmp)
				break;
		}
L
Li Zefan 已提交
471 472 473 474 475 476 477 478 479 480 481 482

		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,
483
			  struct list_head *sort_list)
L
Li Zefan 已提交
484 485 486 487 488 489 490 491 492 493 494
{
	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);
495
		sort_insert(root_sorted, data, sort_list);
L
Li Zefan 已提交
496 497 498 499 500
	}
}

static void sort_result(void)
{
501 502
	__sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
	__sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
L
Li Zefan 已提交
503 504 505 506
}

static int __cmd_kmem(void)
{
507 508 509 510 511 512
	int err;
	struct perf_session *session = perf_session__new(input_name, O_RDONLY,
							 0, NULL);
	if (session == NULL)
		return -ENOMEM;

L
Li Zefan 已提交
513
	setup_pager();
514 515 516
	err = perf_session__process_events(session, &event_ops);
	if (err != 0)
		goto out_delete;
L
Li Zefan 已提交
517
	sort_result();
518 519 520 521
	print_result(session);
out_delete:
	perf_session__delete(session);
	return err;
L
Li Zefan 已提交
522 523 524
}

static const char * const kmem_usage[] = {
525
	"perf kmem [<options>] {record|stat}",
L
Li Zefan 已提交
526 527 528 529 530 531 532 533 534 535 536 537
	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;
}

538 539 540 541 542
static struct sort_dimension ptr_sort_dimension = {
	.name	= "ptr",
	.cmp	= ptr_cmp,
};

L
Li Zefan 已提交
543 544 545 546 547 548 549 550 551
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;
}

552 553 554 555 556
static struct sort_dimension callsite_sort_dimension = {
	.name	= "callsite",
	.cmp	= callsite_cmp,
};

557 558 559 560 561 562 563 564 565
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;
}

566 567 568 569 570
static struct sort_dimension hit_sort_dimension = {
	.name	= "hit",
	.cmp	= hit_cmp,
};

L
Li Zefan 已提交
571 572 573 574 575 576 577 578 579
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;
}

580 581 582 583 584
static struct sort_dimension bytes_sort_dimension = {
	.name	= "bytes",
	.cmp	= bytes_cmp,
};

585 586 587 588 589 590 591 592 593 594 595 596 597 598
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;
}

599 600 601 602 603
static struct sort_dimension frag_sort_dimension = {
	.name	= "frag",
	.cmp	= frag_cmp,
};

604 605 606 607 608 609 610 611 612 613 614 615 616 617
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,
};

618 619 620 621 622 623
static struct sort_dimension *avail_sorts[] = {
	&ptr_sort_dimension,
	&callsite_sort_dimension,
	&hit_sort_dimension,
	&bytes_sort_dimension,
	&frag_sort_dimension,
624
	&pingpong_sort_dimension,
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 660 661 662 663 664 665 666 667 668 669 670
};

#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 已提交
671 672 673 674 675 676 677
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)
678
		return setup_sorting(&caller_sort, arg);
L
Li Zefan 已提交
679
	else
680
		return setup_sorting(&alloc_sort, arg);
L
Li Zefan 已提交
681 682 683 684

	return 0;
}

685
static int parse_caller_opt(const struct option *opt __used,
686
			  const char *arg __used, int unset __used)
L
Li Zefan 已提交
687
{
688 689 690
	caller_flag = (alloc_flag + 1);
	return 0;
}
L
Li Zefan 已提交
691

692
static int parse_alloc_opt(const struct option *opt __used,
693
			  const char *arg __used, int unset __used)
694 695
{
	alloc_flag = (caller_flag + 1);
L
Li Zefan 已提交
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
	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"),
720 721 722 723 724 725
	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),
726
	OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
727
		     "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
L
Li Zefan 已提交
728 729
		     parse_sort_opt),
	OPT_CALLBACK('l', "line", NULL, "num",
730
		     "show n lines",
L
Li Zefan 已提交
731
		     parse_line_opt),
732
	OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
L
Li Zefan 已提交
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 761 762 763 764 765 766 767 768 769 770 771 772 773
	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);

774
	if (!argc)
L
Li Zefan 已提交
775 776
		usage_with_options(kmem_usage, kmem_options);

777 778 779 780 781 782 783 784 785
	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 已提交
786

787 788
		return __cmd_kmem();
	}
789

790
	return 0;
L
Li Zefan 已提交
791 792
}