perf trace: Pass augmented args to the arg formatters when available

/*

 * is_exit: is this "exit" or "exit_group"?

 * is_open: is this "open" or "openat"? To associate the fd returned in sys_exit with the pathname in sys_enter.

 * args_size: sum of the sizes of the syscall arguments, anything after that is augmented stuff: pathname for openat, etc.

 */

struct syscall {

	struct event_format *tp_format;

	int		    nr_args;

	int		    args_size;

	bool		    is_exit;

	bool		    is_open;

	struct format_field *args;

static int syscall__set_arg_fmts(struct syscall *sc)

{

	struct format_field *field;

	struct format_field *field, *last_field = NULL;

	int idx = 0, len;

	for (field = sc->args; field; field = field->next, ++idx) {

		last_field = field;

		if (sc->fmt && sc->fmt->arg[idx].scnprintf)

			continue;

		}

	}

	if (last_field)

		sc->args_size = last_field->offset + last_field->size;

	return 0;

}

}

static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,

				      unsigned char *args, struct trace *trace,

				      struct thread *thread)

				      unsigned char *args, void *augmented_args, int augmented_args_size,

				      struct trace *trace, struct thread *thread)

{

	size_t printed = 0;

	unsigned long val;

	u8 bit = 1;

	struct syscall_arg arg = {

		.args	= args,

		.augmented = {

			.size = augmented_args_size,

			.args = augmented_args,

		},

		.idx	= 0,

		.mask	= 0,

		.trace  = trace,

	printed += scnprintf(msg + printed, trace__entry_str_size - printed, "%s(", sc->name);

	printed += syscall__scnprintf_args(sc, msg + printed, trace__entry_str_size - printed,

					   args, trace, thread);

					   args, NULL, 0, trace, thread);

	if (sc->is_exit) {

		if (!(trace->duration_filter || trace->summary_only || trace->failure_only || trace->min_stack)) {

	int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;

	struct syscall *sc = trace__syscall_info(trace, evsel, id);

	char msg[1024];

	void *args;

	void *args, *augmented_args = NULL;

	int augmented_args_size;

	if (sc == NULL)

		return -1;

		goto out_put;

	args = perf_evsel__sc_tp_ptr(evsel, args, sample);

	syscall__scnprintf_args(sc, msg, sizeof(msg), args, trace, thread);

	augmented_args_size = sample->raw_size - sc->args_size;

	if (augmented_args_size > 0)

		augmented_args = sample->raw_data + sc->args_size;

	syscall__scnprintf_args(sc, msg, sizeof(msg), args, augmented_args, augmented_args_size, trace, thread);

	fprintf(trace->output, "%s", msg);

	err = 0;

out_put:

size_t pid__scnprintf_fd(struct trace *trace, pid_t pid, int fd, char *bf, size_t size);

/**

 * augmented_arg: extra payload for syscall pointer arguments

 * If perf_sample->raw_size is more than what a syscall sys_enter_FOO puts,

 * then its the arguments contents, so that we can show more than just a

 * pointer. This will be done initially with eBPF, the start of that is at the

 * tools/perf/examples/bpf/augmented_syscalls.c example for the openat, but

 * will eventually be done automagically caching the running kernel tracefs

 * events data into an eBPF C script, that then gets compiled and its .o file

 * cached for subsequent use. For char pointers like the ones for 'open' like

 * syscalls its easy, for the rest we should use DWARF or better, BTF, much

 * more compact.

 *

 * @size: 8 if all we need is an integer, otherwise all of the augmented arg.

 * @int_arg: will be used for integer like pointer contents, like 'accept's 'upeer_addrlen'

 * @value: u64 aligned, for structs, pathnames

 */

struct augmented_arg {

	int  size;

	int  int_arg;

	u64  value[];

};

/**

 * @val: value of syscall argument being formatted

 * @args: All the args, use syscall_args__val(arg, nth) to access one

 * @augmented_args: Extra data that can be collected, for instance, with eBPF for expanding the pathname for open, etc

 * @augmented_args_size: augmented_args total payload size

 * @thread: tid state (maps, pid, tid, etc)

 * @trace: 'perf trace' internals: all threads, etc

 * @parm: private area, may be an strarray, for instance

struct syscall_arg {

	unsigned long val;

	unsigned char *args;

	struct {

		struct augmented_arg *args;

		int		     size;

	} augmented;

	struct thread *thread;

	struct trace  *trace;

	void	      *parm;