/* $NetBSD: t_proc4.c,v 1.1 2021/10/10 17:43:15 thorpej Exp $ */

/*-
 * Copyright (c) 2021 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__RCSID("$NetBSD: t_proc4.c,v 1.1 2021/10/10 17:43:15 thorpej Exp $");

#include <sys/event.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <err.h>
#include <limits.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <atf-c.h>

/* 10 children each create 10 grandchildren. */
#define	TOTAL_CHILDREN		10
#define	TOTAL_GRANDCHILDREN	(TOTAL_CHILDREN * TOTAL_CHILDREN)
#define	TOTAL_DESCENDENTS	(TOTAL_CHILDREN + TOTAL_GRANDCHILDREN)

#define	EXIT_CHILD		66
#define	EXIT_GRANDCHILD		76

static void
child(void)
{
	int i, status;
	pid_t pid;

	for (i = 0; i < TOTAL_CHILDREN; i++) {
		ATF_REQUIRE((pid = fork()) != -1);
		if (pid == 0) {
			/* grandchild */
			_exit(EXIT_GRANDCHILD);
		}
	}

	for (i = 0; i < TOTAL_CHILDREN; i++) {
		ATF_REQUIRE((pid = wait(&status)) != -1);
	}
	_exit(EXIT_CHILD);
}

ATF_TC(proc4);
ATF_TC_HEAD(proc4, tc)
{
	atf_tc_set_md_var(tc, "descr", "Exercises EVFILT_PROC + NOTE_TRACK");
}

ATF_TC_BODY(proc4, tc)
{
	int total_tracks = 0;
	int child_exits = 0;
	int grandchild_exits = 0;
	pid_t pid;
	int kq, status;
	struct kevent event;
	struct timespec ts = { 0, 0 };
	int i, rv;

	ATF_REQUIRE((kq = kqueue()) >= 0);

	EV_SET(&event, getpid(), EVFILT_PROC, EV_ADD,
	    NOTE_TRACK | NOTE_EXIT, 0, 0);

	ATF_REQUIRE(kevent(kq, &event, 1, NULL, 0, NULL) == 0);

	for (i = 0; i < TOTAL_CHILDREN; i++) {
		ATF_REQUIRE((pid = fork()) != -1);
		if (pid == 0) {
			child();
			/* NOTREACHED */
		}
	}

	for (;;) {
		if (total_tracks == TOTAL_DESCENDENTS &&
		    child_exits == TOTAL_CHILDREN &&
		    grandchild_exits == TOTAL_GRANDCHILDREN) {
			break;
		}
		memset(&event, 0, sizeof(event));
		rv = kevent(kq, NULL, 0, &event, 1, NULL);
		ATF_REQUIRE(rv != -1);
		ATF_REQUIRE(rv == 1);
		if (event.fflags & NOTE_CHILD) {
			total_tracks++;
			ATF_REQUIRE(total_tracks <= TOTAL_DESCENDENTS);
		} else if (event.fflags & NOTE_EXIT) {
			ATF_REQUIRE(event.flags & EV_EOF);
			ATF_REQUIRE(event.data >= 0);
			ATF_REQUIRE(event.data <= UINT_MAX);
			status = (int)event.data;
			ATF_REQUIRE(WIFEXITED(status));
			ATF_REQUIRE(WEXITSTATUS(status) == EXIT_CHILD ||
				    WEXITSTATUS(status) == EXIT_GRANDCHILD);
			if (WEXITSTATUS(status) == EXIT_CHILD) {
				child_exits++;
				ATF_REQUIRE(child_exits <= TOTAL_CHILDREN);
				ATF_REQUIRE(wait4((pid_t)event.ident,
						  &status,
						  WNOHANG,
						  NULL) != -1);
				ATF_REQUIRE(status == (int)event.data);
			} else {
				grandchild_exits++;
				ATF_REQUIRE(grandchild_exits <=
					    TOTAL_GRANDCHILDREN);
			}
		} else {
			/*
			 * We didn't ask for NOTE_FORK, so we don't
			 * expect to ever see it, even though we are
			 * getting NOTE_CHILD as the result of the
			 * NOTE_TRACK.
			 */
			ATF_REQUIRE((event.fflags & NOTE_FORK) == 0);

			/*
			 * Bomb out of we are getting a TRACKERR.
			 * XXX This could legitimately happen if
			 * the kernel is low on memory because the
			 * code path involved specifically chooses
			 * not to block when allocating memory.
			 */
			ATF_REQUIRE((event.fflags & NOTE_TRACKERR) == 0);
		}
	}

	ATF_REQUIRE(kevent(kq, NULL, 0, &event, 1, &ts) == 0);

	(void)close(kq);
}

ATF_TP_ADD_TCS(tp)
{
	ATF_TP_ADD_TC(tp, proc4);

	return atf_no_error();
}