builtin-trace.c 71.4 KB
Newer Older
1
#include <traceevent/event-parse.h>
A
Arnaldo Carvalho de Melo 已提交
2
#include "builtin.h"
3
#include "util/color.h"
4
#include "util/debug.h"
A
Arnaldo Carvalho de Melo 已提交
5
#include "util/evlist.h"
6
#include "util/machine.h"
7
#include "util/session.h"
8
#include "util/thread.h"
A
Arnaldo Carvalho de Melo 已提交
9
#include "util/parse-options.h"
10
#include "util/strlist.h"
11
#include "util/intlist.h"
A
Arnaldo Carvalho de Melo 已提交
12
#include "util/thread_map.h"
13
#include "util/stat.h"
14
#include "trace-event.h"
15
#include "util/parse-events.h"
A
Arnaldo Carvalho de Melo 已提交
16 17 18

#include <libaudit.h>
#include <stdlib.h>
19
#include <sys/eventfd.h>
20
#include <sys/mman.h>
21
#include <linux/futex.h>
A
Arnaldo Carvalho de Melo 已提交
22

23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
/* For older distros: */
#ifndef MAP_STACK
# define MAP_STACK		0x20000
#endif

#ifndef MADV_HWPOISON
# define MADV_HWPOISON		100
#endif

#ifndef MADV_MERGEABLE
# define MADV_MERGEABLE		12
#endif

#ifndef MADV_UNMERGEABLE
# define MADV_UNMERGEABLE	13
#endif

40 41 42 43
#ifndef EFD_SEMAPHORE
# define EFD_SEMAPHORE		1
#endif

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
struct tp_field {
	int offset;
	union {
		u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
		void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
	};
};

#define TP_UINT_FIELD(bits) \
static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
{ \
	return *(u##bits *)(sample->raw_data + field->offset); \
}

TP_UINT_FIELD(8);
TP_UINT_FIELD(16);
TP_UINT_FIELD(32);
TP_UINT_FIELD(64);

#define TP_UINT_FIELD__SWAPPED(bits) \
static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
{ \
	u##bits value = *(u##bits *)(sample->raw_data + field->offset); \
	return bswap_##bits(value);\
}

TP_UINT_FIELD__SWAPPED(16);
TP_UINT_FIELD__SWAPPED(32);
TP_UINT_FIELD__SWAPPED(64);

static int tp_field__init_uint(struct tp_field *field,
			       struct format_field *format_field,
			       bool needs_swap)
{
	field->offset = format_field->offset;

	switch (format_field->size) {
	case 1:
		field->integer = tp_field__u8;
		break;
	case 2:
		field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
		break;
	case 4:
		field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
		break;
	case 8:
		field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
		break;
	default:
		return -1;
	}

	return 0;
}

static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
{
	return sample->raw_data + field->offset;
}

static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
{
	field->offset = format_field->offset;
	field->pointer = tp_field__ptr;
	return 0;
}

struct syscall_tp {
	struct tp_field id;
	union {
		struct tp_field args, ret;
	};
};

static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
					  struct tp_field *field,
					  const char *name)
{
	struct format_field *format_field = perf_evsel__field(evsel, name);

	if (format_field == NULL)
		return -1;

	return tp_field__init_uint(field, format_field, evsel->needs_swap);
}

#define perf_evsel__init_sc_tp_uint_field(evsel, name) \
	({ struct syscall_tp *sc = evsel->priv;\
	   perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })

static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
					 struct tp_field *field,
					 const char *name)
{
	struct format_field *format_field = perf_evsel__field(evsel, name);

	if (format_field == NULL)
		return -1;

	return tp_field__init_ptr(field, format_field);
}

#define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
	({ struct syscall_tp *sc = evsel->priv;\
	   perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })

static void perf_evsel__delete_priv(struct perf_evsel *evsel)
{
153
	zfree(&evsel->priv);
154 155 156
	perf_evsel__delete(evsel);
}

157 158 159 160 161 162 163 164 165 166 167 168 169 170
static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel, void *handler)
{
	evsel->priv = malloc(sizeof(struct syscall_tp));
	if (evsel->priv != NULL) {
		if (perf_evsel__init_sc_tp_uint_field(evsel, id))
			goto out_delete;

		evsel->handler = handler;
		return 0;
	}

	return -ENOMEM;

out_delete:
171
	zfree(&evsel->priv);
172 173 174
	return -ENOENT;
}

175
static struct perf_evsel *perf_evsel__syscall_newtp(const char *direction, void *handler)
176
{
177
	struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
178

179 180 181 182
	/* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
	if (evsel == NULL)
		evsel = perf_evsel__newtp("syscalls", direction);

183
	if (evsel) {
184
		if (perf_evsel__init_syscall_tp(evsel, handler))
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
			goto out_delete;
	}

	return evsel;

out_delete:
	perf_evsel__delete_priv(evsel);
	return NULL;
}

#define perf_evsel__sc_tp_uint(evsel, name, sample) \
	({ struct syscall_tp *fields = evsel->priv; \
	   fields->name.integer(&fields->name, sample); })

#define perf_evsel__sc_tp_ptr(evsel, name, sample) \
	({ struct syscall_tp *fields = evsel->priv; \
	   fields->name.pointer(&fields->name, sample); })

static int perf_evlist__add_syscall_newtp(struct perf_evlist *evlist,
					  void *sys_enter_handler,
					  void *sys_exit_handler)
{
	int ret = -1;
	struct perf_evsel *sys_enter, *sys_exit;

210
	sys_enter = perf_evsel__syscall_newtp("sys_enter", sys_enter_handler);
211 212 213 214 215 216
	if (sys_enter == NULL)
		goto out;

	if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
		goto out_delete_sys_enter;

217
	sys_exit = perf_evsel__syscall_newtp("sys_exit", sys_exit_handler);
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
	if (sys_exit == NULL)
		goto out_delete_sys_enter;

	if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
		goto out_delete_sys_exit;

	perf_evlist__add(evlist, sys_enter);
	perf_evlist__add(evlist, sys_exit);

	ret = 0;
out:
	return ret;

out_delete_sys_exit:
	perf_evsel__delete_priv(sys_exit);
out_delete_sys_enter:
	perf_evsel__delete_priv(sys_enter);
	goto out;
}


239 240
struct syscall_arg {
	unsigned long val;
241 242
	struct thread *thread;
	struct trace  *trace;
243
	void	      *parm;
244 245 246 247
	u8	      idx;
	u8	      mask;
};

248
struct strarray {
249
	int	    offset;
250 251 252 253 254 255 256 257 258
	int	    nr_entries;
	const char **entries;
};

#define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
	.nr_entries = ARRAY_SIZE(array), \
	.entries = array, \
}

259 260 261 262 263 264
#define DEFINE_STRARRAY_OFFSET(array, off) struct strarray strarray__##array = { \
	.offset	    = off, \
	.nr_entries = ARRAY_SIZE(array), \
	.entries = array, \
}

265 266 267
static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
						const char *intfmt,
					        struct syscall_arg *arg)
268 269
{
	struct strarray *sa = arg->parm;
270
	int idx = arg->val - sa->offset;
271 272

	if (idx < 0 || idx >= sa->nr_entries)
273
		return scnprintf(bf, size, intfmt, arg->val);
274 275 276 277

	return scnprintf(bf, size, "%s", sa->entries[idx]);
}

278 279 280 281 282 283
static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
					      struct syscall_arg *arg)
{
	return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
}

284 285
#define SCA_STRARRAY syscall_arg__scnprintf_strarray

286 287 288 289 290
#if defined(__i386__) || defined(__x86_64__)
/*
 * FIXME: Make this available to all arches as soon as the ioctl beautifier
 * 	  gets rewritten to support all arches.
 */
291 292 293 294 295 296 297
static size_t syscall_arg__scnprintf_strhexarray(char *bf, size_t size,
						 struct syscall_arg *arg)
{
	return __syscall_arg__scnprintf_strarray(bf, size, "%#x", arg);
}

#define SCA_STRHEXARRAY syscall_arg__scnprintf_strhexarray
298
#endif /* defined(__i386__) || defined(__x86_64__) */
299

300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
					struct syscall_arg *arg);

#define SCA_FD syscall_arg__scnprintf_fd

static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
					   struct syscall_arg *arg)
{
	int fd = arg->val;

	if (fd == AT_FDCWD)
		return scnprintf(bf, size, "CWD");

	return syscall_arg__scnprintf_fd(bf, size, arg);
}

#define SCA_FDAT syscall_arg__scnprintf_fd_at

static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
					      struct syscall_arg *arg);

#define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd

323
static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
324
					 struct syscall_arg *arg)
325
{
326
	return scnprintf(bf, size, "%#lx", arg->val);
327 328
}

329 330
#define SCA_HEX syscall_arg__scnprintf_hex

331
static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
332
					       struct syscall_arg *arg)
333
{
334
	int printed = 0, prot = arg->val;
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361

	if (prot == PROT_NONE)
		return scnprintf(bf, size, "NONE");
#define	P_MMAP_PROT(n) \
	if (prot & PROT_##n) { \
		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
		prot &= ~PROT_##n; \
	}

	P_MMAP_PROT(EXEC);
	P_MMAP_PROT(READ);
	P_MMAP_PROT(WRITE);
#ifdef PROT_SEM
	P_MMAP_PROT(SEM);
#endif
	P_MMAP_PROT(GROWSDOWN);
	P_MMAP_PROT(GROWSUP);
#undef P_MMAP_PROT

	if (prot)
		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);

	return printed;
}

#define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot

362
static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
363
						struct syscall_arg *arg)
364
{
365
	int printed = 0, flags = arg->val;
366 367 368 369 370 371 372 373 374

#define	P_MMAP_FLAG(n) \
	if (flags & MAP_##n) { \
		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
		flags &= ~MAP_##n; \
	}

	P_MMAP_FLAG(SHARED);
	P_MMAP_FLAG(PRIVATE);
375
#ifdef MAP_32BIT
376
	P_MMAP_FLAG(32BIT);
377
#endif
378 379 380 381 382 383
	P_MMAP_FLAG(ANONYMOUS);
	P_MMAP_FLAG(DENYWRITE);
	P_MMAP_FLAG(EXECUTABLE);
	P_MMAP_FLAG(FILE);
	P_MMAP_FLAG(FIXED);
	P_MMAP_FLAG(GROWSDOWN);
384
#ifdef MAP_HUGETLB
385
	P_MMAP_FLAG(HUGETLB);
386
#endif
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
	P_MMAP_FLAG(LOCKED);
	P_MMAP_FLAG(NONBLOCK);
	P_MMAP_FLAG(NORESERVE);
	P_MMAP_FLAG(POPULATE);
	P_MMAP_FLAG(STACK);
#ifdef MAP_UNINITIALIZED
	P_MMAP_FLAG(UNINITIALIZED);
#endif
#undef P_MMAP_FLAG

	if (flags)
		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);

	return printed;
}

#define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags

