arg-decoder.c

/*
 * Routines to take a syscallrecord and turn it into an ascii representation.
 */
#include <stdarg.h>
#include <stdio.h>
#include "arch.h"	//PAGE_MASK
#include "arg-decoder.h"
#include "params.h"	// verbosity
#include "pids.h"
#include "sanitise.h"	// get_argval
#include "shm.h"
#include "syscall.h"
#include "tables.h"
#include "utils.h"

/*
 * Bounded sprintf for the sptr/end rendering pattern.
 * Advances sptr by the number of characters written, clamped to
 * available space so we never write past end.
 */
static char * bprintf(char *sptr, char *end, const char *fmt, ...)
	__attribute__((format(printf, 3, 4)));

static char * bprintf(char *sptr, char *end, const char *fmt, ...)
{
	va_list ap;
	int n;

	if (sptr >= end)
		return sptr;

	va_start(ap, fmt);
	n = vsnprintf(sptr, end - sptr, fmt, ap);
	va_end(ap);

	if (n > 0)
		sptr += (n < end - sptr) ? n : end - sptr - 1;

	return sptr;
}

static char * decode_argtype(char *sptr, char *end, unsigned long reg, enum argtype type)
{
	if (is_typed_fdarg(type)) {
		sptr = bprintf(sptr, end, "%ld", (long) reg);
		return sptr;
	}

	switch (type) {
	case ARG_PATHNAME:
		sptr = bprintf(sptr, end, "\"%s\"", (char *) reg);
		break;
	case ARG_PID:
	case ARG_FD:
	case ARG_SOCKETINFO:
		sptr = bprintf(sptr, end, "%ld", (long) reg);
		break;
	case ARG_MODE_T:
		sptr = bprintf(sptr, end, "%o", (mode_t) reg);
		break;

	case ARG_ADDRESS:
	case ARG_NON_NULL_ADDRESS:
	case ARG_IOVEC:
	case ARG_SOCKADDR:
		sptr = bprintf(sptr, end, "0x%lx", reg);
		break;

	case ARG_MMAP:
		/* Although generic sanitise has set this to a map struct,
		 * common_set_mmap_ptr_len() will subsequently set it to the ->ptr
		 * in the per syscall ->sanitise routine. */
		sptr = bprintf(sptr, end, "0x%lx", reg);
		break;

	case ARG_OP:
	case ARG_LIST:
		sptr = bprintf(sptr, end, "0x%lx", reg);
		break;

	case ARG_UNDEFINED:
	case ARG_LEN:
	case ARG_RANGE:
	case ARG_CPU:
	case ARG_NUMA_NODE:
	case ARG_IOVECLEN:
	case ARG_SOCKADDRLEN:
		if (((long) reg < -16384) || ((long) reg > 16384)) {
			/* Print everything outside -16384 and 16384 as hex. */
			sptr = bprintf(sptr, end, "0x%lx", reg);
		} else {
			/* Print everything else as signed decimal. */
			sptr = bprintf(sptr, end, "%ld", (long) reg);
		}
		break;
	default:
		break;
	}

	return sptr;
}

static char * render_arg(struct syscallrecord *rec, char *sptr, char *end, unsigned int argnum, struct syscallentry *entry)
{
	const char *name;
	unsigned long reg;
	enum argtype type;

	type = entry->argtype[argnum - 1];
	name = entry->argname[argnum - 1];
	reg = get_argval(rec, argnum);

	if (argnum != 1)
		sptr = bprintf(sptr, end, ", ");

	sptr = bprintf(sptr, end, "%s=", name);

	sptr = decode_argtype(sptr, end, reg, type);

	if (entry->decode != NULL) {
		char *str;

		str = entry->decode(rec, argnum);
		if (str != NULL) {
			sptr = bprintf(sptr, end, "%s", str);
			free(str);
		}
	}

	return sptr;
}

