tc.c revision 1.1.1.2
1 /* 2 * Automated Testing Framework (atf) 3 * 4 * Copyright (c) 2008, 2009 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 #include <sys/types.h> 31 #include <sys/time.h> 32 #include <sys/stat.h> 33 #include <sys/wait.h> 34 35 #include <errno.h> 36 #include <fcntl.h> 37 #include <limits.h> 38 #include <stdarg.h> 39 #include <stdbool.h> 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <string.h> 43 #include <unistd.h> 44 45 #include "atf-c/config.h" 46 #include "atf-c/defs.h" 47 #include "atf-c/env.h" 48 #include "atf-c/error.h" 49 #include "atf-c/fs.h" 50 #include "atf-c/process.h" 51 #include "atf-c/sanity.h" 52 #include "atf-c/signals.h" 53 #include "atf-c/tc.h" 54 #include "atf-c/tcr.h" 55 #include "atf-c/text.h" 56 #include "atf-c/user.h" 57 58 /* --------------------------------------------------------------------- 59 * Auxiliary types and functions. 60 * --------------------------------------------------------------------- */ 61 62 struct child_data { 63 const atf_tc_t *tc; 64 const atf_fs_path_t *workdir; 65 }; 66 67 /* Parent-only stuff. */ 68 struct timeout_data; 69 static atf_error_t body_parent(const atf_tc_t *, const atf_fs_path_t *, 70 atf_process_child_t *, atf_tcr_t *); 71 static atf_error_t cleanup_parent(const atf_tc_t *, atf_process_child_t *); 72 static atf_error_t fork_body(const atf_tc_t *, int, int, 73 const atf_fs_path_t *, atf_tcr_t *); 74 static atf_error_t fork_cleanup(const atf_tc_t *, int, int, 75 const atf_fs_path_t *); 76 static atf_error_t get_tc_result(const atf_fs_path_t *, atf_tcr_t *); 77 static atf_error_t program_timeout(const atf_process_child_t *, 78 const atf_tc_t *, struct timeout_data *); 79 static void unprogram_timeout(struct timeout_data *); 80 static void sigalrm_handler(int); 81 82 /* Child-only stuff. */ 83 static void body_child(void *) ATF_DEFS_ATTRIBUTE_NORETURN; 84 static atf_error_t check_arch(const char *, void *); 85 static atf_error_t check_config(const char *, void *); 86 static atf_error_t check_machine(const char *, void *); 87 static atf_error_t check_prog(const char *, void *); 88 static atf_error_t check_prog_in_dir(const char *, void *); 89 static atf_error_t check_requirements(const atf_tc_t *); 90 static void cleanup_child(void *) ATF_DEFS_ATTRIBUTE_NORETURN; 91 static void fail_internal(const char *, int, const char *, const char *, 92 const char *, va_list, 93 void (*)(atf_dynstr_t *), 94 void (*)(const char *, ...)); 95 static void fatal_atf_error(const char *, atf_error_t) 96 ATF_DEFS_ATTRIBUTE_NORETURN; 97 static void fatal_libc_error(const char *, int) 98 ATF_DEFS_ATTRIBUTE_NORETURN; 99 static atf_error_t prepare_child(const struct child_data *); 100 static void tc_fail(atf_dynstr_t *) ATF_DEFS_ATTRIBUTE_NORETURN; 101 static void tc_fail_nonfatal(atf_dynstr_t *); 102 static void write_tcr(const atf_tcr_t *); 103 104 /* --------------------------------------------------------------------- 105 * The "atf_tc" type. 106 * --------------------------------------------------------------------- */ 107 108 /* 109 * Constructors/destructors. 110 */ 111 112 atf_error_t 113 atf_tc_init(atf_tc_t *tc, const char *ident, atf_tc_head_t head, 114 atf_tc_body_t body, atf_tc_cleanup_t cleanup, 115 const atf_map_t *config) 116 { 117 atf_error_t err; 118 119 atf_object_init(&tc->m_object); 120 121 tc->m_ident = ident; 122 tc->m_head = head; 123 tc->m_body = body; 124 tc->m_cleanup = cleanup; 125 tc->m_config = config; 126 127 err = atf_map_init(&tc->m_vars); 128 if (atf_is_error(err)) 129 goto err_object; 130 131 err = atf_tc_set_md_var(tc, "ident", ident); 132 if (atf_is_error(err)) 133 goto err_map; 134 135 err = atf_tc_set_md_var(tc, "timeout", "300"); 136 if (atf_is_error(err)) 137 goto err_map; 138 139 /* XXX Should the head be able to return error codes? */ 140 tc->m_head(tc); 141 142 if (strcmp(atf_tc_get_md_var(tc, "ident"), ident) != 0) 143 atf_tc_fail("Test case head modified the read-only 'ident' " 144 "property"); 145 146 INV(!atf_is_error(err)); 147 return err; 148 149 err_map: 150 atf_map_fini(&tc->m_vars); 151 err_object: 152 atf_object_fini(&tc->m_object); 153 154 return err; 155 } 156 157 atf_error_t 158 atf_tc_init_pack(atf_tc_t *tc, const atf_tc_pack_t *pack, 159 const atf_map_t *config) 160 { 161 return atf_tc_init(tc, pack->m_ident, pack->m_head, pack->m_body, 162 pack->m_cleanup, config); 163 } 164 165 void 166 atf_tc_fini(atf_tc_t *tc) 167 { 168 atf_map_fini(&tc->m_vars); 169 170 atf_object_fini(&tc->m_object); 171 } 172 173 /* 174 * Getters. 175 */ 176 177 const char * 178 atf_tc_get_ident(const atf_tc_t *tc) 179 { 180 return tc->m_ident; 181 } 182 183 const char * 184 atf_tc_get_config_var(const atf_tc_t *tc, const char *name) 185 { 186 const char *val; 187 atf_map_citer_t iter; 188 189 PRE(atf_tc_has_config_var(tc, name)); 190 iter = atf_map_find_c(tc->m_config, name); 191 val = atf_map_citer_data(iter); 192 INV(val != NULL); 193 194 return val; 195 } 196 197 const char * 198 atf_tc_get_config_var_wd(const atf_tc_t *tc, const char *name, 199 const char *defval) 200 { 201 const char *val; 202 203 if (!atf_tc_has_config_var(tc, name)) 204 val = defval; 205 else 206 val = atf_tc_get_config_var(tc, name); 207 208 return val; 209 } 210 211 const char * 212 atf_tc_get_md_var(const atf_tc_t *tc, const char *name) 213 { 214 const char *val; 215 atf_map_citer_t iter; 216 217 PRE(atf_tc_has_md_var(tc, name)); 218 iter = atf_map_find_c(&tc->m_vars, name); 219 val = atf_map_citer_data(iter); 220 INV(val != NULL); 221 222 return val; 223 } 224 225 bool 226 atf_tc_has_config_var(const atf_tc_t *tc, const char *name) 227 { 228 bool found; 229 atf_map_citer_t end, iter; 230 231 if (tc->m_config == NULL) 232 found = false; 233 else { 234 iter = atf_map_find_c(tc->m_config, name); 235 end = atf_map_end_c(tc->m_config); 236 found = !atf_equal_map_citer_map_citer(iter, end); 237 } 238 239 return found; 240 } 241 242 bool 243 atf_tc_has_md_var(const atf_tc_t *tc, const char *name) 244 { 245 atf_map_citer_t end, iter; 246 247 iter = atf_map_find_c(&tc->m_vars, name); 248 end = atf_map_end_c(&tc->m_vars); 249 return !atf_equal_map_citer_map_citer(iter, end); 250 } 251 252 /* 253 * Modifiers. 254 */ 255 256 atf_error_t 257 atf_tc_set_md_var(atf_tc_t *tc, const char *name, const char *fmt, ...) 258 { 259 atf_error_t err; 260 char *value; 261 va_list ap; 262 263 va_start(ap, fmt); 264 err = atf_text_format_ap(&value, fmt, ap); 265 va_end(ap); 266 267 if (!atf_is_error(err)) 268 err = atf_map_insert(&tc->m_vars, name, value, true); 269 else 270 free(value); 271 272 return err; 273 } 274 275 /* --------------------------------------------------------------------- 276 * Free functions. 277 * --------------------------------------------------------------------- */ 278 279 atf_error_t 280 atf_tc_run(const atf_tc_t *tc, atf_tcr_t *tcr, int fdout, int fderr, 281 const atf_fs_path_t *workdirbase) 282 { 283 atf_error_t err, cleanuperr; 284 atf_fs_path_t workdir; 285 286 err = atf_fs_path_copy(&workdir, workdirbase); 287 if (atf_is_error(err)) 288 goto out; 289 290 err = atf_fs_path_append_fmt(&workdir, "atf.XXXXXX"); 291 if (atf_is_error(err)) 292 goto out_workdir; 293 294 err = atf_fs_mkdtemp(&workdir); 295 if (atf_is_error(err)) 296 goto out_workdir; 297 298 err = fork_body(tc, fdout, fderr, &workdir, tcr); 299 cleanuperr = fork_cleanup(tc, fdout, fderr, &workdir); 300 if (!atf_is_error(cleanuperr)) 301 (void)atf_fs_cleanup(&workdir); 302 if (!atf_is_error(err)) 303 err = cleanuperr; 304 else if (atf_is_error(cleanuperr)) 305 atf_error_free(cleanuperr); 306 307 out_workdir: 308 atf_fs_path_fini(&workdir); 309 out: 310 return err; 311 } 312 313 /* 314 * Parent-only stuff. 315 */ 316 317 static bool sigalrm_killed = false; 318 static pid_t sigalrm_pid = -1; 319 320 static 321 void 322 sigalrm_handler(int signo) 323 { 324 INV(signo == SIGALRM); 325 326 if (sigalrm_pid != -1) { 327 killpg(sigalrm_pid, SIGTERM); 328 sigalrm_killed = true; 329 } 330 } 331 332 struct timeout_data { 333 bool m_programmed; 334 atf_signal_programmer_t m_sigalrm; 335 }; 336 337 static 338 atf_error_t 339 program_timeout(const atf_process_child_t *child, const atf_tc_t *tc, 340 struct timeout_data *td) 341 { 342 atf_error_t err; 343 long timeout; 344 345 err = atf_text_to_long(atf_tc_get_md_var(tc, "timeout"), &timeout); 346 if (atf_is_error(err)) 347 goto out; 348 349 if (timeout != 0) { 350 sigalrm_pid = atf_process_child_pid(child); 351 sigalrm_killed = false; 352 353 err = atf_signal_programmer_init(&td->m_sigalrm, SIGALRM, 354 sigalrm_handler); 355 if (atf_is_error(err)) 356 goto out; 357 358 struct itimerval itv; 359 timerclear(&itv.it_interval); 360 timerclear(&itv.it_value); 361 itv.it_value.tv_sec = timeout; 362 if (setitimer(ITIMER_REAL, &itv, NULL) == -1) { 363 atf_signal_programmer_fini(&td->m_sigalrm); 364 err = atf_libc_error(errno, "Failed to program timeout " 365 "with %ld seconds", timeout); 366 } 367 368 td->m_programmed = !atf_is_error(err); 369 } else 370 td->m_programmed = false; 371 372 out: 373 return err; 374 } 375 376 static 377 void 378 unprogram_timeout(struct timeout_data *td) 379 { 380 if (td->m_programmed) { 381 atf_signal_programmer_fini(&td->m_sigalrm); 382 sigalrm_pid = -1; 383 sigalrm_killed = false; 384 } 385 } 386 387 static 388 atf_error_t 389 body_parent(const atf_tc_t *tc, const atf_fs_path_t *workdir, 390 atf_process_child_t *child, atf_tcr_t *tcr) 391 { 392 atf_error_t err; 393 atf_process_status_t status; 394 struct timeout_data td; 395 396 err = program_timeout(child, tc, &td); 397 if (atf_is_error(err)) { 398 char buf[4096]; 399 400 atf_error_format(err, buf, sizeof(buf)); 401 fprintf(stderr, "Error programming test case's timeout: %s", buf); 402 atf_error_free(err); 403 killpg(atf_process_child_pid(child), SIGKILL); 404 } 405 406 again: 407 err = atf_process_child_wait(child, &status); 408 if (atf_is_error(err)) { 409 if (atf_error_is(err, "libc") && atf_libc_error_code(err) == EINTR) { 410 atf_error_free(err); 411 goto again; 412 } else { 413 /* Propagate err */ 414 } 415 } else { 416 if (sigalrm_killed) 417 err = atf_tcr_init_reason_fmt(tcr, atf_tcr_failed_state, 418 "Test case timed out after %s " 419 "seconds", 420 atf_tc_get_md_var(tc, "timeout")); 421 else { 422 if (atf_process_status_exited(&status)) { 423 const int exitstatus = atf_process_status_exitstatus(&status); 424 if (exitstatus == EXIT_SUCCESS) 425 err = get_tc_result(workdir, tcr); 426 else 427 err = atf_tcr_init_reason_fmt(tcr, atf_tcr_failed_state, 428 "Test case exited with " 429 "status %d", exitstatus); 430 } else if (atf_process_status_signaled(&status)) { 431 const int sig = atf_process_status_termsig(&status); 432 const bool wcore = atf_process_status_coredump(&status); 433 err = atf_tcr_init_reason_fmt(tcr, atf_tcr_failed_state, 434 "Test case was signaled by " 435 "signal %d%s", sig, 436 wcore ? " (core dumped)" : ""); 437 } else { 438 err = atf_tcr_init_reason_fmt(tcr, atf_tcr_failed_state, 439 "Test case exited due to an " 440 "unexpected condition"); 441 } 442 } 443 444 atf_process_status_fini(&status); 445 } 446 447 unprogram_timeout(&td); 448 449 return err; 450 } 451 452 static 453 atf_error_t 454 cleanup_parent(const atf_tc_t *tc, atf_process_child_t *child) 455 { 456 atf_error_t err; 457 atf_process_status_t status; 458 459 err = atf_process_child_wait(child, &status); 460 if (atf_is_error(err)) 461 goto out; 462 463 if (!atf_process_status_exited(&status) || 464 atf_process_status_exitstatus(&status) != EXIT_SUCCESS) { 465 /* XXX Not really a libc error. */ 466 err = atf_libc_error(EINVAL, "Child process did not exit cleanly"); 467 } else 468 err = atf_no_error(); 469 470 atf_process_status_fini(&status); 471 out: 472 return err; 473 } 474 475 static 476 atf_error_t 477 fork_body(const atf_tc_t *tc, int fdout, int fderr, 478 const atf_fs_path_t *workdir, atf_tcr_t *tcr) 479 { 480 atf_error_t err; 481 atf_process_stream_t outsb, errsb; 482 atf_process_child_t child; 483 struct child_data data = { 484 tc, 485 workdir, 486 }; 487 488 err = atf_process_stream_init_redirect_fd(&outsb, fdout); 489 if (atf_is_error(err)) 490 goto out; 491 492 err = atf_process_stream_init_redirect_fd(&errsb, fderr); 493 if (atf_is_error(err)) 494 goto out_outsb; 495 496 err = atf_process_fork(&child, body_child, &outsb, &errsb, &data); 497 if (atf_is_error(err)) 498 goto out_errsb; 499 500 err = body_parent(tc, workdir, &child, tcr); 501 502 out_errsb: 503 atf_process_stream_fini(&errsb); 504 out_outsb: 505 atf_process_stream_fini(&outsb); 506 out: 507 return err; 508 } 509 510 static 511 atf_error_t 512 fork_cleanup(const atf_tc_t *tc, int fdout, int fderr, 513 const atf_fs_path_t *workdir) 514 { 515 atf_error_t err; 516 517 if (tc->m_cleanup == NULL) 518 err = atf_no_error(); 519 else { 520 atf_process_stream_t outsb, errsb; 521 atf_process_child_t child; 522 struct child_data data = { 523 tc, 524 workdir, 525 }; 526 527 err = atf_process_stream_init_redirect_fd(&outsb, fdout); 528 if (atf_is_error(err)) 529 goto out; 530 531 err = atf_process_stream_init_redirect_fd(&errsb, fderr); 532 if (atf_is_error(err)) 533 goto out_outsb; 534 535 err = atf_process_fork(&child, cleanup_child, &outsb, &errsb, &data); 536 if (atf_is_error(err)) 537 goto out_errsb; 538 539 err = cleanup_parent(tc, &child); 540 541 out_errsb: 542 atf_process_stream_fini(&errsb); 543 out_outsb: 544 atf_process_stream_fini(&outsb); 545 } 546 547 out: 548 return err; 549 } 550 551 static 552 atf_error_t 553 get_tc_result(const atf_fs_path_t *workdir, atf_tcr_t *tcr) 554 { 555 atf_error_t err; 556 int fd; 557 atf_fs_path_t tcrfile; 558 559 err = atf_fs_path_copy(&tcrfile, workdir); 560 if (atf_is_error(err)) 561 goto out; 562 563 err = atf_fs_path_append_fmt(&tcrfile, "tc-result"); 564 if (atf_is_error(err)) 565 goto out_tcrfile; 566 567 fd = open(atf_fs_path_cstring(&tcrfile), O_RDONLY); 568 if (fd == -1) { 569 err = atf_libc_error(errno, "Cannot retrieve test case result"); 570 goto out_tcrfile; 571 } 572 573 err = atf_tcr_deserialize(tcr, fd); 574 575 close(fd); 576 out_tcrfile: 577 atf_fs_path_fini(&tcrfile); 578 out: 579 return err; 580 } 581 582 /* 583 * Child-only stuff. 584 */ 585 586 static const atf_tc_t *current_tc = NULL; 587 static const atf_fs_path_t *current_workdir = NULL; 588 static size_t current_tc_fail_count = 0; 589 590 static 591 atf_error_t 592 prepare_child(const struct child_data *cd) 593 { 594 atf_error_t err; 595 int i, ret; 596 597 current_tc = cd->tc; 598 current_workdir = cd->workdir; 599 current_tc_fail_count = 0; 600 601 ret = setpgid(getpid(), 0); 602 INV(ret != -1); 603 604 umask(S_IWGRP | S_IWOTH); 605 606 for (i = 1; i <= atf_signals_last_signo; i++) 607 atf_signal_reset(i); 608 609 err = atf_env_set("HOME", atf_fs_path_cstring(cd->workdir)); 610 if (atf_is_error(err)) 611 goto out; 612 613 err = atf_env_unset("LANG"); 614 if (atf_is_error(err)) 615 goto out; 616 617 err = atf_env_unset("LC_ALL"); 618 if (atf_is_error(err)) 619 goto out; 620 621 err = atf_env_unset("LC_COLLATE"); 622 if (atf_is_error(err)) 623 goto out; 624 625 err = atf_env_unset("LC_CTYPE"); 626 if (atf_is_error(err)) 627 goto out; 628 629 err = atf_env_unset("LC_MESSAGES"); 630 if (atf_is_error(err)) 631 goto out; 632 633 err = atf_env_unset("LC_MONETARY"); 634 if (atf_is_error(err)) 635 goto out; 636 637 err = atf_env_unset("LC_NUMERIC"); 638 if (atf_is_error(err)) 639 goto out; 640 641 err = atf_env_unset("LC_TIME"); 642 if (atf_is_error(err)) 643 goto out; 644 645 err = atf_env_unset("TZ"); 646 if (atf_is_error(err)) 647 goto out; 648 649 if (chdir(atf_fs_path_cstring(cd->workdir)) == -1) { 650 err = atf_libc_error(errno, "Cannot enter work directory '%s'", 651 atf_fs_path_cstring(cd->workdir)); 652 goto out; 653 } 654 655 err = atf_no_error(); 656 657 out: 658 return err; 659 } 660 661 static 662 void 663 body_child(void *v) 664 { 665 const struct child_data *cd = v; 666 atf_error_t err; 667 668 atf_reset_exit_checks(); 669 670 err = prepare_child(cd); 671 if (atf_is_error(err)) 672 goto print_err; 673 err = check_requirements(cd->tc); 674 if (atf_is_error(err)) 675 goto print_err; 676 677 cd->tc->m_body(cd->tc); 678 679 if (current_tc_fail_count == 0) 680 atf_tc_pass(); 681 else 682 atf_tc_fail("%d checks failed; see output for more details", 683 current_tc_fail_count); 684 685 UNREACHABLE; 686 687 print_err: 688 INV(atf_is_error(err)); 689 { 690 char buf[4096]; 691 692 atf_error_format(err, buf, sizeof(buf)); 693 atf_error_free(err); 694 695 atf_tc_fail("Error while preparing child process: %s", buf); 696 } 697 698 UNREACHABLE; 699 } 700 701 static 702 atf_error_t 703 check_arch(const char *arch, void *data) 704 { 705 bool *found = data; 706 707 if (strcmp(arch, atf_config_get("atf_arch")) == 0) 708 *found = true; 709 710 return atf_no_error(); 711 } 712 713 static 714 atf_error_t 715 check_config(const char *var, void *data) 716 { 717 if (!atf_tc_has_config_var(current_tc, var)) 718 atf_tc_skip("Required configuration variable %s not defined", var); 719 720 return atf_no_error(); 721 } 722 723 static 724 atf_error_t 725 check_machine(const char *machine, void *data) 726 { 727 bool *found = data; 728 729 if (strcmp(machine, atf_config_get("atf_machine")) == 0) 730 *found = true; 731 732 return atf_no_error(); 733 } 734 735 struct prog_found_pair { 736 const char *prog; 737 bool found; 738 }; 739 740 static 741 atf_error_t 742 check_prog(const char *prog, void *data) 743 { 744 atf_error_t err; 745 atf_fs_path_t p; 746 747 err = atf_fs_path_init_fmt(&p, "%s", prog); 748 if (atf_is_error(err)) 749 goto out; 750 751 if (atf_fs_path_is_absolute(&p)) { 752 err = atf_fs_eaccess(&p, atf_fs_access_x); 753 if (atf_is_error(err)) { 754 atf_error_free(err); 755 atf_fs_path_fini(&p); 756 atf_tc_skip("The required program %s could not be found", prog); 757 } 758 } else { 759 const char *path = atf_env_get("PATH"); 760 struct prog_found_pair pf; 761 atf_fs_path_t bp; 762 763 err = atf_fs_path_branch_path(&p, &bp); 764 if (atf_is_error(err)) 765 goto out_p; 766 767 if (strcmp(atf_fs_path_cstring(&bp), ".") != 0) { 768 atf_fs_path_fini(&bp); 769 atf_fs_path_fini(&p); 770 atf_tc_fail("Relative paths are not allowed when searching for " 771 "a program (%s)", prog); 772 } 773 774 pf.prog = prog; 775 pf.found = false; 776 err = atf_text_for_each_word(path, ":", check_prog_in_dir, &pf); 777 if (atf_is_error(err)) 778 goto out_bp; 779 780 if (!pf.found) { 781 atf_fs_path_fini(&bp); 782 atf_fs_path_fini(&p); 783 atf_tc_skip("The required program %s could not be found in " 784 "the PATH", prog); 785 } 786 787 out_bp: 788 atf_fs_path_fini(&bp); 789 } 790 791 out_p: 792 atf_fs_path_fini(&p); 793 out: 794 return err; 795 } 796 797 static 798 atf_error_t 799 check_prog_in_dir(const char *dir, void *data) 800 { 801 struct prog_found_pair *pf = data; 802 atf_error_t err; 803 804 if (pf->found) 805 err = atf_no_error(); 806 else { 807 atf_fs_path_t p; 808 809 err = atf_fs_path_init_fmt(&p, "%s/%s", dir, pf->prog); 810 if (atf_is_error(err)) 811 goto out_p; 812 813 err = atf_fs_eaccess(&p, atf_fs_access_x); 814 if (!atf_is_error(err)) 815 pf->found = true; 816 else { 817 atf_error_free(err); 818 INV(!pf->found); 819 err = atf_no_error(); 820 } 821 822 out_p: 823 atf_fs_path_fini(&p); 824 } 825 826 return err; 827 } 828 829 static 830 atf_error_t 831 check_requirements(const atf_tc_t *tc) 832 { 833 atf_error_t err; 834 835 err = atf_no_error(); 836 837 if (atf_tc_has_md_var(tc, "require.arch")) { 838 const char *arches = atf_tc_get_md_var(tc, "require.arch"); 839 bool found = false; 840 841 if (strlen(arches) == 0) 842 atf_tc_fail("Invalid value in the require.arch property"); 843 else { 844 err = atf_text_for_each_word(arches, " ", check_arch, &found); 845 if (atf_is_error(err)) 846 goto out; 847 848 if (!found) 849 atf_tc_skip("Requires one of the '%s' architectures", 850 arches); 851 } 852 } 853 854 if (atf_tc_has_md_var(tc, "require.config")) { 855 const char *vars = atf_tc_get_md_var(tc, "require.config"); 856 857 if (strlen(vars) == 0) 858 atf_tc_fail("Invalid value in the require.config property"); 859 else { 860 err = atf_text_for_each_word(vars, " ", check_config, NULL); 861 if (atf_is_error(err)) 862 goto out; 863 } 864 } 865 866 if (atf_tc_has_md_var(tc, "require.machine")) { 867 const char *machines = atf_tc_get_md_var(tc, "require.machine"); 868 bool found = false; 869 870 if (strlen(machines) == 0) 871 atf_tc_fail("Invalid value in the require.machine property"); 872 else { 873 err = atf_text_for_each_word(machines, " ", check_machine, 874 &found); 875 if (atf_is_error(err)) 876 goto out; 877 878 if (!found) 879 atf_tc_skip("Requires one of the '%s' machine types", 880 machines); 881 } 882 } 883 884 if (atf_tc_has_md_var(tc, "require.progs")) { 885 const char *progs = atf_tc_get_md_var(tc, "require.progs"); 886 887 if (strlen(progs) == 0) 888 atf_tc_fail("Invalid value in the require.progs property"); 889 else { 890 err = atf_text_for_each_word(progs, " ", check_prog, NULL); 891 if (atf_is_error(err)) 892 goto out; 893 } 894 } 895 896 if (atf_tc_has_md_var(tc, "require.user")) { 897 const char *u = atf_tc_get_md_var(tc, "require.user"); 898 899 if (strcmp(u, "root") == 0) { 900 if (!atf_user_is_root()) 901 atf_tc_skip("Requires root privileges"); 902 } else if (strcmp(u, "unprivileged") == 0) { 903 if (atf_user_is_root()) 904 atf_tc_skip("Requires an unprivileged user"); 905 } else 906 atf_tc_fail("Invalid value in the require.user property"); 907 } 908 909 INV(!atf_is_error(err)); 910 out: 911 return err; 912 } 913 914 static 915 void 916 cleanup_child(void *v) 917 { 918 const struct child_data *cd = v; 919 atf_error_t err; 920 921 err = prepare_child(cd); 922 if (atf_is_error(err)) { 923 atf_reset_exit_checks(); 924 exit(EXIT_FAILURE); 925 } else { 926 atf_reset_exit_checks(); 927 cd->tc->m_cleanup(cd->tc); 928 exit(EXIT_SUCCESS); 929 } 930 931 UNREACHABLE; 932 } 933 934 static 935 void 936 fatal_atf_error(const char *prefix, atf_error_t err) 937 { 938 char buf[1024]; 939 940 INV(atf_is_error(err)); 941 942 atf_error_format(err, buf, sizeof(buf)); 943 atf_error_free(err); 944 945 fprintf(stderr, "%s: %s", prefix, buf); 946 947 abort(); 948 } 949 950 static 951 void 952 fatal_libc_error(const char *prefix, int err) 953 { 954 fprintf(stderr, "%s: %s", prefix, strerror(err)); 955 956 abort(); 957 } 958 959 static 960 void 961 write_tcr(const atf_tcr_t *tcr) 962 { 963 atf_error_t err; 964 int fd; 965 atf_fs_path_t tcrfile; 966 967 err = atf_fs_path_copy(&tcrfile, current_workdir); 968 if (atf_is_error(err)) 969 fatal_atf_error("Cannot write test case results", err); 970 971 err = atf_fs_path_append_fmt(&tcrfile, "tc-result"); 972 if (atf_is_error(err)) 973 fatal_atf_error("Cannot write test case results", err); 974 975 fd = open(atf_fs_path_cstring(&tcrfile), 976 O_WRONLY | O_CREAT | O_TRUNC, 0755); 977 if (fd == -1) 978 fatal_libc_error("Cannot write test case results", errno); 979 980 err = atf_tcr_serialize(tcr, fd); 981 if (atf_is_error(err)) 982 fatal_atf_error("Cannot write test case results", err); 983 984 close(fd); 985 atf_fs_path_fini(&tcrfile); 986 } 987 988 static 989 void 990 tc_fail(atf_dynstr_t *msg) 991 { 992 atf_tcr_t tcr; 993 atf_error_t err; 994 995 PRE(current_tc != NULL); 996 997 err = atf_tcr_init_reason_fmt(&tcr, atf_tcr_failed_state, "%s", 998 atf_dynstr_cstring(msg)); 999 if (atf_is_error(err)) 1000 abort(); 1001 1002 write_tcr(&tcr); 1003 1004 atf_tcr_fini(&tcr); 1005 atf_dynstr_fini(msg); 1006 1007 exit(EXIT_SUCCESS); 1008 } 1009 1010 static 1011 void 1012 tc_fail_nonfatal(atf_dynstr_t *msg) 1013 { 1014 fprintf(stderr, "%s\n", atf_dynstr_cstring(msg)); 1015 atf_dynstr_fini(msg); 1016 1017 current_tc_fail_count++; 1018 } 1019 1020 void 1021 atf_tc_fail(const char *fmt, ...) 1022 { 1023 va_list ap; 1024 atf_tcr_t tcr; 1025 atf_error_t err; 1026 1027 PRE(current_tc != NULL); 1028 1029 va_start(ap, fmt); 1030 err = atf_tcr_init_reason_ap(&tcr, atf_tcr_failed_state, fmt, ap); 1031 va_end(ap); 1032 if (atf_is_error(err)) 1033 abort(); 1034 1035 write_tcr(&tcr); 1036 1037 atf_tcr_fini(&tcr); 1038 1039 exit(EXIT_SUCCESS); 1040 } 1041 1042 void 1043 atf_tc_fail_nonfatal(const char *fmt, ...) 1044 { 1045 va_list ap; 1046 1047 va_start(ap, fmt); 1048 vfprintf(stderr, fmt, ap); 1049 va_end(ap); 1050 fprintf(stderr, "\n"); 1051 1052 current_tc_fail_count++; 1053 } 1054 1055 void 1056 atf_tc_fail_check(const char *file, int line, const char *fmt, ...) 1057 { 1058 va_list ap; 1059 1060 va_start(ap, fmt); 1061 fail_internal(file, line, "Check failed", "*** ", fmt, ap, 1062 tc_fail_nonfatal, atf_tc_fail_nonfatal); 1063 va_end(ap); 1064 } 1065 1066 void 1067 atf_tc_fail_requirement(const char *file, int line, const char *fmt, ...) 1068 { 1069 va_list ap; 1070 1071 atf_reset_exit_checks(); 1072 1073 va_start(ap, fmt); 1074 fail_internal(file, line, "Requirement failed", "", fmt, ap, 1075 tc_fail, atf_tc_fail); 1076 va_end(ap); 1077 1078 UNREACHABLE; 1079 abort(); 1080 } 1081 1082 static 1083 void 1084 fail_internal(const char *file, int line, const char *reason, 1085 const char *prefix, const char *fmt, va_list ap, 1086 void (*failfunc)(atf_dynstr_t *), 1087 void (*backupfunc)(const char *, ...)) 1088 { 1089 va_list ap2; 1090 atf_error_t err; 1091 atf_dynstr_t msg; 1092 1093 err = atf_dynstr_init_fmt(&msg, "%s%s:%d: %s: ", prefix, file, line, 1094 reason); 1095 if (atf_is_error(err)) 1096 goto backup; 1097 1098 va_copy(ap2, ap); 1099 err = atf_dynstr_append_ap(&msg, fmt, ap2); 1100 va_end(ap2); 1101 if (atf_is_error(err)) { 1102 atf_dynstr_fini(&msg); 1103 goto backup; 1104 } 1105 1106 va_copy(ap2, ap); 1107 failfunc(&msg); 1108 return; 1109 1110 backup: 1111 atf_error_free(err); 1112 va_copy(ap2, ap); 1113 backupfunc(fmt, ap2); 1114 va_end(ap2); 1115 } 1116 1117 void 1118 atf_tc_pass(void) 1119 { 1120 atf_tcr_t tcr; 1121 atf_error_t err; 1122 1123 PRE(current_tc != NULL); 1124 1125 err = atf_tcr_init(&tcr, atf_tcr_passed_state); 1126 if (atf_is_error(err)) 1127 abort(); 1128 1129 write_tcr(&tcr); 1130 1131 atf_tcr_fini(&tcr); 1132 1133 exit(EXIT_SUCCESS); 1134 } 1135 1136 void 1137 atf_tc_require_prog(const char *prog) 1138 { 1139 atf_error_t err; 1140 1141 err = check_prog(prog, NULL); 1142 if (atf_is_error(err)) { 1143 atf_error_free(err); 1144 atf_tc_fail("atf_tc_require_prog failed"); /* XXX Correct? */ 1145 } 1146 } 1147 1148 void 1149 atf_tc_skip(const char *fmt, ...) 1150 { 1151 va_list ap; 1152 atf_tcr_t tcr; 1153 atf_error_t err; 1154 1155 PRE(current_tc != NULL); 1156 1157 va_start(ap, fmt); 1158 err = atf_tcr_init_reason_ap(&tcr, atf_tcr_skipped_state, fmt, ap); 1159 va_end(ap); 1160 if (atf_is_error(err)) 1161 abort(); 1162 1163 write_tcr(&tcr); 1164 1165 atf_tcr_fini(&tcr); 1166 1167 exit(EXIT_SUCCESS); 1168 } 1169
Indexes created Wed Mar 25 00:23:37 UTC 2026