405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
static size_t syscall_arg__scnprintf_mremap_flags(char *bf, size_t size,
						  struct syscall_arg *arg)
{
	int printed = 0, flags = arg->val;

#define P_MREMAP_FLAG(n) \
	if (flags & MREMAP_##n) { \
		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
		flags &= ~MREMAP_##n; \
	}

	P_MREMAP_FLAG(MAYMOVE);
#ifdef MREMAP_FIXED
	P_MREMAP_FLAG(FIXED);
#endif
#undef P_MREMAP_FLAG

	if (flags)
		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);

	return printed;
}

#define SCA_MREMAP_FLAGS syscall_arg__scnprintf_mremap_flags

430
static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
431
						      struct syscall_arg *arg)
432
{
433
	int behavior = arg->val;
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450

	switch (behavior) {
#define	P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
	P_MADV_BHV(NORMAL);
	P_MADV_BHV(RANDOM);
	P_MADV_BHV(SEQUENTIAL);
	P_MADV_BHV(WILLNEED);
	P_MADV_BHV(DONTNEED);
	P_MADV_BHV(REMOVE);
	P_MADV_BHV(DONTFORK);
	P_MADV_BHV(DOFORK);
	P_MADV_BHV(HWPOISON);
#ifdef MADV_SOFT_OFFLINE
	P_MADV_BHV(SOFT_OFFLINE);
#endif
	P_MADV_BHV(MERGEABLE);
	P_MADV_BHV(UNMERGEABLE);
451
#ifdef MADV_HUGEPAGE
452
	P_MADV_BHV(HUGEPAGE);
453 454
#endif
#ifdef MADV_NOHUGEPAGE
455
	P_MADV_BHV(NOHUGEPAGE);
456
#endif
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
#ifdef MADV_DONTDUMP
	P_MADV_BHV(DONTDUMP);
#endif
#ifdef MADV_DODUMP
	P_MADV_BHV(DODUMP);
#endif
#undef P_MADV_PHV
	default: break;
	}

	return scnprintf(bf, size, "%#x", behavior);
}

#define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
					   struct syscall_arg *arg)
{
	int printed = 0, op = arg->val;

	if (op == 0)
		return scnprintf(bf, size, "NONE");
#define	P_CMD(cmd) \
	if ((op & LOCK_##cmd) == LOCK_##cmd) { \
		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #cmd); \
		op &= ~LOCK_##cmd; \
	}

	P_CMD(SH);
	P_CMD(EX);
	P_CMD(NB);
	P_CMD(UN);
	P_CMD(MAND);
	P_CMD(RW);
	P_CMD(READ);
	P_CMD(WRITE);
#undef P_OP

	if (op)
		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", op);

	return printed;
}

#define SCA_FLOCK syscall_arg__scnprintf_flock

503
static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
504 505 506 507 508 509 510 511 512
{
	enum syscall_futex_args {
		SCF_UADDR   = (1 << 0),
		SCF_OP	    = (1 << 1),
		SCF_VAL	    = (1 << 2),
		SCF_TIMEOUT = (1 << 3),
		SCF_UADDR2  = (1 << 4),
		SCF_VAL3    = (1 << 5),
	};
513
	int op = arg->val;
514 515 516 517 518
	int cmd = op & FUTEX_CMD_MASK;
	size_t printed = 0;

	switch (cmd) {
#define	P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
519 520 521 522 523 524
	P_FUTEX_OP(WAIT);	    arg->mask |= SCF_VAL3|SCF_UADDR2;		  break;
	P_FUTEX_OP(WAKE);	    arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
	P_FUTEX_OP(FD);		    arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
	P_FUTEX_OP(REQUEUE);	    arg->mask |= SCF_VAL3|SCF_TIMEOUT;	          break;
	P_FUTEX_OP(CMP_REQUEUE);    arg->mask |= SCF_TIMEOUT;			  break;
	P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT;			  break;
525
	P_FUTEX_OP(WAKE_OP);							  break;
526 527 528 529 530
	P_FUTEX_OP(LOCK_PI);	    arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
	P_FUTEX_OP(UNLOCK_PI);	    arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
	P_FUTEX_OP(TRYLOCK_PI);	    arg->mask |= SCF_VAL3|SCF_UADDR2;		  break;
	P_FUTEX_OP(WAIT_BITSET);    arg->mask |= SCF_UADDR2;			  break;
	P_FUTEX_OP(WAKE_BITSET);    arg->mask |= SCF_UADDR2;			  break;
531 532 533 534 535 536 537 538 539 540 541 542 543
	P_FUTEX_OP(WAIT_REQUEUE_PI);						  break;
	default: printed = scnprintf(bf, size, "%#x", cmd);			  break;
	}

	if (op & FUTEX_PRIVATE_FLAG)
		printed += scnprintf(bf + printed, size - printed, "|PRIV");

	if (op & FUTEX_CLOCK_REALTIME)
		printed += scnprintf(bf + printed, size - printed, "|CLKRT");

	return printed;
}

544 545
#define SCA_FUTEX_OP  syscall_arg__scnprintf_futex_op

546 547
static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
548

549 550 551
static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
static DEFINE_STRARRAY(itimers);

552 553 554 555 556 557 558 559 560
static const char *whences[] = { "SET", "CUR", "END",
#ifdef SEEK_DATA
"DATA",
#endif
#ifdef SEEK_HOLE
"HOLE",
#endif
};
static DEFINE_STRARRAY(whences);
561

562 563 564 565 566 567 568 569
static const char *fcntl_cmds[] = {
	"DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
	"SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
	"F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
	"F_GETOWNER_UIDS",
};
static DEFINE_STRARRAY(fcntl_cmds);

570 571 572 573 574 575 576
static const char *rlimit_resources[] = {
	"CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
	"MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
	"RTTIME",
};
static DEFINE_STRARRAY(rlimit_resources);

577 578 579
static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
static DEFINE_STRARRAY(sighow);

580 581 582 583 584 585
static const char *clockid[] = {
	"REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
	"MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE",
};
static DEFINE_STRARRAY(clockid);

586 587 588 589 590 591 592 593 594 595
static const char *socket_families[] = {
	"UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
	"BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
	"SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
	"RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
	"BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
	"ALG", "NFC", "VSOCK",
};
static DEFINE_STRARRAY(socket_families);

596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
#ifndef SOCK_TYPE_MASK
#define SOCK_TYPE_MASK 0xf
#endif

static size_t syscall_arg__scnprintf_socket_type(char *bf, size_t size,
						      struct syscall_arg *arg)
{
	size_t printed;
	int type = arg->val,
	    flags = type & ~SOCK_TYPE_MASK;

	type &= SOCK_TYPE_MASK;
	/*
 	 * Can't use a strarray, MIPS may override for ABI reasons.
 	 */
	switch (type) {
#define	P_SK_TYPE(n) case SOCK_##n: printed = scnprintf(bf, size, #n); break;
	P_SK_TYPE(STREAM);
	P_SK_TYPE(DGRAM);
	P_SK_TYPE(RAW);
	P_SK_TYPE(RDM);
	P_SK_TYPE(SEQPACKET);
	P_SK_TYPE(DCCP);
	P_SK_TYPE(PACKET);
#undef P_SK_TYPE
	default:
		printed = scnprintf(bf, size, "%#x", type);
	}

#define	P_SK_FLAG(n) \
	if (flags & SOCK_##n) { \
		printed += scnprintf(bf + printed, size - printed, "|%s", #n); \
		flags &= ~SOCK_##n; \
	}

	P_SK_FLAG(CLOEXEC);
	P_SK_FLAG(NONBLOCK);
#undef P_SK_FLAG

	if (flags)
		printed += scnprintf(bf + printed, size - printed, "|%#x", flags);

	return printed;
}

#define SCA_SK_TYPE syscall_arg__scnprintf_socket_type

643 644 645
#ifndef MSG_PROBE
#define MSG_PROBE	     0x10
#endif
646 647 648
#ifndef MSG_WAITFORONE
#define MSG_WAITFORONE	0x10000
#endif
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699
#ifndef MSG_SENDPAGE_NOTLAST
#define MSG_SENDPAGE_NOTLAST 0x20000
#endif
#ifndef MSG_FASTOPEN
#define MSG_FASTOPEN	     0x20000000
#endif

static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
					       struct syscall_arg *arg)
{
	int printed = 0, flags = arg->val;

	if (flags == 0)
		return scnprintf(bf, size, "NONE");
#define	P_MSG_FLAG(n) \
	if (flags & MSG_##n) { \
		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
		flags &= ~MSG_##n; \
	}

	P_MSG_FLAG(OOB);
	P_MSG_FLAG(PEEK);
	P_MSG_FLAG(DONTROUTE);
	P_MSG_FLAG(TRYHARD);
	P_MSG_FLAG(CTRUNC);
	P_MSG_FLAG(PROBE);
	P_MSG_FLAG(TRUNC);
	P_MSG_FLAG(DONTWAIT);
	P_MSG_FLAG(EOR);
	P_MSG_FLAG(WAITALL);
	P_MSG_FLAG(FIN);
	P_MSG_FLAG(SYN);
	P_MSG_FLAG(CONFIRM);
	P_MSG_FLAG(RST);
	P_MSG_FLAG(ERRQUEUE);
	P_MSG_FLAG(NOSIGNAL);
	P_MSG_FLAG(MORE);
	P_MSG_FLAG(WAITFORONE);
	P_MSG_FLAG(SENDPAGE_NOTLAST);
	P_MSG_FLAG(FASTOPEN);
	P_MSG_FLAG(CMSG_CLOEXEC);
#undef P_MSG_FLAG

	if (flags)
		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);

	return printed;
}

#define SCA_MSG_FLAGS syscall_arg__scnprintf_msg_flags

700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
						 struct syscall_arg *arg)
{
	size_t printed = 0;
	int mode = arg->val;

	if (mode == F_OK) /* 0 */
		return scnprintf(bf, size, "F");
#define	P_MODE(n) \
	if (mode & n##_OK) { \
		printed += scnprintf(bf + printed, size - printed, "%s", #n); \
		mode &= ~n##_OK; \
	}

	P_MODE(R);
	P_MODE(W);
	P_MODE(X);
#undef P_MODE

	if (mode)
		printed += scnprintf(bf + printed, size - printed, "|%#x", mode);

	return printed;
}

#define SCA_ACCMODE syscall_arg__scnprintf_access_mode

727
static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
728
					       struct syscall_arg *arg)