/*
 * Render the live -vv trace line for one syscall into bufferstart.
 * Returns the number of bytes written (excluding the NUL).  Only feeds
 * output_syscall_prefix; the post-mortem dumper reconstructs from the
 * chronicle ring instead of reading the rendered prebuffer.
 */
static unsigned int render_syscall_prefix(struct syscallrecord *rec,
					  struct syscallentry *entry,
					  char *bufferstart)
{
	struct childdata *child = this_child();
	char *sptr = bufferstart;
	char *end = bufferstart + PREBUFFER_LEN;
	unsigned int i;

	sptr = bprintf(sptr, end, "[child%u:%u] [%lu] %s",
			child->num, __atomic_load_n(&pids[child->num], __ATOMIC_RELAXED), child->op_nr,
			rec->do32bit == true ? "[32BIT] " : "");

	sptr = bprintf(sptr, end, "%s(", entry->name);

	for_each_arg(entry, i) {
		sptr = render_arg(rec, sptr, end, i, entry);
	}

	sptr = bprintf(sptr, end, ") ");

	return sptr - bufferstart;
}

static unsigned int render_syscall_postfix(struct syscallrecord *rec, char *bufferstart)
{
	char *sptr = bufferstart;
	char *end = bufferstart + POSTBUFFER_LEN;

	if (IS_ERR(rec->retval)) {
		sptr = bprintf(sptr, end, "= %ld (%s)",
			(long) rec->retval, strerror(rec->errno_post));
	} else {
		sptr = bprintf(sptr, end, "= ");
		if ((unsigned long) rec->retval > 10000)
			sptr = bprintf(sptr, end, "0x%lx", rec->retval);
		else
			sptr = bprintf(sptr, end, "%ld", (long) rec->retval);
	}
	sptr = bprintf(sptr, end, "\n");

	return sptr - bufferstart;
}

/* These next two functions are called from dispatch_step() once per syscall.
 * They render a one-line trace into the shm-resident pre/postbuffer and feed
 * it to output_rendered_buffer for live emission.  output_rendered_buffer
 * itself only prints at verbosity > 1, and the post-mortem dumper reads
 * structured chronicle_slot fields rather than these rendered buffers, so
 * the per-call render is wasted work on the common (verbosity <= 1) path.
 * Skip it unless the live trace will be printed or a post-mortem is
 * currently running (where any in-parent diagnostic that defensively reads
 * rec->pre/postbuffer should still find a coherent string).
 */
void output_syscall_prefix(struct syscallrecord *rec, struct syscallentry *entry)
{
	static char *buffer = NULL;
	unsigned int len;

	if (verbosity <= 1 &&
	    !__atomic_load_n(&shm->postmortem_in_progress, __ATOMIC_ACQUIRE)) {
		rec->prebuffer[0] = '\0';
		return;
	}

	if (buffer == NULL)
		buffer = zmalloc(PREBUFFER_LEN);

	len = render_syscall_prefix(rec, entry, buffer);

	/* copy child-local buffer to shm, NUL-terminate */
	memcpy(rec->prebuffer, buffer, len);
	rec->prebuffer[len] = '\0';

	output_rendered_buffer(rec->prebuffer);
}

void output_syscall_postfix(struct syscallrecord *rec)
{
	static char *buffer = NULL;
	unsigned int len;

	if (verbosity <= 1 &&
	    !__atomic_load_n(&shm->postmortem_in_progress, __ATOMIC_ACQUIRE)) {
		rec->postbuffer[0] = '\0';
		return;
	}

	if (buffer == NULL)
		buffer = zmalloc(POSTBUFFER_LEN);

	len = render_syscall_postfix(rec, buffer);

	/* copy child-local buffer to shm, NUL-terminate */
	memcpy(rec->postbuffer, buffer, len);
	rec->postbuffer[len] = '\0';

	output_rendered_buffer(rec->postbuffer);
}