projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
perf trace: Add possibility to switch off syscall events
[deliverable/linux.git] / tools / perf / builtin-trace.c
1 #include <traceevent/event-parse.h>
2 #include "builtin.h"
3 #include "util/color.h"
4 #include "util/debug.h"
5 #include "util/evlist.h"
6 #include "util/machine.h"
7 #include "util/session.h"
8 #include "util/thread.h"
9 #include "util/parse-options.h"
10 #include "util/strlist.h"
11 #include "util/intlist.h"
12 #include "util/thread_map.h"
13 #include "util/stat.h"
14 #include "trace-event.h"
15 #include "util/parse-events.h"
16
17 #include <libaudit.h>
18 #include <stdlib.h>
19 #include <sys/eventfd.h>
20 #include <sys/mman.h>
21 #include <linux/futex.h>
22
23 /* For older distros: */
24 #ifndef MAP_STACK
25 # define MAP_STACK 0x20000
26 #endif
27
28 #ifndef MADV_HWPOISON
29 # define MADV_HWPOISON 100
30 #endif
31
32 #ifndef MADV_MERGEABLE
33 # define MADV_MERGEABLE 12
34 #endif
35
36 #ifndef MADV_UNMERGEABLE
37 # define MADV_UNMERGEABLE 13
38 #endif
39
40 #ifndef EFD_SEMAPHORE
41 # define EFD_SEMAPHORE 1
42 #endif
43
44 struct tp_field {
45 int offset;
46 union {
47 u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
48 void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
49 };
50 };
51
52 #define TP_UINT_FIELD(bits) \
53 static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
54 { \
55 return *(u##bits *)(sample->raw_data + field->offset); \
56 }
57
58 TP_UINT_FIELD(8);
59 TP_UINT_FIELD(16);
60 TP_UINT_FIELD(32);
61 TP_UINT_FIELD(64);
62
63 #define TP_UINT_FIELD__SWAPPED(bits) \
64 static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
65 { \
66 u##bits value = *(u##bits *)(sample->raw_data + field->offset); \
67 return bswap_##bits(value);\
68 }
69
70 TP_UINT_FIELD__SWAPPED(16);
71 TP_UINT_FIELD__SWAPPED(32);
72 TP_UINT_FIELD__SWAPPED(64);
73
74 static int tp_field__init_uint(struct tp_field *field,
75 struct format_field *format_field,
76 bool needs_swap)
77 {
78 field->offset = format_field->offset;
79
80 switch (format_field->size) {
81 case 1:
82 field->integer = tp_field__u8;
83 break;
84 case 2:
85 field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
86 break;
87 case 4:
88 field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
89 break;
90 case 8:
91 field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
92 break;
93 default:
94 return -1;
95 }
96
97 return 0;
98 }
99
100 static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
101 {
102 return sample->raw_data + field->offset;
103 }
104
105 static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
106 {
107 field->offset = format_field->offset;
108 field->pointer = tp_field__ptr;
109 return 0;
110 }
111
112 struct syscall_tp {
113 struct tp_field id;
114 union {
115 struct tp_field args, ret;
116 };
117 };
118
119 static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
120 struct tp_field *field,
121 const char *name)
122 {
123 struct format_field *format_field = perf_evsel__field(evsel, name);
124
125 if (format_field == NULL)
126 return -1;
127
128 return tp_field__init_uint(field, format_field, evsel->needs_swap);
129 }
130
131 #define perf_evsel__init_sc_tp_uint_field(evsel, name) \
132 ({ struct syscall_tp *sc = evsel->priv;\
133 perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })
134
135 static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
136 struct tp_field *field,
137 const char *name)
138 {
139 struct format_field *format_field = perf_evsel__field(evsel, name);
140
141 if (format_field == NULL)
142 return -1;
143
144 return tp_field__init_ptr(field, format_field);
145 }
146
147 #define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
148 ({ struct syscall_tp *sc = evsel->priv;\
149 perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
150
151 static void perf_evsel__delete_priv(struct perf_evsel *evsel)
152 {
153 zfree(&evsel->priv);
154 perf_evsel__delete(evsel);
155 }
156
157 static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel, void *handler)
158 {
159 evsel->priv = malloc(sizeof(struct syscall_tp));
160 if (evsel->priv != NULL) {
161 if (perf_evsel__init_sc_tp_uint_field(evsel, id))
162 goto out_delete;
163
164 evsel->handler = handler;
165 return 0;
166 }
167
168 return -ENOMEM;
169
170 out_delete:
171 zfree(&evsel->priv);
172 return -ENOENT;
173 }
174
175 static struct perf_evsel *perf_evsel__syscall_newtp(const char *direction, void *handler)
176 {
177 struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
178
179 /* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
180 if (evsel == NULL)
181 evsel = perf_evsel__newtp("syscalls", direction);
182
183 if (evsel) {
184 if (perf_evsel__init_syscall_tp(evsel, handler))
185 goto out_delete;
186 }
187
188 return evsel;
189
190 out_delete:
191 perf_evsel__delete_priv(evsel);
192 return NULL;
193 }
194
195 #define perf_evsel__sc_tp_uint(evsel, name, sample) \
196 ({ struct syscall_tp *fields = evsel->priv; \
197 fields->name.integer(&fields->name, sample); })
198
199 #define perf_evsel__sc_tp_ptr(evsel, name, sample) \
200 ({ struct syscall_tp *fields = evsel->priv; \
201 fields->name.pointer(&fields->name, sample); })
202
203 static int perf_evlist__add_syscall_newtp(struct perf_evlist *evlist,
204 void *sys_enter_handler,
205 void *sys_exit_handler)
206 {
207 int ret = -1;
208 struct perf_evsel *sys_enter, *sys_exit;
209
210 sys_enter = perf_evsel__syscall_newtp("sys_enter", sys_enter_handler);
211 if (sys_enter == NULL)
212 goto out;
213
214 if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
215 goto out_delete_sys_enter;
216
217 sys_exit = perf_evsel__syscall_newtp("sys_exit", sys_exit_handler);
218 if (sys_exit == NULL)
219 goto out_delete_sys_enter;
220
221 if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
222 goto out_delete_sys_exit;
223
224 perf_evlist__add(evlist, sys_enter);
225 perf_evlist__add(evlist, sys_exit);
226
227 ret = 0;
228 out:
229 return ret;
230
231 out_delete_sys_exit:
232 perf_evsel__delete_priv(sys_exit);
233 out_delete_sys_enter:
234 perf_evsel__delete_priv(sys_enter);
235 goto out;
236 }
237
238
239 struct syscall_arg {
240 unsigned long val;
241 struct thread *thread;
242 struct trace *trace;
243 void *parm;
244 u8 idx;
245 u8 mask;
246 };
247
248 struct strarray {
249 int offset;
250 int nr_entries;
251 const char **entries;
252 };
253
254 #define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
255 .nr_entries = ARRAY_SIZE(array), \
256 .entries = array, \
257 }
258
259 #define DEFINE_STRARRAY_OFFSET(array, off) struct strarray strarray__##array = { \
260 .offset = off, \
261 .nr_entries = ARRAY_SIZE(array), \
262 .entries = array, \
263 }
264
265 static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
266 const char *intfmt,
267 struct syscall_arg *arg)
268 {
269 struct strarray *sa = arg->parm;
270 int idx = arg->val - sa->offset;
271
272 if (idx < 0 || idx >= sa->nr_entries)
273 return scnprintf(bf, size, intfmt, arg->val);
274
275 return scnprintf(bf, size, "%s", sa->entries[idx]);
276 }
277
278 static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
279 struct syscall_arg *arg)
280 {
281 return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
282 }
283
284 #define SCA_STRARRAY syscall_arg__scnprintf_strarray
285
286 #if defined(__i386__) || defined(__x86_64__)
287 /*
288 * FIXME: Make this available to all arches as soon as the ioctl beautifier
289 * gets rewritten to support all arches.
290 */
291 static size_t syscall_arg__scnprintf_strhexarray(char *bf, size_t size,
292 struct syscall_arg *arg)
293 {
294 return __syscall_arg__scnprintf_strarray(bf, size, "%#x", arg);
295 }
296
297 #define SCA_STRHEXARRAY syscall_arg__scnprintf_strhexarray
298 #endif /* defined(__i386__) || defined(__x86_64__) */
299
300 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
301 struct syscall_arg *arg);
302
303 #define SCA_FD syscall_arg__scnprintf_fd
304
305 static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
306 struct syscall_arg *arg)
307 {
308 int fd = arg->val;
309
310 if (fd == AT_FDCWD)
311 return scnprintf(bf, size, "CWD");
312
313 return syscall_arg__scnprintf_fd(bf, size, arg);
314 }
315
316 #define SCA_FDAT syscall_arg__scnprintf_fd_at
317
318 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
319 struct syscall_arg *arg);
320
321 #define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
322
323 static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
324 struct syscall_arg *arg)
325 {
326 return scnprintf(bf, size, "%#lx", arg->val);
327 }
328
329 #define SCA_HEX syscall_arg__scnprintf_hex
330
331 static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
332 struct syscall_arg *arg)
333 {
334 int printed = 0, prot = arg->val;
335
336 if (prot == PROT_NONE)
337 return scnprintf(bf, size, "NONE");
338 #define P_MMAP_PROT(n) \
339 if (prot & PROT_##n) { \
340 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
341 prot &= ~PROT_##n; \
342 }
343
344 P_MMAP_PROT(EXEC);
345 P_MMAP_PROT(READ);
346 P_MMAP_PROT(WRITE);
347 #ifdef PROT_SEM
348 P_MMAP_PROT(SEM);
349 #endif
350 P_MMAP_PROT(GROWSDOWN);
351 P_MMAP_PROT(GROWSUP);
352 #undef P_MMAP_PROT
353
354 if (prot)
355 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
356
357 return printed;
358 }
359
360 #define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
361
362 static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
363 struct syscall_arg *arg)
364 {
365 int printed = 0, flags = arg->val;
366
367 #define P_MMAP_FLAG(n) \
368 if (flags & MAP_##n) { \
369 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
370 flags &= ~MAP_##n; \
371 }
372
373 P_MMAP_FLAG(SHARED);
374 P_MMAP_FLAG(PRIVATE);
375 #ifdef MAP_32BIT
376 P_MMAP_FLAG(32BIT);
377 #endif
378 P_MMAP_FLAG(ANONYMOUS);
379 P_MMAP_FLAG(DENYWRITE);
380 P_MMAP_FLAG(EXECUTABLE);
381 P_MMAP_FLAG(FILE);
382 P_MMAP_FLAG(FIXED);
383 P_MMAP_FLAG(GROWSDOWN);
384 #ifdef MAP_HUGETLB
385 P_MMAP_FLAG(HUGETLB);
386 #endif
387 P_MMAP_FLAG(LOCKED);
388 P_MMAP_FLAG(NONBLOCK);
389 P_MMAP_FLAG(NORESERVE);
390 P_MMAP_FLAG(POPULATE);
391 P_MMAP_FLAG(STACK);
392 #ifdef MAP_UNINITIALIZED
393 P_MMAP_FLAG(UNINITIALIZED);
394 #endif
395 #undef P_MMAP_FLAG
396
397 if (flags)
398 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
399
400 return printed;
401 }
402
403 #define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
404
405 static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
406 struct syscall_arg *arg)
407 {
408 int behavior = arg->val;
409
410 switch (behavior) {
411 #define P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
412 P_MADV_BHV(NORMAL);
413 P_MADV_BHV(RANDOM);
414 P_MADV_BHV(SEQUENTIAL);
415 P_MADV_BHV(WILLNEED);
416 P_MADV_BHV(DONTNEED);
417 P_MADV_BHV(REMOVE);
418 P_MADV_BHV(DONTFORK);
419 P_MADV_BHV(DOFORK);
420 P_MADV_BHV(HWPOISON);
421 #ifdef MADV_SOFT_OFFLINE
422 P_MADV_BHV(SOFT_OFFLINE);
423 #endif
424 P_MADV_BHV(MERGEABLE);
425 P_MADV_BHV(UNMERGEABLE);
426 #ifdef MADV_HUGEPAGE
427 P_MADV_BHV(HUGEPAGE);
428 #endif
429 #ifdef MADV_NOHUGEPAGE
430 P_MADV_BHV(NOHUGEPAGE);
431 #endif
432 #ifdef MADV_DONTDUMP
433 P_MADV_BHV(DONTDUMP);
434 #endif
435 #ifdef MADV_DODUMP
436 P_MADV_BHV(DODUMP);
437 #endif
438 #undef P_MADV_PHV
439 default: break;
440 }
441
442 return scnprintf(bf, size, "%#x", behavior);
443 }
444
445 #define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
446
447 static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
448 struct syscall_arg *arg)
449 {
450 int printed = 0, op = arg->val;
451
452 if (op == 0)
453 return scnprintf(bf, size, "NONE");
454 #define P_CMD(cmd) \
455 if ((op & LOCK_##cmd) == LOCK_##cmd) { \
456 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #cmd); \
457 op &= ~LOCK_##cmd; \
458 }
459
460 P_CMD(SH);
461 P_CMD(EX);
462 P_CMD(NB);
463 P_CMD(UN);
464 P_CMD(MAND);
465 P_CMD(RW);
466 P_CMD(READ);
467 P_CMD(WRITE);
468 #undef P_OP
469
470 if (op)
471 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", op);
472
473 return printed;
474 }
475
476 #define SCA_FLOCK syscall_arg__scnprintf_flock
477
478 static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
479 {
480 enum syscall_futex_args {
481 SCF_UADDR = (1 << 0),
482 SCF_OP = (1 << 1),
483 SCF_VAL = (1 << 2),
484 SCF_TIMEOUT = (1 << 3),
485 SCF_UADDR2 = (1 << 4),
486 SCF_VAL3 = (1 << 5),
487 };
488 int op = arg->val;
489 int cmd = op & FUTEX_CMD_MASK;
490 size_t printed = 0;
491
492 switch (cmd) {
493 #define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
494 P_FUTEX_OP(WAIT); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
495 P_FUTEX_OP(WAKE); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
496 P_FUTEX_OP(FD); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
497 P_FUTEX_OP(REQUEUE); arg->mask |= SCF_VAL3|SCF_TIMEOUT; break;
498 P_FUTEX_OP(CMP_REQUEUE); arg->mask |= SCF_TIMEOUT; break;
499 P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT; break;
500 P_FUTEX_OP(WAKE_OP); break;
501 P_FUTEX_OP(LOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
502 P_FUTEX_OP(UNLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
503 P_FUTEX_OP(TRYLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
504 P_FUTEX_OP(WAIT_BITSET); arg->mask |= SCF_UADDR2; break;
505 P_FUTEX_OP(WAKE_BITSET); arg->mask |= SCF_UADDR2; break;
506 P_FUTEX_OP(WAIT_REQUEUE_PI); break;
507 default: printed = scnprintf(bf, size, "%#x", cmd); break;
508 }
509
510 if (op & FUTEX_PRIVATE_FLAG)
511 printed += scnprintf(bf + printed, size - printed, "|PRIV");
512
513 if (op & FUTEX_CLOCK_REALTIME)
514 printed += scnprintf(bf + printed, size - printed, "|CLKRT");
515
516 return printed;
517 }
518
519 #define SCA_FUTEX_OP syscall_arg__scnprintf_futex_op
520
521 static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
522 static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
523
524 static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
525 static DEFINE_STRARRAY(itimers);
526
527 static const char *whences[] = { "SET", "CUR", "END",
528 #ifdef SEEK_DATA
529 "DATA",
530 #endif
531 #ifdef SEEK_HOLE
532 "HOLE",
533 #endif
534 };
535 static DEFINE_STRARRAY(whences);
536
537 static const char *fcntl_cmds[] = {
538 "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
539 "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
540 "F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
541 "F_GETOWNER_UIDS",
542 };
543 static DEFINE_STRARRAY(fcntl_cmds);
544
545 static const char *rlimit_resources[] = {
546 "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
547 "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
548 "RTTIME",
549 };
550 static DEFINE_STRARRAY(rlimit_resources);
551
552 static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
553 static DEFINE_STRARRAY(sighow);
554
555 static const char *clockid[] = {
556 "REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
557 "MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE",
558 };
559 static DEFINE_STRARRAY(clockid);
560
561 static const char *socket_families[] = {
562 "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
563 "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
564 "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
565 "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
566 "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
567 "ALG", "NFC", "VSOCK",
568 };
569 static DEFINE_STRARRAY(socket_families);
570
571 #ifndef SOCK_TYPE_MASK
572 #define SOCK_TYPE_MASK 0xf
573 #endif
574
575 static size_t syscall_arg__scnprintf_socket_type(char *bf, size_t size,
576 struct syscall_arg *arg)
577 {
578 size_t printed;
579 int type = arg->val,
580 flags = type & ~SOCK_TYPE_MASK;
581
582 type &= SOCK_TYPE_MASK;
583 /*
584 * Can't use a strarray, MIPS may override for ABI reasons.
585 */
586 switch (type) {
587 #define P_SK_TYPE(n) case SOCK_##n: printed = scnprintf(bf, size, #n); break;
588 P_SK_TYPE(STREAM);
589 P_SK_TYPE(DGRAM);
590 P_SK_TYPE(RAW);
591 P_SK_TYPE(RDM);
592 P_SK_TYPE(SEQPACKET);
593 P_SK_TYPE(DCCP);
594 P_SK_TYPE(PACKET);
595 #undef P_SK_TYPE
596 default:
597 printed = scnprintf(bf, size, "%#x", type);
598 }
599
600 #define P_SK_FLAG(n) \
601 if (flags & SOCK_##n) { \
602 printed += scnprintf(bf + printed, size - printed, "|%s", #n); \
603 flags &= ~SOCK_##n; \
604 }
605
606 P_SK_FLAG(CLOEXEC);
607 P_SK_FLAG(NONBLOCK);
608 #undef P_SK_FLAG
609
610 if (flags)
611 printed += scnprintf(bf + printed, size - printed, "|%#x", flags);
612
613 return printed;
614 }
615
616 #define SCA_SK_TYPE syscall_arg__scnprintf_socket_type
617
618 #ifndef MSG_PROBE
619 #define MSG_PROBE 0x10
620 #endif
621 #ifndef MSG_WAITFORONE
622 #define MSG_WAITFORONE 0x10000
623 #endif
624 #ifndef MSG_SENDPAGE_NOTLAST
625 #define MSG_SENDPAGE_NOTLAST 0x20000
626 #endif
627 #ifndef MSG_FASTOPEN
628 #define MSG_FASTOPEN 0x20000000
629 #endif
630
631 static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
632 struct syscall_arg *arg)
633 {
634 int printed = 0, flags = arg->val;
635
636 if (flags == 0)
637 return scnprintf(bf, size, "NONE");
638 #define P_MSG_FLAG(n) \
639 if (flags & MSG_##n) { \
640 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
641 flags &= ~MSG_##n; \
642 }
643
644 P_MSG_FLAG(OOB);
645 P_MSG_FLAG(PEEK);
646 P_MSG_FLAG(DONTROUTE);
647 P_MSG_FLAG(TRYHARD);
648 P_MSG_FLAG(CTRUNC);
649 P_MSG_FLAG(PROBE);
650 P_MSG_FLAG(TRUNC);
651 P_MSG_FLAG(DONTWAIT);
652 P_MSG_FLAG(EOR);
653 P_MSG_FLAG(WAITALL);
654 P_MSG_FLAG(FIN);
655 P_MSG_FLAG(SYN);
656 P_MSG_FLAG(CONFIRM);
657 P_MSG_FLAG(RST);
658 P_MSG_FLAG(ERRQUEUE);
659 P_MSG_FLAG(NOSIGNAL);
660 P_MSG_FLAG(MORE);
661 P_MSG_FLAG(WAITFORONE);
662 P_MSG_FLAG(SENDPAGE_NOTLAST);
663 P_MSG_FLAG(FASTOPEN);
664 P_MSG_FLAG(CMSG_CLOEXEC);
665 #undef P_MSG_FLAG
666
667 if (flags)
668 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
669
670 return printed;
671 }
672
673 #define SCA_MSG_FLAGS syscall_arg__scnprintf_msg_flags
674
675 static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
676 struct syscall_arg *arg)
677 {
678 size_t printed = 0;
679 int mode = arg->val;
680
681 if (mode == F_OK) /* 0 */
682 return scnprintf(bf, size, "F");
683 #define P_MODE(n) \
684 if (mode & n##_OK) { \
685 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
686 mode &= ~n##_OK; \
687 }
688
689 P_MODE(R);
690 P_MODE(W);
691 P_MODE(X);
692 #undef P_MODE
693
694 if (mode)
695 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
696
697 return printed;
698 }
699
700 #define SCA_ACCMODE syscall_arg__scnprintf_access_mode
701
702 static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
703 struct syscall_arg *arg)
704 {
705 int printed = 0, flags = arg->val;
706
707 if (!(flags & O_CREAT))
708 arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
709
710 if (flags == 0)
711 return scnprintf(bf, size, "RDONLY");
712 #define P_FLAG(n) \
713 if (flags & O_##n) { \
714 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
715 flags &= ~O_##n; \
716 }
717
718 P_FLAG(APPEND);
719 P_FLAG(ASYNC);
720 P_FLAG(CLOEXEC);
721 P_FLAG(CREAT);
722 P_FLAG(DIRECT);
723 P_FLAG(DIRECTORY);
724 P_FLAG(EXCL);
725 P_FLAG(LARGEFILE);
726 P_FLAG(NOATIME);
727 P_FLAG(NOCTTY);
728 #ifdef O_NONBLOCK
729 P_FLAG(NONBLOCK);
730 #elif O_NDELAY
731 P_FLAG(NDELAY);
732 #endif
733 #ifdef O_PATH
734 P_FLAG(PATH);
735 #endif
736 P_FLAG(RDWR);
737 #ifdef O_DSYNC
738 if ((flags & O_SYNC) == O_SYNC)
739 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
740 else {
741 P_FLAG(DSYNC);
742 }
743 #else
744 P_FLAG(SYNC);
745 #endif
746 P_FLAG(TRUNC);
747 P_FLAG(WRONLY);
748 #undef P_FLAG
749
750 if (flags)
751 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
752
753 return printed;
754 }
755
756 #define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
757
758 static size_t syscall_arg__scnprintf_eventfd_flags(char *bf, size_t size,
759 struct syscall_arg *arg)
760 {
761 int printed = 0, flags = arg->val;
762
763 if (flags == 0)
764 return scnprintf(bf, size, "NONE");
765 #define P_FLAG(n) \
766 if (flags & EFD_##n) { \
767 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
768 flags &= ~EFD_##n; \
769 }
770
771 P_FLAG(SEMAPHORE);
772 P_FLAG(CLOEXEC);
773 P_FLAG(NONBLOCK);
774 #undef P_FLAG
775
776 if (flags)
777 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
778
779 return printed;
780 }
781
782 #define SCA_EFD_FLAGS syscall_arg__scnprintf_eventfd_flags
783
784 static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
785 struct syscall_arg *arg)
786 {
787 int printed = 0, flags = arg->val;
788
789 #define P_FLAG(n) \
790 if (flags & O_##n) { \
791 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
792 flags &= ~O_##n; \
793 }
794
795 P_FLAG(CLOEXEC);
796 P_FLAG(NONBLOCK);
797 #undef P_FLAG
798
799 if (flags)
800 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
801
802 return printed;
803 }
804
805 #define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
806
807 static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
808 {
809 int sig = arg->val;
810
811 switch (sig) {
812 #define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
813 P_SIGNUM(HUP);
814 P_SIGNUM(INT);
815 P_SIGNUM(QUIT);
816 P_SIGNUM(ILL);
817 P_SIGNUM(TRAP);
818 P_SIGNUM(ABRT);
819 P_SIGNUM(BUS);
820 P_SIGNUM(FPE);
821 P_SIGNUM(KILL);
822 P_SIGNUM(USR1);
823 P_SIGNUM(SEGV);
824 P_SIGNUM(USR2);
825 P_SIGNUM(PIPE);
826 P_SIGNUM(ALRM);
827 P_SIGNUM(TERM);
828 P_SIGNUM(CHLD);
829 P_SIGNUM(CONT);
830 P_SIGNUM(STOP);
831 P_SIGNUM(TSTP);
832 P_SIGNUM(TTIN);
833 P_SIGNUM(TTOU);
834 P_SIGNUM(URG);
835 P_SIGNUM(XCPU);
836 P_SIGNUM(XFSZ);
837 P_SIGNUM(VTALRM);
838 P_SIGNUM(PROF);
839 P_SIGNUM(WINCH);
840 P_SIGNUM(IO);
841 P_SIGNUM(PWR);
842 P_SIGNUM(SYS);
843 #ifdef SIGEMT
844 P_SIGNUM(EMT);
845 #endif
846 #ifdef SIGSTKFLT
847 P_SIGNUM(STKFLT);
848 #endif
849 #ifdef SIGSWI
850 P_SIGNUM(SWI);
851 #endif
852 default: break;
853 }
854
855 return scnprintf(bf, size, "%#x", sig);
856 }
857
858 #define SCA_SIGNUM syscall_arg__scnprintf_signum
859
860 #if defined(__i386__) || defined(__x86_64__)
861 /*
862 * FIXME: Make this available to all arches.
863 */
864 #define TCGETS 0x5401
865
866 static const char *tioctls[] = {
867 "TCGETS", "TCSETS", "TCSETSW", "TCSETSF", "TCGETA", "TCSETA", "TCSETAW",
868 "TCSETAF", "TCSBRK", "TCXONC", "TCFLSH", "TIOCEXCL", "TIOCNXCL",
869 "TIOCSCTTY", "TIOCGPGRP", "TIOCSPGRP", "TIOCOUTQ", "TIOCSTI",
870 "TIOCGWINSZ", "TIOCSWINSZ", "TIOCMGET", "TIOCMBIS", "TIOCMBIC",
871 "TIOCMSET", "TIOCGSOFTCAR", "TIOCSSOFTCAR", "FIONREAD", "TIOCLINUX",
872 "TIOCCONS", "TIOCGSERIAL", "TIOCSSERIAL", "TIOCPKT", "FIONBIO",
873 "TIOCNOTTY", "TIOCSETD", "TIOCGETD", "TCSBRKP", [0x27] = "TIOCSBRK",
874 "TIOCCBRK", "TIOCGSID", "TCGETS2", "TCSETS2", "TCSETSW2", "TCSETSF2",
875 "TIOCGRS485", "TIOCSRS485", "TIOCGPTN", "TIOCSPTLCK",
876 "TIOCGDEV||TCGETX", "TCSETX", "TCSETXF", "TCSETXW", "TIOCSIG",
877 "TIOCVHANGUP", "TIOCGPKT", "TIOCGPTLCK", "TIOCGEXCL",
878 [0x50] = "FIONCLEX", "FIOCLEX", "FIOASYNC", "TIOCSERCONFIG",
879 "TIOCSERGWILD", "TIOCSERSWILD", "TIOCGLCKTRMIOS", "TIOCSLCKTRMIOS",
880 "TIOCSERGSTRUCT", "TIOCSERGETLSR", "TIOCSERGETMULTI", "TIOCSERSETMULTI",
881 "TIOCMIWAIT", "TIOCGICOUNT", [0x60] = "FIOQSIZE",
882 };
883
884 static DEFINE_STRARRAY_OFFSET(tioctls, 0x5401);
885 #endif /* defined(__i386__) || defined(__x86_64__) */
886
887 #define STRARRAY(arg, name, array) \
888 .arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
889 .arg_parm = { [arg] = &strarray__##array, }
890
891 static struct syscall_fmt {
892 const char *name;
893 const char *alias;
894 size_t (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
895 void *arg_parm[6];
896 bool errmsg;
897 bool timeout;
898 bool hexret;
899 } syscall_fmts[] = {
900 { .name = "access", .errmsg = true,
901 .arg_scnprintf = { [1] = SCA_ACCMODE, /* mode */ }, },
902 { .name = "arch_prctl", .errmsg = true, .alias = "prctl", },
903 { .name = "brk", .hexret = true,
904 .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
905 { .name = "clock_gettime", .errmsg = true, STRARRAY(0, clk_id, clockid), },
906 { .name = "close", .errmsg = true,
907 .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
908 { .name = "connect", .errmsg = true, },
909 { .name = "dup", .errmsg = true,
910 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
911 { .name = "dup2", .errmsg = true,
912 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
913 { .name = "dup3", .errmsg = true,
914 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
915 { .name = "epoll_ctl", .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
916 { .name = "eventfd2", .errmsg = true,
917 .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
918 { .name = "faccessat", .errmsg = true,
919 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
920 { .name = "fadvise64", .errmsg = true,
921 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
922 { .name = "fallocate", .errmsg = true,
923 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
924 { .name = "fchdir", .errmsg = true,
925 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
926 { .name = "fchmod", .errmsg = true,
927 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
928 { .name = "fchmodat", .errmsg = true,
929 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
930 { .name = "fchown", .errmsg = true,
931 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
932 { .name = "fchownat", .errmsg = true,
933 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
934 { .name = "fcntl", .errmsg = true,
935 .arg_scnprintf = { [0] = SCA_FD, /* fd */
936 [1] = SCA_STRARRAY, /* cmd */ },
937 .arg_parm = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
938 { .name = "fdatasync", .errmsg = true,
939 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
940 { .name = "flock", .errmsg = true,
941 .arg_scnprintf = { [0] = SCA_FD, /* fd */
942 [1] = SCA_FLOCK, /* cmd */ }, },
943 { .name = "fsetxattr", .errmsg = true,
944 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
945 { .name = "fstat", .errmsg = true, .alias = "newfstat",
946 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
947 { .name = "fstatat", .errmsg = true, .alias = "newfstatat",
948 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
949 { .name = "fstatfs", .errmsg = true,
950 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
951 { .name = "fsync", .errmsg = true,
952 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
953 { .name = "ftruncate", .errmsg = true,
954 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
955 { .name = "futex", .errmsg = true,
956 .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
957 { .name = "futimesat", .errmsg = true,
958 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
959 { .name = "getdents", .errmsg = true,
960 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
961 { .name = "getdents64", .errmsg = true,
962 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
963 { .name = "getitimer", .errmsg = true, STRARRAY(0, which, itimers), },
964 { .name = "getrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
965 { .name = "ioctl", .errmsg = true,
966 .arg_scnprintf = { [0] = SCA_FD, /* fd */
967 #if defined(__i386__) || defined(__x86_64__)
968 /*
969 * FIXME: Make this available to all arches.
970 */
971 [1] = SCA_STRHEXARRAY, /* cmd */
972 [2] = SCA_HEX, /* arg */ },
973 .arg_parm = { [1] = &strarray__tioctls, /* cmd */ }, },
974 #else
975 [2] = SCA_HEX, /* arg */ }, },
976 #endif
977 { .name = "kill", .errmsg = true,
978 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
979 { .name = "linkat", .errmsg = true,
980 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
981 { .name = "lseek", .errmsg = true,
982 .arg_scnprintf = { [0] = SCA_FD, /* fd */
983 [2] = SCA_STRARRAY, /* whence */ },
984 .arg_parm = { [2] = &strarray__whences, /* whence */ }, },
985 { .name = "lstat", .errmsg = true, .alias = "newlstat", },
986 { .name = "madvise", .errmsg = true,
987 .arg_scnprintf = { [0] = SCA_HEX, /* start */
988 [2] = SCA_MADV_BHV, /* behavior */ }, },
989 { .name = "mkdirat", .errmsg = true,
990 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
991 { .name = "mknodat", .errmsg = true,
992 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
993 { .name = "mlock", .errmsg = true,
994 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
995 { .name = "mlockall", .errmsg = true,
996 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
997 { .name = "mmap", .hexret = true,
998 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
999 [2] = SCA_MMAP_PROT, /* prot */
1000 [3] = SCA_MMAP_FLAGS, /* flags */
1001 [4] = SCA_FD, /* fd */ }, },
1002 { .name = "mprotect", .errmsg = true,
1003 .arg_scnprintf = { [0] = SCA_HEX, /* start */
1004 [2] = SCA_MMAP_PROT, /* prot */ }, },
1005 { .name = "mremap", .hexret = true,
1006 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
1007 [4] = SCA_HEX, /* new_addr */ }, },
1008 { .name = "munlock", .errmsg = true,
1009 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1010 { .name = "munmap", .errmsg = true,
1011 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1012 { .name = "name_to_handle_at", .errmsg = true,
1013 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1014 { .name = "newfstatat", .errmsg = true,
1015 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1016 { .name = "open", .errmsg = true,
1017 .arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
1018 { .name = "open_by_handle_at", .errmsg = true,
1019 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1020 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1021 { .name = "openat", .errmsg = true,
1022 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1023 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1024 { .name = "pipe2", .errmsg = true,
1025 .arg_scnprintf = { [1] = SCA_PIPE_FLAGS, /* flags */ }, },
1026 { .name = "poll", .errmsg = true, .timeout = true, },
1027 { .name = "ppoll", .errmsg = true, .timeout = true, },
1028 { .name = "pread", .errmsg = true, .alias = "pread64",
1029 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1030 { .name = "preadv", .errmsg = true, .alias = "pread",
1031 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1032 { .name = "prlimit64", .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
1033 { .name = "pwrite", .errmsg = true, .alias = "pwrite64",
1034 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1035 { .name = "pwritev", .errmsg = true,
1036 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1037 { .name = "read", .errmsg = true,
1038 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1039 { .name = "readlinkat", .errmsg = true,
1040 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1041 { .name = "readv", .errmsg = true,
1042 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1043 { .name = "recvfrom", .errmsg = true,
1044 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1045 { .name = "recvmmsg", .errmsg = true,
1046 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1047 { .name = "recvmsg", .errmsg = true,
1048 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
1049 { .name = "renameat", .errmsg = true,
1050 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1051 { .name = "rt_sigaction", .errmsg = true,
1052 .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
1053 { .name = "rt_sigprocmask", .errmsg = true, STRARRAY(0, how, sighow), },
1054 { .name = "rt_sigqueueinfo", .errmsg = true,
1055 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1056 { .name = "rt_tgsigqueueinfo", .errmsg = true,
1057 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1058 { .name = "select", .errmsg = true, .timeout = true, },
1059 { .name = "sendmmsg", .errmsg = true,
1060 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1061 { .name = "sendmsg", .errmsg = true,
1062 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
1063 { .name = "sendto", .errmsg = true,
1064 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1065 { .name = "setitimer", .errmsg = true, STRARRAY(0, which, itimers), },
1066 { .name = "setrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
1067 { .name = "shutdown", .errmsg = true,
1068 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1069 { .name = "socket", .errmsg = true,
1070 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1071 [1] = SCA_SK_TYPE, /* type */ },
1072 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
1073 { .name = "socketpair", .errmsg = true,
1074 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1075 [1] = SCA_SK_TYPE, /* type */ },
1076 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
1077 { .name = "stat", .errmsg = true, .alias = "newstat", },
1078 { .name = "symlinkat", .errmsg = true,
1079 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1080 { .name = "tgkill", .errmsg = true,
1081 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1082 { .name = "tkill", .errmsg = true,
1083 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1084 { .name = "uname", .errmsg = true, .alias = "newuname", },
1085 { .name = "unlinkat", .errmsg = true,
1086 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1087 { .name = "utimensat", .errmsg = true,
1088 .arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */ }, },
1089 { .name = "write", .errmsg = true,
1090 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1091 { .name = "writev", .errmsg = true,
1092 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1093 };
1094
1095 static int syscall_fmt__cmp(const void *name, const void *fmtp)
1096 {
1097 const struct syscall_fmt *fmt = fmtp;
1098 return strcmp(name, fmt->name);
1099 }
1100
1101 static struct syscall_fmt *syscall_fmt__find(const char *name)
1102 {
1103 const int nmemb = ARRAY_SIZE(syscall_fmts);
1104 return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
1105 }
1106
1107 struct syscall {
1108 struct event_format *tp_format;
1109 const char *name;
1110 bool filtered;
1111 bool is_exit;
1112 struct syscall_fmt *fmt;
1113 size_t (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
1114 void **arg_parm;
1115 };
1116
1117 static size_t fprintf_duration(unsigned long t, FILE *fp)
1118 {
1119 double duration = (double)t / NSEC_PER_MSEC;
1120 size_t printed = fprintf(fp, "(");
1121
1122 if (duration >= 1.0)
1123 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
1124 else if (duration >= 0.01)
1125 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
1126 else
1127 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
1128 return printed + fprintf(fp, "): ");
1129 }
1130
1131 struct thread_trace {
1132 u64 entry_time;
1133 u64 exit_time;
1134 bool entry_pending;
1135 unsigned long nr_events;
1136 char *entry_str;
1137 double runtime_ms;
1138 struct {
1139 int max;
1140 char **table;
1141 } paths;
1142
1143 struct intlist *syscall_stats;
1144 };
1145
1146 static struct thread_trace *thread_trace__new(void)
1147 {
1148 struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));
1149
1150 if (ttrace)
1151 ttrace->paths.max = -1;
1152
1153 ttrace->syscall_stats = intlist__new(NULL);
1154
1155 return ttrace;
1156 }
1157
1158 static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
1159 {
1160 struct thread_trace *ttrace;
1161
1162 if (thread == NULL)
1163 goto fail;
1164
1165 if (thread->priv == NULL)
1166 thread->priv = thread_trace__new();
1167
1168 if (thread->priv == NULL)
1169 goto fail;
1170
1171 ttrace = thread->priv;
1172 ++ttrace->nr_events;
1173
1174 return ttrace;
1175 fail:
1176 color_fprintf(fp, PERF_COLOR_RED,
1177 "WARNING: not enough memory, dropping samples!\n");
1178 return NULL;
1179 }
1180
1181 #define TRACE_PFMAJ (1 << 0)
1182 #define TRACE_PFMIN (1 << 1)
1183
1184 struct trace {
1185 struct perf_tool tool;
1186 struct {
1187 int machine;
1188 int open_id;
1189 } audit;
1190 struct {
1191 int max;
1192 struct syscall *table;
1193 } syscalls;
1194 struct record_opts opts;
1195 struct machine *host;
1196 u64 base_time;
1197 FILE *output;
1198 unsigned long nr_events;
1199 struct strlist *ev_qualifier;
1200 const char *last_vfs_getname;
1201 struct intlist *tid_list;
1202 struct intlist *pid_list;
1203 double duration_filter;
1204 double runtime_ms;
1205 struct {
1206 u64 vfs_getname,
1207 proc_getname;
1208 } stats;
1209 bool not_ev_qualifier;
1210 bool live;
1211 bool full_time;
1212 bool sched;
1213 bool multiple_threads;
1214 bool summary;
1215 bool summary_only;
1216 bool show_comm;
1217 bool show_tool_stats;
1218 bool trace_syscalls;
1219 int trace_pgfaults;
1220 };
1221
1222 static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
1223 {
1224 struct thread_trace *ttrace = thread->priv;
1225
1226 if (fd > ttrace->paths.max) {
1227 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
1228
1229 if (npath == NULL)
1230 return -1;
1231
1232 if (ttrace->paths.max != -1) {
1233 memset(npath + ttrace->paths.max + 1, 0,
1234 (fd - ttrace->paths.max) * sizeof(char *));
1235 } else {
1236 memset(npath, 0, (fd + 1) * sizeof(char *));
1237 }
1238
1239 ttrace->paths.table = npath;
1240 ttrace->paths.max = fd;
1241 }
1242
1243 ttrace->paths.table[fd] = strdup(pathname);
1244
1245 return ttrace->paths.table[fd] != NULL ? 0 : -1;
1246 }
1247
1248 static int thread__read_fd_path(struct thread *thread, int fd)
1249 {
1250 char linkname[PATH_MAX], pathname[PATH_MAX];
1251 struct stat st;
1252 int ret;
1253
1254 if (thread->pid_ == thread->tid) {
1255 scnprintf(linkname, sizeof(linkname),
1256 "/proc/%d/fd/%d", thread->pid_, fd);
1257 } else {
1258 scnprintf(linkname, sizeof(linkname),
1259 "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
1260 }
1261
1262 if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1263 return -1;
1264
1265 ret = readlink(linkname, pathname, sizeof(pathname));
1266
1267 if (ret < 0 || ret > st.st_size)
1268 return -1;
1269
1270 pathname[ret] = '\0';
1271 return trace__set_fd_pathname(thread, fd, pathname);
1272 }
1273
1274 static const char *thread__fd_path(struct thread *thread, int fd,
1275 struct trace *trace)
1276 {
1277 struct thread_trace *ttrace = thread->priv;
1278
1279 if (ttrace == NULL)
1280 return NULL;
1281
1282 if (fd < 0)
1283 return NULL;
1284
1285 if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
1286 if (!trace->live)
1287 return NULL;
1288 ++trace->stats.proc_getname;
1289 if (thread__read_fd_path(thread, fd))
1290 return NULL;
1291 }
1292
1293 return ttrace->paths.table[fd];
1294 }
1295
1296 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
1297 struct syscall_arg *arg)
1298 {
1299 int fd = arg->val;
1300 size_t printed = scnprintf(bf, size, "%d", fd);
1301 const char *path = thread__fd_path(arg->thread, fd, arg->trace);
1302
1303 if (path)
1304 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1305
1306 return printed;
1307 }
1308
1309 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1310 struct syscall_arg *arg)
1311 {
1312 int fd = arg->val;
1313 size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
1314 struct thread_trace *ttrace = arg->thread->priv;
1315
1316 if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
1317 zfree(&ttrace->paths.table[fd]);
1318
1319 return printed;
1320 }
1321
1322 static bool trace__filter_duration(struct trace *trace, double t)
1323 {
1324 return t < (trace->duration_filter * NSEC_PER_MSEC);
1325 }
1326
1327 static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1328 {
1329 double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1330
1331 return fprintf(fp, "%10.3f ", ts);
1332 }
1333
1334 static bool done = false;
1335 static bool interrupted = false;
1336
1337 static void sig_handler(int sig)
1338 {
1339 done = true;
1340 interrupted = sig == SIGINT;
1341 }
1342
1343 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
1344 u64 duration, u64 tstamp, FILE *fp)
1345 {
1346 size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
1347 printed += fprintf_duration(duration, fp);
1348
1349 if (trace->multiple_threads) {
1350 if (trace->show_comm)
1351 printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
1352 printed += fprintf(fp, "%d ", thread->tid);
1353 }
1354
1355 return printed;
1356 }
1357
1358 static int trace__process_event(struct trace *trace, struct machine *machine,
1359 union perf_event *event, struct perf_sample *sample)
1360 {
1361 int ret = 0;
1362
1363 switch (event->header.type) {
1364 case PERF_RECORD_LOST:
1365 color_fprintf(trace->output, PERF_COLOR_RED,
1366 "LOST %" PRIu64 " events!\n", event->lost.lost);
1367 ret = machine__process_lost_event(machine, event, sample);
1368 default:
1369 ret = machine__process_event(machine, event, sample);
1370 break;
1371 }
1372
1373 return ret;
1374 }
1375
1376 static int trace__tool_process(struct perf_tool *tool,
1377 union perf_event *event,
1378 struct perf_sample *sample,
1379 struct machine *machine)
1380 {
1381 struct trace *trace = container_of(tool, struct trace, tool);
1382 return trace__process_event(trace, machine, event, sample);
1383 }
1384
1385 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1386 {
1387 int err = symbol__init();
1388
1389 if (err)
1390 return err;
1391
1392 trace->host = machine__new_host();
1393 if (trace->host == NULL)
1394 return -ENOMEM;
1395
1396 err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
1397 evlist->threads, trace__tool_process, false);
1398 if (err)
1399 symbol__exit();
1400
1401 return err;
1402 }
1403
1404 static int syscall__set_arg_fmts(struct syscall *sc)
1405 {
1406 struct format_field *field;
1407 int idx = 0;
1408
1409 sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
1410 if (sc->arg_scnprintf == NULL)
1411 return -1;
1412
1413 if (sc->fmt)
1414 sc->arg_parm = sc->fmt->arg_parm;
1415
1416 for (field = sc->tp_format->format.fields->next; field; field = field->next) {
1417 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
1418 sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
1419 else if (field->flags & FIELD_IS_POINTER)
1420 sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
1421 ++idx;
1422 }
1423
1424 return 0;
1425 }
1426
1427 static int trace__read_syscall_info(struct trace *trace, int id)
1428 {
1429 char tp_name[128];
1430 struct syscall *sc;
1431 const char *name = audit_syscall_to_name(id, trace->audit.machine);
1432
1433 if (name == NULL)
1434 return -1;
1435
1436 if (id > trace->syscalls.max) {
1437 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1438
1439 if (nsyscalls == NULL)
1440 return -1;
1441
1442 if (trace->syscalls.max != -1) {
1443 memset(nsyscalls + trace->syscalls.max + 1, 0,
1444 (id - trace->syscalls.max) * sizeof(*sc));
1445 } else {
1446 memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1447 }
1448
1449 trace->syscalls.table = nsyscalls;
1450 trace->syscalls.max = id;
1451 }
1452
1453 sc = trace->syscalls.table + id;
1454 sc->name = name;
1455
1456 if (trace->ev_qualifier) {
1457 bool in = strlist__find(trace->ev_qualifier, name) != NULL;
1458
1459 if (!(in ^ trace->not_ev_qualifier)) {
1460 sc->filtered = true;
1461 /*
1462 * No need to do read tracepoint information since this will be
1463 * filtered out.
1464 */
1465 return 0;
1466 }
1467 }
1468
1469 sc->fmt = syscall_fmt__find(sc->name);
1470
1471 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
1472 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1473
1474 if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
1475 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
1476 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1477 }
1478
1479 if (sc->tp_format == NULL)
1480 return -1;
1481
1482 sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
1483
1484 return syscall__set_arg_fmts(sc);
1485 }
1486
1487 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
1488 unsigned long *args, struct trace *trace,
1489 struct thread *thread)
1490 {
1491 size_t printed = 0;
1492
1493 if (sc->tp_format != NULL) {
1494 struct format_field *field;
1495 u8 bit = 1;
1496 struct syscall_arg arg = {
1497 .idx = 0,
1498 .mask = 0,
1499 .trace = trace,
1500 .thread = thread,
1501 };
1502
1503 for (field = sc->tp_format->format.fields->next; field;
1504 field = field->next, ++arg.idx, bit <<= 1) {
1505 if (arg.mask & bit)
1506 continue;
1507 /*
1508 * Suppress this argument if its value is zero and
1509 * and we don't have a string associated in an
1510 * strarray for it.
1511 */
1512 if (args[arg.idx] == 0 &&
1513 !(sc->arg_scnprintf &&
1514 sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
1515 sc->arg_parm[arg.idx]))
1516 continue;
1517
1518 printed += scnprintf(bf + printed, size - printed,
1519 "%s%s: ", printed ? ", " : "", field->name);
1520 if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
1521 arg.val = args[arg.idx];
1522 if (sc->arg_parm)
1523 arg.parm = sc->arg_parm[arg.idx];
1524 printed += sc->arg_scnprintf[arg.idx](bf + printed,
1525 size - printed, &arg);
1526 } else {
1527 printed += scnprintf(bf + printed, size - printed,
1528 "%ld", args[arg.idx]);
1529 }
1530 }
1531 } else {
1532 int i = 0;
1533
1534 while (i < 6) {
1535 printed += scnprintf(bf + printed, size - printed,
1536 "%sarg%d: %ld",
1537 printed ? ", " : "", i, args[i]);
1538 ++i;
1539 }
1540 }
1541
1542 return printed;
1543 }
1544
1545 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
1546 union perf_event *event,
1547 struct perf_sample *sample);
1548
1549 static struct syscall *trace__syscall_info(struct trace *trace,
1550 struct perf_evsel *evsel, int id)
1551 {
1552
1553 if (id < 0) {
1554
1555 /*
1556 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1557 * before that, leaving at a higher verbosity level till that is
1558 * explained. Reproduced with plain ftrace with:
1559 *
1560 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1561 * grep "NR -1 " /t/trace_pipe
1562 *
1563 * After generating some load on the machine.
1564 */
1565 if (verbose > 1) {
1566 static u64 n;
1567 fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1568 id, perf_evsel__name(evsel), ++n);
1569 }
1570 return NULL;
1571 }
1572
1573 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1574 trace__read_syscall_info(trace, id))
1575 goto out_cant_read;
1576
1577 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1578 goto out_cant_read;
1579
1580 return &trace->syscalls.table[id];
1581
1582 out_cant_read:
1583 if (verbose) {
1584 fprintf(trace->output, "Problems reading syscall %d", id);
1585 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1586 fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1587 fputs(" information\n", trace->output);
1588 }
1589 return NULL;
1590 }
1591
1592 static void thread__update_stats(struct thread_trace *ttrace,
1593 int id, struct perf_sample *sample)
1594 {
1595 struct int_node *inode;
1596 struct stats *stats;
1597 u64 duration = 0;
1598
1599 inode = intlist__findnew(ttrace->syscall_stats, id);
1600 if (inode == NULL)
1601 return;
1602
1603 stats = inode->priv;
1604 if (stats == NULL) {
1605 stats = malloc(sizeof(struct stats));
1606 if (stats == NULL)
1607 return;
1608 init_stats(stats);
1609 inode->priv = stats;
1610 }
1611
1612 if (ttrace->entry_time && sample->time > ttrace->entry_time)
1613 duration = sample->time - ttrace->entry_time;
1614
1615 update_stats(stats, duration);
1616 }
1617
1618 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1619 union perf_event *event __maybe_unused,
1620 struct perf_sample *sample)
1621 {
1622 char *msg;
1623 void *args;
1624 size_t printed = 0;
1625 struct thread *thread;
1626 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
1627 struct syscall *sc = trace__syscall_info(trace, evsel, id);
1628 struct thread_trace *ttrace;
1629
1630 if (sc == NULL)
1631 return -1;
1632
1633 if (sc->filtered)
1634 return 0;
1635
1636 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1637 ttrace = thread__trace(thread, trace->output);
1638 if (ttrace == NULL)
1639 return -1;
1640
1641 args = perf_evsel__sc_tp_ptr(evsel, args, sample);
1642
1643 if (ttrace->entry_str == NULL) {
1644 ttrace->entry_str = malloc(1024);
1645 if (!ttrace->entry_str)
1646 return -1;
1647 }
1648
1649 ttrace->entry_time = sample->time;
1650 msg = ttrace->entry_str;
1651 printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
1652
1653 printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed,
1654 args, trace, thread);
1655
1656 if (sc->is_exit) {
1657 if (!trace->duration_filter && !trace->summary_only) {
1658 trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
1659 fprintf(trace->output, "%-70s\n", ttrace->entry_str);
1660 }
1661 } else
1662 ttrace->entry_pending = true;
1663
1664 return 0;
1665 }
1666
1667 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
1668 union perf_event *event __maybe_unused,
1669 struct perf_sample *sample)
1670 {
1671 int ret;
1672 u64 duration = 0;
1673 struct thread *thread;
1674 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
1675 struct syscall *sc = trace__syscall_info(trace, evsel, id);
1676 struct thread_trace *ttrace;
1677
1678 if (sc == NULL)
1679 return -1;
1680
1681 if (sc->filtered)
1682 return 0;
1683
1684 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1685 ttrace = thread__trace(thread, trace->output);
1686 if (ttrace == NULL)
1687 return -1;
1688
1689 if (trace->summary)
1690 thread__update_stats(ttrace, id, sample);
1691
1692 ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
1693
1694 if (id == trace->audit.open_id && ret >= 0 && trace->last_vfs_getname) {
1695 trace__set_fd_pathname(thread, ret, trace->last_vfs_getname);
1696 trace->last_vfs_getname = NULL;
1697 ++trace->stats.vfs_getname;
1698 }
1699
1700 ttrace->exit_time = sample->time;
1701
1702 if (ttrace->entry_time) {
1703 duration = sample->time - ttrace->entry_time;
1704 if (trace__filter_duration(trace, duration))
1705 goto out;
1706 } else if (trace->duration_filter)
1707 goto out;
1708
1709 if (trace->summary_only)
1710 goto out;
1711
1712 trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
1713
1714 if (ttrace->entry_pending) {
1715 fprintf(trace->output, "%-70s", ttrace->entry_str);
1716 } else {
1717 fprintf(trace->output, " ... [");
1718 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1719 fprintf(trace->output, "]: %s()", sc->name);
1720 }
1721
1722 if (sc->fmt == NULL) {
1723 signed_print:
1724 fprintf(trace->output, ") = %d", ret);
1725 } else if (ret < 0 && sc->fmt->errmsg) {
1726 char bf[256];
1727 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
1728 *e = audit_errno_to_name(-ret);
1729
1730 fprintf(trace->output, ") = -1 %s %s", e, emsg);
1731 } else if (ret == 0 && sc->fmt->timeout)
1732 fprintf(trace->output, ") = 0 Timeout");
1733 else if (sc->fmt->hexret)
1734 fprintf(trace->output, ") = %#x", ret);
1735 else
1736 goto signed_print;
1737
1738 fputc('\n', trace->output);
1739 out:
1740 ttrace->entry_pending = false;
1741
1742 return 0;
1743 }
1744
1745 static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
1746 union perf_event *event __maybe_unused,
1747 struct perf_sample *sample)
1748 {
1749 trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
1750 return 0;
1751 }
1752
1753 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
1754 union perf_event *event __maybe_unused,
1755 struct perf_sample *sample)
1756 {
1757 u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
1758 double runtime_ms = (double)runtime / NSEC_PER_MSEC;
1759 struct thread *thread = machine__findnew_thread(trace->host,
1760 sample->pid,
1761 sample->tid);
1762 struct thread_trace *ttrace = thread__trace(thread, trace->output);
1763
1764 if (ttrace == NULL)
1765 goto out_dump;
1766
1767 ttrace->runtime_ms += runtime_ms;
1768 trace->runtime_ms += runtime_ms;
1769 return 0;
1770
1771 out_dump:
1772 fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1773 evsel->name,
1774 perf_evsel__strval(evsel, sample, "comm"),
1775 (pid_t)perf_evsel__intval(evsel, sample, "pid"),
1776 runtime,
1777 perf_evsel__intval(evsel, sample, "vruntime"));
1778 return 0;
1779 }
1780
1781 static void print_location(FILE *f, struct perf_sample *sample,
1782 struct addr_location *al,
1783 bool print_dso, bool print_sym)
1784 {
1785
1786 if ((verbose || print_dso) && al->map)
1787 fprintf(f, "%s@", al->map->dso->long_name);
1788
1789 if ((verbose || print_sym) && al->sym)
1790 fprintf(f, "%s+0x%lx", al->sym->name,
1791 al->addr - al->sym->start);
1792 else if (al->map)
1793 fprintf(f, "0x%lx", al->addr);
1794 else
1795 fprintf(f, "0x%lx", sample->addr);
1796 }
1797
1798 static int trace__pgfault(struct trace *trace,
1799 struct perf_evsel *evsel,
1800 union perf_event *event,
1801 struct perf_sample *sample)
1802 {
1803 struct thread *thread;
1804 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1805 struct addr_location al;
1806 char map_type = 'd';
1807
1808 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1809
1810 thread__find_addr_location(thread, trace->host, cpumode, MAP__FUNCTION,
1811 sample->ip, &al);
1812
1813 trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
1814
1815 fprintf(trace->output, "%sfault [",
1816 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
1817 "maj" : "min");
1818
1819 print_location(trace->output, sample, &al, false, true);
1820
1821 fprintf(trace->output, "] => ");
1822
1823 thread__find_addr_location(thread, trace->host, cpumode, MAP__VARIABLE,
1824 sample->addr, &al);
1825
1826 if (!al.map) {
1827 thread__find_addr_location(thread, trace->host, cpumode,
1828 MAP__FUNCTION, sample->addr, &al);
1829
1830 if (al.map)
1831 map_type = 'x';
1832 else
1833 map_type = '?';
1834 }
1835
1836 print_location(trace->output, sample, &al, true, false);
1837
1838 fprintf(trace->output, " (%c%c)\n", map_type, al.level);
1839
1840 return 0;
1841 }
1842
1843 static bool skip_sample(struct trace *trace, struct perf_sample *sample)
1844 {
1845 if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
1846 (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
1847 return false;
1848
1849 if (trace->pid_list || trace->tid_list)
1850 return true;
1851
1852 return false;
1853 }
1854
1855 static int trace__process_sample(struct perf_tool *tool,
1856 union perf_event *event,
1857 struct perf_sample *sample,
1858 struct perf_evsel *evsel,
1859 struct machine *machine __maybe_unused)
1860 {
1861 struct trace *trace = container_of(tool, struct trace, tool);
1862 int err = 0;
1863
1864 tracepoint_handler handler = evsel->handler;
1865
1866 if (skip_sample(trace, sample))
1867 return 0;
1868
1869 if (!trace->full_time && trace->base_time == 0)
1870 trace->base_time = sample->time;
1871
1872 if (handler) {
1873 ++trace->nr_events;
1874 handler(trace, evsel, event, sample);
1875 }
1876
1877 return err;
1878 }
1879
1880 static int parse_target_str(struct trace *trace)
1881 {
1882 if (trace->opts.target.pid) {
1883 trace->pid_list = intlist__new(trace->opts.target.pid);
1884 if (trace->pid_list == NULL) {
1885 pr_err("Error parsing process id string\n");
1886 return -EINVAL;
1887 }
1888 }
1889
1890 if (trace->opts.target.tid) {
1891 trace->tid_list = intlist__new(trace->opts.target.tid);
1892 if (trace->tid_list == NULL) {
1893 pr_err("Error parsing thread id string\n");
1894 return -EINVAL;
1895 }
1896 }
1897
1898 return 0;
1899 }
1900
1901 static int trace__record(struct trace *trace, int argc, const char **argv)
1902 {
1903 unsigned int rec_argc, i, j;
1904 const char **rec_argv;
1905 const char * const record_args[] = {
1906 "record",
1907 "-R",
1908 "-m", "1024",
1909 "-c", "1",
1910 };
1911
1912 const char * const sc_args[] = { "-e", };
1913 unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
1914 const char * const majpf_args[] = { "-e", "major-faults" };
1915 unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
1916 const char * const minpf_args[] = { "-e", "minor-faults" };
1917 unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
1918
1919 /* +1 is for the event string below */
1920 rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
1921 majpf_args_nr + minpf_args_nr + argc;
1922 rec_argv = calloc(rec_argc + 1, sizeof(char *));
1923
1924 if (rec_argv == NULL)
1925 return -ENOMEM;
1926
1927 j = 0;
1928 for (i = 0; i < ARRAY_SIZE(record_args); i++)
1929 rec_argv[j++] = record_args[i];
1930
1931 if (trace->trace_syscalls) {
1932 for (i = 0; i < sc_args_nr; i++)
1933 rec_argv[j++] = sc_args[i];
1934
1935 /* event string may be different for older kernels - e.g., RHEL6 */
1936 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
1937 rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
1938 else if (is_valid_tracepoint("syscalls:sys_enter"))
1939 rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
1940 else {
1941 pr_err("Neither raw_syscalls nor syscalls events exist.\n");
1942 return -1;
1943 }
1944 }
1945
1946 if (trace->trace_pgfaults & TRACE_PFMAJ)
1947 for (i = 0; i < majpf_args_nr; i++)
1948 rec_argv[j++] = majpf_args[i];
1949
1950 if (trace->trace_pgfaults & TRACE_PFMIN)
1951 for (i = 0; i < minpf_args_nr; i++)
1952 rec_argv[j++] = minpf_args[i];
1953
1954 for (i = 0; i < (unsigned int)argc; i++)
1955 rec_argv[j++] = argv[i];
1956
1957 return cmd_record(j, rec_argv, NULL);
1958 }
1959
1960 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
1961
1962 static void perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
1963 {
1964 struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
1965 if (evsel == NULL)
1966 return;
1967
1968 if (perf_evsel__field(evsel, "pathname") == NULL) {
1969 perf_evsel__delete(evsel);
1970 return;
1971 }
1972
1973 evsel->handler = trace__vfs_getname;
1974 perf_evlist__add(evlist, evsel);
1975 }
1976
1977 static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
1978 u64 config)
1979 {
1980 struct perf_evsel *evsel;
1981 struct perf_event_attr attr = {
1982 .type = PERF_TYPE_SOFTWARE,
1983 .mmap_data = 1,
1984 .sample_period = 1,
1985 };
1986
1987 attr.config = config;
1988
1989 event_attr_init(&attr);
1990
1991 evsel = perf_evsel__new(&attr);
1992 if (!evsel)
1993 return -ENOMEM;
1994
1995 evsel->handler = trace__pgfault;
1996 perf_evlist__add(evlist, evsel);
1997
1998 return 0;
1999 }
2000
2001 static int trace__run(struct trace *trace, int argc, const char **argv)
2002 {
2003 struct perf_evlist *evlist = perf_evlist__new();
2004 struct perf_evsel *evsel;
2005 int err = -1, i;
2006 unsigned long before;
2007 const bool forks = argc > 0;
2008
2009 trace->live = true;
2010
2011 if (evlist == NULL) {
2012 fprintf(trace->output, "Not enough memory to run!\n");
2013 goto out;
2014 }
2015
2016 if (trace->trace_syscalls &&
2017 perf_evlist__add_syscall_newtp(evlist, trace__sys_enter,
2018 trace__sys_exit))
2019 goto out_error_tp;
2020
2021 if (trace->trace_syscalls)
2022 perf_evlist__add_vfs_getname(evlist);
2023
2024 if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
2025 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ))
2026 goto out_error_tp;
2027
2028 if ((trace->trace_pgfaults & TRACE_PFMIN) &&
2029 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
2030 goto out_error_tp;
2031
2032 if (trace->sched &&
2033 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2034 trace__sched_stat_runtime))
2035 goto out_error_tp;
2036
2037 err = perf_evlist__create_maps(evlist, &trace->opts.target);
2038 if (err < 0) {
2039 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
2040 goto out_delete_evlist;
2041 }
2042
2043 err = trace__symbols_init(trace, evlist);
2044 if (err < 0) {
2045 fprintf(trace->output, "Problems initializing symbol libraries!\n");
2046 goto out_delete_evlist;
2047 }
2048
2049 perf_evlist__config(evlist, &trace->opts);
2050
2051 signal(SIGCHLD, sig_handler);
2052 signal(SIGINT, sig_handler);
2053
2054 if (forks) {
2055 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
2056 argv, false, NULL);
2057 if (err < 0) {
2058 fprintf(trace->output, "Couldn't run the workload!\n");
2059 goto out_delete_evlist;
2060 }
2061 }
2062
2063 err = perf_evlist__open(evlist);
2064 if (err < 0)
2065 goto out_error_open;
2066
2067 err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
2068 if (err < 0) {
2069 fprintf(trace->output, "Couldn't mmap the events: %s\n", strerror(errno));
2070 goto out_delete_evlist;
2071 }
2072
2073 perf_evlist__enable(evlist);
2074
2075 if (forks)
2076 perf_evlist__start_workload(evlist);
2077
2078 trace->multiple_threads = evlist->threads->map[0] == -1 || evlist->threads->nr > 1;
2079 again:
2080 before = trace->nr_events;
2081
2082 for (i = 0; i < evlist->nr_mmaps; i++) {
2083 union perf_event *event;
2084
2085 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
2086 const u32 type = event->header.type;
2087 tracepoint_handler handler;
2088 struct perf_sample sample;
2089
2090 ++trace->nr_events;
2091
2092 err = perf_evlist__parse_sample(evlist, event, &sample);
2093 if (err) {
2094 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
2095 goto next_event;
2096 }
2097
2098 if (!trace->full_time && trace->base_time == 0)
2099 trace->base_time = sample.time;
2100
2101 if (type != PERF_RECORD_SAMPLE) {
2102 trace__process_event(trace, trace->host, event, &sample);
2103 continue;
2104 }
2105
2106 evsel = perf_evlist__id2evsel(evlist, sample.id);
2107 if (evsel == NULL) {
2108 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
2109 goto next_event;
2110 }
2111
2112 if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2113 sample.raw_data == NULL) {
2114 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2115 perf_evsel__name(evsel), sample.tid,
2116 sample.cpu, sample.raw_size);
2117 goto next_event;
2118 }
2119
2120 handler = evsel->handler;
2121 handler(trace, evsel, event, &sample);
2122 next_event:
2123 perf_evlist__mmap_consume(evlist, i);
2124
2125 if (interrupted)
2126 goto out_disable;
2127 }
2128 }
2129
2130 if (trace->nr_events == before) {
2131 int timeout = done ? 100 : -1;
2132
2133 if (poll(evlist->pollfd, evlist->nr_fds, timeout) > 0)
2134 goto again;
2135 } else {
2136 goto again;
2137 }
2138
2139 out_disable:
2140 perf_evlist__disable(evlist);
2141
2142 if (!err) {
2143 if (trace->summary)
2144 trace__fprintf_thread_summary(trace, trace->output);
2145
2146 if (trace->show_tool_stats) {
2147 fprintf(trace->output, "Stats:\n "
2148 " vfs_getname : %" PRIu64 "\n"
2149 " proc_getname: %" PRIu64 "\n",
2150 trace->stats.vfs_getname,
2151 trace->stats.proc_getname);
2152 }
2153 }
2154
2155 out_delete_evlist:
2156 perf_evlist__delete(evlist);
2157 out:
2158 trace->live = false;
2159 return err;
2160 {
2161 char errbuf[BUFSIZ];
2162
2163 out_error_tp:
2164 perf_evlist__strerror_tp(evlist, errno, errbuf, sizeof(errbuf));
2165 goto out_error;
2166
2167 out_error_open:
2168 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2169
2170 out_error:
2171 fprintf(trace->output, "%s\n", errbuf);
2172 goto out_delete_evlist;
2173 }
2174 }
2175
2176 static int trace__replay(struct trace *trace)
2177 {
2178 const struct perf_evsel_str_handler handlers[] = {
2179 { "probe:vfs_getname", trace__vfs_getname, },
2180 };
2181 struct perf_data_file file = {
2182 .path = input_name,
2183 .mode = PERF_DATA_MODE_READ,
2184 };
2185 struct perf_session *session;
2186 struct perf_evsel *evsel;
2187 int err = -1;
2188
2189 trace->tool.sample = trace__process_sample;
2190 trace->tool.mmap = perf_event__process_mmap;
2191 trace->tool.mmap2 = perf_event__process_mmap2;
2192 trace->tool.comm = perf_event__process_comm;
2193 trace->tool.exit = perf_event__process_exit;
2194 trace->tool.fork = perf_event__process_fork;
2195 trace->tool.attr = perf_event__process_attr;
2196 trace->tool.tracing_data = perf_event__process_tracing_data;
2197 trace->tool.build_id = perf_event__process_build_id;
2198
2199 trace->tool.ordered_samples = true;
2200 trace->tool.ordering_requires_timestamps = true;
2201
2202 /* add tid to output */
2203 trace->multiple_threads = true;
2204
2205 if (symbol__init() < 0)
2206 return -1;
2207
2208 session = perf_session__new(&file, false, &trace->tool);
2209 if (session == NULL)
2210 return -ENOMEM;
2211
2212 trace->host = &session->machines.host;
2213
2214 err = perf_session__set_tracepoints_handlers(session, handlers);
2215 if (err)
2216 goto out;
2217
2218 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2219 "raw_syscalls:sys_enter");
2220 /* older kernels have syscalls tp versus raw_syscalls */
2221 if (evsel == NULL)
2222 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2223 "syscalls:sys_enter");
2224
2225 if (evsel &&
2226 (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2227 perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
2228 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2229 goto out;
2230 }
2231
2232 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2233 "raw_syscalls:sys_exit");
2234 if (evsel == NULL)
2235 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2236 "syscalls:sys_exit");
2237 if (evsel &&
2238 (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2239 perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
2240 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
2241 goto out;
2242 }
2243
2244 evlist__for_each(session->evlist, evsel) {
2245 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2246 (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2247 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2248 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2249 evsel->handler = trace__pgfault;
2250 }
2251
2252 err = parse_target_str(trace);
2253 if (err != 0)
2254 goto out;
2255
2256 setup_pager();
2257
2258 err = perf_session__process_events(session, &trace->tool);
2259 if (err)
2260 pr_err("Failed to process events, error %d", err);
2261
2262 else if (trace->summary)
2263 trace__fprintf_thread_summary(trace, trace->output);
2264
2265 out:
2266 perf_session__delete(session);
2267
2268 return err;
2269 }
2270
2271 static size_t trace__fprintf_threads_header(FILE *fp)
2272 {
2273 size_t printed;
2274
2275 printed = fprintf(fp, "\n Summary of events:\n\n");
2276
2277 return printed;
2278 }
2279
2280 static size_t thread__dump_stats(struct thread_trace *ttrace,
2281 struct trace *trace, FILE *fp)
2282 {
2283 struct stats *stats;
2284 size_t printed = 0;
2285 struct syscall *sc;
2286 struct int_node *inode = intlist__first(ttrace->syscall_stats);
2287
2288 if (inode == NULL)
2289 return 0;
2290
2291 printed += fprintf(fp, "\n");
2292
2293 printed += fprintf(fp, " syscall calls min avg max stddev\n");
2294 printed += fprintf(fp, " (msec) (msec) (msec) (%%)\n");
2295 printed += fprintf(fp, " --------------- -------- --------- --------- --------- ------\n");
2296
2297 /* each int_node is a syscall */
2298 while (inode) {
2299 stats = inode->priv;
2300 if (stats) {
2301 double min = (double)(stats->min) / NSEC_PER_MSEC;
2302 double max = (double)(stats->max) / NSEC_PER_MSEC;
2303 double avg = avg_stats(stats);
2304 double pct;
2305 u64 n = (u64) stats->n;
2306
2307 pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2308 avg /= NSEC_PER_MSEC;
2309
2310 sc = &trace->syscalls.table[inode->i];
2311 printed += fprintf(fp, " %-15s", sc->name);
2312 printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f",
2313 n, min, avg);
2314 printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
2315 }
2316
2317 inode = intlist__next(inode);
2318 }
2319
2320 printed += fprintf(fp, "\n\n");
2321
2322 return printed;
2323 }
2324
2325 /* struct used to pass data to per-thread function */
2326 struct summary_data {
2327 FILE *fp;
2328 struct trace *trace;
2329 size_t printed;
2330 };
2331
2332 static int trace__fprintf_one_thread(struct thread *thread, void *priv)
2333 {
2334 struct summary_data *data = priv;
2335 FILE *fp = data->fp;
2336 size_t printed = data->printed;
2337 struct trace *trace = data->trace;
2338 struct thread_trace *ttrace = thread->priv;
2339 double ratio;
2340
2341 if (ttrace == NULL)
2342 return 0;
2343
2344 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2345
2346 printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
2347 printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
2348 printed += fprintf(fp, "%.1f%%", ratio);
2349 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
2350 printed += thread__dump_stats(ttrace, trace, fp);
2351
2352 data->printed += printed;
2353
2354 return 0;
2355 }
2356
2357 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2358 {
2359 struct summary_data data = {
2360 .fp = fp,
2361 .trace = trace
2362 };
2363 data.printed = trace__fprintf_threads_header(fp);
2364
2365 machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
2366
2367 return data.printed;
2368 }
2369
2370 static int trace__set_duration(const struct option *opt, const char *str,
2371 int unset __maybe_unused)
2372 {
2373 struct trace *trace = opt->value;
2374
2375 trace->duration_filter = atof(str);
2376 return 0;
2377 }
2378
2379 static int trace__open_output(struct trace *trace, const char *filename)
2380 {
2381 struct stat st;
2382
2383 if (!stat(filename, &st) && st.st_size) {
2384 char oldname[PATH_MAX];
2385
2386 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2387 unlink(oldname);
2388 rename(filename, oldname);
2389 }
2390
2391 trace->output = fopen(filename, "w");
2392
2393 return trace->output == NULL ? -errno : 0;
2394 }
2395
2396 static int parse_pagefaults(const struct option *opt, const char *str,
2397 int unset __maybe_unused)
2398 {
2399 int *trace_pgfaults = opt->value;
2400
2401 if (strcmp(str, "all") == 0)
2402 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2403 else if (strcmp(str, "maj") == 0)
2404 *trace_pgfaults |= TRACE_PFMAJ;
2405 else if (strcmp(str, "min") == 0)
2406 *trace_pgfaults |= TRACE_PFMIN;
2407 else
2408 return -1;
2409
2410 return 0;
2411 }
2412
2413 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
2414 {
2415 const char * const trace_usage[] = {
2416 "perf trace [<options>] [<command>]",
2417 "perf trace [<options>] -- <command> [<options>]",
2418 "perf trace record [<options>] [<command>]",
2419 "perf trace record [<options>] -- <command> [<options>]",
2420 NULL
2421 };
2422 struct trace trace = {
2423 .audit = {
2424 .machine = audit_detect_machine(),
2425 .open_id = audit_name_to_syscall("open", trace.audit.machine),
2426 },
2427 .syscalls = {
2428 . max = -1,
2429 },
2430 .opts = {
2431 .target = {
2432 .uid = UINT_MAX,
2433 .uses_mmap = true,
2434 },
2435 .user_freq = UINT_MAX,
2436 .user_interval = ULLONG_MAX,
2437 .no_buffering = true,
2438 .mmap_pages = 1024,
2439 },
2440 .output = stdout,
2441 .show_comm = true,
2442 .trace_syscalls = true,
2443 };
2444 const char *output_name = NULL;
2445 const char *ev_qualifier_str = NULL;
2446 const struct option trace_options[] = {
2447 OPT_BOOLEAN(0, "comm", &trace.show_comm,
2448 "show the thread COMM next to its id"),
2449 OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
2450 OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
2451 "list of events to trace"),
2452 OPT_STRING('o', "output", &output_name, "file", "output file name"),
2453 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
2454 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
2455 "trace events on existing process id"),
2456 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
2457 "trace events on existing thread id"),
2458 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
2459 "system-wide collection from all CPUs"),
2460 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
2461 "list of cpus to monitor"),
2462 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
2463 "child tasks do not inherit counters"),
2464 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
2465 "number of mmap data pages",
2466 perf_evlist__parse_mmap_pages),
2467 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
2468 "user to profile"),
2469 OPT_CALLBACK(0, "duration", &trace, "float",
2470 "show only events with duration > N.M ms",
2471 trace__set_duration),
2472 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
2473 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
2474 OPT_BOOLEAN('T', "time", &trace.full_time,
2475 "Show full timestamp, not time relative to first start"),
2476 OPT_BOOLEAN('s', "summary", &trace.summary_only,
2477 "Show only syscall summary with statistics"),
2478 OPT_BOOLEAN('S', "with-summary", &trace.summary,
2479 "Show all syscalls and summary with statistics"),
2480 OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
2481 "Trace pagefaults", parse_pagefaults, "maj"),
2482 OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
2483 OPT_END()
2484 };
2485 int err;
2486 char bf[BUFSIZ];
2487
2488 argc = parse_options(argc, argv, trace_options, trace_usage,
2489 PARSE_OPT_STOP_AT_NON_OPTION);
2490
2491 if (trace.trace_pgfaults) {
2492 trace.opts.sample_address = true;
2493 trace.opts.sample_time = true;
2494 }
2495
2496 if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
2497 return trace__record(&trace, argc-1, &argv[1]);
2498
2499 /* summary_only implies summary option, but don't overwrite summary if set */
2500 if (trace.summary_only)
2501 trace.summary = trace.summary_only;
2502
2503 if (!trace.trace_syscalls && !trace.trace_pgfaults) {
2504 pr_err("Please specify something to trace.\n");
2505 return -1;
2506 }
2507
2508 if (output_name != NULL) {
2509 err = trace__open_output(&trace, output_name);
2510 if (err < 0) {
2511 perror("failed to create output file");
2512 goto out;
2513 }
2514 }
2515
2516 if (ev_qualifier_str != NULL) {
2517 const char *s = ev_qualifier_str;
2518
2519 trace.not_ev_qualifier = *s == '!';
2520 if (trace.not_ev_qualifier)
2521 ++s;
2522 trace.ev_qualifier = strlist__new(true, s);
2523 if (trace.ev_qualifier == NULL) {
2524 fputs("Not enough memory to parse event qualifier",
2525 trace.output);
2526 err = -ENOMEM;
2527 goto out_close;
2528 }
2529 }
2530
2531 err = target__validate(&trace.opts.target);
2532 if (err) {
2533 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
2534 fprintf(trace.output, "%s", bf);
2535 goto out_close;
2536 }
2537
2538 err = target__parse_uid(&trace.opts.target);
2539 if (err) {
2540 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
2541 fprintf(trace.output, "%s", bf);
2542 goto out_close;
2543 }
2544
2545 if (!argc && target__none(&trace.opts.target))
2546 trace.opts.target.system_wide = true;
2547
2548 if (input_name)
2549 err = trace__replay(&trace);
2550 else
2551 err = trace__run(&trace, argc, argv);
2552
2553 out_close:
2554 if (output_name != NULL)
2555 fclose(trace.output);
2556 out:
2557 return err;
2558 }
Linux kernel - Deliverables
This page took 0.087416 seconds and 5 git commands to generate.