/*	$OpenBSD: siginfo-fault.c,v 1.2 2021/09/28 08:56:15 kettenis Exp $	*/
/*
 * Copyright (c) 2014 Google Inc.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/mman.h>

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <setjmp.h>
#include <signal.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

/*
 * Some architectures may deliver an imprecise fault address.
 */
#ifdef __sparc64__
#define EXPADDR_MASK	~(3UL)
#else
#define EXPADDR_MASK	~(0UL)
#endif

#define CHECK_EQ(a, b) assert((a) == (b))
#define CHECK_NE(a, b) assert((a) != (b))
#define CHECK_LE(a, b) assert((a) <= (b))
#define FAIL() assert(0)

static jmp_buf env;
static volatile int gotsigno;
static volatile siginfo_t gotsi;

static void
sigsegv(int signo, siginfo_t *si, void *ctx)
{
	gotsigno = signo;
	gotsi = *si;
	siglongjmp(env, 1);
}

static const char *
strsigcode(int signum, int sigcode)
{
	switch (signum) {
	case SIGSEGV:
		switch (sigcode) {
		case SEGV_MAPERR:
			return "address not mapped to object";
		case SEGV_ACCERR:
			return "invalid permissions";
		}
		break;
	case SIGBUS:
		switch (sigcode) {
		case BUS_ADRALN:
			return "invalid address alignment";
		case BUS_ADRERR:
			return "non-existent physical address";
		case BUS_OBJERR:
			return "object specific hardware error";
		}
		break;
	}
	return "unknown";
}

static int
checksig(const char *name, int expsigno, int expcode, volatile char *expaddr)
{
	int fail = 0;
	char str1[NL_TEXTMAX], str2[NL_TEXTMAX];

	expaddr = (char *)((uintptr_t)expaddr & EXPADDR_MASK);

	if (expsigno != gotsigno) {
		strlcpy(str1, strsignal(expsigno), sizeof(str1));
		strlcpy(str2, strsignal(gotsigno), sizeof(str2));
		fprintf(stderr, "%s signo: expect %d (%s), actual %d (%s)\n",
		    name, expsigno, str1, gotsigno, str2);
		++fail;
	}
	if (expsigno != gotsi.si_signo) {
		strlcpy(str1, strsignal(expsigno), sizeof(str1));
		strlcpy(str2, strsignal(gotsi.si_signo), sizeof(str2));
		fprintf(stderr, "%s si_signo: expect %d (%s), actual %d (%s)\n",
		    name, expsigno, str1, gotsi.si_signo, str2);
		++fail;
	}
	if (expcode != gotsi.si_code) {
		fprintf(stderr, "%s si_code: expect %d (%s), actual %d (%s)\n",
		    name, expcode, strsigcode(expsigno, expcode),
		    gotsi.si_code, strsigcode(gotsigno, gotsi.si_code));
		++fail;
	}
	if (expaddr != (char *)((uintptr_t)gotsi.si_addr & EXPADDR_MASK)) {
		fprintf(stderr, "%s si_addr: expect %p, actual %p\n",
		    name, expaddr, gotsi.si_addr);
		++fail;
	}
	return (fail);
}

int
main()
{
	int fail = 0;
	long pagesize = sysconf(_SC_PAGESIZE);
	CHECK_NE(-1, pagesize);

	const struct sigaction sa = {
		.sa_sigaction = sigsegv,
		.sa_flags = SA_SIGINFO,
	};
	CHECK_EQ(0, sigaction(SIGSEGV, &sa, NULL));
	CHECK_EQ(0, sigaction(SIGBUS, &sa, NULL));

	volatile char *p;
	CHECK_NE(MAP_FAILED, (p = mmap(NULL, pagesize, PROT_NONE,
	    MAP_PRIVATE|MAP_ANON, -1, 0)));

	CHECK_EQ(0, mprotect((void *)p, pagesize, PROT_READ));
	if (sigsetjmp(env, 1) == 0) {
		p[0] = 1;
		FAIL();
	}
	fail += checksig("mprotect read", SIGSEGV, SEGV_ACCERR, p);

	CHECK_EQ(0, mprotect((void *)p, pagesize, PROT_NONE));
	if (sigsetjmp(env, 1) == 0) {
		(void)p[1];
		FAIL();
	}
	fail += checksig("mprotect none", SIGSEGV, SEGV_ACCERR, p + 1);

	CHECK_EQ(0, munmap((void *)p, pagesize));
	if (sigsetjmp(env, 1) == 0) {
		(void)p[2];
		FAIL();
	}
	fail += checksig("munmap", SIGSEGV, SEGV_MAPERR, p + 2);

	char filename[] = "/tmp/siginfo-fault.XXXXXXXX";
	int fd;
	CHECK_LE(0, (fd = mkstemp(filename)));
	CHECK_EQ(0, unlink(filename));
	CHECK_EQ(0, ftruncate(fd, 0));  /* just in case */
	CHECK_NE(MAP_FAILED, (p = mmap(NULL, pagesize, PROT_READ|PROT_WRITE,
	    MAP_SHARED, fd, 0)));
	CHECK_EQ(0, close(fd));

	if (sigsetjmp(env, 1) == 0) {
		p[3] = 1;
		FAIL();
	}
	fail += checksig("mmap file", SIGBUS, BUS_OBJERR, p + 3);

	return (fail);
}