// SPDX-License-Identifier: GPL-2.0

#include <sys/stat.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <sys/un.h>

#include "coredump_test.h"

#define NUM_CRASHING_COREDUMPS 5

FIXTURE_SETUP(coredump)
{
	FILE *file;
	int ret;

	self->pid_coredump_server = -ESRCH;
	self->fd_tmpfs_detached = -1;
	file = fopen("/proc/sys/kernel/core_pattern", "r");
	ASSERT_NE(NULL, file);

	ret = fread(self->original_core_pattern, 1, sizeof(self->original_core_pattern), file);
	ASSERT_TRUE(ret || feof(file));
	ASSERT_LT(ret, sizeof(self->original_core_pattern));

	self->original_core_pattern[ret] = '\0';
	self->fd_tmpfs_detached = create_detached_tmpfs();
	ASSERT_GE(self->fd_tmpfs_detached, 0);

	ret = fclose(file);
	ASSERT_EQ(0, ret);
}

FIXTURE_TEARDOWN(coredump)
{
	const char *reason;
	FILE *file;
	int ret, status;

	if (self->pid_coredump_server > 0) {
		kill(self->pid_coredump_server, SIGTERM);
		waitpid(self->pid_coredump_server, &status, 0);
	}
	unlink("/tmp/coredump.file");
	unlink("/tmp/coredump.socket");

	file = fopen("/proc/sys/kernel/core_pattern", "w");
	if (!file) {
		reason = "Unable to open core_pattern";
		goto fail;
	}

	ret = fprintf(file, "%s", self->original_core_pattern);
	if (ret < 0) {
		reason = "Unable to write to core_pattern";
		goto fail;
	}

	ret = fclose(file);
	if (ret) {
		reason = "Unable to close core_pattern";
		goto fail;
	}

	if (self->fd_tmpfs_detached >= 0) {
		ret = close(self->fd_tmpfs_detached);
		if (ret < 0) {
			reason = "Unable to close detached tmpfs";
			goto fail;
		}
		self->fd_tmpfs_detached = -1;
	}

	return;
fail:
	/* This should never happen */
	fprintf(stderr, "Failed to cleanup coredump test: %s\n", reason);
}

TEST_F(coredump, socket_request_kernel)
{
	int pidfd, ret, status;
	pid_t pid, pid_coredump_server;
	struct stat st;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	char c;

	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	ret = socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets);
	ASSERT_EQ(ret, 0);

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		struct coredump_req req = {};
		int fd_server = -1, fd_coredump = -1, fd_core_file = -1, fd_peer_pidfd = -1;
		int exit_code = EXIT_FAILURE;

		close(ipc_sockets[0]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0) {
			fprintf(stderr, "socket_request_kernel: create_and_listen_unix_socket failed: %m\n");
			goto out;
		}

		if (write_nointr(ipc_sockets[1], "1", 1) < 0) {
			fprintf(stderr, "socket_request_kernel: write_nointr to ipc socket failed: %m\n");
			goto out;
		}

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0) {
			fprintf(stderr, "socket_request_kernel: accept4 failed: %m\n");
			goto out;
		}

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0) {
			fprintf(stderr, "socket_request_kernel: get_peer_pidfd failed\n");
			goto out;
		}

		if (!get_pidfd_info(fd_peer_pidfd, &info)) {
			fprintf(stderr, "socket_request_kernel: get_pidfd_info failed\n");
			goto out;
		}

		if (!(info.mask & PIDFD_INFO_COREDUMP)) {
			fprintf(stderr, "socket_request_kernel: PIDFD_INFO_COREDUMP not set in mask\n");
			goto out;
		}

		if (!(info.coredump_mask & PIDFD_COREDUMPED)) {
			fprintf(stderr, "socket_request_kernel: PIDFD_COREDUMPED not set in coredump_mask\n");
			goto out;
		}

		fd_core_file = creat("/tmp/coredump.file", 0644);
		if (fd_core_file < 0) {
			fprintf(stderr, "socket_request_kernel: creat coredump file failed: %m\n");
			goto out;
		}

		if (!read_coredump_req(fd_coredump, &req)) {
			fprintf(stderr, "socket_request_kernel: read_coredump_req failed\n");
			goto out;
		}

		if (!check_coredump_req(&req)) {
			fprintf(stderr, "socket_request_kernel: check_coredump_req failed\n");
			goto out;
		}

		if (!send_coredump_ack(fd_coredump, &req,
				       COREDUMP_KERNEL | COREDUMP_WAIT, 0)) {
			fprintf(stderr, "socket_request_kernel: send_coredump_ack failed\n");
			goto out;
		}

		if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK)) {
			fprintf(stderr, "socket_request_kernel: read_marker COREDUMP_MARK_REQACK failed\n");
			goto out;
		}

		for (;;) {
			char buffer[4096];
			ssize_t bytes_read, bytes_write;

			bytes_read = read(fd_coredump, buffer, sizeof(buffer));
			if (bytes_read < 0) {
				fprintf(stderr, "socket_request_kernel: read from coredump socket failed: %m\n");
				goto out;
			}

			if (bytes_read == 0)
				break;

			bytes_write = write(fd_core_file, buffer, bytes_read);
			if (bytes_read != bytes_write) {
				if (bytes_write < 0 && errno == ENOSPC)
					continue;
				fprintf(stderr, "socket_request_kernel: write to core file failed (read=%zd, write=%zd): %m\n",
					bytes_read, bytes_write);
				goto out;
			}
		}

		exit_code = EXIT_SUCCESS;
		fprintf(stderr, "socket_request_kernel: completed successfully\n");
out:
		if (fd_core_file >= 0)
			close(fd_core_file);
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		crashing_child();

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	ASSERT_TRUE(WCOREDUMP(status));

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
	ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);

	ASSERT_EQ(stat("/tmp/coredump.file", &st), 0);
	ASSERT_GT(st.st_size, 0);
	system("file /tmp/coredump.file");
}

TEST_F(coredump, socket_request_userspace)
{
	int pidfd, ret, status;
	pid_t pid, pid_coredump_server;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	char c;

	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	ret = socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets);
	ASSERT_EQ(ret, 0);

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		struct coredump_req req = {};
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1;
		int exit_code = EXIT_FAILURE;

		close(ipc_sockets[0]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0) {
			fprintf(stderr, "socket_request_userspace: create_and_listen_unix_socket failed: %m\n");
			goto out;
		}

		if (write_nointr(ipc_sockets[1], "1", 1) < 0) {
			fprintf(stderr, "socket_request_userspace: write_nointr to ipc socket failed: %m\n");
			goto out;
		}

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0) {
			fprintf(stderr, "socket_request_userspace: accept4 failed: %m\n");
			goto out;
		}

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0) {
			fprintf(stderr, "socket_request_userspace: get_peer_pidfd failed\n");
			goto out;
		}

		if (!get_pidfd_info(fd_peer_pidfd, &info)) {
			fprintf(stderr, "socket_request_userspace: get_pidfd_info failed\n");
			goto out;
		}

		if (!(info.mask & PIDFD_INFO_COREDUMP)) {
			fprintf(stderr, "socket_request_userspace: PIDFD_INFO_COREDUMP not set in mask\n");
			goto out;
		}

		if (!(info.coredump_mask & PIDFD_COREDUMPED)) {
			fprintf(stderr, "socket_request_userspace: PIDFD_COREDUMPED not set in coredump_mask\n");
			goto out;
		}

		if (!read_coredump_req(fd_coredump, &req)) {
			fprintf(stderr, "socket_request_userspace: read_coredump_req failed\n");
			goto out;
		}

		if (!check_coredump_req(&req)) {
			fprintf(stderr, "socket_request_userspace: check_coredump_req failed\n");
			goto out;
		}

		if (!send_coredump_ack(fd_coredump, &req,
				       COREDUMP_USERSPACE | COREDUMP_WAIT, 0)) {
			fprintf(stderr, "socket_request_userspace: send_coredump_ack failed\n");
			goto out;
		}

		if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK)) {
			fprintf(stderr, "socket_request_userspace: read_marker COREDUMP_MARK_REQACK failed\n");
			goto out;
		}

		for (;;) {
			char buffer[4096];
			ssize_t bytes_read;

			bytes_read = read(fd_coredump, buffer, sizeof(buffer));
			if (bytes_read > 0) {
				fprintf(stderr, "socket_request_userspace: unexpected data received (expected no coredump data)\n");
				goto out;
			}

			if (bytes_read < 0) {
				fprintf(stderr, "socket_request_userspace: read from coredump socket failed: %m\n");
				goto out;
			}

			if (bytes_read == 0)
				break;
		}

		exit_code = EXIT_SUCCESS;
		fprintf(stderr, "socket_request_userspace: completed successfully\n");
out:
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		crashing_child();

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	ASSERT_TRUE(WCOREDUMP(status));

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
	ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);
}

