Unverified Commit 853ab1ff authored by Christian Brauner's avatar Christian Brauner
Browse files

selftests/pidfd: add first PIDFD_INFO_EXIT selftest 

Add a selftest for PIDFD_INFO_EXIT behavior.

Link: https://lore.kernel.org/r/20250305-work-pidfs-kill_on_last_close-v3-10-c8c3d8361705@kernel.org


Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent ddf53155

tools/testing/selftests/pidfd/.gitignore

+1 −0
Original line number Diff line number Diff line
@@ -8,3 +8,4 @@ pidfd_getfd_test 
pidfd_setns_test

pidfd_file_handle_test

pidfd_bind_mount

pidfd_info_test

tools/testing/selftests/pidfd/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -3,7 +3,7 @@ CFLAGS += -g $(KHDR_INCLUDES) -pthread -Wall 


TEST_GEN_PROGS := pidfd_test pidfd_fdinfo_test pidfd_open_test \

	pidfd_poll_test pidfd_wait pidfd_getfd_test pidfd_setns_test \

	pidfd_file_handle_test pidfd_bind_mount

	pidfd_file_handle_test pidfd_bind_mount pidfd_info_test



include ../lib.mk

tools/testing/selftests/pidfd/pidfd.h

+5 −1
Original line number Diff line number Diff line
@@ -127,6 +127,10 @@ 
#define PIDFD_INFO_CGROUPID		(1UL << 2) /* Always returned if available, even if not requested */

#endif



#ifndef PIDFD_INFO_EXIT

#define PIDFD_INFO_EXIT			(1UL << 3) /* Always returned if available, even if not requested */

#endif



struct pidfd_info {

	__u64 mask;

	__u64 cgroupid;
@@ -141,7 +145,7 @@ struct pidfd_info { 
	__u32 sgid;

	__u32 fsuid;

	__u32 fsgid;

	__u32 spare0[1];

	__s32 exit_code;

};



/*

tools/testing/selftests/pidfd/pidfd_info_test.c

0 → 100644
+146 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



#define _GNU_SOURCE

#include <errno.h>

#include <fcntl.h>

#include <limits.h>

#include <linux/types.h>

#include <poll.h>

#include <pthread.h>

#include <sched.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <syscall.h>

#include <sys/prctl.h>

#include <sys/wait.h>

#include <unistd.h>

#include <sys/socket.h>

#include <linux/kcmp.h>

#include <sys/stat.h>



#include "pidfd.h"

#include "../kselftest_harness.h"



FIXTURE(pidfd_info)

{

	pid_t child_pid1;

	int child_pidfd1;



	pid_t child_pid2;

	int child_pidfd2;



	pid_t child_pid3;

	int child_pidfd3;



	pid_t child_pid4;

	int child_pidfd4;

};



FIXTURE_SETUP(pidfd_info)

{

	int ret;

	int ipc_sockets[2];

	char c;



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

	EXPECT_EQ(ret, 0);



	self->child_pid1 = create_child(&self->child_pidfd1, 0);

	EXPECT_GE(self->child_pid1, 0);



	if (self->child_pid1 == 0) {

		close(ipc_sockets[0]);



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

			_exit(EXIT_FAILURE);



		close(ipc_sockets[1]);



		pause();

		_exit(EXIT_SUCCESS);

	}



	EXPECT_EQ(close(ipc_sockets[1]), 0);

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

	EXPECT_EQ(close(ipc_sockets[0]), 0);



	/* SIGKILL but don't reap. */

	EXPECT_EQ(sys_pidfd_send_signal(self->child_pidfd1, SIGKILL, NULL, 0), 0);



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

	EXPECT_EQ(ret, 0);



	self->child_pid2 = create_child(&self->child_pidfd2, 0);

	EXPECT_GE(self->child_pid2, 0);



	if (self->child_pid2 == 0) {

		close(ipc_sockets[0]);



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

			_exit(EXIT_FAILURE);



		close(ipc_sockets[1]);



		pause();

		_exit(EXIT_SUCCESS);

	}



	EXPECT_EQ(close(ipc_sockets[1]), 0);

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

	EXPECT_EQ(close(ipc_sockets[0]), 0);



	/* SIGKILL and reap. */

	EXPECT_EQ(sys_pidfd_send_signal(self->child_pidfd2, SIGKILL, NULL, 0), 0);

	EXPECT_EQ(sys_waitid(P_PID, self->child_pid2, NULL, WEXITED), 0);



	self->child_pid3 = create_child(&self->child_pidfd3, CLONE_NEWUSER | CLONE_NEWPID);

	EXPECT_GE(self->child_pid3, 0);



	if (self->child_pid3 == 0)

		_exit(EXIT_SUCCESS);



	self->child_pid4 = create_child(&self->child_pidfd4, CLONE_NEWUSER | CLONE_NEWPID);

	EXPECT_GE(self->child_pid4, 0);



	if (self->child_pid4 == 0)

		_exit(EXIT_SUCCESS);



	EXPECT_EQ(sys_waitid(P_PID, self->child_pid4, NULL, WEXITED), 0);

}



FIXTURE_TEARDOWN(pidfd_info)

{

	sys_pidfd_send_signal(self->child_pidfd1, SIGKILL, NULL, 0);

	if (self->child_pidfd1 >= 0)

		EXPECT_EQ(0, close(self->child_pidfd1));



	sys_waitid(P_PID, self->child_pid1, NULL, WEXITED);



	sys_pidfd_send_signal(self->child_pidfd2, SIGKILL, NULL, 0);

	if (self->child_pidfd2 >= 0)

		EXPECT_EQ(0, close(self->child_pidfd2));



	sys_waitid(P_PID, self->child_pid2, NULL, WEXITED);

	sys_waitid(P_PID, self->child_pid3, NULL, WEXITED);

	sys_waitid(P_PID, self->child_pid4, NULL, WEXITED);

}



TEST_F(pidfd_info, sigkill_exit)

{

	struct pidfd_info info = {

		.mask = PIDFD_INFO_CGROUPID,

	};



	/* Process has exited but not been reaped so this must work. */

	ASSERT_EQ(ioctl(self->child_pidfd1, PIDFD_GET_INFO, &info), 0);



	info.mask = PIDFD_INFO_CGROUPID | PIDFD_INFO_EXIT;

	ASSERT_EQ(ioctl(self->child_pidfd1, PIDFD_GET_INFO, &info), 0);

	ASSERT_TRUE(!!(info.mask & PIDFD_INFO_CREDS));

	/* Process has exited but not been reaped, so no PIDFD_INFO_EXIT information yet. */

	ASSERT_FALSE(!!(info.mask & PIDFD_INFO_EXIT));

}



TEST_HARNESS_MAIN