mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2025-01-07 06:14:24 +08:00
4cbd93c3c1
When running the pidfd_fdinfo_test on arm64, it fails for me. After some digging, the reason is that the child exits due to SIGBUS, because it overflows the 1024 byte stack we've reserved for it. To fix the issue, increase the stack size to 8192 bytes (this number is somewhat arbitrary, and was arrived at through experimentation -- I kept doubling until the failure no longer occurred). Also, let's make the issue easier to debug. wait_for_pid() returns an ambiguous value: it may return -1 in all of these cases: 1. waitpid() itself returned -1 2. waitpid() returned success, but we found !WIFEXITED(status). 3. The child process exited, but it did so with a -1 exit code. There's no way for the caller to tell the difference. So, at least log which occurred, so the test runner can debug things. While debugging this, I found that we had !WIFEXITED(), because the child exited due to a signal. This seems like a reasonably common case, so also print out whether or not we have WIFSIGNALED(), and the associated WTERMSIG() (if any). This lets us see the SIGBUS I'm fixing clearly when it occurs. Finally, I'm suspicious of allocating the child's stack on our stack. man clone(2) suggests that the correct way to do this is with mmap(), and in particular by setting MAP_STACK. So, switch to doing it that way instead. Signed-off-by: Axel Rasmussen <axelrasmussen@google.com> Acked-by: Christian Brauner <brauner@kernel.org> Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>
119 lines
2.4 KiB
C
119 lines
2.4 KiB
C
/* 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 <sys/types.h>
|
|
#include <sys/wait.h>
|
|
|
|
#include "../kselftest.h"
|
|
|
|
#ifndef P_PIDFD
|
|
#define P_PIDFD 3
|
|
#endif
|
|
|
|
#ifndef CLONE_NEWTIME
|
|
#define CLONE_NEWTIME 0x00000080
|
|
#endif
|
|
|
|
#ifndef CLONE_PIDFD
|
|
#define CLONE_PIDFD 0x00001000
|
|
#endif
|
|
|
|
#ifndef __NR_pidfd_open
|
|
#define __NR_pidfd_open -1
|
|
#endif
|
|
|
|
#ifndef __NR_pidfd_send_signal
|
|
#define __NR_pidfd_send_signal -1
|
|
#endif
|
|
|
|
#ifndef __NR_clone3
|
|
#define __NR_clone3 -1
|
|
#endif
|
|
|
|
#ifndef __NR_pidfd_getfd
|
|
#define __NR_pidfd_getfd -1
|
|
#endif
|
|
|
|
#ifndef PIDFD_NONBLOCK
|
|
#define PIDFD_NONBLOCK O_NONBLOCK
|
|
#endif
|
|
|
|
/*
|
|
* 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
|
|
|
|
static inline int wait_for_pid(pid_t pid)
|
|
{
|
|
int status, ret;
|
|
|
|
again:
|
|
ret = waitpid(pid, &status, 0);
|
|
if (ret == -1) {
|
|
if (errno == EINTR)
|
|
goto again;
|
|
|
|
ksft_print_msg("waitpid returned -1, errno=%d\n", errno);
|
|
return -1;
|
|
}
|
|
|
|
if (!WIFEXITED(status)) {
|
|
ksft_print_msg(
|
|
"waitpid !WIFEXITED, WIFSIGNALED=%d, WTERMSIG=%d\n",
|
|
WIFSIGNALED(status), WTERMSIG(status));
|
|
return -1;
|
|
}
|
|
|
|
ret = WEXITSTATUS(status);
|
|
ksft_print_msg("waitpid WEXITSTATUS=%d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
static inline int sys_pidfd_open(pid_t pid, unsigned int flags)
|
|
{
|
|
return syscall(__NR_pidfd_open, pid, flags);
|
|
}
|
|
|
|
static inline int sys_pidfd_send_signal(int pidfd, int sig, siginfo_t *info,
|
|
unsigned int flags)
|
|
{
|
|
return syscall(__NR_pidfd_send_signal, pidfd, sig, info, flags);
|
|
}
|
|
|
|
static inline int sys_pidfd_getfd(int pidfd, int fd, int flags)
|
|
{
|
|
return syscall(__NR_pidfd_getfd, pidfd, fd, flags);
|
|
}
|
|
|
|
static inline int sys_memfd_create(const char *name, unsigned int flags)
|
|
{
|
|
return syscall(__NR_memfd_create, name, flags);
|
|
}
|
|
|
|
#endif /* __PIDFD_H */
|