729
{
730
	int printed = 0, flags = arg->val;
731 732

	if (!(flags & O_CREAT))
733
		arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782

	if (flags == 0)
		return scnprintf(bf, size, "RDONLY");
#define	P_FLAG(n) \
	if (flags & O_##n) { \
		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
		flags &= ~O_##n; \
	}

	P_FLAG(APPEND);
	P_FLAG(ASYNC);
	P_FLAG(CLOEXEC);
	P_FLAG(CREAT);
	P_FLAG(DIRECT);
	P_FLAG(DIRECTORY);
	P_FLAG(EXCL);
	P_FLAG(LARGEFILE);
	P_FLAG(NOATIME);
	P_FLAG(NOCTTY);
#ifdef O_NONBLOCK
	P_FLAG(NONBLOCK);
#elif O_NDELAY
	P_FLAG(NDELAY);
#endif
#ifdef O_PATH
	P_FLAG(PATH);
#endif
	P_FLAG(RDWR);
#ifdef O_DSYNC
	if ((flags & O_SYNC) == O_SYNC)
		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
	else {
		P_FLAG(DSYNC);
	}
#else
	P_FLAG(SYNC);
#endif
	P_FLAG(TRUNC);
	P_FLAG(WRONLY);
#undef P_FLAG

	if (flags)
		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);

	return printed;
}

#define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags

783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
static size_t syscall_arg__scnprintf_eventfd_flags(char *bf, size_t size,
						   struct syscall_arg *arg)
{
	int printed = 0, flags = arg->val;

	if (flags == 0)
		return scnprintf(bf, size, "NONE");
#define	P_FLAG(n) \
	if (flags & EFD_##n) { \
		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
		flags &= ~EFD_##n; \
	}

	P_FLAG(SEMAPHORE);
	P_FLAG(CLOEXEC);
	P_FLAG(NONBLOCK);
#undef P_FLAG

	if (flags)
		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);

	return printed;
}

#define SCA_EFD_FLAGS syscall_arg__scnprintf_eventfd_flags

809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831
static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
						struct syscall_arg *arg)
{
	int printed = 0, flags = arg->val;

#define	P_FLAG(n) \
	if (flags & O_##n) { \
		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
		flags &= ~O_##n; \
	}

	P_FLAG(CLOEXEC);
	P_FLAG(NONBLOCK);
#undef P_FLAG

	if (flags)
		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);

	return printed;
}

#define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags

832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
{
	int sig = arg->val;

	switch (sig) {
#define	P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
	P_SIGNUM(HUP);
	P_SIGNUM(INT);
	P_SIGNUM(QUIT);
	P_SIGNUM(ILL);
	P_SIGNUM(TRAP);
	P_SIGNUM(ABRT);
	P_SIGNUM(BUS);
	P_SIGNUM(FPE);
	P_SIGNUM(KILL);
	P_SIGNUM(USR1);
	P_SIGNUM(SEGV);
	P_SIGNUM(USR2);
	P_SIGNUM(PIPE);
	P_SIGNUM(ALRM);
	P_SIGNUM(TERM);
	P_SIGNUM(CHLD);
	P_SIGNUM(CONT);
	P_SIGNUM(STOP);
	P_SIGNUM(TSTP);
	P_SIGNUM(TTIN);
	P_SIGNUM(TTOU);
	P_SIGNUM(URG);
	P_SIGNUM(XCPU);
	P_SIGNUM(XFSZ);
	P_SIGNUM(VTALRM);
	P_SIGNUM(PROF);
	P_SIGNUM(WINCH);
	P_SIGNUM(IO);
	P_SIGNUM(PWR);
	P_SIGNUM(SYS);
868 869 870 871 872 873 874 875 876
#ifdef SIGEMT
	P_SIGNUM(EMT);
#endif
#ifdef SIGSTKFLT
	P_SIGNUM(STKFLT);
#endif
#ifdef SIGSWI
	P_SIGNUM(SWI);
#endif
877 878 879 880 881 882 883 884
	default: break;
	}

	return scnprintf(bf, size, "%#x", sig);
}

#define SCA_SIGNUM syscall_arg__scnprintf_signum

885 886 887 888
#if defined(__i386__) || defined(__x86_64__)
/*
 * FIXME: Make this available to all arches.
 */
889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909
#define TCGETS		0x5401

static const char *tioctls[] = {
	"TCGETS", "TCSETS", "TCSETSW", "TCSETSF", "TCGETA", "TCSETA", "TCSETAW",
	"TCSETAF", "TCSBRK", "TCXONC", "TCFLSH", "TIOCEXCL", "TIOCNXCL",
	"TIOCSCTTY", "TIOCGPGRP", "TIOCSPGRP", "TIOCOUTQ", "TIOCSTI",
	"TIOCGWINSZ", "TIOCSWINSZ", "TIOCMGET", "TIOCMBIS", "TIOCMBIC",
	"TIOCMSET", "TIOCGSOFTCAR", "TIOCSSOFTCAR", "FIONREAD", "TIOCLINUX",
	"TIOCCONS", "TIOCGSERIAL", "TIOCSSERIAL", "TIOCPKT", "FIONBIO",
	"TIOCNOTTY", "TIOCSETD", "TIOCGETD", "TCSBRKP", [0x27] = "TIOCSBRK",
	"TIOCCBRK", "TIOCGSID", "TCGETS2", "TCSETS2", "TCSETSW2", "TCSETSF2",
	"TIOCGRS485", "TIOCSRS485", "TIOCGPTN", "TIOCSPTLCK",
	"TIOCGDEV||TCGETX", "TCSETX", "TCSETXF", "TCSETXW", "TIOCSIG",
	"TIOCVHANGUP", "TIOCGPKT", "TIOCGPTLCK", "TIOCGEXCL",
	[0x50] = "FIONCLEX", "FIOCLEX", "FIOASYNC", "TIOCSERCONFIG",
	"TIOCSERGWILD", "TIOCSERSWILD", "TIOCGLCKTRMIOS", "TIOCSLCKTRMIOS",
	"TIOCSERGSTRUCT", "TIOCSERGETLSR", "TIOCSERGETMULTI", "TIOCSERSETMULTI",
	"TIOCMIWAIT", "TIOCGICOUNT", [0x60] = "FIOQSIZE",
};

static DEFINE_STRARRAY_OFFSET(tioctls, 0x5401);
910
#endif /* defined(__i386__) || defined(__x86_64__) */
911

