xref: /openbmc/linux/tools/perf/builtin-trace.c (revision b34e08d5)
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