projects / deliverable / linux.git / blob
? search:


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