Unverified Commit 172bb24a authored by Christian Brauner's avatar Christian Brauner
Browse files

tests: add pidfd_open() tests 



This adds testing for the new pidfd_open() syscalls. Specifically, we test:
- that no invalid flags can be passed to pidfd_open()
- that no invalid pid can be passed to pidfd_open()
- that a pidfd can be retrieved with pidfd_open()
- that the retrieved pidfd references the correct pid

Signed-off-by: default avatarChristian Brauner <christian@brauner.io>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Joel Fernandes (Google) <joel@joelfernandes.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Jann Horn <jannh@google.com>
Cc: David Howells <dhowells@redhat.com>
Cc: "Michael Kerrisk (man-pages)" <mtk.manpages@gmail.com>
Cc: Andy Lutomirsky <luto@kernel.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-api@vger.kernel.org
parent 7615d9e1

tools/testing/selftests/pidfd/.gitignore

+1 −0
Original line number Diff line number Diff line 
pidfd_open_test

pidfd_test

tools/testing/selftests/pidfd/Makefile

+2 −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

TEST_GEN_PROGS := pidfd_test pidfd_open_test



include ../lib.mk

tools/testing/selftests/pidfd/pidfd.h

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



#ifndef __PIDFD_H

#define __PIDFD_H



#define _GNU_SOURCE

#include <errno.h>

#include <fcntl.h>

#include <sched.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <syscall.h>

#include <sys/mount.h>



#include "../kselftest.h"



/*

 * The kernel reserves 300 pids via RESERVED_PIDS in kernel/pid.c

 * That means, when it wraps around any pid < 300 will be skipped.

 * So we need to use a pid > 300 in order to test recycling.

 */

#define PID_RECYCLE 1000



/*

 * Define a few custom error codes for the child process to clearly indicate

 * what is happening. This way we can tell the difference between a system

 * error, a test error, etc.

 */

#define PIDFD_PASS 0

#define PIDFD_FAIL 1

#define PIDFD_ERROR 2

#define PIDFD_SKIP 3

#define PIDFD_XFAIL 4



int wait_for_pid(pid_t pid)

{

	int status, ret;



again:

	ret = waitpid(pid, &status, 0);

	if (ret == -1) {

		if (errno == EINTR)

			goto again;



		return -1;

	}



	if (!WIFEXITED(status))

		return -1;



	return WEXITSTATUS(status);

}





#endif /* __PIDFD_H */

tools/testing/selftests/pidfd/pidfd_open_test.c

0 → 100644
+169 −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 <inttypes.h>

#include <limits.h>

#include <linux/types.h>

#include <linux/wait.h>

#include <sched.h>

#include <signal.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <syscall.h>

#include <sys/mount.h>

#include <sys/prctl.h>

#include <sys/wait.h>

#include <unistd.h>



#include "pidfd.h"

#include "../kselftest.h"



static inline int sys_pidfd_open(pid_t pid, unsigned int flags)

{

	return syscall(__NR_pidfd_open, pid, flags);

}



static int safe_int(const char *numstr, int *converted)

{

	char *err = NULL;

	long sli;



	errno = 0;

	sli = strtol(numstr, &err, 0);

	if (errno == ERANGE && (sli == LONG_MAX || sli == LONG_MIN))

		return -ERANGE;



	if (errno != 0 && sli == 0)

		return -EINVAL;



	if (err == numstr || *err != '\0')

		return -EINVAL;



	if (sli > INT_MAX || sli < INT_MIN)

		return -ERANGE;



	*converted = (int)sli;

	return 0;

}



static int char_left_gc(const char *buffer, size_t len)

{

	size_t i;



	for (i = 0; i < len; i++) {

		if (buffer[i] == ' ' ||

		    buffer[i] == '\t')

			continue;



		return i;

	}



	return 0;

}



static int char_right_gc(const char *buffer, size_t len)

{

	int i;



	for (i = len - 1; i >= 0; i--) {

		if (buffer[i] == ' '  ||

		    buffer[i] == '\t' ||

		    buffer[i] == '\n' ||

		    buffer[i] == '\0')

			continue;



		return i + 1;

	}



	return 0;

}



static char *trim_whitespace_in_place(char *buffer)

{

	buffer += char_left_gc(buffer, strlen(buffer));

	buffer[char_right_gc(buffer, strlen(buffer))] = '\0';

	return buffer;

}



static pid_t get_pid_from_fdinfo_file(int pidfd, const char *key, size_t keylen)

