1 // SPDX-License-Identifier: GPL-2.0
2 #include <inttypes.h>
3 #include <sys/types.h>
4 #include <sys/stat.h>
5 #include <unistd.h>
6 #include "builtin.h"
7 #include "perf.h"
8
9 #include <subcmd/parse-options.h>
10 #include "util/auxtrace.h"
11 #include "util/trace-event.h"
12 #include "util/tool.h"
13 #include "util/session.h"
14 #include "util/data.h"
15 #include "util/map_symbol.h"
16 #include "util/mem-events.h"
17 #include "util/debug.h"
18 #include "util/dso.h"
19 #include "util/map.h"
20 #include "util/symbol.h"
21 #include "util/pmus.h"
22 #include "util/sample.h"
23 #include "util/sort.h"
24 #include "util/string2.h"
25 #include "util/util.h"
26 #include <linux/err.h>
27
28 #define MEM_OPERATION_LOAD 0x1
29 #define MEM_OPERATION_STORE 0x2
30
31 struct perf_mem {
32 struct perf_tool tool;
33 const char *input_name;
34 const char *sort_key;
35 bool hide_unresolved;
36 bool dump_raw;
37 bool force;
38 bool phys_addr;
39 bool data_page_size;
40 bool all_kernel;
41 bool all_user;
42 bool data_type;
43 int operation;
44 const char *cpu_list;
45 DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
46 };
47
parse_record_events(const struct option * opt,const char * str,int unset __maybe_unused)48 static int parse_record_events(const struct option *opt,
49 const char *str, int unset __maybe_unused)
50 {
51 struct perf_mem *mem = (struct perf_mem *)opt->value;
52 struct perf_pmu *pmu;
53
54 pmu = perf_mem_events_find_pmu();
55 if (!pmu) {
56 pr_err("failed: there is no PMU that supports perf mem\n");
57 exit(-1);
58 }
59
60 if (!strcmp(str, "list")) {
61 perf_pmu__mem_events_list(pmu);
62 exit(0);
63 }
64 if (perf_pmu__mem_events_parse(pmu, str))
65 exit(-1);
66
67 mem->operation = 0;
68 return 0;
69 }
70
__cmd_record(int argc,const char ** argv,struct perf_mem * mem,const struct option * options)71 static int __cmd_record(int argc, const char **argv, struct perf_mem *mem,
72 const struct option *options)
73 {
74 int rec_argc, i = 0, j;
75 int start, end;
76 const char **rec_argv;
77 char *event_name_storage = NULL;
78 int ret;
79 struct perf_mem_event *e;
80 struct perf_pmu *pmu;
81 const char * const record_usage[] = {
82 "perf mem record [<options>] [<command>]",
83 "perf mem record [<options>] -- <command> [<options>]",
84 NULL
85 };
86
87 pmu = perf_mem_events_find_pmu();
88 if (!pmu) {
89 pr_err("failed: no PMU supports the memory events\n");
90 return -1;
91 }
92
93 if (perf_pmu__mem_events_init()) {
94 pr_err("failed: memory events not supported\n");
95 return -1;
96 }
97
98 argc = parse_options(argc, argv, options, record_usage,
99 PARSE_OPT_KEEP_UNKNOWN);
100
101 /* Max number of arguments multiplied by number of PMUs that can support them. */
102 rec_argc = argc + 9 * (perf_pmu__mem_events_num_mem_pmus(pmu) + 1);
103
104 if (mem->cpu_list)
105 rec_argc += 2;
106
107 rec_argv = calloc(rec_argc + 1, sizeof(char *));
108 if (!rec_argv)
109 return -1;
110
111 rec_argv[i++] = "record";
112
113 e = perf_pmu__mem_events_ptr(pmu, PERF_MEM_EVENTS__LOAD_STORE);
114
115 /*
116 * The load and store operations are required, use the event
117 * PERF_MEM_EVENTS__LOAD_STORE if it is supported.
118 */
119 if (e->tag &&
120 (mem->operation & MEM_OPERATION_LOAD) &&
121 (mem->operation & MEM_OPERATION_STORE)) {
122 perf_mem_record[PERF_MEM_EVENTS__LOAD_STORE] = true;
123 rec_argv[i++] = "-W";
124 } else {
125 if (mem->operation & MEM_OPERATION_LOAD)
126 perf_mem_record[PERF_MEM_EVENTS__LOAD] = true;
127
128 if (mem->operation & MEM_OPERATION_STORE)
129 perf_mem_record[PERF_MEM_EVENTS__STORE] = true;
130 }
131
132 if (perf_mem_record[PERF_MEM_EVENTS__LOAD])
133 rec_argv[i++] = "-W";
134
135 rec_argv[i++] = "-d";
136
137 if (mem->phys_addr)
138 rec_argv[i++] = "--phys-data";
139
140 if (mem->data_page_size)
141 rec_argv[i++] = "--data-page-size";
142
143 start = i;
144 ret = perf_mem_events__record_args(rec_argv, &i, &event_name_storage);
145 if (ret)
146 goto out;
147 end = i;
148
149 if (mem->all_user)
150 rec_argv[i++] = "--all-user";
151
152 if (mem->all_kernel)
153 rec_argv[i++] = "--all-kernel";
154
155 if (mem->cpu_list) {
156 rec_argv[i++] = "-C";
157 rec_argv[i++] = mem->cpu_list;
158 }
159
160 for (j = 0; j < argc; j++, i++)
161 rec_argv[i] = argv[j];
162
163 if (verbose > 0) {
164 pr_debug("calling: record ");
165
166 for (j = start; j < end; j++)
167 pr_debug("%s ", rec_argv[j]);
168
169 pr_debug("\n");
170 }
171
172 ret = cmd_record(i, rec_argv);
173 out:
174 free(event_name_storage);
175 free(rec_argv);
176 return ret;
177 }
178
179 static int
dump_raw_samples(const struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)180 dump_raw_samples(const struct perf_tool *tool,
181 union perf_event *event,
182 struct perf_sample *sample,
183 struct machine *machine)
184 {
185 struct perf_mem *mem = container_of(tool, struct perf_mem, tool);
186 struct addr_location al;
187 const char *fmt, *field_sep;
188 char str[PAGE_SIZE_NAME_LEN];
189 struct dso *dso = NULL;
190
191 addr_location__init(&al);
192 if (machine__resolve(machine, &al, sample) < 0) {
193 fprintf(stderr, "problem processing %d event, skipping it.\n",
194 event->header.type);
195 addr_location__exit(&al);
196 return -1;
197 }
198
199 if (al.filtered || (mem->hide_unresolved && al.sym == NULL))
200 goto out_put;
201
202 if (al.map != NULL) {
203 dso = map__dso(al.map);
204 if (dso)
205 dso__set_hit(dso);
206 }
207
208 field_sep = symbol_conf.field_sep;
209 if (field_sep) {
210 fmt = "%d%s%d%s0x%"PRIx64"%s0x%"PRIx64"%s";
211 } else {
212 fmt = "%5d%s%5d%s0x%016"PRIx64"%s0x016%"PRIx64"%s";
213 symbol_conf.field_sep = " ";
214 }
215 printf(fmt,
216 sample->pid,
217 symbol_conf.field_sep,
218 sample->tid,
219 symbol_conf.field_sep,
220 sample->ip,
221 symbol_conf.field_sep,
222 sample->addr,
223 symbol_conf.field_sep);
224
225 if (mem->phys_addr) {
226 printf("0x%016"PRIx64"%s",
227 sample->phys_addr,
228 symbol_conf.field_sep);
229 }
230
231 if (mem->data_page_size) {
232 printf("%s%s",
233 get_page_size_name(sample->data_page_size, str),
234 symbol_conf.field_sep);
235 }
236
237 if (field_sep)
238 fmt = "%"PRIu64"%s0x%"PRIx64"%s%s:%s\n";
239 else
240 fmt = "%5"PRIu64"%s0x%06"PRIx64"%s%s:%s\n";
241
242 printf(fmt,
243 sample->weight,
244 symbol_conf.field_sep,
245 sample->data_src,
246 symbol_conf.field_sep,
247 dso ? dso__long_name(dso) : "???",
248 al.sym ? al.sym->name : "???");
249 out_put:
250 addr_location__exit(&al);
251 return 0;
252 }
253
process_sample_event(const struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct evsel * evsel __maybe_unused,struct machine * machine)254 static int process_sample_event(const struct perf_tool *tool,
255 union perf_event *event,
256 struct perf_sample *sample,
257 struct evsel *evsel __maybe_unused,
258 struct machine *machine)
259 {
260 return dump_raw_samples(tool, event, sample, machine);
261 }
262
report_raw_events(struct perf_mem * mem)263 static int report_raw_events(struct perf_mem *mem)
264 {
265 struct itrace_synth_opts itrace_synth_opts = {
266 .set = true,
267 .mem = true, /* Only enable memory event */
268 .default_no_sample = true,
269 };
270
271 struct perf_data data = {
272 .path = input_name,
273 .mode = PERF_DATA_MODE_READ,
274 .force = mem->force,
275 };
276 int ret;
277 struct perf_session *session;
278
279 perf_tool__init(&mem->tool, /*ordered_events=*/true);
280 mem->tool.sample = process_sample_event;
281 mem->tool.mmap = perf_event__process_mmap;
282 mem->tool.mmap2 = perf_event__process_mmap2;
283 mem->tool.comm = perf_event__process_comm;
284 mem->tool.lost = perf_event__process_lost;
285 mem->tool.fork = perf_event__process_fork;
286 mem->tool.attr = perf_event__process_attr;
287 mem->tool.build_id = perf_event__process_build_id;
288 mem->tool.namespaces = perf_event__process_namespaces;
289 mem->tool.auxtrace_info = perf_event__process_auxtrace_info;
290 mem->tool.auxtrace = perf_event__process_auxtrace;
291 mem->tool.auxtrace_error = perf_event__process_auxtrace_error;
292
293 session = perf_session__new(&data, &mem->tool);
294
295 if (IS_ERR(session))
296 return PTR_ERR(session);
297
298 session->itrace_synth_opts = &itrace_synth_opts;
299
300 if (mem->cpu_list) {
301 ret = perf_session__cpu_bitmap(session, mem->cpu_list,
302 mem->cpu_bitmap);
303 if (ret < 0)
304 goto out_delete;
305 }
306
307 ret = symbol__init(&session->header.env);
308 if (ret < 0)
309 goto out_delete;
310
311 printf("# PID, TID, IP, ADDR, ");
312
313 if (mem->phys_addr)
314 printf("PHYS ADDR, ");
315
316 if (mem->data_page_size)
317 printf("DATA PAGE SIZE, ");
318
319 printf("LOCAL WEIGHT, DSRC, SYMBOL\n");
320
321 ret = perf_session__process_events(session);
322
323 out_delete:
324 perf_session__delete(session);
325 return ret;
326 }
327
get_sort_order(struct perf_mem * mem)328 static char *get_sort_order(struct perf_mem *mem)
329 {
330 bool has_extra_options = (mem->phys_addr | mem->data_page_size) ? true : false;
331 char sort[128];
332
333 if (mem->sort_key)
334 scnprintf(sort, sizeof(sort), "--sort=%s", mem->sort_key);
335 else if (mem->data_type)
336 strcpy(sort, "--sort=mem,snoop,tlb,type");
337 /*
338 * there is no weight (cost) associated with stores, so don't print
339 * the column
340 */
341 else if (!(mem->operation & MEM_OPERATION_LOAD)) {
342 strcpy(sort, "--sort=mem,sym,dso,symbol_daddr,"
343 "dso_daddr,tlb,locked");
344 } else if (has_extra_options) {
345 strcpy(sort, "--sort=local_weight,mem,sym,dso,symbol_daddr,"
346 "dso_daddr,snoop,tlb,locked,blocked");
347 } else
348 return NULL;
349
350 if (mem->phys_addr)
351 strcat(sort, ",phys_daddr");
352
353 if (mem->data_page_size)
354 strcat(sort, ",data_page_size");
355
356 /* make sure it has 'type' sort key even -s option is used */
357 if (mem->data_type && !strstr(sort, "type"))
358 strcat(sort, ",type");
359
360 return strdup(sort);
361 }
362
__cmd_report(int argc,const char ** argv,struct perf_mem * mem,const struct option * options)363 static int __cmd_report(int argc, const char **argv, struct perf_mem *mem,
364 const struct option *options)
365 {
366 const char **rep_argv;
367 int ret, i = 0, j, rep_argc;
368 char *new_sort_order;
369 const char * const report_usage[] = {
370 "perf mem report [<options>]",
371 NULL
372 };
373
374 argc = parse_options(argc, argv, options, report_usage,
375 PARSE_OPT_KEEP_UNKNOWN);
376
377 if (mem->dump_raw)
378 return report_raw_events(mem);
379
380 rep_argc = argc + 3;
381 rep_argv = calloc(rep_argc + 1, sizeof(char *));
382 if (!rep_argv)
383 return -1;
384
385 rep_argv[i++] = "report";
386 rep_argv[i++] = "--mem-mode";
387 rep_argv[i++] = "-n"; /* display number of samples */
388
389 new_sort_order = get_sort_order(mem);
390 if (new_sort_order)
391 rep_argv[i++] = new_sort_order;
392
393 for (j = 0; j < argc; j++, i++)
394 rep_argv[i] = argv[j];
395
396 ret = cmd_report(i, rep_argv);
397 free(new_sort_order);
398 free(rep_argv);
399 return ret;
400 }
401
402 struct mem_mode {
403 const char *name;
404 int mode;
405 };
406
407 #define MEM_OPT(n, m) \
408 { .name = n, .mode = (m) }
409
410 #define MEM_END { .name = NULL }
411
412 static const struct mem_mode mem_modes[]={
413 MEM_OPT("load", MEM_OPERATION_LOAD),
414 MEM_OPT("store", MEM_OPERATION_STORE),
415 MEM_END
416 };
417
418 static int
parse_mem_ops(const struct option * opt,const char * str,int unset)419 parse_mem_ops(const struct option *opt, const char *str, int unset)
420 {
421 int *mode = (int *)opt->value;
422 const struct mem_mode *m;
423 char *s, *os = NULL, *p;
424 int ret = -1;
425
426 if (unset)
427 return 0;
428
429 /* str may be NULL in case no arg is passed to -t */
430 if (str) {
431 /* because str is read-only */
432 s = os = strdup(str);
433 if (!s)
434 return -1;
435
436 /* reset mode */
437 *mode = 0;
438
439 for (;;) {
440 p = strchr(s, ',');
441 if (p)
442 *p = '\0';
443
444 for (m = mem_modes; m->name; m++) {
445 if (!strcasecmp(s, m->name))
446 break;
447 }
448 if (!m->name) {
449 fprintf(stderr, "unknown sampling op %s,"
450 " check man page\n", s);
451 goto error;
452 }
453
454 *mode |= m->mode;
455
456 if (!p)
457 break;
458
459 s = p + 1;
460 }
461 }
462 ret = 0;
463
464 if (*mode == 0)
465 *mode = MEM_OPERATION_LOAD;
466 error:
467 free(os);
468 return ret;
469 }
470
cmd_mem(int argc,const char ** argv)471 int cmd_mem(int argc, const char **argv)
472 {
473 struct stat st;
474 struct perf_mem mem = {
475 .input_name = "perf.data",
476 /*
477 * default to both load an store sampling
478 */
479 .operation = MEM_OPERATION_LOAD | MEM_OPERATION_STORE,
480 };
481 char *sort_order_help = sort_help("sort by key(s):", SORT_MODE__MEMORY);
482 const struct option mem_options[] = {
483 OPT_CALLBACK('t', "type", &mem.operation,
484 "type", "memory operations(load,store) Default load,store",
485 parse_mem_ops),
486 OPT_STRING('C', "cpu", &mem.cpu_list, "cpu",
487 "list of cpus to profile"),
488 OPT_BOOLEAN('f', "force", &mem.force, "don't complain, do it"),
489 OPT_INCR('v', "verbose", &verbose,
490 "be more verbose (show counter open errors, etc)"),
491 OPT_BOOLEAN('p', "phys-data", &mem.phys_addr, "Record/Report sample physical addresses"),
492 OPT_BOOLEAN(0, "data-page-size", &mem.data_page_size, "Record/Report sample data address page size"),
493 OPT_END()
494 };
495 const struct option record_options[] = {
496 OPT_CALLBACK('e', "event", &mem, "event",
497 "event selector. use 'perf mem record -e list' to list available events",
498 parse_record_events),
499 OPT_UINTEGER(0, "ldlat", &perf_mem_events__loads_ldlat, "mem-loads latency"),
500 OPT_BOOLEAN('U', "all-user", &mem.all_user, "collect only user level data"),
501 OPT_BOOLEAN('K', "all-kernel", &mem.all_kernel, "collect only kernel level data"),
502 OPT_PARENT(mem_options)
503 };
504 const struct option report_options[] = {
505 OPT_BOOLEAN('D', "dump-raw-samples", &mem.dump_raw,
506 "dump raw samples in ASCII"),
507 OPT_BOOLEAN('U', "hide-unresolved", &mem.hide_unresolved,
508 "Only display entries resolved to a symbol"),
509 OPT_STRING('i', "input", &input_name, "file",
510 "input file name"),
511 OPT_STRING_NOEMPTY('x', "field-separator", &symbol_conf.field_sep,
512 "separator",
513 "separator for columns, no spaces will be added"
514 " between columns '.' is reserved."),
515 OPT_STRING('s', "sort", &mem.sort_key, "key[,key2...]",
516 sort_order_help),
517 OPT_BOOLEAN('T', "type-profile", &mem.data_type,
518 "Show data-type profile result"),
519 OPT_PARENT(mem_options)
520 };
521 const char *const mem_subcommands[] = { "record", "report", NULL };
522 const char *mem_usage[] = {
523 NULL,
524 NULL
525 };
526 int ret;
527
528 argc = parse_options_subcommand(argc, argv, mem_options, mem_subcommands,
529 mem_usage, PARSE_OPT_STOP_AT_NON_OPTION);
530
531 if (!argc || !(strncmp(argv[0], "rec", 3) || mem.operation))
532 usage_with_options(mem_usage, mem_options);
533
534 if (!mem.input_name || !strlen(mem.input_name)) {
535 if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
536 mem.input_name = "-";
537 else
538 mem.input_name = "perf.data";
539 }
540
541 if (strlen(argv[0]) > 2 && strstarts("record", argv[0]))
542 ret = __cmd_record(argc, argv, &mem, record_options);
543 else if (strlen(argv[0]) > 2 && strstarts("report", argv[0]))
544 ret = __cmd_report(argc, argv, &mem, report_options);
545 else
546 usage_with_options(mem_usage, mem_options);
547
548 /* free usage string allocated by parse_options_subcommand */
549 free((void *)mem_usage[0]);
550 free(sort_order_help);
551
552 return ret;
553 }
554