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