TEST_F(coredump, socket_request_reject)
{
	int pidfd, ret, status;
	pid_t pid, pid_coredump_server;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	char c;

	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	ret = socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets);
	ASSERT_EQ(ret, 0);

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		struct coredump_req req = {};
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1;
		int exit_code = EXIT_FAILURE;

		close(ipc_sockets[0]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0) {
			fprintf(stderr, "socket_request_reject: create_and_listen_unix_socket failed: %m\n");
			goto out;
		}

		if (write_nointr(ipc_sockets[1], "1", 1) < 0) {
			fprintf(stderr, "socket_request_reject: write_nointr to ipc socket failed: %m\n");
			goto out;
		}

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0) {
			fprintf(stderr, "socket_request_reject: accept4 failed: %m\n");
			goto out;
		}

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0) {
			fprintf(stderr, "socket_request_reject: get_peer_pidfd failed\n");
			goto out;
		}

		if (!get_pidfd_info(fd_peer_pidfd, &info)) {
			fprintf(stderr, "socket_request_reject: get_pidfd_info failed\n");
			goto out;
		}

		if (!(info.mask & PIDFD_INFO_COREDUMP)) {
			fprintf(stderr, "socket_request_reject: PIDFD_INFO_COREDUMP not set in mask\n");
			goto out;
		}

		if (!(info.coredump_mask & PIDFD_COREDUMPED)) {
			fprintf(stderr, "socket_request_reject: PIDFD_COREDUMPED not set in coredump_mask\n");
			goto out;
		}

		if (!read_coredump_req(fd_coredump, &req)) {
			fprintf(stderr, "socket_request_reject: read_coredump_req failed\n");
			goto out;
		}

		if (!check_coredump_req(&req)) {
			fprintf(stderr, "socket_request_reject: check_coredump_req failed\n");
			goto out;
		}

		if (!send_coredump_ack(fd_coredump, &req,
				       COREDUMP_REJECT | COREDUMP_WAIT, 0)) {
			fprintf(stderr, "socket_request_reject: send_coredump_ack failed\n");
			goto out;
		}

		if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK)) {
			fprintf(stderr, "socket_request_reject: read_marker COREDUMP_MARK_REQACK failed\n");
			goto out;
		}

		for (;;) {
			char buffer[4096];
			ssize_t bytes_read;

			bytes_read = read(fd_coredump, buffer, sizeof(buffer));
			if (bytes_read > 0) {
				fprintf(stderr, "socket_request_reject: unexpected data received (expected no coredump data for REJECT)\n");
				goto out;
			}

			if (bytes_read < 0) {
				fprintf(stderr, "socket_request_reject: read from coredump socket failed: %m\n");
				goto out;
			}

			if (bytes_read == 0)
				break;
		}

		exit_code = EXIT_SUCCESS;
		fprintf(stderr, "socket_request_reject: completed successfully\n");
out:
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		crashing_child();

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	ASSERT_FALSE(WCOREDUMP(status));

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
	ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);
}

/* An ack the kernel must refuse and how. */
struct refused_ack {
	/* The ack, and how many bytes of it the server sends before it hangs up. */
	struct coredump_ack ack;
	size_t bytes;
	/* The marker the kernel answers with, or none if @no_marker. */
	enum coredump_mark mark;
	bool no_marker;
};

/* Send @refused, expect the kernel to refuse it and hang up. */
static void check_refused_ack(struct __test_metadata *const _metadata,
			      FIXTURE_DATA(coredump) *self,
			      const struct refused_ack *refused)
{
	int pidfd, status;
	pid_t pid, pid_coredump_server;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	char c;

	ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets), 0);
	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1;
		int exit_code = EXIT_FAILURE;
		struct coredump_req req = {};

		close(ipc_sockets[0]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0)
			goto out;

		if (write_nointr(ipc_sockets[1], "1", 1) < 0)
			goto out;

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0)
			goto out;

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0)
			goto out;

		/* The task shows as dumping while it waits for the ack. */
		if (!get_pidfd_info(fd_peer_pidfd, &info))
			goto out;

		if (!(info.mask & PIDFD_INFO_COREDUMP) ||
		    !(info.coredump_mask & PIDFD_COREDUMPED)) {
			fprintf(stderr, "Peer isn't marked as dumping\n");
			goto out;
		}

		if (!read_coredump_req(fd_coredump, &req))
			goto out;

		if (!check_coredump_req(&req))
			goto out;

		if (!send_coredump_ack_bytes(fd_coredump, &refused->ack,
					     refused->bytes))
			goto out;

		/* Nothing more to say. A server that died looks the same. */
		if (shutdown(fd_coredump, SHUT_WR))
			goto out;

		if (!refused->no_marker &&
		    !read_marker(fd_coredump, refused->mark))
			goto out;

		/* The kernel hangs up after a refusal, marker or not. */
		if (!read_hangup(fd_coredump))
			goto out;

		exit_code = EXIT_SUCCESS;
out:
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		crashing_child();

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	ASSERT_FALSE(WCOREDUMP(status));

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
	ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);
}

/* Ack @ack_mask, expect the kernel to refuse it as conflicting. */
static void check_conflicting_ack(struct __test_metadata *const _metadata,
				  FIXTURE_DATA(coredump) *self, __u64 ack_mask)
{
	struct refused_ack refused = {
		.ack = {
			.size = sizeof(struct coredump_ack),
			.mask = ack_mask,
		},
		.bytes = sizeof(struct coredump_ack),
		.mark = COREDUMP_MARK_CONFLICTING,
	};

	check_refused_ack(_metadata, self, &refused);
}

/* More than one of KERNEL, USERSPACE and REJECT. */
TEST_F(coredump, socket_request_invalid_flag_combination)
{
	check_conflicting_ack(_metadata, self,
			      COREDUMP_KERNEL | COREDUMP_REJECT | COREDUMP_WAIT);
}

/* A flag the kernel didn't advertise in coredump_req->mask. */
TEST_F(coredump, socket_request_unknown_flag)
{
	struct refused_ack refused = {
		.ack = {
			.size = sizeof(struct coredump_ack),
			.mask = 1ULL << 63,
		},
		.bytes = sizeof(struct coredump_ack),
		.mark = COREDUMP_MARK_UNSUPPORTED,
	};

	check_refused_ack(_metadata, self, &refused);
}

/* An ack smaller than the first published struct. */
TEST_F(coredump, socket_request_invalid_size_small)
{
	struct refused_ack refused = {
		.ack = {
			.size = COREDUMP_ACK_SIZE_VER0 / 2,
			.mask = COREDUMP_REJECT | COREDUMP_WAIT,
		},
		.bytes = COREDUMP_ACK_SIZE_VER0 / 2,
		.mark = COREDUMP_MARK_MINSIZE,
	};

	check_refused_ack(_metadata, self, &refused);
}

/* An ack bigger than the kernel said it accepts. */
TEST_F(coredump, socket_request_invalid_size_large)
{
	struct refused_ack refused = {
		.ack = {
			.size = COREDUMP_ACK_SIZE_VER0 + PAGE_SIZE,
			.mask = COREDUMP_REJECT | COREDUMP_WAIT,
		},
		.bytes = COREDUMP_ACK_SIZE_VER0 + PAGE_SIZE,
		.mark = COREDUMP_MARK_MAXSIZE,
	};

	check_refused_ack(_metadata, self, &refused);
}

/*
 * Test: PIDFD_INFO_COREDUMP_SIGNAL via socket coredump with SIGSEGV
 *
 * Verify that when using socket-based coredump protocol,
 * the coredump_signal field is correctly exposed as SIGSEGV.
 * Also check that the coredump_code field is correctly exposed
 * as SEGV_MAPERR.
 */
TEST_F(coredump, socket_coredump_signal_sigsegv)
{
	int pidfd, ret, status;
	pid_t pid, pid_coredump_server;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	char c;

	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	ret = socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets);
	ASSERT_EQ(ret, 0);

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		struct coredump_req req = {};
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1;
		int exit_code = EXIT_FAILURE;

		close(ipc_sockets[0]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: create_and_listen_unix_socket failed: %m\n");
			goto out;
		}

		if (write_nointr(ipc_sockets[1], "1", 1) < 0) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: write_nointr to ipc socket failed: %m\n");
			goto out;
		}

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: accept4 failed: %m\n");
			goto out;
		}

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: get_peer_pidfd failed\n");
			goto out;
		}

		if (!get_pidfd_info(fd_peer_pidfd, &info)) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: get_pidfd_info failed\n");
			goto out;
		}

		if (!(info.mask & PIDFD_INFO_COREDUMP)) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: PIDFD_INFO_COREDUMP not set in mask\n");
			goto out;
		}

		if (!(info.coredump_mask & PIDFD_COREDUMPED)) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: PIDFD_COREDUMPED not set in coredump_mask\n");
			goto out;
		}

		/* Verify coredump_signal is available and correct */
		if (!(info.mask & PIDFD_INFO_COREDUMP_SIGNAL)) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: PIDFD_INFO_COREDUMP_SIGNAL not set in mask\n");
			goto out;
		}

		if (info.coredump_signal != SIGSEGV) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: coredump_signal=%d, expected SIGSEGV=%d\n",
				info.coredump_signal, SIGSEGV);
			goto out;
		}

		/* Verify coredump_code is available and correct */
		if (!(info.mask & PIDFD_INFO_COREDUMP_CODE)) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: PIDFD_INFO_COREDUMP_CODE not set in mask\n");
			goto out;
		}

		if (info.coredump_code != SEGV_MAPERR) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: coredump_code=%d, expected SEGV_MAPERR=%d\n",
				info.coredump_code, SEGV_MAPERR);
			goto out;
		}

		if (!read_coredump_req(fd_coredump, &req)) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: read_coredump_req failed\n");
			goto out;
		}

		if (!send_coredump_ack(fd_coredump, &req,
				       COREDUMP_REJECT | COREDUMP_WAIT, 0)) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: send_coredump_ack failed\n");
			goto out;
		}

		if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK)) {
			fprintf(stderr, "socket_coredump_signal_sigsegv: read_marker COREDUMP_MARK_REQACK failed\n");
			goto out;
		}

		exit_code = EXIT_SUCCESS;
		fprintf(stderr, "socket_coredump_signal_sigsegv: completed successfully\n");
