tests: add pidfd poll tests (aed5a8df) · Commits · 戴 / test

tools/testing/selftests/pidfd/.gitignore

+1 −0

Original line number	Diff line number	Diff line
		pidfd_open_test
		pidfd_poll_test
		pidfd_test
		pidfd_wait

tools/testing/selftests/pidfd/Makefile

+1 −1

Original line number	Diff line number	Diff line
		# SPDX-License-Identifier: GPL-2.0-only
		CFLAGS += -g -I../../../../usr/include/ -lpthread

		TEST_GEN_PROGS := pidfd_test pidfd_open_test pidfd_wait
		TEST_GEN_PROGS := pidfd_test pidfd_open_test pidfd_poll_test pidfd_wait

		include ../lib.mk

tools/testing/selftests/pidfd/pidfd_poll_test.c

0 → 100644

+117 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0

		#define _GNU_SOURCE
		#include <errno.h>
		#include <linux/types.h>
		#include <linux/wait.h>
		#include <poll.h>
		#include <signal.h>
		#include <stdbool.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <syscall.h>
		#include <sys/wait.h>
		#include <unistd.h>

		#include "pidfd.h"
		#include "../kselftest.h"

		static bool timeout;

		static void handle_alarm(int sig)
		{
		timeout = true;
		}

		int main(int argc, char **argv)
		{
		struct pollfd fds;
		int iter, nevents;
		int nr_iterations = 10000;

		fds.events = POLLIN;

		if (argc > 2)
		ksft_exit_fail_msg("Unexpected command line argument\n");

		if (argc == 2) {
		nr_iterations = atoi(argv[1]);
		if (nr_iterations <= 0)
		ksft_exit_fail_msg("invalid input parameter %s\n",
		argv[1]);
		}

		ksft_print_msg("running pidfd poll test for %d iterations\n",
		nr_iterations);

		for (iter = 0; iter < nr_iterations; iter++) {
		int pidfd;
		int child_pid = fork();

		if (child_pid < 0) {
		if (errno == EAGAIN) {
		iter--;
		continue;
		}
		ksft_exit_fail_msg(
		"%s - failed to fork a child process\n",
		strerror(errno));
		}

		if (child_pid == 0) {
		/* Child process just sleeps for a min and exits */
		sleep(60);
		exit(EXIT_SUCCESS);
		}

		/* Parent kills the child and waits for its death */
		pidfd = sys_pidfd_open(child_pid, 0);
		if (pidfd < 0)
		ksft_exit_fail_msg("%s - pidfd_open failed\n",
		strerror(errno));

		/* Setup 3 sec alarm - plenty of time */
		if (signal(SIGALRM, handle_alarm) == SIG_ERR)
		ksft_exit_fail_msg("%s - signal failed\n",
		strerror(errno));
		alarm(3);

		/* Send SIGKILL to the child */
		if (sys_pidfd_send_signal(pidfd, SIGKILL, NULL, 0))
		ksft_exit_fail_msg("%s - pidfd_send_signal failed\n",
		strerror(errno));

		/* Wait for the death notification */
		fds.fd = pidfd;
		nevents = poll(&fds, 1, -1);

		/* Check for error conditions */
		if (nevents < 0)
		ksft_exit_fail_msg("%s - poll failed\n",
		strerror(errno));

		if (nevents != 1)
		ksft_exit_fail_msg("unexpected poll result: %d\n",
		nevents);

		if (!(fds.revents & POLLIN))
		ksft_exit_fail_msg(
		"unexpected event type received: 0x%x\n",
		fds.revents);

		if (timeout)
		ksft_exit_fail_msg(
		"death notification wait timeout\n");

		close(pidfd);
		/* Wait for child to prevent zombies */
		if (waitpid(child_pid, NULL, 0) < 0)
		ksft_exit_fail_msg("%s - waitpid failed\n",
		strerror(errno));

		}

		ksft_test_result_pass("pidfd poll test: pass\n");
		return ksft_exit_pass();
		}

Admin message