~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/builtin-trace.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp