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