builtin-kmem.c 17.0 KB
Newer Older
L
Li Zefan 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
#include "builtin.h"
#include "perf.h"

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

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

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

#include <linux/rbtree.h>

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

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

static struct perf_header	*header;
static u64			sample_type;

static int			alloc_flag;
static int			caller_flag;

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

32 33
static bool			raw_ip;

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

36 37 38
static int			*cpunode_map;
static int			max_cpu_num;

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

	short	alloc_cpu;
L
Li Zefan 已提交
48 49 50 51 52 53 54 55 56 57

	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;
58
static unsigned long nr_allocs, nr_cross_allocs;
L
Li Zefan 已提交
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 118 119 120
#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;
		}
	}
}

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

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));
186 187
		if (!data)
			die("malloc");
L
Li Zefan 已提交
188
		data->call_site = call_site;
189
		data->pingpong = 0;
L
Li Zefan 已提交
190 191 192 193 194 195 196 197 198
		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 已提交
199
static void process_alloc_event(void *data,
L
Li Zefan 已提交
200
				struct event *event,
201
				int cpu,
L
Li Zefan 已提交
202 203
				u64 timestamp __used,
				struct thread *thread __used,
204
				int node)
L
Li Zefan 已提交
205 206 207 208 209
{
	unsigned long call_site;
	unsigned long ptr;
	int bytes_req;
	int bytes_alloc;
210
	int node1, node2;
L
Li Zefan 已提交
211

X
Xiao Guangrong 已提交
212 213 214 215
	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 已提交
216

217
	insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
L
Li Zefan 已提交
218 219 220 221
	insert_caller_stat(call_site, bytes_req, bytes_alloc);

	total_requested += bytes_req;
	total_allocated += bytes_alloc;
222 223 224

	if (node) {
		node1 = cpunode_map[cpu];
X
Xiao Guangrong 已提交
225
		node2 = raw_field_value(event, "node", data);
226 227 228 229
		if (node1 != node2)
			nr_cross_allocs++;
	}
	nr_allocs++;
L
Li Zefan 已提交
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 257 258 259
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 已提交
260
static void process_free_event(void *data,
261 262
			       struct event *event,
			       int cpu,
L
Li Zefan 已提交
263 264 265
			       u64 timestamp __used,
			       struct thread *thread __used)
{
266 267 268
	unsigned long ptr;
	struct alloc_stat *s_alloc, *s_caller;

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

	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 已提交
284 285 286
}

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

X
Xiao Guangrong 已提交
293
	type = trace_parse_common_type(data);
L
Li Zefan 已提交
294 295 296 297
	event = trace_find_event(type);

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

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

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

315
static int process_sample_event(event_t *event)
L
Li Zefan 已提交
316
{
317 318
	struct sample_data data;
	struct thread *thread;
L
Li Zefan 已提交
319

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

325
	event__parse_sample(event, sample_type, &data);
L
Li Zefan 已提交
326

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

333
	thread = threads__findnew(event->ip.pid);
L
Li Zefan 已提交
334 335 336 337 338 339 340 341
	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 已提交
342
	process_raw_event(event, data.raw_data, data.cpu,
343
			  data.time, thread);
L
Li Zefan 已提交
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363

	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,
364
	.process_comm_event	= event__process_comm,
L
Li Zefan 已提交
365 366 367 368 369 370 371 372
	.sample_type_check	= sample_type_check,
};

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

373
	return mmap_dispatch_perf_file(&header, input_name, 0, 0,
374
				       &event__cwdlen, &event__cwd);
L
Li Zefan 已提交
375 376 377 378 379 380 381 382 383 384 385 386 387 388
}

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;

389 390 391 392
	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 已提交
393 394 395 396

	next = rb_first(root);

	while (next && n_lines--) {
397 398 399
		struct alloc_stat *data = rb_entry(next, struct alloc_stat,
						   node);
		struct symbol *sym = NULL;
400
		char buf[BUFSIZ];
401 402 403 404
		u64 addr;

		if (is_caller) {
			addr = data->call_site;
405
			if (!raw_ip)
406
				sym = map_groups__find_function(kmaps, addr, NULL);
407 408 409 410
		} else
			addr = data->ptr;

		if (sym != NULL)
411
			snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
412 413
				 addr - sym->start);
		else