out:
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		crashing_child();

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	ASSERT_EQ(WTERMSIG(status), SIGSEGV);

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_TRUE(!!(info.mask & PIDFD_INFO_COREDUMP));
	ASSERT_TRUE(!!(info.mask & PIDFD_INFO_COREDUMP_SIGNAL));
	ASSERT_EQ(info.coredump_signal, SIGSEGV);
	ASSERT_TRUE(!!(info.mask & PIDFD_INFO_COREDUMP_CODE));
	ASSERT_EQ(info.coredump_code, SEGV_MAPERR);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);
}

/*
 * Test: PIDFD_INFO_COREDUMP_SIGNAL via socket coredump with SIGABRT
 *
 * Verify that when using socket-based coredump protocol,
 * the coredump_signal field is correctly exposed as SIGABRT.
 * Also check that the coredump_code field is correctly exposed
 * as SI_TKILL.
 */
TEST_F(coredump, socket_coredump_signal_sigabrt)
{
	int pidfd, ret, status;
	pid_t pid, pid_coredump_server;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	char c;

	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	ret = socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets);
	ASSERT_EQ(ret, 0);

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		struct coredump_req req = {};
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1;
		int exit_code = EXIT_FAILURE;

		close(ipc_sockets[0]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: create_and_listen_unix_socket failed: %m\n");
			goto out;
		}

		if (write_nointr(ipc_sockets[1], "1", 1) < 0) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: write_nointr to ipc socket failed: %m\n");
			goto out;
		}

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: accept4 failed: %m\n");
			goto out;
		}

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: get_peer_pidfd failed\n");
			goto out;
		}

		if (!get_pidfd_info(fd_peer_pidfd, &info)) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: get_pidfd_info failed\n");
			goto out;
		}

		if (!(info.mask & PIDFD_INFO_COREDUMP)) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: PIDFD_INFO_COREDUMP not set in mask\n");
			goto out;
		}

		if (!(info.coredump_mask & PIDFD_COREDUMPED)) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: PIDFD_COREDUMPED not set in coredump_mask\n");
			goto out;
		}

		/* Verify coredump_signal is available and correct */
		if (!(info.mask & PIDFD_INFO_COREDUMP_SIGNAL)) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: PIDFD_INFO_COREDUMP_SIGNAL not set in mask\n");
			goto out;
		}

		if (info.coredump_signal != SIGABRT) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: coredump_signal=%d, expected SIGABRT=%d\n",
				info.coredump_signal, SIGABRT);
			goto out;
		}

		if (info.coredump_code != SI_TKILL) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: coredump_code=%d, expected SI_TKILL=%d\n",
				info.coredump_code, SI_TKILL);
			goto out;
		}

		if (!read_coredump_req(fd_coredump, &req)) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: read_coredump_req failed\n");
			goto out;
		}

		if (!send_coredump_ack(fd_coredump, &req,
				       COREDUMP_REJECT | COREDUMP_WAIT, 0)) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: send_coredump_ack failed\n");
			goto out;
		}

		if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK)) {
			fprintf(stderr, "socket_coredump_signal_sigabrt: read_marker COREDUMP_MARK_REQACK failed\n");
			goto out;
		}

		exit_code = EXIT_SUCCESS;
		fprintf(stderr, "socket_coredump_signal_sigabrt: completed successfully\n");
out:
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		abort();

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	ASSERT_EQ(WTERMSIG(status), SIGABRT);

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_TRUE(!!(info.mask & PIDFD_INFO_COREDUMP));
	ASSERT_TRUE(!!(info.mask & PIDFD_INFO_COREDUMP_SIGNAL));
	ASSERT_EQ(info.coredump_signal, SIGABRT);
	ASSERT_TRUE(!!(info.mask & PIDFD_INFO_COREDUMP_CODE));
	ASSERT_EQ(info.coredump_code, SI_TKILL);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);
}

TEST_F_TIMEOUT(coredump, socket_multiple_crashing_coredumps, 500)
{
	int pidfd[NUM_CRASHING_COREDUMPS], status[NUM_CRASHING_COREDUMPS];
	pid_t pid[NUM_CRASHING_COREDUMPS], pid_coredump_server;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	char c;

	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets), 0);

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1, fd_core_file = -1;
		int exit_code = EXIT_FAILURE;
		struct coredump_req req = {};

		close(ipc_sockets[0]);
		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0) {
			fprintf(stderr, "Failed to create and listen on unix socket\n");
			goto out;
		}

		if (write_nointr(ipc_sockets[1], "1", 1) < 0) {
			fprintf(stderr, "Failed to notify parent via ipc socket\n");
			goto out;
		}
		close(ipc_sockets[1]);

		for (int i = 0; i < NUM_CRASHING_COREDUMPS; i++) {
			fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
			if (fd_coredump < 0) {
				fprintf(stderr, "accept4 failed: %m\n");
				goto out;
			}

			fd_peer_pidfd = get_peer_pidfd(fd_coredump);
			if (fd_peer_pidfd < 0) {
				fprintf(stderr, "get_peer_pidfd failed for fd %d: %m\n", fd_coredump);
				goto out;
			}

			if (!get_pidfd_info(fd_peer_pidfd, &info)) {
				fprintf(stderr, "get_pidfd_info failed for fd %d\n", fd_peer_pidfd);
				goto out;
			}

			if (!(info.mask & PIDFD_INFO_COREDUMP)) {
				fprintf(stderr, "pidfd info missing PIDFD_INFO_COREDUMP for fd %d\n", fd_peer_pidfd);
				goto out;
			}
			if (!(info.coredump_mask & PIDFD_COREDUMPED)) {
				fprintf(stderr, "pidfd info missing PIDFD_COREDUMPED for fd %d\n", fd_peer_pidfd);
				goto out;
			}

			if (!read_coredump_req(fd_coredump, &req)) {
				fprintf(stderr, "read_coredump_req failed for fd %d\n", fd_coredump);
				goto out;
			}

			if (!check_coredump_req(&req)) {
				fprintf(stderr, "check_coredump_req failed for fd %d\n", fd_coredump);
				goto out;
			}

			if (!send_coredump_ack(fd_coredump, &req,
					       COREDUMP_KERNEL | COREDUMP_WAIT, 0)) {
				fprintf(stderr, "send_coredump_ack failed for fd %d\n", fd_coredump);
				goto out;
			}

			if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK)) {
				fprintf(stderr, "read_marker failed for fd %d\n", fd_coredump);
				goto out;
			}

			fd_core_file = open_coredump_tmpfile(self->fd_tmpfs_detached);
			if (fd_core_file < 0) {
				fprintf(stderr, "%m - open_coredump_tmpfile failed for fd %d\n", fd_coredump);
				goto out;
			}

			for (;;) {
				char buffer[4096];
				ssize_t bytes_read, bytes_write;

				bytes_read = read(fd_coredump, buffer, sizeof(buffer));
				if (bytes_read < 0) {
					fprintf(stderr, "read failed for fd %d: %m\n", fd_coredump);
					goto out;
				}

				if (bytes_read == 0)
					break;

				bytes_write = write(fd_core_file, buffer, bytes_read);
				if (bytes_read != bytes_write) {
					if (bytes_write < 0 && errno == ENOSPC)
						continue;
					fprintf(stderr, "write failed for fd %d: %m\n", fd_core_file);
					goto out;
				}
			}

			close(fd_core_file);
			close(fd_peer_pidfd);
			close(fd_coredump);
			fd_peer_pidfd = -1;
			fd_coredump = -1;
		}

		exit_code = EXIT_SUCCESS;
out:
		if (fd_core_file >= 0)
			close(fd_core_file);
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	for (int i = 0; i < NUM_CRASHING_COREDUMPS; i++) {
		pid[i] = fork();
		ASSERT_GE(pid[i], 0);
		if (pid[i] == 0)
			crashing_child();
		pidfd[i] = sys_pidfd_open(pid[i], 0);
		ASSERT_GE(pidfd[i], 0);
	}

	for (int i = 0; i < NUM_CRASHING_COREDUMPS; i++) {
		waitpid(pid[i], &status[i], 0);
		ASSERT_TRUE(WIFSIGNALED(status[i]));
		ASSERT_TRUE(WCOREDUMP(status[i]));
	}

	for (int i = 0; i < NUM_CRASHING_COREDUMPS; i++) {
		info.mask = PIDFD_INFO_EXIT | PIDFD_INFO_COREDUMP;
		ASSERT_EQ(ioctl(pidfd[i], PIDFD_GET_INFO, &info), 0);
		ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
		ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);
	}

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);
}

TEST_F_TIMEOUT(coredump, socket_multiple_crashing_coredumps_epoll_workers, 500)
{
	int pidfd[NUM_CRASHING_COREDUMPS], status[NUM_CRASHING_COREDUMPS];
	pid_t pid[NUM_CRASHING_COREDUMPS], pid_coredump_server, worker_pids[NUM_CRASHING_COREDUMPS];
	struct pidfd_info info = {};
	int ipc_sockets[2];
	char c;

	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));
	ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets), 0);

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		int fd_server = -1, exit_code = EXIT_FAILURE, n_conns = 0;
		fd_server = -1;
		exit_code = EXIT_FAILURE;
		n_conns = 0;
		close(ipc_sockets[0]);
		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0) {
			fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: create_and_listen_unix_socket failed: %m\n");
			goto out;
		}

		if (write_nointr(ipc_sockets[1], "1", 1) < 0) {
			fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: write_nointr to ipc socket failed: %m\n");
			goto out;
		}
		close(ipc_sockets[1]);

		while (n_conns < NUM_CRASHING_COREDUMPS) {
			int fd_coredump = -1, fd_peer_pidfd = -1, fd_core_file = -1;
			struct coredump_req req = {};
			fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
			if (fd_coredump < 0) {
				if (errno == EAGAIN || errno == EWOULDBLOCK)
					continue;
				fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: accept4 failed: %m\n");
				goto out;
			}
			fd_peer_pidfd = get_peer_pidfd(fd_coredump);
			if (fd_peer_pidfd < 0) {
				fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: get_peer_pidfd failed\n");
				goto out;
			}
			if (!get_pidfd_info(fd_peer_pidfd, &info)) {
				fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: get_pidfd_info failed\n");
				goto out;
			}
			if (!(info.mask & PIDFD_INFO_COREDUMP) || !(info.coredump_mask & PIDFD_COREDUMPED)) {
				fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: missing PIDFD_INFO_COREDUMP or PIDFD_COREDUMPED\n");
				goto out;
			}
			if (!read_coredump_req(fd_coredump, &req)) {
				fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: read_coredump_req failed\n");
				goto out;
			}
			if (!check_coredump_req(&req)) {
				fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: check_coredump_req failed\n");
				goto out;
			}
			if (!send_coredump_ack(fd_coredump, &req, COREDUMP_KERNEL | COREDUMP_WAIT, 0)) {
				fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: send_coredump_ack failed\n");
				goto out;
			}
			if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK)) {
				fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: read_marker failed\n");
				goto out;
			}
			fd_core_file = open_coredump_tmpfile(self->fd_tmpfs_detached);
			if (fd_core_file < 0) {
				fprintf(stderr, "socket_multiple_crashing_coredumps_epoll_workers: open_coredump_tmpfile failed: %m\n");
				goto out;
			}
			pid_t worker = fork();
			if (worker == 0) {
				close(fd_server);
				process_coredump_worker(fd_coredump, fd_peer_pidfd, fd_core_file);
			}
			worker_pids[n_conns] = worker;
			if (fd_coredump >= 0)
				close(fd_coredump);
			if (fd_peer_pidfd >= 0)
				close(fd_peer_pidfd);
			if (fd_core_file >= 0)
				close(fd_core_file);
			n_conns++;
		}
		exit_code = EXIT_SUCCESS;
out:
		if (fd_server >= 0)
			close(fd_server);

		// Reap all worker processes
		for (int i = 0; i < n_conns; i++) {
			int wstatus;
			if (waitpid(worker_pids[i], &wstatus, 0) < 0) {
				fprintf(stderr, "Failed to wait for worker %d: %m\n", worker_pids[i]);
			} else if (WIFEXITED(wstatus) && WEXITSTATUS(wstatus) != EXIT_SUCCESS) {
				fprintf(stderr, "Worker %d exited with error code %d\n", worker_pids[i], WEXITSTATUS(wstatus));
				exit_code = EXIT_FAILURE;
			}
		}

		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	for (int i = 0; i < NUM_CRASHING_COREDUMPS; i++) {
		pid[i] = fork();
		ASSERT_GE(pid[i], 0);
		if (pid[i] == 0)
			crashing_child();
		pidfd[i] = sys_pidfd_open(pid[i], 0);
		ASSERT_GE(pidfd[i], 0);
	}

	for (int i = 0; i < NUM_CRASHING_COREDUMPS; i++) {
		ASSERT_GE(waitpid(pid[i], &status[i], 0), 0);
		ASSERT_TRUE(WIFSIGNALED(status[i]));
		ASSERT_TRUE(WCOREDUMP(status[i]));
	}

	for (int i = 0; i < NUM_CRASHING_COREDUMPS; i++) {
		info.mask = PIDFD_INFO_EXIT | PIDFD_INFO_COREDUMP;
		ASSERT_EQ(ioctl(pidfd[i], PIDFD_GET_INFO, &info), 0);
		ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
		ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);
	}

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);
}

/*
 * Reassemble a record stream and check that what comes out is an ELF
 * core file. The records themselves are validated by recv_coredump_records().
 */
TEST_F(coredump, socket_request_sparse_reassemble)
{
	int fd_core_file, pidfd, status;
	pid_t pid, pid_coredump_server;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	char c;

	ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets), 0);
	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1;
		int fd_file = -1;
		int exit_code = EXIT_FAILURE;
		struct coredump_req req = {};

		close(ipc_sockets[0]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0)
			goto out;

		if (write_nointr(ipc_sockets[1], "1", 1) < 0)
			goto out;

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0)
			goto out;

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0)
			goto out;

		fd_file = creat("/tmp/coredump.file", 0644);
		if (fd_file < 0)
			goto out;

		if (!read_coredump_req(fd_coredump, &req))
			goto out;

		if (!check_coredump_req(&req))
			goto out;

		if (!send_coredump_ack(fd_coredump, &req,
				       COREDUMP_KERNEL | COREDUMP_RECORDS |
				       COREDUMP_SPARSE | COREDUMP_WAIT, 0))
			goto out;

		if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK))
			goto out;

		if (recv_coredump_records(fd_coredump, fd_file, NULL, NULL, -1) < 0)
			goto out;

		exit_code = EXIT_SUCCESS;
out:
		if (fd_file >= 0)
			close(fd_file);
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		crashing_child();

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	ASSERT_TRUE(WCOREDUMP(status));

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
	ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);

	/* What the records reassemble into has to be an ELF core file. */
	fd_core_file = open("/tmp/coredump.file", O_RDONLY | O_CLOEXEC);
	ASSERT_GE(fd_core_file, 0);
	ASSERT_TRUE(is_elf_core(fd_core_file));
	EXPECT_EQ(close(fd_core_file), 0);
}

/*
 * Crash a child with a mostly-unpopulated mapping and reassemble its
 * record stream, reporting what crossed the socket and the coredump
 * size the records describe. With @kill_peer the server kills the task
 * once the coredump is under way so the kernel has to cut it short.
 */
static void check_record_dump(struct __test_metadata *const _metadata,
			      FIXTURE_DATA(coredump) *self, __u64 ack_mask,
			      bool kill_peer, ssize_t *received,
			      off_t *coredump_size)
{
	bool truncated = false;
	int pidfd, status;
	pid_t pid, pid_coredump_server;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	int pipefds[2];
	char c;

	ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets), 0);
	ASSERT_EQ(pipe(pipefds), 0);
	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1;
		int fd_file = -1;
		int exit_code = EXIT_FAILURE;
		struct coredump_req req = {};
		bool is_truncated = false;
		off_t size = 0;
		ssize_t ret;

		close(ipc_sockets[0]);
		close(pipefds[0]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0)
			goto out;

		if (write_nointr(ipc_sockets[1], "1", 1) < 0)
			goto out;

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0)
			goto out;

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0)
			goto out;

		/*
		 * The reassembled coredump is bigger than the mapping the
		 * child made, so keep it on the detached tmpfs and sparse.
		 */
		fd_file = open_coredump_tmpfile(self->fd_tmpfs_detached);
		if (fd_file < 0)
			goto out;

		if (!read_coredump_req(fd_coredump, &req))
			goto out;

		if (!check_coredump_req(&req))
			goto out;

		if (!send_coredump_ack(fd_coredump, &req, ack_mask, 0))
			goto out;

		if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK))
			goto out;

		ret = recv_coredump_records(fd_coredump, fd_file, &size, &is_truncated,
					    kill_peer ? fd_peer_pidfd : -1);
		if (ret < 0)
			goto out;

		if (write_nointr(pipefds[1], &ret, sizeof(ret)) != sizeof(ret))
			goto out;
		if (write_nointr(pipefds[1], &size, sizeof(size)) != sizeof(size))
			goto out;
		if (write_nointr(pipefds[1], &is_truncated,
				 sizeof(is_truncated)) != sizeof(is_truncated))
			goto out;

		exit_code = EXIT_SUCCESS;
out:
		close(pipefds[1]);
		if (fd_file >= 0)
			close(fd_file);
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	EXPECT_EQ(close(pipefds[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		crashing_child_sparse(SPARSE_MAPPING_SIZE);

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));

	ASSERT_EQ(read_nointr(pipefds[0], received, sizeof(*received)),
		  sizeof(*received));
	ASSERT_EQ(read_nointr(pipefds[0], coredump_size, sizeof(*coredump_size)),
		  sizeof(*coredump_size));
	ASSERT_EQ(read_nointr(pipefds[0], &truncated, sizeof(truncated)),
		  sizeof(truncated));
	EXPECT_EQ(close(pipefds[0]), 0);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);

	if (kill_peer) {
		/* The kernel gave up partway, so no end record closed the stream. */
		ASSERT_TRUE(truncated);
		ASSERT_FALSE(WCOREDUMP(status));
		ASSERT_LT(*coredump_size, (off_t)SPARSE_MAPPING_SIZE);
		return;
	}

	ASSERT_FALSE(truncated);
	ASSERT_TRUE(WCOREDUMP(status));

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
	ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);

	/* The mapping is in the coredump, holes included. */
	ASSERT_GT(*coredump_size, (off_t)SPARSE_MAPPING_SIZE);
}

/*
 * A mapping that has been written to is dumped whole, including the parts
 * of it that were never faulted in. With COREDUMP_SPARSE the holes stay
 * off the wire.
 */
TEST_F(coredump, socket_request_sparse_hole)
{
	off_t coredump_size = 0;
	ssize_t received = 0;

	check_record_dump(_metadata, self,
			  COREDUMP_KERNEL | COREDUMP_RECORDS |
			  COREDUMP_SPARSE | COREDUMP_WAIT,
			  false, &received, &coredump_size);

	/* The holes didn't have to go over the socket. */
	ASSERT_LT(received, coredump_size / 8);
}

/*
 * COREDUMP_RECORDS alone splits the stream into records but elides
 * nothing: the holes cross the socket as data records.
 */
TEST_F(coredump, socket_request_records_hole)
{
	off_t coredump_size = 0;
	ssize_t received = 0;

	check_record_dump(_metadata, self,
			  COREDUMP_KERNEL | COREDUMP_RECORDS | COREDUMP_WAIT,
			  false, &received, &coredump_size);

	/* Records alone elide nothing, so everything crossed the socket. */
	ASSERT_GT(received, coredump_size);
}

/*
 * A coredump the kernel gives up on halfway still ends in an end record,
 * and that record says the coredump is incomplete. COREDUMP_SPARSE is left
 * out on purpose: the holes have to cross the socket so the coredump is
 * far larger than the socket buffer and the kernel is still writing it
 * when the kill lands.
 */
TEST_F(coredump, socket_request_records_truncated)
{
	off_t coredump_size = 0;
	ssize_t received = 0;

	check_record_dump(_metadata, self,
			  COREDUMP_KERNEL | COREDUMP_RECORDS | COREDUMP_WAIT,
			  true, &received, &coredump_size);

	/* The end record crossed the socket even though the task was killed. */
	ASSERT_GT(received, 0);
}

/*
 * A coredump server that uploads to a blob store can't upload a sparse
 * file. It doesn't have to: it streams the data records into the object
 * as they arrive, leaves the holes out, and uploads the corrected
 * program header table last. What it ends up with is an ordinary ELF
 * core file that describes the same memory as the coredump the records
 * came from, minus the holes.
 */
TEST_F(coredump, socket_request_sparse_blob_upload)
{
	int fd_core_file, pidfd, status;
	pid_t pid, pid_coredump_server;
	struct pidfd_info info = {};
	off_t coredump_size = 0;
	ssize_t received = 0;
	int ipc_sockets[2];
	int pipefds[2];
	struct stat st;
	char c;

	ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets), 0);
	ASSERT_EQ(pipe(pipefds), 0);
	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1;
		int fd_object = -1, fd_reference = -1;
		int exit_code = EXIT_FAILURE;
		struct coredump_req req = {};
		off_t size = 0;
		ssize_t ret;

		close(ipc_sockets[0]);
		close(pipefds[0]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0)
			goto out;

		if (write_nointr(ipc_sockets[1], "1", 1) < 0)
			goto out;

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0)
			goto out;

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0)
			goto out;

		/* The object is a plain file. It never sees a hole. */
		fd_object = open("/tmp/coredump.file",
				 O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0600);
		if (fd_object < 0)
			goto out;

		/*
		 * The coredump with its holes still in it is bigger than
		 * the mapping the child made, so keep it on the detached
		 * tmpfs and sparse.
		 */
		fd_reference = open_coredump_tmpfile(self->fd_tmpfs_detached);
		if (fd_reference < 0)
			goto out;

		if (!read_coredump_req(fd_coredump, &req))
			goto out;

		if (!check_coredump_req(&req))
			goto out;

		if (!send_coredump_ack(fd_coredump, &req,
				       COREDUMP_KERNEL | COREDUMP_RECORDS |
				       COREDUMP_SPARSE | COREDUMP_WAIT, 0))
			goto out;

		if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK))
			goto out;

		ret = recv_coredump_compact(fd_coredump, fd_object,
					    fd_reference, &size);
		if (ret < 0)
			goto out;

		if (check_compact_coredump(fd_object, fd_reference))
			goto out;

		if (write_nointr(pipefds[1], &ret, sizeof(ret)) != sizeof(ret))
			goto out;
		if (write_nointr(pipefds[1], &size, sizeof(size)) != sizeof(size))
			goto out;

		exit_code = EXIT_SUCCESS;
out:
		close(pipefds[1]);
		if (fd_reference >= 0)
			close(fd_reference);
		if (fd_object >= 0)
			close(fd_object);
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	EXPECT_EQ(close(pipefds[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		crashing_child_sparse(SPARSE_MAPPING_SIZE);

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	ASSERT_TRUE(WCOREDUMP(status));

	ASSERT_EQ(read_nointr(pipefds[0], &received, sizeof(received)),
		  sizeof(received));
	ASSERT_EQ(read_nointr(pipefds[0], &coredump_size, sizeof(coredump_size)),
		  sizeof(coredump_size));
	EXPECT_EQ(close(pipefds[0]), 0);

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
	ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);

	/* The mapping is in the coredump, holes included. */
	ASSERT_GT(coredump_size, (off_t)SPARSE_MAPPING_SIZE);

	/* The object isn't sparse and doesn't carry them. */
	ASSERT_EQ(stat("/tmp/coredump.file", &st), 0);
	ASSERT_LT(st.st_size, coredump_size / 8);

	/* And a debugger still sees an ordinary ELF core file. */
	fd_core_file = open("/tmp/coredump.file", O_RDONLY | O_CLOEXEC);
	ASSERT_GE(fd_core_file, 0);
	ASSERT_TRUE(is_elf_core(fd_core_file));
	EXPECT_EQ(close(fd_core_file), 0);
}

/* COREDUMP_RECORDS applies to a coredump the kernel writes, nothing else. */
TEST_F(coredump, socket_request_records_without_kernel)
{
	check_conflicting_ack(_metadata, self, COREDUMP_USERSPACE | COREDUMP_RECORDS);
}

/* A zero record can't exist outside a record stream. */
TEST_F(coredump, socket_request_sparse_without_records)
{
	check_conflicting_ack(_metadata, self, COREDUMP_KERNEL | COREDUMP_SPARSE);
}

/* What the server reports back about the coredump it decided to take. */
struct stream_choice {
	bool sparse;
	ssize_t received;
	off_t size;
	ssize_t vm_size;
};

/*
 * The kernel blocks in the coredump request until the ack arrives, so a
 * coredump server gets to look at the task before it commits to a
 * stream. Take the record stream only for a task whose mappings are
 * worth it and the plain byte stream for everything else.
 */
static void check_stream_choice(struct __test_metadata *const _metadata,
				FIXTURE_DATA(coredump) *self, bool big,
				struct stream_choice *choice)
{
	int pidfd, status;
	pid_t pid, pid_coredump_server;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	int pipefds[2];
	char c;

	ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets), 0);
	ASSERT_EQ(pipe(pipefds), 0);
	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1;
		int fd_file = -1;
		int exit_code = EXIT_FAILURE;
		struct coredump_req req = {};
		struct stream_choice got = {};
		__u64 mask;

		close(ipc_sockets[0]);
		close(pipefds[0]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0)
			goto out;

		if (write_nointr(ipc_sockets[1], "1", 1) < 0)
			goto out;

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0)
			goto out;

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0)
			goto out;

		/*
		 * The reassembled coredump is bigger than the mapping the
		 * child made, so keep it on the detached tmpfs and sparse.
		 */
		fd_file = open_coredump_tmpfile(self->fd_tmpfs_detached);
		if (fd_file < 0)
			goto out;

		if (!read_coredump_req(fd_coredump, &req))
			goto out;

		if (!check_coredump_req(&req))
			goto out;

		/*
		 * Nothing is on the wire yet and the kernel is waiting for
		 * the ack, so there is all the time in the world to look at
		 * the task and decide what to ask it for.
		 */
		got.vm_size = peer_vm_size(fd_peer_pidfd);
		if (got.vm_size < 0)
			goto out;
		got.sparse = got.vm_size >= SPARSE_STREAM_THRESHOLD;

		fprintf(stderr, "Peer maps %zd bytes, asking for %s\n",
			got.vm_size,
			got.sparse ? "a sparse record stream" : "a byte stream");

		mask = COREDUMP_KERNEL | COREDUMP_WAIT;
		if (got.sparse)
			mask |= COREDUMP_RECORDS | COREDUMP_SPARSE;

		if (!send_coredump_ack(fd_coredump, &req, mask, 0))
			goto out;

		if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK))
			goto out;

		if (got.sparse) {
			got.received = recv_coredump_records(fd_coredump, fd_file,
							     &got.size, NULL, -1);
		} else {
			got.received = recv_coredump_bytes(fd_coredump, fd_file);
			got.size = got.received;
		}
		if (got.received < 0)
			goto out;

		/* Either way a debugger has to see an ordinary core file. */
		if (!is_elf_core(fd_file))
			goto out;

		if (write_nointr(pipefds[1], &got, sizeof(got)) != sizeof(got))
			goto out;

		exit_code = EXIT_SUCCESS;
out:
		close(pipefds[1]);
		if (fd_file >= 0)
			close(fd_file);
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	EXPECT_EQ(close(pipefds[1]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		crashing_child_sparse(big ? SPARSE_MAPPING_SIZE : PAGE_SIZE);

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	ASSERT_TRUE(WCOREDUMP(status));

	ASSERT_EQ(read_nointr(pipefds[0], choice, sizeof(*choice)),
		  sizeof(*choice));
	EXPECT_EQ(close(pipefds[0]), 0);

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
	ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);
}

/* A task with little mapped isn't worth a record stream. */
TEST_F(coredump, socket_request_stream_choice_small)
{
	struct stream_choice choice = {};

	check_stream_choice(_metadata, self, false, &choice);

	ASSERT_LT(choice.vm_size, (ssize_t)SPARSE_STREAM_THRESHOLD);
	ASSERT_FALSE(choice.sparse);
	ASSERT_GT(choice.received, 0);
}

/* A task sitting on a big mapping is. */
TEST_F(coredump, socket_request_stream_choice_large)
{
	struct stream_choice choice = {};

	check_stream_choice(_metadata, self, true, &choice);

	ASSERT_GE(choice.vm_size, (ssize_t)SPARSE_STREAM_THRESHOLD);
	ASSERT_TRUE(choice.sparse);
	ASSERT_GT(choice.size, (off_t)SPARSE_MAPPING_SIZE);

	/* The holes didn't have to go over the socket. */
	ASSERT_LT(choice.received, choice.size / 8);
}

/* What a coredump server was built with. */
struct server_build {
	/* sizeof(struct coredump_req) and sizeof(struct coredump_ack) back then. */
	size_t req_size;
	size_t ack_size;
	/* The features it raises if the kernel offers them. */
	__u64 wants;
	/* Its policy: what it drops from and adds to the task's selection. */
	__u64 drop;
	__u64 add;
};

/* A server from when the structs were first published: kernel-written dumps. */
static const struct server_build server_build_ver0 = {
	.req_size	= COREDUMP_REQ_SIZE_VER0,
	.ack_size	= COREDUMP_ACK_SIZE_VER0,
	.wants		= COREDUMP_KERNEL,
};

/* A server built against this header: no shared memory, always the ELF headers. */
static const struct server_build server_build_ver1 = {
	.req_size	= sizeof(struct coredump_req),
	.ack_size	= sizeof(struct coredump_ack),
	.wants		= COREDUMP_KERNEL | COREDUMP_RECORDS | COREDUMP_SPARSE |
			  COREDUMP_MEMORY_TYPES,
	.drop		= COREDUMP_MEMORY_ANON_SHARED | COREDUMP_MEMORY_FILE_SHARED,
	.add		= COREDUMP_MEMORY_ELF_HEADERS,
};

/*
 * Build the ack the way a server does: from what the kernel offers, what
 * this build implements, and what fits in the ack the kernel accepts.
 * Fields the build never read are zero and never consulted.
 */
static void negotiate(const struct coredump_req *req,
		      const struct server_build *build,
		      struct coredump_ack *ack)
{
	__u64 offered = req->mask & build->wants;

	memset(ack, 0, sizeof(*ack));
	ack->size = build->ack_size < req->size_ack ? build->ack_size : req->size_ack;
	/* These builds only ever have the kernel write the coredump. */
	ack->mask = COREDUMP_KERNEL;

	/* Sparse needs records, records need the kernel to write. */
	if (offered & COREDUMP_RECORDS) {
		ack->mask |= COREDUMP_RECORDS;
		if (offered & COREDUMP_SPARSE)
			ack->mask |= COREDUMP_SPARSE;
	}

	/* The memory types need an ack that carries them. */
	if ((offered & COREDUMP_MEMORY_TYPES) && ack->size >= COREDUMP_ACK_SIZE_VER1) {
		ack->mask |= COREDUMP_MEMORY_TYPES;
		/* Start from the task's selection; only advertised types pass. */
		ack->memory_types = (req->memory_types & ~build->drop) | build->add;
		ack->memory_types &= req->memory_types_mask;
	}
}

/* What a memory types test asks of the kernel and what it expects back. */
struct memory_choice {
	/* Memory types the crashing child selects, or FILTER_TASK_INHERIT. */
	__u64 task_filter;
	/* Negotiate the ack as this server build, NULL to send it as given. */
	const struct server_build *build;
	/* The ack, or what the negotiation must arrive at. */
	__u64 mask;
	__u64 memory_types;
	size_t size_ack;
	/* The shared mapping is in the coredump with all of its memory. */
	bool shared_dumped;
	/* No memory at all. Pull a page from /proc/<pid>/mem instead. */
	bool skeleton;
};

/* A skeleton still carries the vdso and friends, nothing bigger. */
#define SKELETON_DATA_PAGES 16

/*
 * The crashing child maps shared anonymous memory and tells the server
 * where. The server acks with @choice and checks whether that mapping's
 * segment in the coredump carries its memory.
 */
static void check_memory_dump(struct __test_metadata *const _metadata,
			      FIXTURE_DATA(coredump) *self,
			      const struct memory_choice *choice)
{
	int pidfd, status;
	pid_t pid, pid_coredump_server;
	struct pidfd_info info = {};
	int ipc_sockets[2];
	int addr_pipe[2];
	char c;

	ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets), 0);
	ASSERT_EQ(pipe(addr_pipe), 0);
	ASSERT_TRUE(set_core_pattern("@@/tmp/coredump.socket"));

	pid_coredump_server = fork();
	ASSERT_GE(pid_coredump_server, 0);
	if (pid_coredump_server == 0) {
		int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1;
		int fd_file = -1;
		int exit_code = EXIT_FAILURE;
		struct coredump_req req = {};
		struct coredump_ack ack = {
			.size = choice->size_ack,
			.mask = choice->mask,
			.memory_types = choice->memory_types,
		};
		/* How much of the request this server reads. */
		size_t req_size = choice->build ? choice->build->req_size : sizeof(req);
		__u64 task_filter;
		ElfW(Phdr) segment;
		ssize_t received;
		off_t size;
		char *addr;

		close(ipc_sockets[0]);
		close(addr_pipe[1]);

		fd_server = create_and_listen_unix_socket("/tmp/coredump.socket");
		if (fd_server < 0)
			goto out;

		if (write_nointr(ipc_sockets[1], "1", 1) < 0)
			goto out;

		close(ipc_sockets[1]);

		fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC);
		if (fd_coredump < 0)
			goto out;

		fd_peer_pidfd = get_peer_pidfd(fd_coredump);
		if (fd_peer_pidfd < 0)
			goto out;

		fd_file = open_coredump_tmpfile(self->fd_tmpfs_detached);
		if (fd_file < 0)
			goto out;

		if (!read_coredump_req_sized(fd_coredump, &req, req_size))
			goto out;

		if (!peer_coredump_filter(fd_peer_pidfd, &task_filter))
			goto out;

		/* A build from before the memory types never read that far. */
		if (req_size >= COREDUMP_REQ_SIZE_VER1) {
			if (!check_coredump_req(&req))
				goto out;

			/* The request reports the memory types the task selected. */
			if (req.memory_types != task_filter) {
				fprintf(stderr, "Request reports 0x%llx, task selected 0x%llx\n",
					(unsigned long long)req.memory_types,
					(unsigned long long)task_filter);
				goto out;
			}
		}

		if (choice->task_filter != FILTER_TASK_INHERIT &&
		    task_filter != choice->task_filter) {
			fprintf(stderr, "Task selected 0x%llx, child asked for 0x%llx\n",
				(unsigned long long)task_filter,
				(unsigned long long)choice->task_filter);
			goto out;
		}

		/* The child sent the address of its mapping before it crashed. */
		if (read_nointr(addr_pipe[0], &addr, sizeof(addr)) != sizeof(addr))
			goto out;

		/* A server build negotiates its ack and must arrive at the choice. */
		if (choice->build) {
			negotiate(&req, choice->build, &ack);

			if (ack.size != choice->size_ack || ack.mask != choice->mask ||
			    ack.memory_types != choice->memory_types) {
				fprintf(stderr,
					"Negotiated %u bytes, mask 0x%llx, types 0x%llx\n",
					ack.size, (unsigned long long)ack.mask,
					(unsigned long long)ack.memory_types);
				goto out;
			}
		}

		if (!send_coredump_ack_types(fd_coredump, &req, ack.mask,
					      ack.memory_types, ack.size))
			goto out;

		if (!read_marker(fd_coredump, COREDUMP_MARK_REQACK))
			goto out;

		if (ack.mask & COREDUMP_RECORDS)
			received = recv_coredump_records(fd_coredump, fd_file,
							 &size, NULL, -1);
		else
			received = recv_coredump_bytes(fd_coredump, fd_file);
		if (received < 0)
			goto out;

		if (!is_elf_core(fd_file))
			goto out;

		/* A dump ending in holes or empty segments must still be whole. */
		if (!check_coredump_extent(fd_file))
			goto out;

		if (!find_coredump_segment(fd_file, (__u64)(uintptr_t)addr, &segment))
			goto out;

		if (segment.p_memsz != MEMORY_MAPPING_SIZE) {
			fprintf(stderr, "Segment spans %llu bytes, the mapping %u\n",
				(unsigned long long)segment.p_memsz,
				MEMORY_MAPPING_SIZE);
			goto out;
		}

		if (segment.p_filesz != (choice->shared_dumped ? segment.p_memsz : 0)) {
			fprintf(stderr, "Segment carries %llu bytes, expected %s of them\n",
				(unsigned long long)segment.p_filesz,
				choice->shared_dumped ? "all" : "none");
			goto out;
		}

		if (choice->skeleton) {
			__u64 data, notes, data_max;
			char buf[PAGE_SIZE];

			if (!sum_coredump_segments(fd_file, &data, &notes))
				goto out;

			data_max = SKELETON_DATA_PAGES * sysconf(_SC_PAGESIZE);
			if (!notes || data > data_max) {
				fprintf(stderr, "Skeleton has %llu note and %llu memory bytes\n",
					(unsigned long long)notes,
					(unsigned long long)data);
				goto out;
			}

			/* The task is parked in COREDUMP_WAIT with its memory. */
			if (peer_read_mem(fd_peer_pidfd, (__u64)(uintptr_t)addr,
					  buf, sizeof(buf)) != sizeof(buf))
				goto out;

			if (buf[0] != 'x') {
				fprintf(stderr, "Pulled memory lacks the child's mark\n");
				goto out;
			}

			fprintf(stderr, "Skeleton of %zd bytes, pulled %zu bytes of memory\n",
				received, sizeof(buf));
		}

		exit_code = EXIT_SUCCESS;
out:
		close(addr_pipe[0]);
		if (fd_file >= 0)
			close(fd_file);
		if (fd_peer_pidfd >= 0)
			close(fd_peer_pidfd);
		if (fd_coredump >= 0)
			close(fd_coredump);
		if (fd_server >= 0)
			close(fd_server);
		_exit(exit_code);
	}
	self->pid_coredump_server = pid_coredump_server;

	EXPECT_EQ(close(ipc_sockets[1]), 0);
	EXPECT_EQ(close(addr_pipe[0]), 0);
	ASSERT_EQ(read_nointr(ipc_sockets[0], &c, 1), 1);
	EXPECT_EQ(close(ipc_sockets[0]), 0);

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		crashing_child_memory(choice->task_filter, addr_pipe[1]);
	EXPECT_EQ(close(addr_pipe[1]), 0);

	pidfd = sys_pidfd_open(pid, 0);
	ASSERT_GE(pidfd, 0);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	ASSERT_TRUE(WCOREDUMP(status));

	ASSERT_TRUE(get_pidfd_info(pidfd, &info));
	ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0);
	ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0);

	wait_and_check_coredump_server(pid_coredump_server, _metadata, self);
}

/* Without COREDUMP_MEMORY_TYPES the task's own selection decides. */
TEST_F(coredump, socket_request_memory_types_task_includes)
{
	struct memory_choice choice = {
		.task_filter = COREDUMP_MEMORY_ANON_PRIVATE |
			       COREDUMP_MEMORY_ANON_SHARED,
		.mask = COREDUMP_KERNEL,
		.shared_dumped = true,
	};

	check_memory_dump(_metadata, self, &choice);
}

TEST_F(coredump, socket_request_memory_types_task_excludes)
{
	struct memory_choice choice = {
		.task_filter = 0,
		.mask = COREDUMP_KERNEL,
		.shared_dumped = false,
	};

	check_memory_dump(_metadata, self, &choice);
}

/* The server drops a memory type the task would have dumped. */
TEST_F(coredump, socket_request_memory_types_restricts)
{
	struct memory_choice choice = {
		.task_filter = COREDUMP_MEMORY_ANON_PRIVATE |
			       COREDUMP_MEMORY_ANON_SHARED,
		.mask = COREDUMP_KERNEL | COREDUMP_MEMORY_TYPES,
		.memory_types = COREDUMP_MEMORY_ANON_PRIVATE,
		.shared_dumped = false,
	};

	check_memory_dump(_metadata, self, &choice);
}

/* The server adds a memory type the task had excluded. */
TEST_F(coredump, socket_request_memory_types_widens)
{
	struct memory_choice choice = {
		.task_filter = 0,
		.mask = COREDUMP_KERNEL | COREDUMP_MEMORY_TYPES,
		.memory_types = COREDUMP_MEMORY_ANON_PRIVATE |
			  COREDUMP_MEMORY_ANON_SHARED,
		.shared_dumped = true,
	};

	check_memory_dump(_metadata, self, &choice);
}

/* The memory types decide what goes into a record stream just the same. */
TEST_F(coredump, socket_request_memory_types_records)
{
	struct memory_choice choice = {
		.task_filter = FILTER_TASK_INHERIT,
		.mask = COREDUMP_KERNEL | COREDUMP_RECORDS | COREDUMP_SPARSE |
			COREDUMP_MEMORY_TYPES,
		.memory_types = COREDUMP_MEMORY_ANON_PRIVATE,
		.shared_dumped = false,
	};

	check_memory_dump(_metadata, self, &choice);
}

/*
 * An empty selection leaves a skeleton: every program header and every note
 * but no memory. A server that wants to pick the memory itself reads it
 * from /proc/<pid>/mem while the task waits for it to finish.
 */
TEST_F(coredump, socket_request_memory_types_skeleton)
{
	struct memory_choice choice = {
		.task_filter = FILTER_TASK_INHERIT,
		.mask = COREDUMP_KERNEL | COREDUMP_WAIT | COREDUMP_MEMORY_TYPES,
		.memory_types = 0,
		.shared_dumped = false,
		.skeleton = true,
	};

	check_memory_dump(_metadata, self, &choice);
}

/* A memory type the kernel didn't advertise in memory_types_mask. */
TEST_F(coredump, socket_request_memory_types_unknown_bit)
{
	struct refused_ack refused = {
		.ack = {
			.size = sizeof(struct coredump_ack),
			.mask = COREDUMP_KERNEL | COREDUMP_MEMORY_TYPES,
			.memory_types = 1ULL << 63,
		},
		.bytes = sizeof(struct coredump_ack),
		.mark = COREDUMP_MARK_UNSUPPORTED,
	};

	check_refused_ack(_metadata, self, &refused);
}

/* The memory types must be zero unless COREDUMP_MEMORY_TYPES is raised. */
TEST_F(coredump, socket_request_memory_types_stale_field)
{
	struct refused_ack refused = {
		.ack = {
			.size = sizeof(struct coredump_ack),
			.mask = COREDUMP_KERNEL,
			.memory_types = COREDUMP_MEMORY_ANON_PRIVATE,
		},
		.bytes = sizeof(struct coredump_ack),
		.mark = COREDUMP_MARK_UNSUPPORTED,
	};

	check_refused_ack(_metadata, self, &refused);
}

/* COREDUMP_MEMORY_TYPES needs an ack that has the memory types. */
TEST_F(coredump, socket_request_memory_types_short_ack)
{
	struct refused_ack refused = {
		.ack = {
			.size = COREDUMP_ACK_SIZE_VER0,
			.mask = COREDUMP_KERNEL | COREDUMP_MEMORY_TYPES,
		},
		.bytes = COREDUMP_ACK_SIZE_VER0,
		.mark = COREDUMP_MARK_MINSIZE,
	};

	check_refused_ack(_metadata, self, &refused);
}

/* The memory types select what the kernel writes, nothing else. */
TEST_F(coredump, socket_request_memory_types_without_kernel)
{
	check_conflicting_ack(_metadata, self, COREDUMP_USERSPACE | COREDUMP_MEMORY_TYPES);
}

