/*	$OpenBSD: minherit_zero.c,v 1.1 2014/06/13 07:17:54 matthew 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 <sys/wait.h>
#include <assert.h>
#include <fcntl.h>
#include <paths.h>
#include <string.h>
#include <unistd.h>

#define CHECK(x) assert((x))
#define CHECK_EQ(a, b) assert((a) == (b))
#define CHECK_NE(a, b) assert((a) != (b))
#define CHECK_GE(a, b) assert((a) >= (b))

static int
ismemset(const void *s, int c, size_t n)
{
	const unsigned char *p = s;
	size_t i;

	for (i = 0; i < n; i++)
		if (p[i] != c)
			return (0);
	return (1);
}

static void
wait_for_clean_exit(pid_t pid)
{
	int status;
	CHECK_EQ(pid, waitpid(pid, &status, 0));
	CHECK(WIFEXITED(status));
	CHECK_EQ(0, WEXITSTATUS(status));
}

enum {
	NPAGES = 4,

	PARENT_BYTE = 42,
	CHILD_BYTE = 53,
	GRANDCHILD_BYTE = 65
};

/*
 * We map some memory, configure it's inheritance for MAP_INHERIT_ZERO,
 * then check that when we fork child or grandchild processes, that they
 * receive new zero'd out memory mappings.  Additionally, we sanity check
 * that after the child (or grandchild) process exits, that the parent's
 * memory is still in tact.
 */
static void
dotest(int fd, size_t len, int flags)
{
	void *p;
	pid_t pid;

	p = mmap(NULL, len, PROT_READ|PROT_WRITE, flags, fd, 0);
	CHECK_NE(MAP_FAILED, p);
	
	CHECK_EQ(0, minherit(p, len, MAP_INHERIT_ZERO));

	memset(p, PARENT_BYTE, len);

	pid = fork();
	CHECK_GE(pid, 0);
	if (pid == 0) {
		CHECK(ismemset(p, 0, len));
		memset(p, CHILD_BYTE, len);

		pid = fork();
		CHECK_GE(pid, 0);
		if (pid == 0) {
			CHECK(ismemset(p, 0, len));
			memset(p, GRANDCHILD_BYTE, len);
			_exit(0);
		}

		wait_for_clean_exit(pid);
		CHECK(ismemset(p, CHILD_BYTE, len));
		memset(p, 0, len);
		_exit(0);
	}

	wait_for_clean_exit(pid);
	CHECK(ismemset(p, PARENT_BYTE, len));
	memset(p, 0, len);

	CHECK_EQ(0, munmap(p, len));
}

int
main()
{
	long pagesize;
	size_t len;

	pagesize = sysconf(_SC_PAGESIZE);
	CHECK_GE(pagesize, 1);
	len = NPAGES * pagesize;

	/* First run test with private anonymous memory. */
	dotest(-1, len, MAP_ANON|MAP_PRIVATE);

	/* Test again with shared anonymous memory. */
	dotest(-1, len, MAP_ANON|MAP_SHARED);

	/* Finally, test with private file mapping. */
	int fd = open(_PATH_BSHELL, O_RDONLY);
	CHECK_GE(fd, 0);
	dotest(fd, len, MAP_FILE|MAP_PRIVATE);
	CHECK_EQ(0, close(fd));

	return (0);
}