912 913 914 915
#define STRARRAY(arg, name, array) \
	  .arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
	  .arg_parm	 = { [arg] = &strarray__##array, }

A
Arnaldo Carvalho de Melo 已提交
916 917
static struct syscall_fmt {
	const char *name;
918
	const char *alias;
919
	size_t	   (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
920
	void	   *arg_parm[6];
A
Arnaldo Carvalho de Melo 已提交
921 922
	bool	   errmsg;
	bool	   timeout;
923
	bool	   hexret;
A
Arnaldo Carvalho de Melo 已提交
924
} syscall_fmts[] = {
925 926
	{ .name	    = "access",	    .errmsg = true,
	  .arg_scnprintf = { [1] = SCA_ACCMODE, /* mode */ }, },
927
	{ .name	    = "arch_prctl", .errmsg = true, .alias = "prctl", },
928 929
	{ .name	    = "brk",	    .hexret = true,
	  .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
930
	{ .name     = "clock_gettime",  .errmsg = true, STRARRAY(0, clk_id, clockid), },
931
	{ .name	    = "close",	    .errmsg = true,
932
	  .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
933
	{ .name	    = "connect",    .errmsg = true, },
934
	{ .name	    = "dup",	    .errmsg = true,
935
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
936
	{ .name	    = "dup2",	    .errmsg = true,
937
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
938
	{ .name	    = "dup3",	    .errmsg = true,
939
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
940
	{ .name	    = "epoll_ctl",  .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
941 942
	{ .name	    = "eventfd2",   .errmsg = true,
	  .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
943 944 945
	{ .name	    = "faccessat",  .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
	{ .name	    = "fadvise64",  .errmsg = true,
946
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
947
	{ .name	    = "fallocate",  .errmsg = true,
948
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
949
	{ .name	    = "fchdir",	    .errmsg = true,
950
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
951
	{ .name	    = "fchmod",	    .errmsg = true,
952
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
953
	{ .name	    = "fchmodat",   .errmsg = true,
954
	  .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
955
	{ .name	    = "fchown",	    .errmsg = true,
956
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
957
	{ .name	    = "fchownat",   .errmsg = true,
958
	  .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
959 960 961 962 963
	{ .name	    = "fcntl",	    .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */
			     [1] = SCA_STRARRAY, /* cmd */ },
	  .arg_parm	 = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
	{ .name	    = "fdatasync",  .errmsg = true,
964
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
965
	{ .name	    = "flock",	    .errmsg = true,
966 967 968
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */
			     [1] = SCA_FLOCK, /* cmd */ }, },
	{ .name	    = "fsetxattr",  .errmsg = true,
969
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
970
	{ .name	    = "fstat",	    .errmsg = true, .alias = "newfstat",
971
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
972
	{ .name	    = "fstatat",    .errmsg = true, .alias = "newfstatat",
973
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
974
	{ .name	    = "fstatfs",    .errmsg = true,
975
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
976
	{ .name	    = "fsync",    .errmsg = true,
977
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
978
	{ .name	    = "ftruncate", .errmsg = true,
979
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
980 981
	{ .name	    = "futex",	    .errmsg = true,
	  .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
982
	{ .name	    = "futimesat", .errmsg = true,
983
	  .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
984
	{ .name	    = "getdents",   .errmsg = true,
985
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
986
	{ .name	    = "getdents64", .errmsg = true,
987
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
988 989
	{ .name	    = "getitimer",  .errmsg = true, STRARRAY(0, which, itimers), },
	{ .name	    = "getrlimit",  .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
990
	{ .name	    = "ioctl",	    .errmsg = true,
991
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */
992 993 994 995
#if defined(__i386__) || defined(__x86_64__)
/*
 * FIXME: Make this available to all arches.
 */
996 997 998
			     [1] = SCA_STRHEXARRAY, /* cmd */
			     [2] = SCA_HEX, /* arg */ },
	  .arg_parm	 = { [1] = &strarray__tioctls, /* cmd */ }, },
999 1000 1001
#else
			     [2] = SCA_HEX, /* arg */ }, },
#endif
1002 1003
	{ .name	    = "kill",	    .errmsg = true,
	  .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1004
	{ .name	    = "linkat",	    .errmsg = true,
1005
	  .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
1006 1007 1008 1009
	{ .name	    = "lseek",	    .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */
			     [2] = SCA_STRARRAY, /* whence */ },
	  .arg_parm	 = { [2] = &strarray__whences, /* whence */ }, },
1010
	{ .name	    = "lstat",	    .errmsg = true, .alias = "newlstat", },
1011 1012 1013
	{ .name     = "madvise",    .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_HEX,	 /* start */
			     [2] = SCA_MADV_BHV, /* behavior */ }, },
1014
	{ .name	    = "mkdirat",    .errmsg = true,
1015
	  .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
1016
	{ .name	    = "mknodat",    .errmsg = true,
1017
	  .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
1018 1019 1020 1021
	{ .name	    = "mlock",	    .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
	{ .name	    = "mlockall",   .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1022
	{ .name	    = "mmap",	    .hexret = true,
1023
	  .arg_scnprintf = { [0] = SCA_HEX,	  /* addr */
1024
			     [2] = SCA_MMAP_PROT, /* prot */
1025 1026
			     [3] = SCA_MMAP_FLAGS, /* flags */
			     [4] = SCA_FD, 	  /* fd */ }, },
1027
	{ .name	    = "mprotect",   .errmsg = true,
1028 1029 1030 1031
	  .arg_scnprintf = { [0] = SCA_HEX, /* start */
			     [2] = SCA_MMAP_PROT, /* prot */ }, },
	{ .name	    = "mremap",	    .hexret = true,
	  .arg_scnprintf = { [0] = SCA_HEX, /* addr */
1032
			     [3] = SCA_MREMAP_FLAGS, /* flags */
1033
			     [4] = SCA_HEX, /* new_addr */ }, },
1034 1035
	{ .name	    = "munlock",    .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1036 1037
	{ .name	    = "munmap",	    .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1038
	{ .name	    = "name_to_handle_at", .errmsg = true,
1039
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1040
	{ .name	    = "newfstatat", .errmsg = true,
1041
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1042 1043
	{ .name	    = "open",	    .errmsg = true,
	  .arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
1044
	{ .name	    = "open_by_handle_at", .errmsg = true,
1045 1046
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
			     [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1047
	{ .name	    = "openat",	    .errmsg = true,
1048 1049
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
			     [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1050 1051
	{ .name	    = "pipe2",	    .errmsg = true,
	  .arg_scnprintf = { [1] = SCA_PIPE_FLAGS, /* flags */ }, },
1052 1053
	{ .name	    = "poll",	    .errmsg = true, .timeout = true, },
	{ .name	    = "ppoll",	    .errmsg = true, .timeout = true, },
1054
	{ .name	    = "pread",	    .errmsg = true, .alias = "pread64",
1055
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1056
	{ .name	    = "preadv",	    .errmsg = true, .alias = "pread",
1057
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1058
	{ .name	    = "prlimit64",  .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
1059
	{ .name	    = "pwrite",	    .errmsg = true, .alias = "pwrite64",
1060
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1061
	{ .name	    = "pwritev",    .errmsg = true,
1062
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1063
	{ .name	    = "read",	    .errmsg = true,
1064
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1065
	{ .name	    = "readlinkat", .errmsg = true,
1066
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1067
	{ .name	    = "readv",	    .errmsg = true,
1068
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1069 1070 1071 1072 1073 1074
	{ .name	    = "recvfrom",   .errmsg = true,
	  .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
	{ .name	    = "recvmmsg",   .errmsg = true,
	  .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
	{ .name	    = "recvmsg",    .errmsg = true,
	  .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
1075
	{ .name	    = "renameat",   .errmsg = true,
1076
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1077 1078
	{ .name	    = "rt_sigaction", .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
1079
	{ .name	    = "rt_sigprocmask",  .errmsg = true, STRARRAY(0, how, sighow), },
1080 1081 1082 1083
	{ .name	    = "rt_sigqueueinfo", .errmsg = true,
	  .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
	{ .name	    = "rt_tgsigqueueinfo", .errmsg = true,
	  .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1084
	{ .name	    = "select",	    .errmsg = true, .timeout = true, },
1085 1086 1087 1088 1089 1090
	{ .name	    = "sendmmsg",    .errmsg = true,
	  .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
	{ .name	    = "sendmsg",    .errmsg = true,
	  .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
	{ .name	    = "sendto",	    .errmsg = true,
	  .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1091 1092
	{ .name	    = "setitimer",  .errmsg = true, STRARRAY(0, which, itimers), },
	{ .name	    = "setrlimit",  .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
1093
	{ .name	    = "shutdown",   .errmsg = true,
1094
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1095
	{ .name	    = "socket",	    .errmsg = true,
1096 1097
	  .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
			     [1] = SCA_SK_TYPE, /* type */ },
1098 1099 1100 1101
	  .arg_parm	 = { [0] = &strarray__socket_families, /* family */ }, },
	{ .name	    = "socketpair", .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
			     [1] = SCA_SK_TYPE, /* type */ },
1102
	  .arg_parm	 = { [0] = &strarray__socket_families, /* family */ }, },
1103
	{ .name	    = "stat",	    .errmsg = true, .alias = "newstat", },
1104
	{ .name	    = "symlinkat",  .errmsg = true,
1105
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1106 1107 1108 1109
	{ .name	    = "tgkill",	    .errmsg = true,
	  .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
	{ .name	    = "tkill",	    .errmsg = true,
	  .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1110
	{ .name	    = "uname",	    .errmsg = true, .alias = "newuname", },
1111 1112 1113 1114 1115
	{ .name	    = "unlinkat",   .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
	{ .name	    = "utimensat",  .errmsg = true,
	  .arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */ }, },
	{ .name	    = "write",	    .errmsg = true,
1116
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1117
	{ .name	    = "writev",	    .errmsg = true,
1118
	  .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
A
Arnaldo Carvalho de Melo 已提交
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
};

static int syscall_fmt__cmp(const void *name, const void *fmtp)
{
	const struct syscall_fmt *fmt = fmtp;
	return strcmp(name, fmt->name);
}

static struct syscall_fmt *syscall_fmt__find(const char *name)
{
	const int nmemb = ARRAY_SIZE(syscall_fmts);
	return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
}

struct syscall {
	struct event_format *tp_format;
	const char	    *name;
1136
	bool		    filtered;
1137
	bool		    is_exit;
A
Arnaldo Carvalho de Melo 已提交
1138
	struct syscall_fmt  *fmt;
1139
	size_t		    (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
1140
	void		    **arg_parm;
A
Arnaldo Carvalho de Melo 已提交
1141 1142
};

1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153
static size_t fprintf_duration(unsigned long t, FILE *fp)
{
	double duration = (double)t / NSEC_PER_MSEC;
	size_t printed = fprintf(fp, "(");

	if (duration >= 1.0)
		printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
	else if (duration >= 0.01)
		printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
	else
		printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
1154
	return printed + fprintf(fp, "): ");
1155 1156
}

1157 1158 1159 1160
struct thread_trace {
	u64		  entry_time;
	u64		  exit_time;
	bool		  entry_pending;
1161
	unsigned long	  nr_events;
1162
	unsigned long	  pfmaj, pfmin;
1163
	char		  *entry_str;
1164
	double		  runtime_ms;
1165 1166 1167 1168
	struct {
		int	  max;
		char	  **table;
	} paths;
1169 1170

	struct intlist *syscall_stats;
1171 1172 1173 1174
};

static struct thread_trace *thread_trace__new(void)
{
1175 1176 1177 1178 1179
	struct thread_trace *ttrace =  zalloc(sizeof(struct thread_trace));

	if (ttrace)
		ttrace->paths.max = -1;

1180 1181
	ttrace->syscall_stats = intlist__new(NULL);

1182
	return ttrace;
1183 1184
}

1185
static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
1186
{
1187 1188
	struct thread_trace *ttrace;

1189 1190 1191
	if (thread == NULL)
		goto fail;

1192 1193
	if (thread__priv(thread) == NULL)
		thread__set_priv(thread, thread_trace__new());
1194

1195
	if (thread__priv(thread) == NULL)
1196 1197
		goto fail;

1198
	ttrace = thread__priv(thread);
1199 1200 1201
	++ttrace->nr_events;

	return ttrace;
1202
fail:
1203
	color_fprintf(fp, PERF_COLOR_RED,
1204 1205 1206 1207
		      "WARNING: not enough memory, dropping samples!\n");
	return NULL;
}

1208 1209 1210
#define TRACE_PFMAJ		(1 << 0)
#define TRACE_PFMIN		(1 << 1)

A
Arnaldo Carvalho de Melo 已提交
1211
struct trace {
1212
	struct perf_tool	tool;
1213 1214 1215 1216
	struct {
		int		machine;
		int		open_id;
	}			audit;
A
Arnaldo Carvalho de Melo 已提交
1217 1218 1219 1220
	struct {
		int		max;
		struct syscall  *table;
	} syscalls;
1221
	struct record_opts	opts;
1222
	struct perf_evlist	*evlist;
1223
	struct machine		*host;
1224
	struct thread		*current;
1225
	u64			base_time;
1226
	FILE			*output;
1227
	unsigned long		nr_events;
1228
	struct strlist		*ev_qualifier;
1229
	const char 		*last_vfs_getname;
1230 1231
	struct intlist		*tid_list;
	struct intlist		*pid_list;
1232 1233 1234 1235 1236 1237 1238 1239 1240
	double			duration_filter;
	double			runtime_ms;
	struct {
		u64		vfs_getname,
				proc_getname;
	} stats;
	bool			not_ev_qualifier;
	bool			live;
	bool			full_time;
1241
	bool			sched;
1242
	bool			multiple_threads;
1243
	bool			summary;
D
David Ahern 已提交
1244
	bool			summary_only;
1245
	bool			show_comm;
1246
	bool			show_tool_stats;
1247
	bool			trace_syscalls;
1248
	int			trace_pgfaults;
A
Arnaldo Carvalho de Melo 已提交
1249 1250
};

1251
static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
1252
{
1253
	struct thread_trace *ttrace = thread__priv(thread);
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276

	if (fd > ttrace->paths.max) {
		char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));

		if (npath == NULL)
			return -1;

		if (ttrace->paths.max != -1) {
			memset(npath + ttrace->paths.max + 1, 0,
			       (fd - ttrace->paths.max) * sizeof(char *));
		} else {
			memset(npath, 0, (fd + 1) * sizeof(char *));
		}

		ttrace->paths.table = npath;
		ttrace->paths.max   = fd;
	}

	ttrace->paths.table[fd] = strdup(pathname);

	return ttrace->paths.table[fd] != NULL ? 0 : -1;
}

1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
static int thread__read_fd_path(struct thread *thread, int fd)
{
	char linkname[PATH_MAX], pathname[PATH_MAX];
	struct stat st;
	int ret;

	if (thread->pid_ == thread->tid) {
		scnprintf(linkname, sizeof(linkname),
			  "/proc/%d/fd/%d", thread->pid_, fd);
	} else {
		scnprintf(linkname, sizeof(linkname),
			  "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
	}

	if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
		return -1;

	ret = readlink(linkname, pathname, sizeof(pathname));

	if (ret < 0 || ret > st.st_size)
		return -1;

	pathname[ret] = '\0';
	return trace__set_fd_pathname(thread, fd, pathname);
}

1303 1304
static const char *thread__fd_path(struct thread *thread, int fd,
				   struct trace *trace)
1305
{
1306
	struct thread_trace *ttrace = thread__priv(thread);
1307 1308 1309 1310 1311 1312 1313

	if (ttrace == NULL)
		return NULL;

	if (fd < 0)
		return NULL;

1314
	if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
1315 1316 1317
		if (!trace->live)
			return NULL;
		++trace->stats.proc_getname;
1318
		if (thread__read_fd_path(thread, fd))
1319 1320
			return NULL;
	}
1321 1322 1323 1324 1325 1326 1327 1328 1329

	return ttrace->paths.table[fd];
}

static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
					struct syscall_arg *arg)
{
	int fd = arg->val;
	size_t printed = scnprintf(bf, size, "%d", fd);
1330
	const char *path = thread__fd_path(arg->thread, fd, arg->trace);
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342

	if (path)
		printed += scnprintf(bf + printed, size - printed, "<%s>", path);

	return printed;
}

static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
					      struct syscall_arg *arg)
{
	int fd = arg->val;
	size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
1343
	struct thread_trace *ttrace = thread__priv(arg->thread);
1344

1345 1346
	if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
		zfree(&ttrace->paths.table[fd]);
1347 1348 1349 1350

	return printed;
}

1351 1352 1353 1354 1355
static bool trace__filter_duration(struct trace *trace, double t)
{
	return t < (trace->duration_filter * NSEC_PER_MSEC);
}

1356 1357 1358 1359
static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
{
	double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;

1360
	return fprintf(fp, "%10.3f ", ts);
1361 1362
}

1363
static bool done = false;
1364
static bool interrupted = false;
1365

1366
static void sig_handler(int sig)
1367 1368
{
	done = true;
1369
	interrupted = sig == SIGINT;
1370 1371
}

1372
static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
1373
					u64 duration, u64 tstamp, FILE *fp)
1374 1375
{
	size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
1376
	printed += fprintf_duration(duration, fp);
1377

1378 1379
	if (trace->multiple_threads) {
		if (trace->show_comm)
1380
			printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
1381
		printed += fprintf(fp, "%d ", thread->tid);
1382
	}
1383 1384 1385 1386

	return printed;
}

1387
static int trace__process_event(struct trace *trace, struct machine *machine,
1388
				union perf_event *event, struct perf_sample *sample)
1389 1390 1391 1392 1393
{
	int ret = 0;

	switch (event->header.type) {
	case PERF_RECORD_LOST:
1394
		color_fprintf(trace->output, PERF_COLOR_RED,
1395
			      "LOST %" PRIu64 " events!\n", event->lost.lost);
1396
		ret = machine__process_lost_event(machine, event, sample);
1397
	default:
1398
		ret = machine__process_event(machine, event, sample);
1399 1400 1401 1402 1403 1404
		break;
	}

	return ret;
}

1405
static int trace__tool_process(struct perf_tool *tool,
1406
			       union perf_event *event,
1407
			       struct perf_sample *sample,
1408 1409
			       struct machine *machine)
{
1410
	struct trace *trace = container_of(tool, struct trace, tool);
1411
	return trace__process_event(trace, machine, event, sample);
1412 1413 1414 1415
}

static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
{
1416
	int err = symbol__init(NULL);
1417 1418 1419 1420

	if (err)
		return err;

1421 1422 1423
	trace->host = machine__new_host();
	if (trace->host == NULL)
		return -ENOMEM;
1424

1425 1426
	err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
					    evlist->threads, trace__tool_process, false);
1427 1428 1429 1430 1431 1432
	if (err)
		symbol__exit();

	return err;
}

1433 1434 1435 1436 1437 1438 1439 1440 1441
static int syscall__set_arg_fmts(struct syscall *sc)
{
	struct format_field *field;
	int idx = 0;

	sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
	if (sc->arg_scnprintf == NULL)
		return -1;

1442 1443 1444
	if (sc->fmt)
		sc->arg_parm = sc->fmt->arg_parm;

1445
	for (field = sc->tp_format->format.fields->next; field; field = field->next) {
1446 1447 1448
		if (sc->fmt && sc->fmt->arg_scnprintf[idx])
			sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
		else if (field->flags & FIELD_IS_POINTER)
1449 1450 1451 1452 1453 1454 1455
			sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
		++idx;
	}

	return 0;
}

A
Arnaldo Carvalho de Melo 已提交
1456 1457 1458 1459
static int trace__read_syscall_info(struct trace *trace, int id)
{
	char tp_name[128];
	struct syscall *sc;
1460
	const char *name = audit_syscall_to_name(id, trace->audit.machine);
1461 1462 1463

	if (name == NULL)
		return -1;
A
Arnaldo Carvalho de Melo 已提交
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482

	if (id > trace->syscalls.max) {
		struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));

		if (nsyscalls == NULL)
			return -1;

		if (trace->syscalls.max != -1) {
			memset(nsyscalls + trace->syscalls.max + 1, 0,
			       (id - trace->syscalls.max) * sizeof(*sc));
		} else {
			memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
		}

		trace->syscalls.table = nsyscalls;
		trace->syscalls.max   = id;
	}

	sc = trace->syscalls.table + id;
1483
	sc->name = name;
1484

1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
	if (trace->ev_qualifier) {
		bool in = strlist__find(trace->ev_qualifier, name) != NULL;

		if (!(in ^ trace->not_ev_qualifier)) {
			sc->filtered = true;
			/*
			 * No need to do read tracepoint information since this will be
			 * filtered out.
			 */
			return 0;
		}
1496 1497
	}

1498
	sc->fmt  = syscall_fmt__find(sc->name);
A
Arnaldo Carvalho de Melo 已提交
1499

1500
	snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
1501
	sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1502 1503 1504

	if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
		snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
1505
		sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1506
	}
A
Arnaldo Carvalho de Melo 已提交
1507

1508 1509 1510
	if (sc->tp_format == NULL)
		return -1;

1511 1512
	sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");

1513
	return syscall__set_arg_fmts(sc);
A
Arnaldo Carvalho de Melo 已提交
1514 1515
}

1516
static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
1517 1518
				      unsigned long *args, struct trace *trace,
				      struct thread *thread)
A
Arnaldo Carvalho de Melo 已提交
1519 1520 1521 1522 1523
{
	size_t printed = 0;

	if (sc->tp_format != NULL) {
		struct format_field *field;
1524 1525
		u8 bit = 1;
		struct syscall_arg arg = {
1526 1527 1528 1529
			.idx	= 0,
			.mask	= 0,
			.trace  = trace,
			.thread = thread,
1530
		};
1531 1532

		for (field = sc->tp_format->format.fields->next; field;
1533 1534
		     field = field->next, ++arg.idx, bit <<= 1) {
			if (arg.mask & bit)
1535
				continue;
1536 1537 1538 1539 1540 1541 1542 1543 1544
			/*
 			 * Suppress this argument if its value is zero and
 			 * and we don't have a string associated in an
 			 * strarray for it.
 			 */
			if (args[arg.idx] == 0 &&
			    !(sc->arg_scnprintf &&
			      sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
			      sc->arg_parm[arg.idx]))
1545 1546
				continue;

1547
			printed += scnprintf(bf + printed, size - printed,
1548
					     "%s%s: ", printed ? ", " : "", field->name);
1549 1550
			if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
				arg.val = args[arg.idx];
1551 1552
				if (sc->arg_parm)
					arg.parm = sc->arg_parm[arg.idx];
1553 1554
				printed += sc->arg_scnprintf[arg.idx](bf + printed,
								      size - printed, &arg);
1555
			} else {
1556
				printed += scnprintf(bf + printed, size - printed,
1557
						     "%ld", args[arg.idx]);
1558
			}
A
Arnaldo Carvalho de Melo 已提交
1559 1560
		}
	} else {
1561 1562
		int i = 0;

A
Arnaldo Carvalho de Melo 已提交
1563
		while (i < 6) {
1564 1565 1566
			printed += scnprintf(bf + printed, size - printed,
					     "%sarg%d: %ld",
					     printed ? ", " : "", i, args[i]);
A
Arnaldo Carvalho de Melo 已提交
1567 1568 1569 1570 1571 1572 1573
			++i;
		}
	}

	return printed;
}

1574
typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
1575
				  union perf_event *event,
1576 1577 1578
				  struct perf_sample *sample);

static struct syscall *trace__syscall_info(struct trace *trace,
1579
					   struct perf_evsel *evsel, int id)
1580 1581 1582
{

	if (id < 0) {
1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598

		/*
		 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
		 * before that, leaving at a higher verbosity level till that is
		 * explained. Reproduced with plain ftrace with:
		 *
		 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
		 * grep "NR -1 " /t/trace_pipe
		 *
		 * After generating some load on the machine.
 		 */
		if (verbose > 1) {
			static u64 n;
			fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
				id, perf_evsel__name(evsel), ++n);
		}
1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
		return NULL;
	}

	if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
	    trace__read_syscall_info(trace, id))
		goto out_cant_read;

	if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
		goto out_cant_read;

	return &trace->syscalls.table[id];

out_cant_read:
1612 1613 1614 1615 1616 1617
	if (verbose) {
		fprintf(trace->output, "Problems reading syscall %d", id);
		if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
			fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
		fputs(" information\n", trace->output);
	}
1618 1619 1620
	return NULL;
}

1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
static void thread__update_stats(struct thread_trace *ttrace,
				 int id, struct perf_sample *sample)
{
	struct int_node *inode;
	struct stats *stats;
	u64 duration = 0;

	inode = intlist__findnew(ttrace->syscall_stats, id);
	if (inode == NULL)
		return;

	stats = inode->priv;
	if (stats == NULL) {
		stats = malloc(sizeof(struct stats));
		if (stats == NULL)
			return;
		init_stats(stats);
		inode->priv = stats;
	}

	if (ttrace->entry_time && sample->time > ttrace->entry_time)
		duration = sample->time - ttrace->entry_time;

	update_stats(stats, duration);
}

1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669
static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
{
	struct thread_trace *ttrace;
	u64 duration;
	size_t printed;

	if (trace->current == NULL)
		return 0;

	ttrace = thread__priv(trace->current);

	if (!ttrace->entry_pending)
		return 0;

	duration = sample->time - ttrace->entry_time;

	printed  = trace__fprintf_entry_head(trace, trace->current, duration, sample->time, trace->output);
	printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
	ttrace->entry_pending = false;

	return printed;
}

1670
static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1671
			    union perf_event *event __maybe_unused,
1672 1673
			    struct perf_sample *sample)
{
1674
	char *msg;
1675
	void *args;
1676
	size_t printed = 0;
1677
	struct thread *thread;
1678
	int id = perf_evsel__sc_tp_uint(evsel, id, sample);
1679
	struct syscall *sc = trace__syscall_info(trace, evsel, id);
1680 1681 1682 1683
	struct thread_trace *ttrace;

	if (sc == NULL)
		return -1;
1684

1685 1686 1687
	if (sc->filtered)
		return 0;

1688
	thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1689
	ttrace = thread__trace(thread, trace->output);
1690
	if (ttrace == NULL)
1691 1692
		return -1;

1693
	args = perf_evsel__sc_tp_ptr(evsel, args, sample);
1694 1695 1696 1697 1698 1699 1700

	if (ttrace->entry_str == NULL) {
		ttrace->entry_str = malloc(1024);
		if (!ttrace->entry_str)
			return -1;
	}

1701 1702
	printed += trace__printf_interrupted_entry(trace, sample);

1703 1704 1705 1706
	ttrace->entry_time = sample->time;
	msg = ttrace->entry_str;
	printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);

1707 1708
	printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed,
					   args, trace, thread);
1709

1710
	if (sc->is_exit) {
D
David Ahern 已提交
1711
		if (!trace->duration_filter && !trace->summary_only) {
1712 1713
			trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
			fprintf(trace->output, "%-70s\n", ttrace->entry_str);
1714
		}
1715 1716
	} else
		ttrace->entry_pending = true;
1717

1718 1719
	trace->current = thread;

1720 1721 1722 1723
	return 0;
}

static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
1724
			   union perf_event *event __maybe_unused,
1725 1726
			   struct perf_sample *sample)
{
1727
	long ret;
1728
	u64 duration = 0;
1729
	struct thread *thread;
1730
	int id = perf_evsel__sc_tp_uint(evsel, id, sample);
1731
	struct syscall *sc = trace__syscall_info(trace, evsel, id);
1732 1733 1734 1735
	struct thread_trace *ttrace;

	if (sc == NULL)
		return -1;
1736

1737 1738 1739
	if (sc->filtered)
		return 0;

1740
	thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1741
	ttrace = thread__trace(thread, trace->output);
1742
	if (ttrace == NULL)
1743 1744
		return -1;

1745 1746 1747
	if (trace->summary)
		thread__update_stats(ttrace, id, sample);

1748
	ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
1749

1750 1751 1752 1753 1754 1755
	if (id == trace->audit.open_id && ret >= 0 && trace->last_vfs_getname) {
		trace__set_fd_pathname(thread, ret, trace->last_vfs_getname);
		trace->last_vfs_getname = NULL;
		++trace->stats.vfs_getname;
	}

1756 1757
	ttrace->exit_time = sample->time;

1758
	if (ttrace->entry_time) {
1759
		duration = sample->time - ttrace->entry_time;
1760 1761 1762 1763
		if (trace__filter_duration(trace, duration))
			goto out;
	} else if (trace->duration_filter)
		goto out;
1764

D
David Ahern 已提交
1765 1766 1767
	if (trace->summary_only)
		goto out;

1768
	trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
1769 1770

	if (ttrace->entry_pending) {
1771
		fprintf(trace->output, "%-70s", ttrace->entry_str);
1772
	} else {
1773 1774 1775
		fprintf(trace->output, " ... [");
		color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
		fprintf(trace->output, "]: %s()", sc->name);
1776 1777
	}

1778 1779
	if (sc->fmt == NULL) {
signed_print:
1780
		fprintf(trace->output, ") = %ld", ret);
1781
	} else if (ret < 0 && sc->fmt->errmsg) {
1782
		char bf[STRERR_BUFSIZE];
1783 1784 1785
		const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
			   *e = audit_errno_to_name(-ret);

1786
		fprintf(trace->output, ") = -1 %s %s", e, emsg);
1787
	} else if (ret == 0 && sc->fmt->timeout)
1788
		fprintf(trace->output, ") = 0 Timeout");
1789
	else if (sc->fmt->hexret)
1790
		fprintf(trace->output, ") = %#lx", ret);
1791
	else
1792
		goto signed_print;
1793

1794
	fputc('\n', trace->output);
1795
out:
1796 1797
	ttrace->entry_pending = false;

1798 1799 1800
	return 0;
}

1801
static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
1802
			      union perf_event *event __maybe_unused,
1803 1804 1805 1806 1807 1808
			      struct perf_sample *sample)
{
	trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
	return 0;
}

1809
static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
1810
				     union perf_event *event __maybe_unused,
1811 1812 1813 1814
				     struct perf_sample *sample)
{
        u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
	double runtime_ms = (double)runtime / NSEC_PER_MSEC;
1815
	struct thread *thread = machine__findnew_thread(trace->host,
1816 1817
							sample->pid,
							sample->tid);
1818
	struct thread_trace *ttrace = thread__trace(thread, trace->output);
1819 1820 1821 1822 1823 1824 1825 1826 1827

	if (ttrace == NULL)
		goto out_dump;

	ttrace->runtime_ms += runtime_ms;
	trace->runtime_ms += runtime_ms;
	return 0;

out_dump:
1828
	fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1829 1830 1831 1832 1833 1834 1835 1836
	       evsel->name,
	       perf_evsel__strval(evsel, sample, "comm"),
	       (pid_t)perf_evsel__intval(evsel, sample, "pid"),
	       runtime,
	       perf_evsel__intval(evsel, sample, "vruntime"));
	return 0;
}

1837 1838 1839 1840 1841 1842
static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
				union perf_event *event __maybe_unused,
				struct perf_sample *sample)
{
	trace__printf_interrupted_entry(trace, sample);
	trace__fprintf_tstamp(trace, sample->time, trace->output);
1843 1844 1845 1846 1847

	if (trace->trace_syscalls)
		fprintf(trace->output, "(         ): ");

	fprintf(trace->output, "%s:", evsel->name);
1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858

	if (evsel->tp_format) {
		event_format__fprintf(evsel->tp_format, sample->cpu,
				      sample->raw_data, sample->raw_size,
				      trace->output);
	}

	fprintf(trace->output, ")\n");
	return 0;
}

1859 1860 1861 1862 1863 1864 1865 1866 1867
static void print_location(FILE *f, struct perf_sample *sample,
			   struct addr_location *al,
			   bool print_dso, bool print_sym)
{

	if ((verbose || print_dso) && al->map)
		fprintf(f, "%s@", al->map->dso->long_name);

	if ((verbose || print_sym) && al->sym)
1868
		fprintf(f, "%s+0x%" PRIx64, al->sym->name,
1869 1870
			al->addr - al->sym->start);
	else if (al->map)
1871
		fprintf(f, "0x%" PRIx64, al->addr);
1872
	else
1873
		fprintf(f, "0x%" PRIx64, sample->addr);
1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884
}

static int trace__pgfault(struct trace *trace,
			  struct perf_evsel *evsel,
			  union perf_event *event,
			  struct perf_sample *sample)
{
	struct thread *thread;
	u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
	struct addr_location al;
	char map_type = 'd';
1885
	struct thread_trace *ttrace;
1886 1887

	thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898
	ttrace = thread__trace(thread, trace->output);
	if (ttrace == NULL)
		return -1;

	if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
		ttrace->pfmaj++;
	else
		ttrace->pfmin++;

	if (trace->summary_only)
		return 0;
1899

1900
	thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912
			      sample->ip, &al);

	trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);

	fprintf(trace->output, "%sfault [",
		evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
		"maj" : "min");

	print_location(trace->output, sample, &al, false, true);

	fprintf(trace->output, "] => ");

1913
	thread__find_addr_location(thread, cpumode, MAP__VARIABLE,
1914 1915 1916
				   sample->addr, &al);

	if (!al.map) {
1917
		thread__find_addr_location(thread, cpumode,
1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
					   MAP__FUNCTION, sample->addr, &al);

		if (al.map)
			map_type = 'x';
		else
			map_type = '?';
	}

	print_location(trace->output, sample, &al, true, false);

	fprintf(trace->output, " (%c%c)\n", map_type, al.level);

	return 0;
}

1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
static bool skip_sample(struct trace *trace, struct perf_sample *sample)
{
	if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
	    (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
		return false;

	if (trace->pid_list || trace->tid_list)
		return true;

	return false;
}

1945
static int trace__process_sample(struct perf_tool *tool,
1946
				 union perf_event *event,
1947 1948 1949 1950 1951 1952 1953
				 struct perf_sample *sample,
				 struct perf_evsel *evsel,
				 struct machine *machine __maybe_unused)
{
	struct trace *trace = container_of(tool, struct trace, tool);
	int err = 0;

1954
	tracepoint_handler handler = evsel->handler;
1955

1956 1957 1958
	if (skip_sample(trace, sample))
		return 0;

1959
	if (!trace->full_time && trace->base_time == 0)
1960 1961
		trace->base_time = sample->time;

1962 1963
	if (handler) {
		++trace->nr_events;
1964
		handler(trace, evsel, event, sample);
1965
	}
1966 1967 1968 1969

	return err;
}

1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
static int parse_target_str(struct trace *trace)
{
	if (trace->opts.target.pid) {
		trace->pid_list = intlist__new(trace->opts.target.pid);
		if (trace->pid_list == NULL) {
			pr_err("Error parsing process id string\n");
			return -EINVAL;
		}
	}

	if (trace->opts.target.tid) {
		trace->tid_list = intlist__new(trace->opts.target.tid);
		if (trace->tid_list == NULL) {
			pr_err("Error parsing thread id string\n");
			return -EINVAL;
		}
	}

	return 0;
}

1991
static int trace__record(struct trace *trace, int argc, const char **argv)
D
David Ahern 已提交
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
{
	unsigned int rec_argc, i, j;
	const char **rec_argv;
	const char * const record_args[] = {
		"record",
		"-R",
		"-m", "1024",
		"-c", "1",
	};

2002 2003 2004 2005 2006 2007 2008
	const char * const sc_args[] = { "-e", };
	unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
	const char * const majpf_args[] = { "-e", "major-faults" };
	unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
	const char * const minpf_args[] = { "-e", "minor-faults" };
	unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);

2009
	/* +1 is for the event string below */
2010 2011
	rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
		majpf_args_nr + minpf_args_nr + argc;
D
David Ahern 已提交
2012 2013 2014 2015 2016
	rec_argv = calloc(rec_argc + 1, sizeof(char *));

	if (rec_argv == NULL)
		return -ENOMEM;

2017
	j = 0;
D
David Ahern 已提交
2018
	for (i = 0; i < ARRAY_SIZE(record_args); i++)
2019 2020
		rec_argv[j++] = record_args[i];

2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
	if (trace->trace_syscalls) {
		for (i = 0; i < sc_args_nr; i++)
			rec_argv[j++] = sc_args[i];

		/* event string may be different for older kernels - e.g., RHEL6 */
		if (is_valid_tracepoint("raw_syscalls:sys_enter"))
			rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
		else if (is_valid_tracepoint("syscalls:sys_enter"))
			rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
		else {
			pr_err("Neither raw_syscalls nor syscalls events exist.\n");
			return -1;
		}
2034 2035
	}

2036 2037 2038 2039 2040 2041 2042 2043 2044 2045
	if (trace->trace_pgfaults & TRACE_PFMAJ)
		for (i = 0; i < majpf_args_nr; i++)
			rec_argv[j++] = majpf_args[i];

	if (trace->trace_pgfaults & TRACE_PFMIN)
		for (i = 0; i < minpf_args_nr; i++)
			rec_argv[j++] = minpf_args[i];

	for (i = 0; i < (unsigned int)argc; i++)
		rec_argv[j++] = argv[i];
D
David Ahern 已提交
2046

2047
	return cmd_record(j, rec_argv, NULL);
D
David Ahern 已提交
2048 2049
}

2050 2051
static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);

2052 2053
static void perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
{
2054
	struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
2055 2056 2057 2058 2059 2060 2061 2062
	if (evsel == NULL)
		return;

	if (perf_evsel__field(evsel, "pathname") == NULL) {
		perf_evsel__delete(evsel);
		return;
	}

2063
	evsel->handler = trace__vfs_getname;
2064 2065 2066
	perf_evlist__add(evlist, evsel);
}

2067 2068 2069 2070 2071 2072 2073 2074 2075 2076
static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
				    u64 config)
{
	struct perf_evsel *evsel;
	struct perf_event_attr attr = {
		.type = PERF_TYPE_SOFTWARE,
		.mmap_data = 1,
	};

	attr.config = config;
2077
	attr.sample_period = 1;
2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090

	event_attr_init(&attr);

	evsel = perf_evsel__new(&attr);
	if (!evsel)
		return -ENOMEM;

	evsel->handler = trace__pgfault;
	perf_evlist__add(evlist, evsel);

	return 0;
}

2091
static int trace__run(struct trace *trace, int argc, const char **argv)
A
Arnaldo Carvalho de Melo 已提交
2092
{
2093
	struct perf_evlist *evlist = trace->evlist;
2094
	struct perf_evsel *evsel;
2095 2096
	int err = -1, i;
	unsigned long before;
2097
	const bool forks = argc > 0;
2098
	bool draining = false;
A
Arnaldo Carvalho de Melo 已提交
2099

2100 2101
	trace->live = true;

2102 2103 2104
	if (trace->trace_syscalls &&
	    perf_evlist__add_syscall_newtp(evlist, trace__sys_enter,
					   trace__sys_exit))
2105
		goto out_error_raw_syscalls;
A
Arnaldo Carvalho de Melo 已提交
2106

2107 2108
	if (trace->trace_syscalls)
		perf_evlist__add_vfs_getname(evlist);
2109

2110
	if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
2111
	    perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ)) {
2112
		goto out_error_mem;
2113
	}
2114 2115 2116

	if ((trace->trace_pgfaults & TRACE_PFMIN) &&
	    perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
2117
		goto out_error_mem;
2118

2119
	if (trace->sched &&
2120 2121 2122
	    perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
				   trace__sched_stat_runtime))
		goto out_error_sched_stat_runtime;
2123

A
Arnaldo Carvalho de Melo 已提交
2124 2125
	err = perf_evlist__create_maps(evlist, &trace->opts.target);
	if (err < 0) {
2126
		fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
A
Arnaldo Carvalho de Melo 已提交
2127 2128 2129
		goto out_delete_evlist;
	}

2130 2131
	err = trace__symbols_init(trace, evlist);
	if (err < 0) {
2132
		fprintf(trace->output, "Problems initializing symbol libraries!\n");
2133
		goto out_delete_evlist;
2134 2135
	}

2136
	perf_evlist__config(evlist, &trace->opts);
A
Arnaldo Carvalho de Melo 已提交
2137

2138 2139 2140 2141
	signal(SIGCHLD, sig_handler);
	signal(SIGINT, sig_handler);

	if (forks) {
2142
		err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
2143
						    argv, false, NULL);
2144
		if (err < 0) {
2145
			fprintf(trace->output, "Couldn't run the workload!\n");
2146
			goto out_delete_evlist;
2147 2148 2149
		}
	}

A
Arnaldo Carvalho de Melo 已提交
2150
	err = perf_evlist__open(evlist);
2151 2152
	if (err < 0)
		goto out_error_open;
A
Arnaldo Carvalho de Melo 已提交
2153

J
Jiri Olsa 已提交
2154
	err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
2155 2156
	if (err < 0)
		goto out_error_mmap;
A
Arnaldo Carvalho de Melo 已提交
2157

2158 2159
	if (forks)
		perf_evlist__start_workload(evlist);
2160 2161
	else
		perf_evlist__enable(evlist);
2162

2163 2164 2165
	trace->multiple_threads = evlist->threads->map[0] == -1 ||
				  evlist->threads->nr > 1 ||
				  perf_evlist__first(evlist)->attr.inherit;
A
Arnaldo Carvalho de Melo 已提交
2166
again:
2167
	before = trace->nr_events;
A
Arnaldo Carvalho de Melo 已提交
2168 2169 2170 2171 2172 2173

	for (i = 0; i < evlist->nr_mmaps; i++) {
		union perf_event *event;

		while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
			const u32 type = event->header.type;
2174
			tracepoint_handler handler;
A
Arnaldo Carvalho de Melo 已提交
2175 2176
			struct perf_sample sample;

2177
			++trace->nr_events;
A
Arnaldo Carvalho de Melo 已提交
2178 2179 2180

			err = perf_evlist__parse_sample(evlist, event, &sample);
			if (err) {
2181
				fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
2182
				goto next_event;
A
Arnaldo Carvalho de Melo 已提交
2183 2184
			}

2185
			if (!trace->full_time && trace->base_time == 0)
2186 2187 2188
				trace->base_time = sample.time;

			if (type != PERF_RECORD_SAMPLE) {
2189
				trace__process_event(trace, trace->host, event, &sample);
2190 2191 2192
				continue;
			}

A
Arnaldo Carvalho de Melo 已提交
2193 2194
			evsel = perf_evlist__id2evsel(evlist, sample.id);
			if (evsel == NULL) {
2195
				fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
2196
				goto next_event;
A
Arnaldo Carvalho de Melo 已提交
2197 2198
			}

2199 2200
			if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
			    sample.raw_data == NULL) {
2201
				fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2202 2203
				       perf_evsel__name(evsel), sample.tid,
				       sample.cpu, sample.raw_size);
2204
				goto next_event;
2205 2206
			}

2207
			handler = evsel->handler;
2208
			handler(trace, evsel, event, &sample);
2209 2210
next_event:
			perf_evlist__mmap_consume(evlist, i);
2211

2212 2213
			if (interrupted)
				goto out_disable;
A
Arnaldo Carvalho de Melo 已提交
2214 2215 2216
		}
	}

2217
	if (trace->nr_events == before) {
2218
		int timeout = done ? 100 : -1;
2219

2220 2221 2222 2223
		if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
			if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
				draining = true;

2224
			goto again;
2225
		}
2226 2227
	} else {
		goto again;
2228 2229
	}

2230 2231
out_disable:
	perf_evlist__disable(evlist);
A
Arnaldo Carvalho de Melo 已提交
2232

2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244
	if (!err) {
		if (trace->summary)
			trace__fprintf_thread_summary(trace, trace->output);

		if (trace->show_tool_stats) {
			fprintf(trace->output, "Stats:\n "
					       " vfs_getname : %" PRIu64 "\n"
					       " proc_getname: %" PRIu64 "\n",
				trace->stats.vfs_getname,
				trace->stats.proc_getname);
		}
	}
2245

A
Arnaldo Carvalho de Melo 已提交
2246 2247
out_delete_evlist:
	perf_evlist__delete(evlist);
2248
	trace->evlist = NULL;
2249
	trace->live = false;
A
Arnaldo Carvalho de Melo 已提交
2250
	return err;
2251 2252
{
	char errbuf[BUFSIZ];
2253

2254 2255 2256 2257
out_error_sched_stat_runtime:
	debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
	goto out_error;

2258
out_error_raw_syscalls:
2259
	debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
2260 2261
	goto out_error;

2262 2263 2264 2265
out_error_mmap:
	perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
	goto out_error;

2266 2267 2268 2269
out_error_open:
	perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));

out_error:
2270
	fprintf(trace->output, "%s\n", errbuf);
2271
	goto out_delete_evlist;
A
Arnaldo Carvalho de Melo 已提交
2272
}
2273 2274 2275
out_error_mem:
	fprintf(trace->output, "Not enough memory to run!\n");
	goto out_delete_evlist;
2276
}
A
Arnaldo Carvalho de Melo 已提交
2277

2278 2279 2280
static int trace__replay(struct trace *trace)
{
	const struct perf_evsel_str_handler handlers[] = {
2281
		{ "probe:vfs_getname",	     trace__vfs_getname, },
2282
	};
2283 2284 2285 2286
	struct perf_data_file file = {
		.path  = input_name,
		.mode  = PERF_DATA_MODE_READ,
	};
2287
	struct perf_session *session;
2288
	struct perf_evsel *evsel;
2289 2290 2291 2292
	int err = -1;

	trace->tool.sample	  = trace__process_sample;
	trace->tool.mmap	  = perf_event__process_mmap;
D
David Ahern 已提交
2293
	trace->tool.mmap2	  = perf_event__process_mmap2;
2294 2295 2296 2297 2298 2299 2300
	trace->tool.comm	  = perf_event__process_comm;
	trace->tool.exit	  = perf_event__process_exit;
	trace->tool.fork	  = perf_event__process_fork;
	trace->tool.attr	  = perf_event__process_attr;
	trace->tool.tracing_data = perf_event__process_tracing_data;
	trace->tool.build_id	  = perf_event__process_build_id;

2301
	trace->tool.ordered_events = true;
2302 2303 2304 2305 2306
	trace->tool.ordering_requires_timestamps = true;

	/* add tid to output */
	trace->multiple_threads = true;

2307
	session = perf_session__new(&file, false, &trace->tool);
2308
	if (session == NULL)
2309
		return -1;
2310

2311
	if (symbol__init(&session->header.env) < 0)
2312 2313
		goto out;

2314 2315
	trace->host = &session->machines.host;

2316 2317 2318 2319
	err = perf_session__set_tracepoints_handlers(session, handlers);
	if (err)
		goto out;

2320 2321
	evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
						     "raw_syscalls:sys_enter");
2322 2323 2324 2325
	/* older kernels have syscalls tp versus raw_syscalls */
	if (evsel == NULL)
		evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
							     "syscalls:sys_enter");
2326

2327 2328 2329
	if (evsel &&
	    (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
	    perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
2330 2331 2332 2333 2334 2335
		pr_err("Error during initialize raw_syscalls:sys_enter event\n");
		goto out;
	}

	evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
						     "raw_syscalls:sys_exit");
2336 2337 2338
	if (evsel == NULL)
		evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
							     "syscalls:sys_exit");
2339 2340 2341
	if (evsel &&
	    (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
	    perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
2342
		pr_err("Error during initialize raw_syscalls:sys_exit event\n");
2343 2344 2345
		goto out;
	}

2346 2347 2348 2349 2350 2351 2352 2353
	evlist__for_each(session->evlist, evsel) {
		if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
		    (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
		     evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
		     evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
			evsel->handler = trace__pgfault;
	}

2354 2355 2356 2357
	err = parse_target_str(trace);
	if (err != 0)
		goto out;

2358 2359 2360 2361 2362 2363
	setup_pager();

	err = perf_session__process_events(session, &trace->tool);
	if (err)
		pr_err("Failed to process events, error %d", err);

2364 2365 2366
	else if (trace->summary)
		trace__fprintf_thread_summary(trace, trace->output);

2367 2368 2369 2370 2371 2372
out:
	perf_session__delete(session);

	return err;
}

2373 2374 2375 2376
static size_t trace__fprintf_threads_header(FILE *fp)
{
	size_t printed;

2377
	printed  = fprintf(fp, "\n Summary of events:\n\n");
2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394

	return printed;
}

static size_t thread__dump_stats(struct thread_trace *ttrace,
				 struct trace *trace, FILE *fp)
{
	struct stats *stats;
	size_t printed = 0;
	struct syscall *sc;
	struct int_node *inode = intlist__first(ttrace->syscall_stats);

	if (inode == NULL)
		return 0;

	printed += fprintf(fp, "\n");

P
Pekka Enberg 已提交
2395 2396 2397
	printed += fprintf(fp, "   syscall            calls      min       avg       max      stddev\n");
	printed += fprintf(fp, "                               (msec)    (msec)    (msec)        (%%)\n");
	printed += fprintf(fp, "   --------------- -------- --------- --------- ---------     ------\n");
2398

2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412
	/* each int_node is a syscall */
	while (inode) {
		stats = inode->priv;
		if (stats) {
			double min = (double)(stats->min) / NSEC_PER_MSEC;
			double max = (double)(stats->max) / NSEC_PER_MSEC;
			double avg = avg_stats(stats);
			double pct;
			u64 n = (u64) stats->n;

			pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
			avg /= NSEC_PER_MSEC;

			sc = &trace->syscalls.table[inode->i];
2413
			printed += fprintf(fp, "   %-15s", sc->name);
P
Pekka Enberg 已提交
2414
			printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f",
2415
					   n, min, avg);
P
Pekka Enberg 已提交
2416
			printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
2417 2418 2419 2420 2421 2422
		}

		inode = intlist__next(inode);
	}

	printed += fprintf(fp, "\n\n");
2423 2424 2425 2426

	return printed;
}

2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439
/* struct used to pass data to per-thread function */
struct summary_data {
	FILE *fp;
	struct trace *trace;
	size_t printed;
};

static int trace__fprintf_one_thread(struct thread *thread, void *priv)
{
	struct summary_data *data = priv;
	FILE *fp = data->fp;
	size_t printed = data->printed;
	struct trace *trace = data->trace;
2440
	struct thread_trace *ttrace = thread__priv(thread);
2441 2442 2443 2444 2445 2446 2447
	double ratio;

	if (ttrace == NULL)
		return 0;

	ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;

2448
	printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
2449
	printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
2450
	printed += fprintf(fp, "%.1f%%", ratio);
2451 2452 2453 2454
	if (ttrace->pfmaj)
		printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
	if (ttrace->pfmin)
		printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
2455
	printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
2456
	printed += thread__dump_stats(ttrace, trace, fp);
2457 2458 2459 2460 2461 2462

	data->printed += printed;

	return 0;
}

2463 2464
static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
{
2465 2466 2467 2468 2469
	struct summary_data data = {
		.fp = fp,
		.trace = trace
	};
	data.printed = trace__fprintf_threads_header(fp);
2470

2471 2472 2473
	machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);

	return data.printed;
2474 2475
}

2476 2477 2478 2479 2480 2481 2482 2483 2484
static int trace__set_duration(const struct option *opt, const char *str,
			       int unset __maybe_unused)
{
	struct trace *trace = opt->value;

	trace->duration_filter = atof(str);
	return 0;
}

2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501
static int trace__open_output(struct trace *trace, const char *filename)
{
	struct stat st;

	if (!stat(filename, &st) && st.st_size) {
		char oldname[PATH_MAX];

		scnprintf(oldname, sizeof(oldname), "%s.old", filename);
		unlink(oldname);
		rename(filename, oldname);
	}

	trace->output = fopen(filename, "w");

	return trace->output == NULL ? -errno : 0;
}

2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
static int parse_pagefaults(const struct option *opt, const char *str,
			    int unset __maybe_unused)
{
	int *trace_pgfaults = opt->value;

	if (strcmp(str, "all") == 0)
		*trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
	else if (strcmp(str, "maj") == 0)
		*trace_pgfaults |= TRACE_PFMAJ;
	else if (strcmp(str, "min") == 0)
		*trace_pgfaults |= TRACE_PFMIN;
	else
		return -1;

	return 0;
}

2519 2520 2521 2522 2523 2524 2525 2526
static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
{
	struct perf_evsel *evsel;

	evlist__for_each(evlist, evsel)
		evsel->handler = handler;
}

A
Arnaldo Carvalho de Melo 已提交
2527 2528 2529
int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
{
	const char * const trace_usage[] = {
2530 2531
		"perf trace [<options>] [<command>]",
		"perf trace [<options>] -- <command> [<options>]",
D
David Ahern 已提交
2532 2533
		"perf trace record [<options>] [<command>]",
		"perf trace record [<options>] -- <command> [<options>]",
A
Arnaldo Carvalho de Melo 已提交
2534 2535 2536
		NULL
	};
	struct trace trace = {
2537 2538 2539 2540
		.audit = {
			.machine = audit_detect_machine(),
			.open_id = audit_name_to_syscall("open", trace.audit.machine),
		},
A
Arnaldo Carvalho de Melo 已提交
2541 2542 2543 2544 2545 2546 2547 2548 2549 2550
		.syscalls = {
			. max = -1,
		},
		.opts = {
			.target = {
				.uid	   = UINT_MAX,
				.uses_mmap = true,
			},
			.user_freq     = UINT_MAX,
			.user_interval = ULLONG_MAX,
2551
			.no_buffering  = true,
2552
			.mmap_pages    = UINT_MAX,
A
Arnaldo Carvalho de Melo 已提交
2553
		},
2554
		.output = stdout,
2555
		.show_comm = true,
2556
		.trace_syscalls = true,
A
Arnaldo Carvalho de Melo 已提交
2557
	};
2558
	const char *output_name = NULL;
2559
	const char *ev_qualifier_str = NULL;
A
Arnaldo Carvalho de Melo 已提交
2560
	const struct option trace_options[] = {
2561 2562 2563
	OPT_CALLBACK(0, "event", &trace.evlist, "event",
		     "event selector. use 'perf list' to list available events",
		     parse_events_option),
2564 2565
	OPT_BOOLEAN(0, "comm", &trace.show_comm,
		    "show the thread COMM next to its id"),
2566
	OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
2567 2568
	OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
		    "list of events to trace"),
2569
	OPT_STRING('o', "output", &output_name, "file", "output file name"),
2570
	OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
A
Arnaldo Carvalho de Melo 已提交
2571 2572
	OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
		    "trace events on existing process id"),
2573
	OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
A
Arnaldo Carvalho de Melo 已提交
2574
		    "trace events on existing thread id"),
2575
	OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
A
Arnaldo Carvalho de Melo 已提交
2576
		    "system-wide collection from all CPUs"),
2577
	OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
A
Arnaldo Carvalho de Melo 已提交
2578
		    "list of cpus to monitor"),
2579
	OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
A
Arnaldo Carvalho de Melo 已提交
2580
		    "child tasks do not inherit counters"),
2581 2582 2583
	OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
		     "number of mmap data pages",
		     perf_evlist__parse_mmap_pages),
2584
	OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
A
Arnaldo Carvalho de Melo 已提交
2585
		   "user to profile"),
2586 2587 2588
	OPT_CALLBACK(0, "duration", &trace, "float",
		     "show only events with duration > N.M ms",
		     trace__set_duration),
2589
	OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
2590
	OPT_INCR('v', "verbose", &verbose, "be more verbose"),
2591 2592
	OPT_BOOLEAN('T', "time", &trace.full_time,
		    "Show full timestamp, not time relative to first start"),
D
David Ahern 已提交
2593 2594 2595 2596
	OPT_BOOLEAN('s', "summary", &trace.summary_only,
		    "Show only syscall summary with statistics"),
	OPT_BOOLEAN('S', "with-summary", &trace.summary,
		    "Show all syscalls and summary with statistics"),
2597 2598
	OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
		     "Trace pagefaults", parse_pagefaults, "maj"),
2599
	OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
A
Arnaldo Carvalho de Melo 已提交
2600 2601 2602
	OPT_END()
	};
	int err;
2603
	char bf[BUFSIZ];
A
Arnaldo Carvalho de Melo 已提交
2604

2605 2606 2607 2608 2609 2610 2611 2612 2613
	trace.evlist = perf_evlist__new();
	if (trace.evlist == NULL)
		return -ENOMEM;

	if (trace.evlist == NULL) {
		pr_err("Not enough memory to run!\n");
		goto out;
	}

2614 2615
	argc = parse_options(argc, argv, trace_options, trace_usage,
			     PARSE_OPT_STOP_AT_NON_OPTION);
D
David Ahern 已提交
2616

2617 2618 2619 2620 2621
	if (trace.trace_pgfaults) {
		trace.opts.sample_address = true;
		trace.opts.sample_time = true;
	}

2622 2623 2624
	if (trace.evlist->nr_entries > 0)
		evlist__set_evsel_handler(trace.evlist, trace__event_handler);

2625 2626 2627 2628 2629 2630 2631
	if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
		return trace__record(&trace, argc-1, &argv[1]);

	/* summary_only implies summary option, but don't overwrite summary if set */
	if (trace.summary_only)
		trace.summary = trace.summary_only;

2632 2633
	if (!trace.trace_syscalls && !trace.trace_pgfaults &&
	    trace.evlist->nr_entries == 0 /* Was --events used? */) {
2634 2635 2636 2637
		pr_err("Please specify something to trace.\n");
		return -1;
	}

2638 2639 2640 2641 2642 2643 2644 2645
	if (output_name != NULL) {
		err = trace__open_output(&trace, output_name);
		if (err < 0) {
			perror("failed to create output file");
			goto out;
		}
	}

2646
	if (ev_qualifier_str != NULL) {
2647 2648 2649 2650 2651 2652
		const char *s = ev_qualifier_str;

		trace.not_ev_qualifier = *s == '!';
		if (trace.not_ev_qualifier)
			++s;
		trace.ev_qualifier = strlist__new(true, s);
2653
		if (trace.ev_qualifier == NULL) {
2654 2655 2656 2657
			fputs("Not enough memory to parse event qualifier",
			      trace.output);
			err = -ENOMEM;
			goto out_close;
2658 2659 2660
		}
	}

2661
	err = target__validate(&trace.opts.target);
2662
	if (err) {
2663
		target__strerror(&trace.opts.target, err, bf, sizeof(bf));
2664 2665
		fprintf(trace.output, "%s", bf);
		goto out_close;
2666 2667
	}

2668
	err = target__parse_uid(&trace.opts.target);
A
Arnaldo Carvalho de Melo 已提交
2669
	if (err) {
2670
		target__strerror(&trace.opts.target, err, bf, sizeof(bf));
2671 2672
		fprintf(trace.output, "%s", bf);
		goto out_close;
A
Arnaldo Carvalho de Melo 已提交
2673 2674
	}

2675
	if (!argc && target__none(&trace.opts.target))
2676 2677
		trace.opts.target.system_wide = true;

2678 2679 2680 2681
	if (input_name)
		err = trace__replay(&trace);
	else
		err = trace__run(&trace, argc, argv);
2682

2683 2684 2685 2686
out_close:
	if (output_name != NULL)
		fclose(trace.output);
out:
2687
	return err;
A
Arnaldo Carvalho de Melo 已提交
2688
}