{

	int ret;

	char path[512];

	FILE *f;

	size_t n = 0;

	pid_t result = -1;

	char *line = NULL;



	snprintf(path, sizeof(path), "/proc/self/fdinfo/%d", pidfd);



	f = fopen(path, "re");

	if (!f)

		return -1;



	while (getline(&line, &n, f) != -1) {

		char *numstr;



		if (strncmp(line, key, keylen))

			continue;



		numstr = trim_whitespace_in_place(line + 4);

		ret = safe_int(numstr, &result);

		if (ret < 0)

			goto out;



		break;

	}



out:

	free(line);

	fclose(f);

	return result;

}



int main(int argc, char **argv)

{

	int pidfd = -1, ret = 1;

	pid_t pid;



	ksft_set_plan(3);



	pidfd = sys_pidfd_open(-1, 0);

	if (pidfd >= 0) {

		ksft_print_msg(

			"%s - succeeded to open pidfd for invalid pid -1\n",

			strerror(errno));

		goto on_error;

	}

	ksft_test_result_pass("do not allow invalid pid test: passed\n");



	pidfd = sys_pidfd_open(getpid(), 1);

	if (pidfd >= 0) {

		ksft_print_msg(

			"%s - succeeded to open pidfd with invalid flag value specified\n",

			strerror(errno));

		goto on_error;

	}

	ksft_test_result_pass("do not allow invalid flag test: passed\n");



	pidfd = sys_pidfd_open(getpid(), 0);

	if (pidfd < 0) {

		ksft_print_msg("%s - failed to open pidfd\n", strerror(errno));

		goto on_error;

	}

	ksft_test_result_pass("open a new pidfd test: passed\n");



	pid = get_pid_from_fdinfo_file(pidfd, "Pid:", sizeof("Pid:") - 1);

	ksft_print_msg("pidfd %d refers to process with pid %d\n", pidfd, pid);



	ret = 0;



on_error:

	if (pidfd >= 0)

		close(pidfd);



	return !ret ? ksft_exit_pass() : ksft_exit_fail();

}

tools/testing/selftests/pidfd/pidfd_test.c

+5 −43
Original line number Diff line number Diff line
@@ -18,16 +18,18 @@ 
#include <time.h>

#include <unistd.h>



#include "pidfd.h"

#include "../kselftest.h"



#ifndef __NR_pidfd_send_signal

#define __NR_pidfd_send_signal -1

#endif



#define str(s) _str(s)

#define _str(s) #s

#define CHILD_THREAD_MIN_WAIT 3 /* seconds */



#define MAX_EVENTS 5

#ifndef __NR_pidfd_send_signal

#define __NR_pidfd_send_signal 424

#endif



#ifndef CLONE_PIDFD

#define CLONE_PIDFD 0x00001000
@@ -91,28 +93,6 @@ static int test_pidfd_send_signal_simple_success(void) 
	return 0;

}



static int wait_for_pid(pid_t pid)

{

	int status, ret;



again:

	ret = waitpid(pid, &status, 0);

	if (ret == -1) {

		if (errno == EINTR)

			goto again;



		return -1;

	}



	if (ret != pid)

		goto again;



	if (!WIFEXITED(status))

		return -1;



	return WEXITSTATUS(status);

}



static int test_pidfd_send_signal_exited_fail(void)

{

	int pidfd, ret, saved_errno;
@@ -157,13 +137,6 @@ static int test_pidfd_send_signal_exited_fail(void) 
	return 0;

}



/*

 * The kernel reserves 300 pids via RESERVED_PIDS in kernel/pid.c

 * That means, when it wraps around any pid < 300 will be skipped.

 * So we need to use a pid > 300 in order to test recycling.

 */

#define PID_RECYCLE 1000



/*

 * Maximum number of cycles we allow. This is equivalent to PID_MAX_DEFAULT.

 * If users set a higher limit or we have cycled PIDFD_MAX_DEFAULT number of
@@ -172,17 +145,6 @@ static int test_pidfd_send_signal_exited_fail(void) 
 */

#define PIDFD_MAX_DEFAULT 0x8000



/*

 * Define a few custom error codes for the child process to clearly indicate

 * what is happening. This way we can tell the difference between a system

 * error, a test error, etc.

 */

#define PIDFD_PASS 0

#define PIDFD_FAIL 1

#define PIDFD_ERROR 2

#define PIDFD_SKIP 3

#define PIDFD_XFAIL 4



static int test_pidfd_send_signal_recycled_pid_fail(void)

{

	int i, ret;

CRA Git | Maintained and supported by SUSTech CRA and CCSE