414 415
			snprintf(buf, sizeof(buf), "%#Lx", addr);
		printf(" %-34s |", buf);
L
Li Zefan 已提交
416

417 418
		printf(" %9llu/%-5lu | %9llu/%-5lu | %6lu | %8lu | %6.3f%%\n",
		       (unsigned long long)data->bytes_alloc,
L
Li Zefan 已提交
419 420 421 422
		       (unsigned long)data->bytes_alloc / data->hit,
		       (unsigned long long)data->bytes_req,
		       (unsigned long)data->bytes_req / data->hit,
		       (unsigned long)data->hit,
423
		       (unsigned long)data->pingpong,
L
Li Zefan 已提交
424 425 426 427 428 429
		       fragmentation(data->bytes_req, data->bytes_alloc));

		next = rb_next(next);
	}

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

432
	printf("%.102s\n", graph_dotted_line);
L
Li Zefan 已提交
433 434 435 436 437 438 439 440 441 442 443
}

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));
444
	printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
L
Li Zefan 已提交
445 446 447 448 449 450 451 452 453 454 455
}

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

456 457 458 459 460 461 462 463 464
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 已提交
465
static void sort_insert(struct rb_root *root, struct alloc_stat *data,
466
			struct list_head *sort_list)
L
Li Zefan 已提交
467 468 469
{
	struct rb_node **new = &(root->rb_node);
	struct rb_node *parent = NULL;
470
	struct sort_dimension *sort;
L
Li Zefan 已提交
471 472 473

	while (*new) {
		struct alloc_stat *this;
474
		int cmp = 0;
L
Li Zefan 已提交
475 476 477 478

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

479 480 481 482 483
		list_for_each_entry(sort, sort_list, list) {
			cmp = sort->cmp(data, this);
			if (cmp)
				break;
		}
L
Li Zefan 已提交
484 485 486 487 488 489 490 491 492 493 494 495

		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,
496
			  struct list_head *sort_list)
L
Li Zefan 已提交
497 498 499 500 501 502 503 504 505 506 507
{
	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);
508
		sort_insert(root_sorted, data, sort_list);
L
Li Zefan 已提交
509 510 511 512 513
	}
}

static void sort_result(void)
{
514 515
	__sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
	__sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
L
Li Zefan 已提交
516 517 518 519 520 521 522 523 524 525 526 527 528
}

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

	return 0;
}

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

542 543 544 545 546
static struct sort_dimension ptr_sort_dimension = {
	.name	= "ptr",
	.cmp	= ptr_cmp,
};

L
Li Zefan 已提交
547 548 549 550 551 552 553 554 555
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;
}

556 557 558 559 560
static struct sort_dimension callsite_sort_dimension = {
	.name	= "callsite",
	.cmp	= callsite_cmp,
};

561 562 563 564 565 566 567 568 569
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;
}

570 571 572 573 574
static struct sort_dimension hit_sort_dimension = {
	.name	= "hit",
	.cmp	= hit_cmp,
};

L
Li Zefan 已提交
575 576 577 578 579 580 581 582 583
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;
}

584 585 586 587 588
static struct sort_dimension bytes_sort_dimension = {
	.name	= "bytes",
	.cmp	= bytes_cmp,
};

589 590 591 592 593 594 595 596 597 598 599 600 601 602
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;
}

603 604 605 606 607
static struct sort_dimension frag_sort_dimension = {
	.name	= "frag",
	.cmp	= frag_cmp,
};

608 609 610 611 612 613 614 615 616 617 618 619 620 621
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,
};

622 623 624 625 626 627
static struct sort_dimension *avail_sorts[] = {
	&ptr_sort_dimension,
	&callsite_sort_dimension,
	&hit_sort_dimension,
	&bytes_sort_dimension,
	&frag_sort_dimension,
628
	&pingpong_sort_dimension,
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 671 672 673 674
};

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

	return 0;
}

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

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

778
	if (!argc)
L
Li Zefan 已提交
779 780
		usage_with_options(kmem_usage, kmem_options);

781 782 783 784 785 786 787 788 789
	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 已提交
790

791 792
		return __cmd_kmem();
	}
793

794
	return 0;
L
Li Zefan 已提交
795 796
}