reaper.c revision 310558
150472Speter/*- 238738Sbrian * Copyright (c) 2016 Jilles Tjoelker 337Srgrimes * All rights reserved. 437Srgrimes * 537Srgrimes * Redistribution and use in source and binary forms, with or without 637Srgrimes * modification, are permitted provided that the following conditions 737Srgrimes * are met: 8121309Simp * 1. Redistributions of source code must retain the above copyright 9121309Simp * notice, this list of conditions and the following disclaimer. 10121309Simp * 2. Redistributions in binary form must reproduce the above copyright 11121309Simp * notice, this list of conditions and the following disclaimer in the 1237Srgrimes * documentation and/or other materials provided with the distribution. 1337Srgrimes * 14121309Simp * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15121309Simp * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16121309Simp * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17121309Simp * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18121309Simp * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1937Srgrimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2037Srgrimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2137Srgrimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2237Srgrimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23130151Sschweikh * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24121309Simp * SUCH DAMAGE. 25121309Simp */ 26121309Simp 27121309Simp#include <sys/cdefs.h> 28292Salm__FBSDID("$FreeBSD: stable/10/tests/sys/kern/reaper.c 310558 2016-12-25 22:32:16Z jilles $"); 2937Srgrimes 30121309Simp#include <sys/procctl.h> 31121309Simp#include <sys/wait.h> 32121309Simp 33121309Simp#include <atf-c.h> 3437Srgrimes#include <errno.h> 35292Salm#include <signal.h> 36121309Simp#include <unistd.h> 37121309Simp 38292SalmATF_TC_WITHOUT_HEAD(reaper_wait_child_first); 39121309SimpATF_TC_BODY(reaper_wait_child_first, tc) 40121309Simp{ 41121309Simp pid_t parent, child, grandchild, pid; 42121309Simp int status, r; 43121309Simp int pip[2]; 44121309Simp 45121309Simp /* Be paranoid. */ 46121309Simp pid = waitpid(-1, NULL, WNOHANG); 47121309Simp ATF_REQUIRE(pid == -1 && errno == ECHILD); 48121309Simp 49121309Simp parent = getpid(); 50121309Simp r = procctl(P_PID, parent, PROC_REAP_ACQUIRE, NULL); 51121309Simp ATF_REQUIRE_EQ(0, r); 52121309Simp 53121309Simp r = pipe(pip); 54121309Simp ATF_REQUIRE_EQ(0, r); 55180615Smarcel 5637Srgrimes child = fork(); 5737Srgrimes ATF_REQUIRE(child != -1); 58180615Smarcel if (child == 0) { 5972809Snik if (close(pip[1]) != 0) 6072809Snik _exit(100); 61180680Smarcel grandchild = fork(); 62180680Smarcel if (grandchild == -1) 63180680Smarcel _exit(101); 64180680Smarcel else if (grandchild == 0) { 65180680Smarcel if (read(pip[0], &(uint8_t){ 0 }, 1) != 0) 66180680Smarcel _exit(102); 67180680Smarcel if (getppid() != parent) 68180680Smarcel _exit(103); 69184352Sthompsa _exit(2); 70184352Sthompsa } else 71184352Sthompsa _exit(3); 72184352Sthompsa } 73184352Sthompsa 74184352Sthompsa pid = waitpid(child, &status, 0); 75184352Sthompsa ATF_REQUIRE_EQ(child, pid); 76184352Sthompsa r = WIFEXITED(status) ? WEXITSTATUS(status) : -1; 77 ATF_CHECK_EQ(3, r); 78 79 r = close(pip[1]); 80 ATF_REQUIRE_EQ(0, r); 81 82 pid = waitpid(-1, &status, 0); 83 ATF_REQUIRE(pid > 0 && pid != child); 84 r = WIFEXITED(status) ? WEXITSTATUS(status) : -1; 85 ATF_CHECK_EQ(2, r); 86 87 r = close(pip[0]); 88 ATF_REQUIRE_EQ(0, r); 89} 90 91ATF_TC_WITHOUT_HEAD(reaper_wait_grandchild_first); 92ATF_TC_BODY(reaper_wait_grandchild_first, tc) 93{ 94 pid_t parent, child, grandchild, pid; 95 int status, r; 96 97 /* Be paranoid. */ 98 pid = waitpid(-1, NULL, WNOHANG); 99 ATF_REQUIRE(pid == -1 && errno == ECHILD); 100 101 parent = getpid(); 102 r = procctl(P_PID, parent, PROC_REAP_ACQUIRE, NULL); 103 ATF_REQUIRE_EQ(0, r); 104 105 child = fork(); 106 ATF_REQUIRE(child != -1); 107 if (child == 0) { 108 grandchild = fork(); 109 if (grandchild == -1) 110 _exit(101); 111 else if (grandchild == 0) 112 _exit(2); 113 else { 114 if (waitid(P_PID, grandchild, NULL, 115 WNOWAIT | WEXITED) != 0) 116 _exit(102); 117 _exit(3); 118 } 119 } 120 121 pid = waitpid(child, &status, 0); 122 ATF_REQUIRE_EQ(child, pid); 123 r = WIFEXITED(status) ? WEXITSTATUS(status) : -1; 124 ATF_CHECK_EQ(3, r); 125 126 pid = waitpid(-1, &status, 0); 127 ATF_REQUIRE(pid > 0 && pid != child); 128 r = WIFEXITED(status) ? WEXITSTATUS(status) : -1; 129 ATF_CHECK_EQ(2, r); 130} 131 132ATF_TC_WITHOUT_HEAD(reaper_status); 133ATF_TC_BODY(reaper_status, tc) 134{ 135 struct procctl_reaper_status st; 136 ssize_t sr; 137 pid_t parent, child, pid; 138 int r, status; 139 int pip[2]; 140 141 parent = getpid(); 142 r = procctl(P_PID, parent, PROC_REAP_STATUS, &st); 143 ATF_REQUIRE_EQ(0, r); 144 ATF_CHECK_EQ(0, st.rs_flags & REAPER_STATUS_OWNED); 145 ATF_CHECK(st.rs_children > 0); 146 ATF_CHECK(st.rs_descendants > 0); 147 ATF_CHECK(st.rs_descendants >= st.rs_children); 148 ATF_CHECK(st.rs_reaper != parent); 149 ATF_CHECK(st.rs_reaper > 0); 150 151 r = procctl(P_PID, parent, PROC_REAP_ACQUIRE, NULL); 152 ATF_REQUIRE_EQ(0, r); 153 154 r = procctl(P_PID, parent, PROC_REAP_STATUS, &st); 155 ATF_REQUIRE_EQ(0, r); 156 ATF_CHECK_EQ(REAPER_STATUS_OWNED, 157 st.rs_flags & (REAPER_STATUS_OWNED | REAPER_STATUS_REALINIT)); 158 ATF_CHECK_EQ(0, st.rs_children); 159 ATF_CHECK_EQ(0, st.rs_descendants); 160 ATF_CHECK(st.rs_reaper == parent); 161 ATF_CHECK_EQ(-1, st.rs_pid); 162 163 r = pipe(pip); 164 ATF_REQUIRE_EQ(0, r); 165 child = fork(); 166 ATF_REQUIRE(child != -1); 167 if (child == 0) { 168 if (close(pip[0]) != 0) 169 _exit(100); 170 if (procctl(P_PID, parent, PROC_REAP_STATUS, &st) != 0) 171 _exit(101); 172 if (write(pip[1], &st, sizeof(st)) != (ssize_t)sizeof(st)) 173 _exit(102); 174 if (procctl(P_PID, getpid(), PROC_REAP_STATUS, &st) != 0) 175 _exit(103); 176 if (write(pip[1], &st, sizeof(st)) != (ssize_t)sizeof(st)) 177 _exit(104); 178 _exit(0); 179 } 180 r = close(pip[1]); 181 ATF_REQUIRE_EQ(0, r); 182 183 sr = read(pip[0], &st, sizeof(st)); 184 ATF_REQUIRE_EQ((ssize_t)sizeof(st), sr); 185 ATF_CHECK_EQ(REAPER_STATUS_OWNED, 186 st.rs_flags & (REAPER_STATUS_OWNED | REAPER_STATUS_REALINIT)); 187 ATF_CHECK_EQ(1, st.rs_children); 188 ATF_CHECK_EQ(1, st.rs_descendants); 189 ATF_CHECK(st.rs_reaper == parent); 190 ATF_CHECK_EQ(child, st.rs_pid); 191 sr = read(pip[0], &st, sizeof(st)); 192 ATF_REQUIRE_EQ((ssize_t)sizeof(st), sr); 193 ATF_CHECK_EQ(0, 194 st.rs_flags & (REAPER_STATUS_OWNED | REAPER_STATUS_REALINIT)); 195 ATF_CHECK_EQ(1, st.rs_children); 196 ATF_CHECK_EQ(1, st.rs_descendants); 197 ATF_CHECK(st.rs_reaper == parent); 198 ATF_CHECK_EQ(child, st.rs_pid); 199 200 r = close(pip[0]); 201 ATF_REQUIRE_EQ(0, r); 202 pid = waitpid(child, &status, 0); 203 ATF_REQUIRE_EQ(child, pid); 204 ATF_CHECK_EQ(0, status); 205 206 r = procctl(P_PID, parent, PROC_REAP_STATUS, &st); 207 ATF_REQUIRE_EQ(0, r); 208 ATF_CHECK_EQ(REAPER_STATUS_OWNED, 209 st.rs_flags & (REAPER_STATUS_OWNED | REAPER_STATUS_REALINIT)); 210 ATF_CHECK_EQ(0, st.rs_children); 211 ATF_CHECK_EQ(0, st.rs_descendants); 212 ATF_CHECK(st.rs_reaper == parent); 213 ATF_CHECK_EQ(-1, st.rs_pid); 214} 215 216ATF_TC_WITHOUT_HEAD(reaper_getpids); 217ATF_TC_BODY(reaper_getpids, tc) 218{ 219 struct procctl_reaper_pidinfo info[10]; 220 ssize_t sr; 221 pid_t parent, child, grandchild, pid; 222 int r, status, childidx; 223 int pipa[2], pipb[2]; 224 225 parent = getpid(); 226 r = procctl(P_PID, parent, PROC_REAP_ACQUIRE, NULL); 227 ATF_REQUIRE_EQ(0, r); 228 229 memset(info, '\0', sizeof(info)); 230 r = procctl(P_PID, parent, PROC_REAP_GETPIDS, 231 &(struct procctl_reaper_pids){ 232 .rp_count = sizeof(info) / sizeof(info[0]), 233 .rp_pids = info 234 }); 235 ATF_CHECK_EQ(0, r); 236 ATF_CHECK_EQ(0, info[0].pi_flags & REAPER_PIDINFO_VALID); 237 238 r = pipe(pipa); 239 ATF_REQUIRE_EQ(0, r); 240 r = pipe(pipb); 241 ATF_REQUIRE_EQ(0, r); 242 child = fork(); 243 ATF_REQUIRE(child != -1); 244 if (child == 0) { 245 if (close(pipa[1]) != 0) 246 _exit(100); 247 if (close(pipb[0]) != 0) 248 _exit(100); 249 if (read(pipa[0], &(uint8_t){ 0 }, 1) != 1) 250 _exit(101); 251 grandchild = fork(); 252 if (grandchild == -1) 253 _exit(102); 254 if (grandchild == 0) { 255 if (write(pipb[1], &(uint8_t){ 0 }, 1) != 1) 256 _exit(103); 257 if (read(pipa[0], &(uint8_t){ 0 }, 1) != 1) 258 _exit(104); 259 _exit(0); 260 } 261 for (;;) 262 pause(); 263 } 264 r = close(pipa[0]); 265 ATF_REQUIRE_EQ(0, r); 266 r = close(pipb[1]); 267 ATF_REQUIRE_EQ(0, r); 268 269 memset(info, '\0', sizeof(info)); 270 r = procctl(P_PID, parent, PROC_REAP_GETPIDS, 271 &(struct procctl_reaper_pids){ 272 .rp_count = sizeof(info) / sizeof(info[0]), 273 .rp_pids = info 274 }); 275 ATF_CHECK_EQ(0, r); 276 ATF_CHECK_EQ(REAPER_PIDINFO_VALID | REAPER_PIDINFO_CHILD, 277 info[0].pi_flags & (REAPER_PIDINFO_VALID | REAPER_PIDINFO_CHILD)); 278 ATF_CHECK_EQ(child, info[0].pi_pid); 279 ATF_CHECK_EQ(child, info[0].pi_subtree); 280 ATF_CHECK_EQ(0, info[1].pi_flags & REAPER_PIDINFO_VALID); 281 282 sr = write(pipa[1], &(uint8_t){ 0 }, 1); 283 ATF_REQUIRE_EQ(1, sr); 284 sr = read(pipb[0], &(uint8_t){ 0 }, 1); 285 ATF_REQUIRE_EQ(1, sr); 286 287 memset(info, '\0', sizeof(info)); 288 r = procctl(P_PID, parent, PROC_REAP_GETPIDS, 289 &(struct procctl_reaper_pids){ 290 .rp_count = sizeof(info) / sizeof(info[0]), 291 .rp_pids = info 292 }); 293 ATF_CHECK_EQ(0, r); 294 ATF_CHECK_EQ(REAPER_PIDINFO_VALID, 295 info[0].pi_flags & REAPER_PIDINFO_VALID); 296 ATF_CHECK_EQ(REAPER_PIDINFO_VALID, 297 info[1].pi_flags & REAPER_PIDINFO_VALID); 298 ATF_CHECK_EQ(0, info[2].pi_flags & REAPER_PIDINFO_VALID); 299 ATF_CHECK_EQ(child, info[0].pi_subtree); 300 ATF_CHECK_EQ(child, info[1].pi_subtree); 301 childidx = info[1].pi_pid == child ? 1 : 0; 302 ATF_CHECK_EQ(REAPER_PIDINFO_CHILD, 303 info[childidx].pi_flags & REAPER_PIDINFO_CHILD); 304 ATF_CHECK_EQ(0, info[childidx ^ 1].pi_flags & REAPER_PIDINFO_CHILD); 305 ATF_CHECK(info[childidx].pi_pid == child); 306 grandchild = info[childidx ^ 1].pi_pid; 307 ATF_CHECK(grandchild > 0); 308 ATF_CHECK(grandchild != child); 309 ATF_CHECK(grandchild != parent); 310 311 r = kill(child, SIGTERM); 312 ATF_REQUIRE_EQ(0, r); 313 314 pid = waitpid(child, &status, 0); 315 ATF_REQUIRE_EQ(child, pid); 316 ATF_CHECK(WIFSIGNALED(status) && WTERMSIG(status) == SIGTERM); 317 318 memset(info, '\0', sizeof(info)); 319 r = procctl(P_PID, parent, PROC_REAP_GETPIDS, 320 &(struct procctl_reaper_pids){ 321 .rp_count = sizeof(info) / sizeof(info[0]), 322 .rp_pids = info 323 }); 324 ATF_CHECK_EQ(0, r); 325 ATF_CHECK_EQ(REAPER_PIDINFO_VALID, 326 info[0].pi_flags & REAPER_PIDINFO_VALID); 327 ATF_CHECK_EQ(0, info[1].pi_flags & REAPER_PIDINFO_VALID); 328 ATF_CHECK_EQ(child, info[0].pi_subtree); 329 ATF_CHECK_EQ(REAPER_PIDINFO_CHILD, 330 info[0].pi_flags & REAPER_PIDINFO_CHILD); 331 ATF_CHECK_EQ(grandchild, info[0].pi_pid); 332 333 sr = write(pipa[1], &(uint8_t){ 0 }, 1); 334 ATF_REQUIRE_EQ(1, sr); 335 336 memset(info, '\0', sizeof(info)); 337 r = procctl(P_PID, parent, PROC_REAP_GETPIDS, 338 &(struct procctl_reaper_pids){ 339 .rp_count = sizeof(info) / sizeof(info[0]), 340 .rp_pids = info 341 }); 342 ATF_CHECK_EQ(0, r); 343 ATF_CHECK_EQ(REAPER_PIDINFO_VALID, 344 info[0].pi_flags & REAPER_PIDINFO_VALID); 345 ATF_CHECK_EQ(0, info[1].pi_flags & REAPER_PIDINFO_VALID); 346 ATF_CHECK_EQ(child, info[0].pi_subtree); 347 ATF_CHECK_EQ(REAPER_PIDINFO_CHILD, 348 info[0].pi_flags & REAPER_PIDINFO_CHILD); 349 ATF_CHECK_EQ(grandchild, info[0].pi_pid); 350 351 pid = waitpid(grandchild, &status, 0); 352 ATF_REQUIRE_EQ(grandchild, pid); 353 ATF_CHECK_EQ(0, status); 354 355 memset(info, '\0', sizeof(info)); 356 r = procctl(P_PID, parent, PROC_REAP_GETPIDS, 357 &(struct procctl_reaper_pids){ 358 .rp_count = sizeof(info) / sizeof(info[0]), 359 .rp_pids = info 360 }); 361 ATF_CHECK_EQ(0, r); 362 ATF_CHECK_EQ(0, info[0].pi_flags & REAPER_PIDINFO_VALID); 363 364 r = close(pipa[1]); 365 ATF_REQUIRE_EQ(0, r); 366 r = close(pipb[0]); 367 ATF_REQUIRE_EQ(0, r); 368} 369 370ATF_TC_WITHOUT_HEAD(reaper_kill_badsig); 371ATF_TC_BODY(reaper_kill_badsig, tc) 372{ 373 struct procctl_reaper_kill params; 374 pid_t parent; 375 int r; 376 377 parent = getpid(); 378 r = procctl(P_PID, parent, PROC_REAP_ACQUIRE, NULL); 379 ATF_REQUIRE_EQ(0, r); 380 381 params.rk_sig = -1; 382 params.rk_flags = 0; 383 r = procctl(P_PID, parent, PROC_REAP_KILL, ¶ms); 384 ATF_CHECK(r == -1 && errno == EINVAL); 385} 386 387ATF_TC_WITHOUT_HEAD(reaper_kill_sigzero); 388ATF_TC_BODY(reaper_kill_sigzero, tc) 389{ 390 struct procctl_reaper_kill params; 391 pid_t parent; 392 int r; 393 394 parent = getpid(); 395 r = procctl(P_PID, parent, PROC_REAP_ACQUIRE, NULL); 396 ATF_REQUIRE_EQ(0, r); 397 398 params.rk_sig = 0; 399 params.rk_flags = 0; 400 r = procctl(P_PID, parent, PROC_REAP_KILL, ¶ms); 401 ATF_CHECK(r == -1 && errno == EINVAL); 402} 403 404ATF_TC_WITHOUT_HEAD(reaper_kill_empty); 405ATF_TC_BODY(reaper_kill_empty, tc) 406{ 407 struct procctl_reaper_kill params; 408 pid_t parent; 409 int r; 410 411 parent = getpid(); 412 r = procctl(P_PID, parent, PROC_REAP_ACQUIRE, NULL); 413 ATF_REQUIRE_EQ(0, r); 414 415 params.rk_sig = SIGTERM; 416 params.rk_flags = 0; 417 params.rk_killed = 77; 418 r = procctl(P_PID, parent, PROC_REAP_KILL, ¶ms); 419 ATF_CHECK(r == -1 && errno == ESRCH); 420 ATF_CHECK_EQ(0, params.rk_killed); 421} 422 423ATF_TC_WITHOUT_HEAD(reaper_kill_normal); 424ATF_TC_BODY(reaper_kill_normal, tc) 425{ 426 struct procctl_reaper_kill params; 427 ssize_t sr; 428 pid_t parent, child, grandchild, pid; 429 int r, status; 430 int pip[2]; 431 432 parent = getpid(); 433 r = procctl(P_PID, parent, PROC_REAP_ACQUIRE, NULL); 434 ATF_REQUIRE_EQ(0, r); 435 436 r = pipe(pip); 437 ATF_REQUIRE_EQ(0, r); 438 child = fork(); 439 ATF_REQUIRE(child != -1); 440 if (child == 0) { 441 if (close(pip[0]) != 0) 442 _exit(100); 443 grandchild = fork(); 444 if (grandchild == -1) 445 _exit(101); 446 if (grandchild == 0) { 447 if (write(pip[1], &(uint8_t){ 0 }, 1) != 1) 448 _exit(102); 449 for (;;) 450 pause(); 451 } 452 for (;;) 453 pause(); 454 } 455 r = close(pip[1]); 456 ATF_REQUIRE_EQ(0, r); 457 458 sr = read(pip[0], &(uint8_t){ 0 }, 1); 459 ATF_REQUIRE_EQ(1, sr); 460 461 params.rk_sig = SIGTERM; 462 params.rk_flags = 0; 463 params.rk_killed = 77; 464 r = procctl(P_PID, parent, PROC_REAP_KILL, ¶ms); 465 ATF_CHECK_EQ(0, r); 466 ATF_CHECK_EQ(2, params.rk_killed); 467 468 pid = waitpid(child, &status, 0); 469 ATF_REQUIRE_EQ(child, pid); 470 ATF_CHECK(WIFSIGNALED(status) && WTERMSIG(status) == SIGTERM); 471 472 pid = waitpid(-1, &status, 0); 473 ATF_REQUIRE(pid > 0); 474 ATF_CHECK(pid != parent); 475 ATF_CHECK(pid != child); 476 ATF_CHECK(WIFSIGNALED(status) && WTERMSIG(status) == SIGTERM); 477 478 r = close(pip[0]); 479 ATF_REQUIRE_EQ(0, r); 480} 481 482ATF_TP_ADD_TCS(tp) 483{ 484 485 ATF_TP_ADD_TC(tp, reaper_wait_child_first); 486 ATF_TP_ADD_TC(tp, reaper_wait_grandchild_first); 487 ATF_TP_ADD_TC(tp, reaper_status); 488 ATF_TP_ADD_TC(tp, reaper_getpids); 489 ATF_TP_ADD_TC(tp, reaper_kill_badsig); 490 ATF_TP_ADD_TC(tp, reaper_kill_sigzero); 491 ATF_TP_ADD_TC(tp, reaper_kill_empty); 492 ATF_TP_ADD_TC(tp, reaper_kill_normal); 493 return (atf_no_error()); 494} 495