tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

selftests/coredump: cleanup coredump tests

Make the selftests we added this cycle easier to read.

Link: https://lore.kernel.org/20250603-work-coredump-socket-protocol-v2-3-05a5f0c18ecc@kernel.org
Acked-by: Lennart Poettering <lennart@poettering.net>
Reviewed-by: Alexander Mikhalitsyn <aleksandr.mikhalitsyn@canonical.com>
Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Christian Brauner <brauner@kernel.org>

Christian Brauner 474dd09d 994dc263

+175 -236
+175 -236
tools/testing/selftests/coredump/stackdump_test.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0 2 2 3 + #include <assert.h> 3 4 #include <fcntl.h> 4 5 #include <inttypes.h> 5 6 #include <libgen.h> ··· 20 19 #define STACKDUMP_FILE "stack_values" 21 20 #define STACKDUMP_SCRIPT "stackdump" 22 21 #define NUM_THREAD_SPAWN 128 22 + 23 + #ifndef PAGE_SIZE 24 + #define PAGE_SIZE 4096 25 + #endif 23 26 24 27 static void *do_nothing(void *) 25 28 { ··· 114 109 unsigned long long stack; 115 110 char *test_dir, *line; 116 111 size_t line_length; 117 - char buf[PATH_MAX]; 112 + char buf[PAGE_SIZE]; 118 113 int ret, i, status; 119 114 FILE *file; 120 115 pid_t pid; ··· 173 168 fclose(file); 174 169 } 175 170 171 + static int create_and_listen_unix_socket(const char *path) 172 + { 173 + struct sockaddr_un addr = { 174 + .sun_family = AF_UNIX, 175 + }; 176 + assert(strlen(path) < sizeof(addr.sun_path) - 1); 177 + strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1); 178 + size_t addr_len = 179 + offsetof(struct sockaddr_un, sun_path) + strlen(path) + 1; 180 + int fd, ret; 181 + 182 + fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); 183 + if (fd < 0) 184 + goto out; 185 + 186 + ret = bind(fd, (const struct sockaddr *)&addr, addr_len); 187 + if (ret < 0) 188 + goto out; 189 + 190 + ret = listen(fd, 1); 191 + if (ret < 0) 192 + goto out; 193 + 194 + return fd; 195 + 196 + out: 197 + if (fd >= 0) 198 + close(fd); 199 + return -1; 200 + } 201 + 202 + static bool set_core_pattern(const char *pattern) 203 + { 204 + FILE *file; 205 + int ret; 206 + 207 + file = fopen("/proc/sys/kernel/core_pattern", "w"); 208 + if (!file) 209 + return false; 210 + 211 + ret = fprintf(file, "%s", pattern); 212 + fclose(file); 213 + 214 + return ret == strlen(pattern); 215 + } 216 + 217 + static int get_peer_pidfd(int fd) 218 + { 219 + int fd_peer_pidfd; 220 + socklen_t fd_peer_pidfd_len = sizeof(fd_peer_pidfd); 221 + int ret = getsockopt(fd, SOL_SOCKET, SO_PEERPIDFD, &fd_peer_pidfd, 222 + &fd_peer_pidfd_len); 223 + if (ret < 0) { 224 + fprintf(stderr, "%m - Failed to retrieve peer pidfd for coredump socket connection\n"); 225 + return -1; 226 + } 227 + return fd_peer_pidfd; 228 + } 229 + 230 + static bool get_pidfd_info(int fd_peer_pidfd, struct pidfd_info *info) 231 + { 232 + memset(info, 0, sizeof(*info)); 233 + info->mask = PIDFD_INFO_EXIT | PIDFD_INFO_COREDUMP; 234 + return ioctl(fd_peer_pidfd, PIDFD_GET_INFO, info) == 0; 235 + } 236 + 237 + static void 238 + wait_and_check_coredump_server(pid_t pid_coredump_server, 239 + struct __test_metadata *const _metadata, 240 + FIXTURE_DATA(coredump)* self) 241 + { 242 + int status; 243 + waitpid(pid_coredump_server, &status, 0); 244 + self->pid_coredump_server = -ESRCH; 245 + ASSERT_TRUE(WIFEXITED(status)); 246 + ASSERT_EQ(WEXITSTATUS(status), 0); 247 + } 248 + 176 249 TEST_F(coredump, socket) 177 250 { 178 251 int pidfd, ret, status; 179 - FILE *file; 180 252 pid_t pid, pid_coredump_server; 181 253 struct stat st; 182 254 struct pidfd_info info = {}; 183 255 int ipc_sockets[2]; 184 256 char c; 185 - const struct sockaddr_un coredump_sk = { 186 - .sun_family = AF_UNIX, 187 - .sun_path = "/tmp/coredump.socket", 188 - }; 189 - size_t coredump_sk_len = offsetof(struct sockaddr_un, sun_path) + 190 - sizeof("/tmp/coredump.socket"); 257 + 258 + ASSERT_TRUE(set_core_pattern("@/tmp/coredump.socket")); 191 259 192 260 ret = socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets); 193 261 ASSERT_EQ(ret, 0); 194 262 195 - file = fopen("/proc/sys/kernel/core_pattern", "w"); 196 - ASSERT_NE(file, NULL); 197 - 198 - ret = fprintf(file, "@/tmp/coredump.socket"); 199 - ASSERT_EQ(ret, strlen("@/tmp/coredump.socket")); 200 - ASSERT_EQ(fclose(file), 0); 201 - 202 263 pid_coredump_server = fork(); 203 264 ASSERT_GE(pid_coredump_server, 0); 204 265 if (pid_coredump_server == 0) { 205 - int fd_server, fd_coredump, fd_peer_pidfd, fd_core_file; 206 - socklen_t fd_peer_pidfd_len; 266 + int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1, fd_core_file = -1; 267 + int exit_code = EXIT_FAILURE; 207 268 208 269 close(ipc_sockets[0]); 209 270 210 - fd_server = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); 271 + fd_server = create_and_listen_unix_socket("/tmp/coredump.socket"); 211 272 if (fd_server < 0) 212 - _exit(EXIT_FAILURE); 273 + goto out; 213 274 214 - ret = bind(fd_server, (const struct sockaddr *)&coredump_sk, coredump_sk_len); 215 - if (ret < 0) { 216 - fprintf(stderr, "Failed to bind coredump socket\n"); 217 - close(fd_server); 218 - close(ipc_sockets[1]); 219 - _exit(EXIT_FAILURE); 220 - } 221 - 222 - ret = listen(fd_server, 1); 223 - if (ret < 0) { 224 - fprintf(stderr, "Failed to listen on coredump socket\n"); 225 - close(fd_server); 226 - close(ipc_sockets[1]); 227 - _exit(EXIT_FAILURE); 228 - } 229 - 230 - if (write_nointr(ipc_sockets[1], "1", 1) < 0) { 231 - close(fd_server); 232 - close(ipc_sockets[1]); 233 - _exit(EXIT_FAILURE); 234 - } 275 + if (write_nointr(ipc_sockets[1], "1", 1) < 0) 276 + goto out; 235 277 236 278 close(ipc_sockets[1]); 237 279 238 280 fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC); 239 - if (fd_coredump < 0) { 240 - fprintf(stderr, "Failed to accept coredump socket connection\n"); 241 - close(fd_server); 242 - _exit(EXIT_FAILURE); 243 - } 281 + if (fd_coredump < 0) 282 + goto out; 244 283 245 - fd_peer_pidfd_len = sizeof(fd_peer_pidfd); 246 - ret = getsockopt(fd_coredump, SOL_SOCKET, SO_PEERPIDFD, 247 - &fd_peer_pidfd, &fd_peer_pidfd_len); 248 - if (ret < 0) { 249 - fprintf(stderr, "%m - Failed to retrieve peer pidfd for coredump socket connection\n"); 250 - close(fd_coredump); 251 - close(fd_server); 252 - _exit(EXIT_FAILURE); 253 - } 284 + fd_peer_pidfd = get_peer_pidfd(fd_coredump); 285 + if (fd_peer_pidfd < 0) 286 + goto out; 254 287 255 - memset(&info, 0, sizeof(info)); 256 - info.mask = PIDFD_INFO_EXIT | PIDFD_INFO_COREDUMP; 257 - ret = ioctl(fd_peer_pidfd, PIDFD_GET_INFO, &info); 258 - if (ret < 0) { 259 - fprintf(stderr, "Failed to retrieve pidfd info from peer pidfd for coredump socket connection\n"); 260 - close(fd_coredump); 261 - close(fd_server); 262 - close(fd_peer_pidfd); 263 - _exit(EXIT_FAILURE); 264 - } 288 + if (!get_pidfd_info(fd_peer_pidfd, &info)) 289 + goto out; 265 290 266 - if (!(info.mask & PIDFD_INFO_COREDUMP)) { 267 - fprintf(stderr, "Missing coredump information from coredumping task\n"); 268 - close(fd_coredump); 269 - close(fd_server); 270 - close(fd_peer_pidfd); 271 - _exit(EXIT_FAILURE); 272 - } 291 + if (!(info.mask & PIDFD_INFO_COREDUMP)) 292 + goto out; 273 293 274 - if (!(info.coredump_mask & PIDFD_COREDUMPED)) { 275 - fprintf(stderr, "Received connection from non-coredumping task\n"); 276 - close(fd_coredump); 277 - close(fd_server); 278 - close(fd_peer_pidfd); 279 - _exit(EXIT_FAILURE); 280 - } 294 + if (!(info.coredump_mask & PIDFD_COREDUMPED)) 295 + goto out; 281 296 282 297 fd_core_file = creat("/tmp/coredump.file", 0644); 283 - if (fd_core_file < 0) { 284 - fprintf(stderr, "Failed to create coredump file\n"); 285 - close(fd_coredump); 286 - close(fd_server); 287 - close(fd_peer_pidfd); 288 - _exit(EXIT_FAILURE); 289 - } 298 + if (fd_core_file < 0) 299 + goto out; 290 300 291 301 for (;;) { 292 302 char buffer[4096]; 293 303 ssize_t bytes_read, bytes_write; 294 304 295 305 bytes_read = read(fd_coredump, buffer, sizeof(buffer)); 296 - if (bytes_read < 0) { 297 - close(fd_coredump); 298 - close(fd_server); 299 - close(fd_peer_pidfd); 300 - close(fd_core_file); 301 - _exit(EXIT_FAILURE); 302 - } 306 + if (bytes_read < 0) 307 + goto out; 303 308 304 309 if (bytes_read == 0) 305 310 break; 306 311 307 312 bytes_write = write(fd_core_file, buffer, bytes_read); 308 - if (bytes_read != bytes_write) { 309 - close(fd_coredump); 310 - close(fd_server); 311 - close(fd_peer_pidfd); 312 - close(fd_core_file); 313 - _exit(EXIT_FAILURE); 314 - } 313 + if (bytes_read != bytes_write) 314 + goto out; 315 315 } 316 316 317 - close(fd_coredump); 318 - close(fd_server); 319 - close(fd_peer_pidfd); 320 - close(fd_core_file); 321 - _exit(EXIT_SUCCESS); 317 + exit_code = EXIT_SUCCESS; 318 + out: 319 + if (fd_core_file >= 0) 320 + close(fd_core_file); 321 + if (fd_peer_pidfd >= 0) 322 + close(fd_peer_pidfd); 323 + if (fd_coredump >= 0) 324 + close(fd_coredump); 325 + if (fd_server >= 0) 326 + close(fd_server); 327 + _exit(exit_code); 322 328 } 323 329 self->pid_coredump_server = pid_coredump_server; 324 330 ··· 349 333 ASSERT_TRUE(WIFSIGNALED(status)); 350 334 ASSERT_TRUE(WCOREDUMP(status)); 351 335 352 - info.mask = PIDFD_INFO_EXIT | PIDFD_INFO_COREDUMP; 353 - ASSERT_EQ(ioctl(pidfd, PIDFD_GET_INFO, &info), 0); 336 + ASSERT_TRUE(get_pidfd_info(pidfd, &info)); 354 337 ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0); 355 338 ASSERT_GT((info.coredump_mask & PIDFD_COREDUMPED), 0); 356 339 357 - waitpid(pid_coredump_server, &status, 0); 358 - self->pid_coredump_server = -ESRCH; 359 - ASSERT_TRUE(WIFEXITED(status)); 360 - ASSERT_EQ(WEXITSTATUS(status), 0); 340 + wait_and_check_coredump_server(pid_coredump_server, _metadata, self); 361 341 362 342 ASSERT_EQ(stat("/tmp/coredump.file", &st), 0); 363 343 ASSERT_GT(st.st_size, 0); 364 - /* 365 - * We should somehow validate the produced core file. 366 - * For now just allow for visual inspection 367 - */ 368 344 system("file /tmp/coredump.file"); 369 345 } 370 346 371 347 TEST_F(coredump, socket_detect_userspace_client) 372 348 { 373 349 int pidfd, ret, status; 374 - FILE *file; 375 350 pid_t pid, pid_coredump_server; 376 351 struct stat st; 377 352 struct pidfd_info info = {}; 378 353 int ipc_sockets[2]; 379 354 char c; 380 - const struct sockaddr_un coredump_sk = { 381 - .sun_family = AF_UNIX, 382 - .sun_path = "/tmp/coredump.socket", 383 - }; 384 - size_t coredump_sk_len = offsetof(struct sockaddr_un, sun_path) + 385 - sizeof("/tmp/coredump.socket"); 386 355 387 - file = fopen("/proc/sys/kernel/core_pattern", "w"); 388 - ASSERT_NE(file, NULL); 389 - 390 - ret = fprintf(file, "@/tmp/coredump.socket"); 391 - ASSERT_EQ(ret, strlen("@/tmp/coredump.socket")); 392 - ASSERT_EQ(fclose(file), 0); 356 + ASSERT_TRUE(set_core_pattern("@/tmp/coredump.socket")); 393 357 394 358 ret = socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets); 395 359 ASSERT_EQ(ret, 0); ··· 377 381 pid_coredump_server = fork(); 378 382 ASSERT_GE(pid_coredump_server, 0); 379 383 if (pid_coredump_server == 0) { 380 - int fd_server, fd_coredump, fd_peer_pidfd; 381 - socklen_t fd_peer_pidfd_len; 384 + int fd_server = -1, fd_coredump = -1, fd_peer_pidfd = -1; 385 + int exit_code = EXIT_FAILURE; 382 386 383 387 close(ipc_sockets[0]); 384 388 385 - fd_server = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); 389 + fd_server = create_and_listen_unix_socket("/tmp/coredump.socket"); 386 390 if (fd_server < 0) 387 - _exit(EXIT_FAILURE); 391 + goto out; 388 392 389 - ret = bind(fd_server, (const struct sockaddr *)&coredump_sk, coredump_sk_len); 390 - if (ret < 0) { 391 - fprintf(stderr, "Failed to bind coredump socket\n"); 392 - close(fd_server); 393 - close(ipc_sockets[1]); 394 - _exit(EXIT_FAILURE); 395 - } 396 - 397 - ret = listen(fd_server, 1); 398 - if (ret < 0) { 399 - fprintf(stderr, "Failed to listen on coredump socket\n"); 400 - close(fd_server); 401 - close(ipc_sockets[1]); 402 - _exit(EXIT_FAILURE); 403 - } 404 - 405 - if (write_nointr(ipc_sockets[1], "1", 1) < 0) { 406 - close(fd_server); 407 - close(ipc_sockets[1]); 408 - _exit(EXIT_FAILURE); 409 - } 393 + if (write_nointr(ipc_sockets[1], "1", 1) < 0) 394 + goto out; 410 395 411 396 close(ipc_sockets[1]); 412 397 413 398 fd_coredump = accept4(fd_server, NULL, NULL, SOCK_CLOEXEC); 414 - if (fd_coredump < 0) { 415 - fprintf(stderr, "Failed to accept coredump socket connection\n"); 416 - close(fd_server); 417 - _exit(EXIT_FAILURE); 418 - } 399 + if (fd_coredump < 0) 400 + goto out; 419 401 420 - fd_peer_pidfd_len = sizeof(fd_peer_pidfd); 421 - ret = getsockopt(fd_coredump, SOL_SOCKET, SO_PEERPIDFD, 422 - &fd_peer_pidfd, &fd_peer_pidfd_len); 423 - if (ret < 0) { 424 - fprintf(stderr, "%m - Failed to retrieve peer pidfd for coredump socket connection\n"); 425 - close(fd_coredump); 426 - close(fd_server); 427 - _exit(EXIT_FAILURE); 428 - } 402 + fd_peer_pidfd = get_peer_pidfd(fd_coredump); 403 + if (fd_peer_pidfd < 0) 404 + goto out; 429 405 430 - memset(&info, 0, sizeof(info)); 431 - info.mask = PIDFD_INFO_EXIT | PIDFD_INFO_COREDUMP; 432 - ret = ioctl(fd_peer_pidfd, PIDFD_GET_INFO, &info); 433 - if (ret < 0) { 434 - fprintf(stderr, "Failed to retrieve pidfd info from peer pidfd for coredump socket connection\n"); 435 - close(fd_coredump); 436 - close(fd_server); 406 + if (!get_pidfd_info(fd_peer_pidfd, &info)) 407 + goto out; 408 + 409 + if (!(info.mask & PIDFD_INFO_COREDUMP)) 410 + goto out; 411 + 412 + if (info.coredump_mask & PIDFD_COREDUMPED) 413 + goto out; 414 + 415 + exit_code = EXIT_SUCCESS; 416 + out: 417 + if (fd_peer_pidfd >= 0) 437 418 close(fd_peer_pidfd); 438 - _exit(EXIT_FAILURE); 439 - } 440 - 441 - if (!(info.mask & PIDFD_INFO_COREDUMP)) { 442 - fprintf(stderr, "Missing coredump information from coredumping task\n"); 419 + if (fd_coredump >= 0) 443 420 close(fd_coredump); 421 + if (fd_server >= 0) 444 422 close(fd_server); 445 - close(fd_peer_pidfd); 446 - _exit(EXIT_FAILURE); 447 - } 448 - 449 - if (info.coredump_mask & PIDFD_COREDUMPED) { 450 - fprintf(stderr, "Received unexpected connection from coredumping task\n"); 451 - close(fd_coredump); 452 - close(fd_server); 453 - close(fd_peer_pidfd); 454 - _exit(EXIT_FAILURE); 455 - } 456 - 457 - close(fd_coredump); 458 - close(fd_server); 459 - close(fd_peer_pidfd); 460 - _exit(EXIT_SUCCESS); 423 + _exit(exit_code); 461 424 } 462 425 self->pid_coredump_server = pid_coredump_server; 463 426 ··· 429 474 if (pid == 0) { 430 475 int fd_socket; 431 476 ssize_t ret; 477 + const struct sockaddr_un coredump_sk = { 478 + .sun_family = AF_UNIX, 479 + .sun_path = "/tmp/coredump.socket", 480 + }; 481 + size_t coredump_sk_len = 482 + offsetof(struct sockaddr_un, sun_path) + 483 + sizeof("/tmp/coredump.socket"); 432 484 433 485 fd_socket = socket(AF_UNIX, SOCK_STREAM, 0); 434 486 if (fd_socket < 0) 435 487 _exit(EXIT_FAILURE); 436 - 437 488 438 489 ret = connect(fd_socket, (const struct sockaddr *)&coredump_sk, coredump_sk_len); 439 490 if (ret < 0) ··· 456 495 ASSERT_TRUE(WIFEXITED(status)); 457 496 ASSERT_EQ(WEXITSTATUS(status), 0); 458 497 459 - info.mask = PIDFD_INFO_EXIT | PIDFD_INFO_COREDUMP; 460 - ASSERT_EQ(ioctl(pidfd, PIDFD_GET_INFO, &info), 0); 498 + ASSERT_TRUE(get_pidfd_info(pidfd, &info)); 461 499 ASSERT_GT((info.mask & PIDFD_INFO_COREDUMP), 0); 462 500 ASSERT_EQ((info.coredump_mask & PIDFD_COREDUMPED), 0); 463 501 464 - waitpid(pid_coredump_server, &status, 0); 465 - self->pid_coredump_server = -ESRCH; 466 - ASSERT_TRUE(WIFEXITED(status)); 467 - ASSERT_EQ(WEXITSTATUS(status), 0); 502 + wait_and_check_coredump_server(pid_coredump_server, _metadata, self); 468 503 469 504 ASSERT_NE(stat("/tmp/coredump.file", &st), 0); 470 505 ASSERT_EQ(errno, ENOENT); ··· 468 511 469 512 TEST_F(coredump, socket_enoent) 470 513 { 471 - int pidfd, ret, status; 472 - FILE *file; 514 + int pidfd, status; 473 515 pid_t pid; 474 516 475 - file = fopen("/proc/sys/kernel/core_pattern", "w"); 476 - ASSERT_NE(file, NULL); 477 - 478 - ret = fprintf(file, "@/tmp/coredump.socket"); 479 - ASSERT_EQ(ret, strlen("@/tmp/coredump.socket")); 480 - ASSERT_EQ(fclose(file), 0); 517 + ASSERT_TRUE(set_core_pattern("@/tmp/coredump.socket")); 481 518 482 519 pid = fork(); 483 520 ASSERT_GE(pid, 0); ··· 489 538 TEST_F(coredump, socket_no_listener) 490 539 { 491 540 int pidfd, ret, status; 492 - FILE *file; 493 541 pid_t pid, pid_coredump_server; 494 542 int ipc_sockets[2]; 495 543 char c; ··· 499 549 size_t coredump_sk_len = offsetof(struct sockaddr_un, sun_path) + 500 550 sizeof("/tmp/coredump.socket"); 501 551 552 + ASSERT_TRUE(set_core_pattern("@/tmp/coredump.socket")); 553 + 502 554 ret = socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, ipc_sockets); 503 555 ASSERT_EQ(ret, 0); 504 - 505 - file = fopen("/proc/sys/kernel/core_pattern", "w"); 506 - ASSERT_NE(file, NULL); 507 - 508 - ret = fprintf(file, "@/tmp/coredump.socket"); 509 - ASSERT_EQ(ret, strlen("@/tmp/coredump.socket")); 510 - ASSERT_EQ(fclose(file), 0); 511 556 512 557 pid_coredump_server = fork(); 513 558 ASSERT_GE(pid_coredump_server, 0); 514 559 if (pid_coredump_server == 0) { 515 - int fd_server; 560 + int fd_server = -1; 561 + int exit_code = EXIT_FAILURE; 516 562 517 563 close(ipc_sockets[0]); 518 564 519 565 fd_server = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); 520 566 if (fd_server < 0) 521 - _exit(EXIT_FAILURE); 567 + goto out; 522 568 523 569 ret = bind(fd_server, (const struct sockaddr *)&coredump_sk, coredump_sk_len); 524 - if (ret < 0) { 525 - fprintf(stderr, "Failed to bind coredump socket\n"); 526 - close(fd_server); 527 - close(ipc_sockets[1]); 528 - _exit(EXIT_FAILURE); 529 - } 570 + if (ret < 0) 571 + goto out; 530 572 531 - if (write_nointr(ipc_sockets[1], "1", 1) < 0) { 532 - close(fd_server); 533 - close(ipc_sockets[1]); 534 - _exit(EXIT_FAILURE); 535 - } 573 + if (write_nointr(ipc_sockets[1], "1", 1) < 0) 574 + goto out; 536 575 537 - close(fd_server); 576 + exit_code = EXIT_SUCCESS; 577 + out: 578 + if (fd_server >= 0) 579 + close(fd_server); 538 580 close(ipc_sockets[1]); 539 - _exit(EXIT_SUCCESS); 581 + _exit(exit_code); 540 582 } 541 583 self->pid_coredump_server = pid_coredump_server; 542 584 ··· 548 606 ASSERT_TRUE(WIFSIGNALED(status)); 549 607 ASSERT_FALSE(WCOREDUMP(status)); 550 608 551 - waitpid(pid_coredump_server, &status, 0); 552 - self->pid_coredump_server = -ESRCH; 553 - ASSERT_TRUE(WIFEXITED(status)); 554 - ASSERT_EQ(WEXITSTATUS(status), 0); 609 + wait_and_check_coredump_server(pid_coredump_server, _metadata, self); 555 610 } 556 611 557 612 TEST_HARNESS_MAIN