/*
 * A server built with the first structs reads the request it knows,
 * discards the rest and acks with the ack it knows. It raises nothing
 * it wasn't built for and the kernel dumps what the task selected.
 */
TEST_F(coredump, socket_request_negotiate_ver0)
{
	struct memory_choice choice = {
		.task_filter = COREDUMP_MEMORY_ANON_PRIVATE |
			       COREDUMP_MEMORY_ANON_SHARED,
		.build = &server_build_ver0,
		.mask = COREDUMP_KERNEL,
		.memory_types = 0,
		.size_ack = COREDUMP_ACK_SIZE_VER0,
		.shared_dumped = true,
	};

	check_memory_dump(_metadata, self, &choice);
}

/*
 * A server built against this header takes every feature the kernel
 * offers, drops shared memory from what the task selected and adds the
 * ELF headers.
 */
TEST_F(coredump, socket_request_negotiate_ver1)
{
	struct memory_choice choice = {
		.task_filter = COREDUMP_MEMORY_ANON_PRIVATE |
			       COREDUMP_MEMORY_ANON_SHARED,
		.build = &server_build_ver1,
		.mask = COREDUMP_KERNEL | COREDUMP_RECORDS | COREDUMP_SPARSE |
			COREDUMP_MEMORY_TYPES,
		.memory_types = COREDUMP_MEMORY_ANON_PRIVATE |
				 COREDUMP_MEMORY_ELF_HEADERS,
		.size_ack = COREDUMP_ACK_SIZE_VER1,
		.shared_dumped = false,
	};

	check_memory_dump(_metadata, self, &choice);
}

/* An ack that picks none of KERNEL, USERSPACE and REJECT. */
TEST_F(coredump, socket_request_no_mode)
{
	struct refused_ack refused = {
		.ack = {
			.size = sizeof(struct coredump_ack),
			.mask = COREDUMP_WAIT,
		},
		.bytes = sizeof(struct coredump_ack),
		.mark = COREDUMP_MARK_CONFLICTING,
	};

	check_refused_ack(_metadata, self, &refused);
}

/* @spare must be zero, like every field that isn't in use. */
TEST_F(coredump, socket_request_spare)
{
	struct refused_ack refused = {
		.ack = {
			.size = sizeof(struct coredump_ack),
			.spare = 1,
			.mask = COREDUMP_KERNEL,
		},
		.bytes = sizeof(struct coredump_ack),
		.mark = COREDUMP_MARK_UNSUPPORTED,
	};

	check_refused_ack(_metadata, self, &refused);
}

/* An ack size is a byte count. One that ends inside a field is valid. */
#define ACK_SIZE_BETWEEN (COREDUMP_ACK_SIZE_VER0 + sizeof(__u32))

/* Any size from VER0 up to what the kernel accepts works without memory types. */
TEST_F(coredump, socket_request_ack_size_between)
{
	struct memory_choice choice = {
		.task_filter = COREDUMP_MEMORY_ANON_PRIVATE |
			       COREDUMP_MEMORY_ANON_SHARED,
		.mask = COREDUMP_KERNEL,
		.size_ack = ACK_SIZE_BETWEEN,
		.shared_dumped = true,
	};

	check_memory_dump(_metadata, self, &choice);
}

/* The memory types need the whole field, not the part that happens to fit. */
TEST_F(coredump, socket_request_memory_types_ack_size_between)
{
	struct refused_ack refused = {
		.ack = {
			.size = ACK_SIZE_BETWEEN,
			.mask = COREDUMP_KERNEL | COREDUMP_MEMORY_TYPES,
		},
		.bytes = ACK_SIZE_BETWEEN,
		.mark = COREDUMP_MARK_MINSIZE,
	};

	check_refused_ack(_metadata, self, &refused);
}

/* A server that hangs up without acking gets no marker and no coredump. */
TEST_F(coredump, socket_request_server_hangs_up)
{
	struct refused_ack refused = {
		.bytes = 0,
		.no_marker = true,
	};

	check_refused_ack(_metadata, self, &refused);
}

/* A server that hangs up in the middle of its ack looks the same. */
TEST_F(coredump, socket_request_ack_truncated)
{
	struct refused_ack refused = {
		.ack = {
			.size = COREDUMP_ACK_SIZE_VER0,
			.mask = COREDUMP_KERNEL,
		},
		.bytes = COREDUMP_ACK_SIZE_VER0 / 2,
		.no_marker = true,
	};

	check_refused_ack(_metadata, self, &refused);
}

/*
 * The kernels a server built against this header can't meet here:
 * negotiate() against their requests, no coredump involved.
 */

/* The request of a kernel with the first structs and features. */
static const struct coredump_req req_ver0 = {
	.size			= COREDUMP_REQ_SIZE_VER0,
	.size_ack		= COREDUMP_ACK_SIZE_VER0,
	.mask			= COREDUMP_KERNEL | COREDUMP_USERSPACE |
				  COREDUMP_REJECT | COREDUMP_WAIT,
};

/* The request of this kernel. */
static const struct coredump_req req_ver1 = {
	.size			= COREDUMP_REQ_SIZE_VER1,
	.size_ack		= COREDUMP_ACK_SIZE_VER1,
	.mask			= COREDUMP_KERNEL | COREDUMP_USERSPACE |
				  COREDUMP_REJECT | COREDUMP_WAIT |
				  COREDUMP_RECORDS | COREDUMP_SPARSE |
				  COREDUMP_MEMORY_TYPES,
	.memory_types		= COREDUMP_MEMORY_ANON_PRIVATE |
				  COREDUMP_MEMORY_ANON_SHARED,
	.memory_types_mask	= TEST_MEMORY_ALL,
};

/* A kernel with the first structs gets the first ack and nothing newer. */
TEST(negotiate_ver0_kernel)
{
	struct coredump_ack ack;

	negotiate(&req_ver0, &server_build_ver1, &ack);
	ASSERT_EQ(ack.size, COREDUMP_ACK_SIZE_VER0);
	ASSERT_EQ(ack.mask, COREDUMP_KERNEL);
	ASSERT_EQ(ack.memory_types, 0);
}

/* A kernel with records and sparse but the first structs: both, no types. */
TEST(negotiate_sparse_kernel)
{
	struct coredump_req req = req_ver0;
	struct coredump_ack ack;

	req.mask |= COREDUMP_RECORDS | COREDUMP_SPARSE;
	negotiate(&req, &server_build_ver1, &ack);
	ASSERT_EQ(ack.size, COREDUMP_ACK_SIZE_VER0);
	ASSERT_EQ(ack.mask, COREDUMP_KERNEL | COREDUMP_RECORDS | COREDUMP_SPARSE);
	ASSERT_EQ(ack.memory_types, 0);
}

/* Records without sparse: sparse isn't raised on its own. */
TEST(negotiate_records_without_sparse)
{
	struct coredump_req req = req_ver0;
	struct coredump_ack ack;

	req.mask |= COREDUMP_RECORDS;
	negotiate(&req, &server_build_ver1, &ack);
	ASSERT_EQ(ack.mask, COREDUMP_KERNEL | COREDUMP_RECORDS);
}

/*
 * A feature whose ack field lies past what the kernel accepts can't be
 * raised. No kernel offers the memory types without the room for them, so a
 * request that does stands in for a feature newer than this header.
 */
TEST(negotiate_types_need_room)
{
	struct coredump_req req = req_ver0;
	struct coredump_ack ack;

	req.mask |= COREDUMP_MEMORY_TYPES;
	negotiate(&req, &server_build_ver1, &ack);
	ASSERT_EQ(ack.size, COREDUMP_ACK_SIZE_VER0);
	ASSERT_EQ(ack.mask, COREDUMP_KERNEL);
	ASSERT_EQ(ack.memory_types, 0);
}

/* This kernel: the policy applied to the task's selection. */
TEST(negotiate_ver1_kernel)
{
	struct coredump_ack ack;

	negotiate(&req_ver1, &server_build_ver1, &ack);
	ASSERT_EQ(ack.size, COREDUMP_ACK_SIZE_VER1);
	ASSERT_EQ(ack.mask, COREDUMP_KERNEL | COREDUMP_RECORDS | COREDUMP_SPARSE |
			    COREDUMP_MEMORY_TYPES);
	ASSERT_EQ(ack.memory_types, COREDUMP_MEMORY_ANON_PRIVATE |
				     COREDUMP_MEMORY_ELF_HEADERS);
}

/* A kernel that doesn't know a type the policy adds isn't asked for it. */
TEST(negotiate_unknown_type)
{
	struct coredump_req req = req_ver1;
	struct coredump_ack ack;

	req.memory_types_mask &= ~(__u64)COREDUMP_MEMORY_ELF_HEADERS;
	negotiate(&req, &server_build_ver1, &ack);
	ASSERT_EQ(ack.mask, COREDUMP_KERNEL | COREDUMP_RECORDS | COREDUMP_SPARSE |
			    COREDUMP_MEMORY_TYPES);
	ASSERT_EQ(ack.memory_types, COREDUMP_MEMORY_ANON_PRIVATE);
}

TEST_HARNESS_MAIN