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
{
	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;
W
Wenji Huang 已提交
140
		data->bytes_alloc += bytes_alloc;
L
Li Zefan 已提交
141 142
	} 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
}

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;
W
Wenji Huang 已提交
180
		data->bytes_alloc += bytes_alloc;
L
Li Zefan 已提交
181 182
	} 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
	int err;
508
	struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
509 510 511
	if (session == NULL)
		return -ENOMEM;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return 0;
}

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

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

771
	if (!argc)
L
Li Zefan 已提交
772 773
		usage_with_options(kmem_usage, kmem_options);

774 775
	symbol__init();

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

786 787
		return __cmd_kmem();
	}
788

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