NetBSD/tests/kernel/t_fdrestart.c

/*	$NetBSD: t_fdrestart.c,v 1.4 2023/11/18 19:46:55 riastradh Exp $	*/

/*-
 * Copyright (c) 2023 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.
 */

#define	_KMEMUSER		/* ERESTART */

#include <sys/cdefs.h>
__RCSID("$NetBSD: t_fdrestart.c,v 1.4 2023/11/18 19:46:55 riastradh Exp $");

#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/un.h>

#include <atf-c.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>

#include <rump/rump.h>
#include <rump/rump_syscalls.h>

#include "h_macros.h"

struct fdrestart {
	void			(*op)(struct fdrestart *);
	int			fd;
	pthread_barrier_t	barrier;
};

static void
waitforbarrier(struct fdrestart *F, const char *caller)
{
	int error;

	error = pthread_barrier_wait(&F->barrier);
	switch (error) {
	case 0:
	case PTHREAD_BARRIER_SERIAL_THREAD:
		break;
	default:
		atf_tc_fail("%s: pthread_barrier_wait: %d, %s", caller, error,
		    strerror(error));
	}
}

static void
doread(struct fdrestart *F)
{
	char c;
	ssize_t nread;
	int error;

	/*
	 * Wait for the other thread to be ready.
	 */
	waitforbarrier(F, "reader");

	/*
	 * Start a read.  This should block, and then, when the other
	 * thread closes the fd, should be woken to fail with ERESTART.
	 */
	nread = rump_sys_read(F->fd, &c, sizeof(c));
	ATF_REQUIRE_EQ_MSG(nread, -1, "nread=%zd", nread);
	error = errno;
	ATF_REQUIRE_EQ_MSG(error, ERESTART, "errno=%d (%s)", error,
	    strerror(error));

	/*
	 * Now further attempts at I/O should fail with EBADF because
	 * the fd has been closed.
	 */
	nread = rump_sys_read(F->fd, &c, sizeof(c));
	ATF_REQUIRE_EQ_MSG(nread, -1, "nread=%zd", nread);
	error = errno;
	ATF_REQUIRE_EQ_MSG(error, EBADF, "errno=%d (%s)", error,
	    strerror(error));
}

static void
dowrite(struct fdrestart *F)
{
	static const char buf[1024*1024]; /* XXX >BIG_PIPE_SIZE */
	ssize_t nwrit;
	int error;

	/*
	 * Make sure the pipe's buffer is full first.
	 */
	for (;;) {
		int nspace;

		RL(rump_sys_ioctl(F->fd, FIONSPACE, &nspace));
		ATF_REQUIRE_MSG(nspace >= 0, "nspace=%d", nspace);
		if (nspace == 0)
			break;
		RL(rump_sys_write(F->fd, buf, (size_t)nspace));
	}

	/*
	 * Wait for the other thread to be ready.
	 */
	waitforbarrier(F, "writer");

	/*
	 * Start a write.  This should block, and then, when the other
	 * thread closes the fd, should be woken to fail with ERESTART.
	 */
	nwrit = rump_sys_write(F->fd, buf, sizeof(buf));
	ATF_REQUIRE_EQ_MSG(nwrit, -1, "nwrit=%zd", nwrit);
	error = errno;
	ATF_REQUIRE_EQ_MSG(error, ERESTART, "errno=%d (%s)", error,
	    strerror(error));

	/*
	 * Now further attempts at I/O should fail with EBADF because
	 * the fd has been closed.
	 */
	nwrit = rump_sys_write(F->fd, buf, sizeof(buf));
	ATF_REQUIRE_EQ_MSG(nwrit, -1, "nwrit=%zd", nwrit);
	error = errno;
	ATF_REQUIRE_EQ_MSG(error, EBADF, "errno=%d (%s)", error,
	    strerror(error));
}

static void *
doit(void *cookie)
{
	struct fdrestart *F = cookie;

	(*F->op)(F);

	return NULL;
}

static void
on_sigalrm(int signo)
{

	atf_tc_fail("timed out");
}

static void
testfdrestart(struct fdrestart *F)
{
	pthread_t t;

	ATF_REQUIRE_MSG(signal(SIGALRM, &on_sigalrm) != SIG_ERR,
	    "errno=%d (%s)", errno, strerror(errno));

	RZ(pthread_barrier_init(&F->barrier, NULL, 2));
	RZ(pthread_create(&t, NULL, &doit, F));
	waitforbarrier(F, "closer");	/* wait for thread to start */
	(void)sleep(1);			/* wait for op to start */
	(void)alarm(1);			/* set a deadline */
	RL(rump_sys_close(F->fd));	/* wake op in other thread */
	RZ(pthread_join(t, NULL));	/* wait for op to wake and fail */
	(void)alarm(0);			/* clear the deadline */
}

ATF_TC(pipe_read);
ATF_TC_HEAD(pipe_read, tc)
{
	atf_tc_set_md_var(tc, "descr", "Test pipe read fails on close");
}
ATF_TC_BODY(pipe_read, tc)
{
	struct fdrestart fdrestart, *F = &fdrestart;
	int fd[2];

	rump_init();

	RL(rump_sys_pipe(fd));

	memset(F, 0, sizeof(*F));
	F->op = &doread;
	F->fd = fd[0];
	testfdrestart(F);
}

ATF_TC(pipe_write);
ATF_TC_HEAD(pipe_write, tc)
{
	atf_tc_set_md_var(tc, "descr", "Test pipe write fails on close");
}
ATF_TC_BODY(pipe_write, tc)
{
	struct fdrestart fdrestart, *F = &fdrestart;
	int fd[2];

	rump_init();

	RL(rump_sys_pipe(fd));

	memset(F, 0, sizeof(*F));
	F->op = &dowrite;
	F->fd = fd[1];
	atf_tc_expect_fail("PR kern/57659");
	testfdrestart(F);
}

ATF_TC(socketpair_read);
ATF_TC_HEAD(socketpair_read, tc)
{
	atf_tc_set_md_var(tc, "descr", "Test socketpair read fails on close");
}
ATF_TC_BODY(socketpair_read, tc)
{
	struct fdrestart fdrestart, *F = &fdrestart;
	int fd[2];

	rump_init();

	RL(rump_sys_socketpair(AF_LOCAL, SOCK_STREAM, 0, fd));

	memset(F, 0, sizeof(*F));
	F->op = &doread;
	F->fd = fd[0];
	testfdrestart(F);
}

ATF_TC(socketpair_write);
ATF_TC_HEAD(socketpair_write, tc)
{
	atf_tc_set_md_var(tc, "descr", "Test socketpair write fails on close");
}
ATF_TC_BODY(socketpair_write, tc)
{
	struct fdrestart fdrestart, *F = &fdrestart;
	int fd[2];

	rump_init();

	RL(rump_sys_socketpair(AF_LOCAL, SOCK_STREAM, 0, fd));

	memset(F, 0, sizeof(*F));
	F->op = &dowrite;
	F->fd = fd[0];
	testfdrestart(F);
}

ATF_TP_ADD_TCS(tp)
{

	ATF_TP_ADD_TC(tp, pipe_read);
	ATF_TP_ADD_TC(tp, pipe_write);
	ATF_TP_ADD_TC(tp, socketpair_read);
	ATF_TP_ADD_TC(tp, socketpair_write);

	return atf_no_error();
}