1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright 2022 Google LLC
*/
#define _GNU_SOURCE
#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include "util.h"
#include "../kselftest.h"
#ifndef __NR_pidfd_open
#define __NR_pidfd_open -1
#endif
#ifndef __NR_process_mrelease
#define __NR_process_mrelease -1
#endif
#define MB(x) (x << 20)
#define MAX_SIZE_MB 1024
static int alloc_noexit(unsigned long nr_pages, int pipefd)
{
int ppid = getppid();
int timeout = 10; /* 10sec timeout to get killed */
unsigned long i;
char *buf;
buf = (char *)mmap(NULL, nr_pages * PAGE_SIZE, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, 0, 0);
if (buf == MAP_FAILED) {
perror("mmap failed, halting the test");
return KSFT_FAIL;
}
for (i = 0; i < nr_pages; i++)
*((unsigned long *)(buf + (i * PAGE_SIZE))) = i;
/* Signal the parent that the child is ready */
if (write(pipefd, "", 1) < 0) {
perror("write");
return KSFT_FAIL;
}
/* Wait to be killed (when reparenting happens) */
while (getppid() == ppid && timeout > 0) {
sleep(1);
timeout--;
}
munmap(buf, nr_pages * PAGE_SIZE);
return (timeout > 0) ? KSFT_PASS : KSFT_FAIL;
}
/* The process_mrelease calls in this test are expected to fail */
static void run_negative_tests(int pidfd)
{
int res;
/* Test invalid flags. Expect to fail with EINVAL error code. */
if (!syscall(__NR_process_mrelease, pidfd, (unsigned int)-1) ||
errno != EINVAL) {
res = (errno == ENOSYS ? KSFT_SKIP : KSFT_FAIL);
perror("process_mrelease with wrong flags");
exit(res);
}
/*
* Test reaping while process is alive with no pending SIGKILL.
* Expect to fail with EINVAL error code.
*/
if (!syscall(__NR_process_mrelease, pidfd, 0) || errno != EINVAL) {
res = (errno == ENOSYS ? KSFT_SKIP : KSFT_FAIL);
perror("process_mrelease on a live process");
exit(res);
}
}
static int child_main(int pipefd[], size_t size)
{
int res;
/* Allocate and fault-in memory and wait to be killed */
close(pipefd[0]);
res = alloc_noexit(MB(size) / PAGE_SIZE, pipefd[1]);
close(pipefd[1]);
return res;
}
int main(void)
{
int pipefd[2], pidfd;
bool success, retry;
size_t size;
pid_t pid;
char byte;
int res;
/* Test a wrong pidfd */
if (!syscall(__NR_process_mrelease, -1, 0) || errno != EBADF) {
res = (errno == ENOSYS ? KSFT_SKIP : KSFT_FAIL);
perror("process_mrelease with wrong pidfd");
exit(res);
}
/* Start the test with 1MB child memory allocation */
size = 1;
retry:
/*
* Pipe for the child to signal when it's done allocating
* memory
*/
if (pipe(pipefd)) {
perror("pipe");
exit(KSFT_FAIL);
}
pid = fork();
if (pid < 0) {
perror("fork");
close(pipefd[0]);
close(pipefd[1]);
exit(KSFT_FAIL);
}
if (pid == 0) {
/* Child main routine */
res = child_main(pipefd, size);
exit(res);
}
/*
* Parent main routine:
* Wait for the child to finish allocations, then kill and reap
*/
close(pipefd[1]);
/* Block until the child is ready */
res = read(pipefd[0], &byte, 1);
close(pipefd[0]);
if (res < 0) {
perror("read");
if (!kill(pid, SIGKILL))
waitpid(pid, NULL, 0);
exit(KSFT_FAIL);
}
pidfd = syscall(__NR_pidfd_open, pid, 0);
if (pidfd < 0) {
perror("pidfd_open");
if (!kill(pid, SIGKILL))
waitpid(pid, NULL, 0);
exit(KSFT_FAIL);
}
/* Run negative tests which require a live child */
run_negative_tests(pidfd);
if (kill(pid, SIGKILL)) {
res = (errno == ENOSYS ? KSFT_SKIP : KSFT_FAIL);
perror("kill");
exit(res);
}
success = (syscall(__NR_process_mrelease, pidfd, 0) == 0);
if (!success) {
/*
* If we failed to reap because the child exited too soon,
* before we could call process_mrelease. Double child's memory
* which causes it to spend more time on cleanup and increases
* our chances of reaping its memory before it exits.
* Retry until we succeed or reach MAX_SIZE_MB.
*/
if (errno == ESRCH) {
retry = (size <= MAX_SIZE_MB);
} else {
res = (errno == ENOSYS ? KSFT_SKIP : KSFT_FAIL);
perror("process_mrelease");
waitpid(pid, NULL, 0);
exit(res);
}
}
/* Cleanup to prevent zombies */
if (waitpid(pid, NULL, 0) < 0) {
perror("waitpid");
exit(KSFT_FAIL);
}
close(pidfd);
if (!success) {
if (retry) {
size *= 2;
goto retry;
}
printf("All process_mrelease attempts failed!\n");
exit(KSFT_FAIL);
}
printf("Success reaping a child with %zuMB of memory allocations\n",
size);
return KSFT_PASS;
}
|
