1#!/usr/bin/perl -w 2# SPDX-License-Identifier: GPL-2.0-only 3# 4# Copyright 2010 - Steven Rostedt <srostedt@redhat.com>, Red Hat Inc. 5# 6 7use strict; 8use IPC::Open2; 9use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK); 10use File::Path qw(mkpath); 11use File::Copy qw(cp); 12use FileHandle; 13use FindBin; 14use IO::Handle; 15 16my $VERSION = "0.2"; 17 18$| = 1; 19 20my %opt; 21my %repeat_tests; 22my %repeats; 23my %evals; 24 25#default opts 26my %default = ( 27 "MAILER" => "sendmail", # default mailer 28 "EMAIL_ON_ERROR" => 1, 29 "EMAIL_WHEN_FINISHED" => 1, 30 "EMAIL_WHEN_CANCELED" => 0, 31 "EMAIL_WHEN_STARTED" => 0, 32 "NUM_TESTS" => 1, 33 "TEST_TYPE" => "build", 34 "BUILD_TYPE" => "oldconfig", 35 "MAKE_CMD" => "make", 36 "CLOSE_CONSOLE_SIGNAL" => "INT", 37 "TIMEOUT" => 120, 38 "TMP_DIR" => "/tmp/ktest/\${MACHINE}", 39 "SLEEP_TIME" => 60, # sleep time between tests 40 "BUILD_NOCLEAN" => 0, 41 "REBOOT_ON_ERROR" => 0, 42 "POWEROFF_ON_ERROR" => 0, 43 "REBOOT_ON_SUCCESS" => 1, 44 "POWEROFF_ON_SUCCESS" => 0, 45 "BUILD_OPTIONS" => "", 46 "BISECT_SLEEP_TIME" => 60, # sleep time between bisects 47 "PATCHCHECK_SLEEP_TIME" => 60, # sleep time between patch checks 48 "CLEAR_LOG" => 0, 49 "BISECT_MANUAL" => 0, 50 "BISECT_SKIP" => 1, 51 "BISECT_TRIES" => 1, 52 "MIN_CONFIG_TYPE" => "boot", 53 "SUCCESS_LINE" => "login:", 54 "DETECT_TRIPLE_FAULT" => 1, 55 "NO_INSTALL" => 0, 56 "BOOTED_TIMEOUT" => 1, 57 "DIE_ON_FAILURE" => 1, 58 "SSH_EXEC" => "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND", 59 "SCP_TO_TARGET" => "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE", 60 "SCP_TO_TARGET_INSTALL" => "\${SCP_TO_TARGET}", 61 "REBOOT" => "ssh \$SSH_USER\@\$MACHINE reboot", 62 "REBOOT_RETURN_CODE" => 255, 63 "STOP_AFTER_SUCCESS" => 10, 64 "STOP_AFTER_FAILURE" => 60, 65 "STOP_TEST_AFTER" => 600, 66 "MAX_MONITOR_WAIT" => 1800, 67 "GRUB_REBOOT" => "grub2-reboot", 68 "GRUB_BLS_GET" => "grubby --info=ALL", 69 "SYSLINUX" => "extlinux", 70 "SYSLINUX_PATH" => "/boot/extlinux", 71 "CONNECT_TIMEOUT" => 25, 72 73# required, and we will ask users if they don't have them but we keep the default 74# value something that is common. 75 "REBOOT_TYPE" => "grub", 76 "LOCALVERSION" => "-test", 77 "SSH_USER" => "root", 78 "BUILD_TARGET" => "arch/x86/boot/bzImage", 79 "TARGET_IMAGE" => "/boot/vmlinuz-test", 80 81 "LOG_FILE" => undef, 82 "IGNORE_UNUSED" => 0, 83); 84 85my $test_log_start = 0; 86 87my $ktest_config = "ktest.conf"; 88my $version; 89my $have_version = 0; 90my $machine; 91my $last_machine; 92my $ssh_user; 93my $tmpdir; 94my $builddir; 95my $outputdir; 96my $output_config; 97my $test_type; 98my $build_type; 99my $build_options; 100my $final_post_ktest; 101my $pre_ktest; 102my $post_ktest; 103my $pre_test; 104my $pre_test_die; 105my $post_test; 106my $pre_build; 107my $post_build; 108my $pre_build_die; 109my $post_build_die; 110my $reboot_type; 111my $reboot_script; 112my $power_cycle; 113my $reboot; 114my $reboot_return_code; 115my $reboot_on_error; 116my $switch_to_good; 117my $switch_to_test; 118my $poweroff_on_error; 119my $reboot_on_success; 120my $die_on_failure; 121my $powercycle_after_reboot; 122my $poweroff_after_halt; 123my $max_monitor_wait; 124my $ssh_exec; 125my $scp_to_target; 126my $scp_to_target_install; 127my $power_off; 128my $grub_menu; 129my $last_grub_menu; 130my $grub_file; 131my $grub_number; 132my $grub_reboot; 133my $grub_bls_get; 134my $syslinux; 135my $syslinux_path; 136my $syslinux_label; 137my $target; 138my $make; 139my $pre_install; 140my $post_install; 141my $no_install; 142my $noclean; 143my $minconfig; 144my $start_minconfig; 145my $start_minconfig_defined; 146my $output_minconfig; 147my $minconfig_type; 148my $use_output_minconfig; 149my $warnings_file; 150my $ignore_config; 151my $ignore_errors; 152my $addconfig; 153my $in_bisect = 0; 154my $bisect_bad_commit = ""; 155my $reverse_bisect; 156my $bisect_manual; 157my $bisect_skip; 158my $bisect_tries; 159my $config_bisect_good; 160my $bisect_ret_good; 161my $bisect_ret_bad; 162my $bisect_ret_skip; 163my $bisect_ret_abort; 164my $bisect_ret_default; 165my $in_patchcheck = 0; 166my $run_test; 167my $buildlog; 168my $testlog; 169my $dmesg; 170my $monitor_fp; 171my $monitor_pid; 172my $monitor_cnt = 0; 173my $sleep_time; 174my $bisect_sleep_time; 175my $patchcheck_sleep_time; 176my $ignore_warnings; 177my $store_failures; 178my $store_successes; 179my $test_name; 180my $timeout; 181my $connect_timeout; 182my $config_bisect_exec; 183my $booted_timeout; 184my $detect_triplefault; 185my $console; 186my $close_console_signal; 187my $reboot_success_line; 188my $success_line; 189my $stop_after_success; 190my $stop_after_failure; 191my $stop_test_after; 192my $build_target; 193my $target_image; 194my $checkout; 195my $localversion; 196my $iteration = 0; 197my $successes = 0; 198my $stty_orig; 199my $run_command_status = 0; 200 201my $bisect_good; 202my $bisect_bad; 203my $bisect_type; 204my $bisect_start; 205my $bisect_replay; 206my $bisect_files; 207my $bisect_reverse; 208my $bisect_check; 209 210my $config_bisect; 211my $config_bisect_type; 212my $config_bisect_check; 213 214my $patchcheck_type; 215my $patchcheck_start; 216my $patchcheck_cherry; 217my $patchcheck_end; 218 219my $build_time; 220my $install_time; 221my $reboot_time; 222my $test_time; 223 224my $pwd; 225my $dirname = $FindBin::Bin; 226 227my $mailto; 228my $mailer; 229my $mail_path; 230my $mail_max_size; 231my $mail_command; 232my $email_on_error; 233my $email_when_finished; 234my $email_when_started; 235my $email_when_canceled; 236 237my $script_start_time = localtime(); 238 239# set when a test is something other that just building or install 240# which would require more options. 241my $buildonly = 1; 242 243# tell build not to worry about warnings, even when WARNINGS_FILE is set 244my $warnings_ok = 0; 245 246# set when creating a new config 247my $newconfig = 0; 248 249my %entered_configs; 250my %config_help; 251my %variable; 252 253# force_config is the list of configs that we force enabled (or disabled) 254# in a .config file. The MIN_CONFIG and ADD_CONFIG configs. 255my %force_config; 256 257# do not force reboots on config problems 258my $no_reboot = 1; 259 260# reboot on success 261my $reboot_success = 0; 262 263my %option_map = ( 264 "MAILTO" => \$mailto, 265 "MAILER" => \$mailer, 266 "MAIL_PATH" => \$mail_path, 267 "MAIL_MAX_SIZE" => \$mail_max_size, 268 "MAIL_COMMAND" => \$mail_command, 269 "EMAIL_ON_ERROR" => \$email_on_error, 270 "EMAIL_WHEN_FINISHED" => \$email_when_finished, 271 "EMAIL_WHEN_STARTED" => \$email_when_started, 272 "EMAIL_WHEN_CANCELED" => \$email_when_canceled, 273 "MACHINE" => \$machine, 274 "SSH_USER" => \$ssh_user, 275 "TMP_DIR" => \$tmpdir, 276 "OUTPUT_DIR" => \$outputdir, 277 "BUILD_DIR" => \$builddir, 278 "TEST_TYPE" => \$test_type, 279 "PRE_KTEST" => \$pre_ktest, 280 "POST_KTEST" => \$post_ktest, 281 "PRE_TEST" => \$pre_test, 282 "PRE_TEST_DIE" => \$pre_test_die, 283 "POST_TEST" => \$post_test, 284 "BUILD_TYPE" => \$build_type, 285 "BUILD_OPTIONS" => \$build_options, 286 "PRE_BUILD" => \$pre_build, 287 "POST_BUILD" => \$post_build, 288 "PRE_BUILD_DIE" => \$pre_build_die, 289 "POST_BUILD_DIE" => \$post_build_die, 290 "POWER_CYCLE" => \$power_cycle, 291 "REBOOT" => \$reboot, 292 "REBOOT_RETURN_CODE" => \$reboot_return_code, 293 "BUILD_NOCLEAN" => \$noclean, 294 "MIN_CONFIG" => \$minconfig, 295 "OUTPUT_MIN_CONFIG" => \$output_minconfig, 296 "START_MIN_CONFIG" => \$start_minconfig, 297 "MIN_CONFIG_TYPE" => \$minconfig_type, 298 "USE_OUTPUT_MIN_CONFIG" => \$use_output_minconfig, 299 "WARNINGS_FILE" => \$warnings_file, 300 "IGNORE_CONFIG" => \$ignore_config, 301 "TEST" => \$run_test, 302 "ADD_CONFIG" => \$addconfig, 303 "REBOOT_TYPE" => \$reboot_type, 304 "GRUB_MENU" => \$grub_menu, 305 "GRUB_FILE" => \$grub_file, 306 "GRUB_REBOOT" => \$grub_reboot, 307 "GRUB_BLS_GET" => \$grub_bls_get, 308 "SYSLINUX" => \$syslinux, 309 "SYSLINUX_PATH" => \$syslinux_path, 310 "SYSLINUX_LABEL" => \$syslinux_label, 311 "PRE_INSTALL" => \$pre_install, 312 "POST_INSTALL" => \$post_install, 313 "NO_INSTALL" => \$no_install, 314 "REBOOT_SCRIPT" => \$reboot_script, 315 "REBOOT_ON_ERROR" => \$reboot_on_error, 316 "SWITCH_TO_GOOD" => \$switch_to_good, 317 "SWITCH_TO_TEST" => \$switch_to_test, 318 "POWEROFF_ON_ERROR" => \$poweroff_on_error, 319 "REBOOT_ON_SUCCESS" => \$reboot_on_success, 320 "DIE_ON_FAILURE" => \$die_on_failure, 321 "POWER_OFF" => \$power_off, 322 "POWERCYCLE_AFTER_REBOOT" => \$powercycle_after_reboot, 323 "POWEROFF_AFTER_HALT" => \$poweroff_after_halt, 324 "MAX_MONITOR_WAIT" => \$max_monitor_wait, 325 "SLEEP_TIME" => \$sleep_time, 326 "BISECT_SLEEP_TIME" => \$bisect_sleep_time, 327 "PATCHCHECK_SLEEP_TIME" => \$patchcheck_sleep_time, 328 "IGNORE_WARNINGS" => \$ignore_warnings, 329 "IGNORE_ERRORS" => \$ignore_errors, 330 "BISECT_MANUAL" => \$bisect_manual, 331 "BISECT_SKIP" => \$bisect_skip, 332 "BISECT_TRIES" => \$bisect_tries, 333 "CONFIG_BISECT_GOOD" => \$config_bisect_good, 334 "BISECT_RET_GOOD" => \$bisect_ret_good, 335 "BISECT_RET_BAD" => \$bisect_ret_bad, 336 "BISECT_RET_SKIP" => \$bisect_ret_skip, 337 "BISECT_RET_ABORT" => \$bisect_ret_abort, 338 "BISECT_RET_DEFAULT" => \$bisect_ret_default, 339 "STORE_FAILURES" => \$store_failures, 340 "STORE_SUCCESSES" => \$store_successes, 341 "TEST_NAME" => \$test_name, 342 "TIMEOUT" => \$timeout, 343 "CONNECT_TIMEOUT" => \$connect_timeout, 344 "CONFIG_BISECT_EXEC" => \$config_bisect_exec, 345 "BOOTED_TIMEOUT" => \$booted_timeout, 346 "CONSOLE" => \$console, 347 "CLOSE_CONSOLE_SIGNAL" => \$close_console_signal, 348 "DETECT_TRIPLE_FAULT" => \$detect_triplefault, 349 "SUCCESS_LINE" => \$success_line, 350 "REBOOT_SUCCESS_LINE" => \$reboot_success_line, 351 "STOP_AFTER_SUCCESS" => \$stop_after_success, 352 "STOP_AFTER_FAILURE" => \$stop_after_failure, 353 "STOP_TEST_AFTER" => \$stop_test_after, 354 "BUILD_TARGET" => \$build_target, 355 "SSH_EXEC" => \$ssh_exec, 356 "SCP_TO_TARGET" => \$scp_to_target, 357 "SCP_TO_TARGET_INSTALL" => \$scp_to_target_install, 358 "CHECKOUT" => \$checkout, 359 "TARGET_IMAGE" => \$target_image, 360 "LOCALVERSION" => \$localversion, 361 362 "BISECT_GOOD" => \$bisect_good, 363 "BISECT_BAD" => \$bisect_bad, 364 "BISECT_TYPE" => \$bisect_type, 365 "BISECT_START" => \$bisect_start, 366 "BISECT_REPLAY" => \$bisect_replay, 367 "BISECT_FILES" => \$bisect_files, 368 "BISECT_REVERSE" => \$bisect_reverse, 369 "BISECT_CHECK" => \$bisect_check, 370 371 "CONFIG_BISECT" => \$config_bisect, 372 "CONFIG_BISECT_TYPE" => \$config_bisect_type, 373 "CONFIG_BISECT_CHECK" => \$config_bisect_check, 374 375 "PATCHCHECK_TYPE" => \$patchcheck_type, 376 "PATCHCHECK_START" => \$patchcheck_start, 377 "PATCHCHECK_CHERRY" => \$patchcheck_cherry, 378 "PATCHCHECK_END" => \$patchcheck_end, 379); 380 381# Options may be used by other options, record them. 382my %used_options; 383 384# default variables that can be used 385chomp ($variable{"PWD"} = `pwd`); 386$pwd = $variable{"PWD"}; 387 388$config_help{"MACHINE"} = << "EOF" 389 The machine hostname that you will test. 390 For build only tests, it is still needed to differentiate log files. 391EOF 392 ; 393$config_help{"SSH_USER"} = << "EOF" 394 The box is expected to have ssh on normal bootup, provide the user 395 (most likely root, since you need privileged operations) 396EOF 397 ; 398$config_help{"BUILD_DIR"} = << "EOF" 399 The directory that contains the Linux source code (full path). 400 You can use \${PWD} that will be the path where ktest.pl is run, or use 401 \${THIS_DIR} which is assigned \${PWD} but may be changed later. 402EOF 403 ; 404$config_help{"OUTPUT_DIR"} = << "EOF" 405 The directory that the objects will be built (full path). 406 (can not be same as BUILD_DIR) 407 You can use \${PWD} that will be the path where ktest.pl is run, or use 408 \${THIS_DIR} which is assigned \${PWD} but may be changed later. 409EOF 410 ; 411$config_help{"BUILD_TARGET"} = << "EOF" 412 The location of the compiled file to copy to the target. 413 (relative to OUTPUT_DIR) 414EOF 415 ; 416$config_help{"BUILD_OPTIONS"} = << "EOF" 417 Options to add to \"make\" when building. 418 i.e. -j20 419EOF 420 ; 421$config_help{"TARGET_IMAGE"} = << "EOF" 422 The place to put your image on the test machine. 423EOF 424 ; 425$config_help{"POWER_CYCLE"} = << "EOF" 426 A script or command to reboot the box. 427 428 Here is a digital loggers power switch example 429 POWER_CYCLE = wget --no-proxy -O /dev/null -q --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL' 430 431 Here is an example to reboot a virtual box on the current host 432 with the name "Guest". 433 POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest 434EOF 435 ; 436$config_help{"CONSOLE"} = << "EOF" 437 The script or command that reads the console 438 439 If you use ttywatch server, something like the following would work. 440CONSOLE = nc -d localhost 3001 441 442 For a virtual machine with guest name "Guest". 443CONSOLE = virsh console Guest 444EOF 445 ; 446$config_help{"LOCALVERSION"} = << "EOF" 447 Required version ending to differentiate the test 448 from other linux builds on the system. 449EOF 450 ; 451$config_help{"REBOOT_TYPE"} = << "EOF" 452 Way to reboot the box to the test kernel. 453 Only valid options so far are "grub", "grub2", "grub2bls", "syslinux", and "script". 454 455 If you specify grub, it will assume grub version 1 456 and will search in /boot/grub/menu.lst for the title \$GRUB_MENU 457 and select that target to reboot to the kernel. If this is not 458 your setup, then specify "script" and have a command or script 459 specified in REBOOT_SCRIPT to boot to the target. 460 461 The entry in /boot/grub/menu.lst must be entered in manually. 462 The test will not modify that file. 463 464 If you specify grub2, then you also need to specify both \$GRUB_MENU 465 and \$GRUB_FILE. 466 467 If you specify grub2bls, then you also need to specify \$GRUB_MENU. 468 469 If you specify syslinux, then you may use SYSLINUX to define the syslinux 470 command (defaults to extlinux), and SYSLINUX_PATH to specify the path to 471 the syslinux install (defaults to /boot/extlinux). But you have to specify 472 SYSLINUX_LABEL to define the label to boot to for the test kernel. 473EOF 474 ; 475$config_help{"GRUB_MENU"} = << "EOF" 476 The grub title name for the test kernel to boot 477 (Only mandatory if REBOOT_TYPE = grub or grub2) 478 479 Note, ktest.pl will not update the grub menu.lst, you need to 480 manually add an option for the test. ktest.pl will search 481 the grub menu.lst for this option to find what kernel to 482 reboot into. 483 484 For example, if in the /boot/grub/menu.lst the test kernel title has: 485 title Test Kernel 486 kernel vmlinuz-test 487 GRUB_MENU = Test Kernel 488 489 For grub2, a search of \$GRUB_FILE is performed for the lines 490 that begin with "menuentry". It will not detect submenus. The 491 menu must be a non-nested menu. Add the quotes used in the menu 492 to guarantee your selection, as the first menuentry with the content 493 of \$GRUB_MENU that is found will be used. 494 495 For grub2bls, \$GRUB_MENU is searched on the result of \$GRUB_BLS_GET 496 command for the lines that begin with "title". 497EOF 498 ; 499$config_help{"GRUB_FILE"} = << "EOF" 500 If grub2 is used, the full path for the grub.cfg file is placed 501 here. Use something like /boot/grub2/grub.cfg to search. 502EOF 503 ; 504$config_help{"SYSLINUX_LABEL"} = << "EOF" 505 If syslinux is used, the label that boots the target kernel must 506 be specified with SYSLINUX_LABEL. 507EOF 508 ; 509$config_help{"REBOOT_SCRIPT"} = << "EOF" 510 A script to reboot the target into the test kernel 511 (Only mandatory if REBOOT_TYPE = script) 512EOF 513 ; 514 515sub _logit { 516 if (defined($opt{"LOG_FILE"})) { 517 print LOG @_; 518 } 519} 520 521sub logit { 522 if (defined($opt{"LOG_FILE"})) { 523 _logit @_; 524 } else { 525 print @_; 526 } 527} 528 529sub doprint { 530 print @_; 531 _logit @_; 532} 533 534sub read_prompt { 535 my ($cancel, $prompt) = @_; 536 537 my $ans; 538 539 for (;;) { 540 if ($cancel) { 541 print "$prompt [y/n/C] "; 542 } else { 543 print "$prompt [Y/n] "; 544 } 545 $ans = <STDIN>; 546 chomp $ans; 547 if ($ans =~ /^\s*$/) { 548 if ($cancel) { 549 $ans = "c"; 550 } else { 551 $ans = "y"; 552 } 553 } 554 last if ($ans =~ /^y$/i || $ans =~ /^n$/i); 555 if ($cancel) { 556 last if ($ans =~ /^c$/i); 557 print "Please answer either 'y', 'n' or 'c'.\n"; 558 } else { 559 print "Please answer either 'y' or 'n'.\n"; 560 } 561 } 562 if ($ans =~ /^c/i) { 563 exit; 564 } 565 if ($ans !~ /^y$/i) { 566 return 0; 567 } 568 return 1; 569} 570 571sub read_yn { 572 my ($prompt) = @_; 573 574 return read_prompt 0, $prompt; 575} 576 577sub read_ync { 578 my ($prompt) = @_; 579 580 return read_prompt 1, $prompt; 581} 582 583sub get_mandatory_config { 584 my ($config) = @_; 585 my $ans; 586 587 return if (defined($opt{$config})); 588 589 if (defined($config_help{$config})) { 590 print "\n"; 591 print $config_help{$config}; 592 } 593 594 for (;;) { 595 print "$config = "; 596 if (defined($default{$config}) && length($default{$config})) { 597 print "\[$default{$config}\] "; 598 } 599 $ans = <STDIN>; 600 $ans =~ s/^\s*(.*\S)\s*$/$1/; 601 if ($ans =~ /^\s*$/) { 602 if ($default{$config}) { 603 $ans = $default{$config}; 604 } else { 605 print "Your answer can not be blank\n"; 606 next; 607 } 608 } 609 $entered_configs{$config} = ${ans}; 610 last; 611 } 612} 613 614sub show_time { 615 my ($time) = @_; 616 617 my $hours = 0; 618 my $minutes = 0; 619 620 if ($time > 3600) { 621 $hours = int($time / 3600); 622 $time -= $hours * 3600; 623 } 624 if ($time > 60) { 625 $minutes = int($time / 60); 626 $time -= $minutes * 60; 627 } 628 629 if ($hours > 0) { 630 doprint "$hours hour"; 631 doprint "s" if ($hours > 1); 632 doprint " "; 633 } 634 635 if ($minutes > 0) { 636 doprint "$minutes minute"; 637 doprint "s" if ($minutes > 1); 638 doprint " "; 639 } 640 641 doprint "$time second"; 642 doprint "s" if ($time != 1); 643} 644 645sub print_times { 646 doprint "\n"; 647 if ($build_time) { 648 doprint "Build time: "; 649 show_time($build_time); 650 doprint "\n"; 651 } 652 if ($install_time) { 653 doprint "Install time: "; 654 show_time($install_time); 655 doprint "\n"; 656 } 657 if ($reboot_time) { 658 doprint "Reboot time: "; 659 show_time($reboot_time); 660 doprint "\n"; 661 } 662 if ($test_time) { 663 doprint "Test time: "; 664 show_time($test_time); 665 doprint "\n"; 666 } 667 # reset for iterations like bisect 668 $build_time = 0; 669 $install_time = 0; 670 $reboot_time = 0; 671 $test_time = 0; 672} 673 674sub get_mandatory_configs { 675 get_mandatory_config("MACHINE"); 676 get_mandatory_config("BUILD_DIR"); 677 get_mandatory_config("OUTPUT_DIR"); 678 679 if ($newconfig) { 680 get_mandatory_config("BUILD_OPTIONS"); 681 } 682 683 # options required for other than just building a kernel 684 if (!$buildonly) { 685 get_mandatory_config("POWER_CYCLE"); 686 get_mandatory_config("CONSOLE"); 687 } 688 689 # options required for install and more 690 if ($buildonly != 1) { 691 get_mandatory_config("SSH_USER"); 692 get_mandatory_config("BUILD_TARGET"); 693 get_mandatory_config("TARGET_IMAGE"); 694 } 695 696 get_mandatory_config("LOCALVERSION"); 697 698 return if ($buildonly); 699 700 my $rtype = $opt{"REBOOT_TYPE"}; 701 702 if (!defined($rtype)) { 703 if (!defined($opt{"GRUB_MENU"})) { 704 get_mandatory_config("REBOOT_TYPE"); 705 $rtype = $entered_configs{"REBOOT_TYPE"}; 706 } else { 707 $rtype = "grub"; 708 } 709 } 710 711 if (($rtype eq "grub") or ($rtype eq "grub2bls")) { 712 get_mandatory_config("GRUB_MENU"); 713 } 714 715 if ($rtype eq "grub2") { 716 get_mandatory_config("GRUB_MENU"); 717 get_mandatory_config("GRUB_FILE"); 718 } 719 720 if ($rtype eq "syslinux") { 721 get_mandatory_config("SYSLINUX_LABEL"); 722 } 723} 724 725sub process_variables { 726 my ($value, $remove_undef) = @_; 727 my $retval = ""; 728 729 # We want to check for '\', and it is just easier 730 # to check the previous characet of '$' and not need 731 # to worry if '$' is the first character. By adding 732 # a space to $value, we can just check [^\\]\$ and 733 # it will still work. 734 $value = " $value"; 735 736 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) { 737 my $begin = $1; 738 my $var = $2; 739 my $end = $3; 740 # append beginning of value to retval 741 $retval = "$retval$begin"; 742 if (defined($variable{$var})) { 743 $retval = "$retval$variable{$var}"; 744 } elsif (defined($remove_undef) && $remove_undef) { 745 # for if statements, any variable that is not defined, 746 # we simple convert to 0 747 $retval = "${retval}0"; 748 } else { 749 # put back the origin piece. 750 $retval = "$retval\$\{$var\}"; 751 # This could be an option that is used later, save 752 # it so we don't warn if this option is not one of 753 # ktests options. 754 $used_options{$var} = 1; 755 } 756 $value = $end; 757 } 758 $retval = "$retval$value"; 759 760 # remove the space added in the beginning 761 $retval =~ s/ //; 762 763 return "$retval" 764} 765 766sub set_value { 767 my ($lvalue, $rvalue, $override, $overrides, $name) = @_; 768 769 my $prvalue = process_variables($rvalue); 770 771 if ($lvalue =~ /^(TEST|BISECT|CONFIG_BISECT)_TYPE(\[.*\])?$/ && 772 $prvalue !~ /^(config_|)bisect$/ && 773 $prvalue !~ /^build$/ && 774 $buildonly) { 775 776 # Note if a test is something other than build, then we 777 # will need other mandatory options. 778 if ($prvalue ne "install") { 779 $buildonly = 0; 780 } else { 781 # install still limits some mandatory options. 782 $buildonly = 2; 783 } 784 } 785 786 if (defined($opt{$lvalue})) { 787 if (!$override || defined(${$overrides}{$lvalue})) { 788 my $extra = ""; 789 if ($override) { 790 $extra = "In the same override section!\n"; 791 } 792 die "$name: $.: Option $lvalue defined more than once!\n$extra"; 793 } 794 ${$overrides}{$lvalue} = $prvalue; 795 } 796 797 $opt{$lvalue} = $prvalue; 798} 799 800sub set_eval { 801 my ($lvalue, $rvalue, $name) = @_; 802 803 my $prvalue = process_variables($rvalue); 804 my $arr; 805 806 if (defined($evals{$lvalue})) { 807 $arr = $evals{$lvalue}; 808 } else { 809 $arr = []; 810 $evals{$lvalue} = $arr; 811 } 812 813 push @{$arr}, $rvalue; 814} 815 816sub set_variable { 817 my ($lvalue, $rvalue) = @_; 818 819 if ($rvalue =~ /^\s*$/) { 820 delete $variable{$lvalue}; 821 } else { 822 $rvalue = process_variables($rvalue); 823 $variable{$lvalue} = $rvalue; 824 } 825} 826 827sub process_compare { 828 my ($lval, $cmp, $rval) = @_; 829 830 # remove whitespace 831 832 $lval =~ s/^\s*//; 833 $lval =~ s/\s*$//; 834 835 $rval =~ s/^\s*//; 836 $rval =~ s/\s*$//; 837 838 if ($cmp eq "==") { 839 return $lval eq $rval; 840 } elsif ($cmp eq "!=") { 841 return $lval ne $rval; 842 } elsif ($cmp eq "=~") { 843 return $lval =~ m/$rval/; 844 } elsif ($cmp eq "!~") { 845 return $lval !~ m/$rval/; 846 } 847 848 my $statement = "$lval $cmp $rval"; 849 my $ret = eval $statement; 850 851 # $@ stores error of eval 852 if ($@) { 853 return -1; 854 } 855 856 return $ret; 857} 858 859sub value_defined { 860 my ($val) = @_; 861 862 return defined($variable{$2}) || 863 defined($opt{$2}); 864} 865 866my $d = 0; 867sub process_expression { 868 my ($name, $val) = @_; 869 870 my $c = $d++; 871 872 while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) { 873 my $express = $1; 874 875 if (process_expression($name, $express)) { 876 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /; 877 } else { 878 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /; 879 } 880 } 881 882 $d--; 883 my $OR = "\\|\\|"; 884 my $AND = "\\&\\&"; 885 886 while ($val =~ s/^(.*?)($OR|$AND)//) { 887 my $express = $1; 888 my $op = $2; 889 890 if (process_expression($name, $express)) { 891 if ($op eq "||") { 892 return 1; 893 } 894 } else { 895 if ($op eq "&&") { 896 return 0; 897 } 898 } 899 } 900 901 if ($val =~ /(.*)(==|\!=|>=|<=|>|<|=~|\!~)(.*)/) { 902 my $ret = process_compare($1, $2, $3); 903 if ($ret < 0) { 904 die "$name: $.: Unable to process comparison\n"; 905 } 906 return $ret; 907 } 908 909 if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) { 910 if (defined $1) { 911 return !value_defined($2); 912 } else { 913 return value_defined($2); 914 } 915 } 916 917 if ($val =~ s/^\s*NOT\s+(.*)//) { 918 my $express = $1; 919 my $ret = process_expression($name, $express); 920 return !$ret; 921 } 922 923 if ($val =~ /^\s*0\s*$/) { 924 return 0; 925 } elsif ($val =~ /^\s*\d+\s*$/) { 926 return 1; 927 } 928 929 die ("$name: $.: Undefined content $val in if statement\n"); 930} 931 932sub process_if { 933 my ($name, $value) = @_; 934 935 # Convert variables and replace undefined ones with 0 936 my $val = process_variables($value, 1); 937 my $ret = process_expression $name, $val; 938 939 return $ret; 940} 941 942sub __read_config { 943 my ($config, $current_test_num) = @_; 944 945 my $in; 946 open($in, $config) || die "can't read file $config"; 947 948 my $name = $config; 949 $name =~ s,.*/(.*),$1,; 950 951 my $test_num = $$current_test_num; 952 my $default = 1; 953 my $repeat = 1; 954 my $num_tests_set = 0; 955 my $skip = 0; 956 my $rest; 957 my $line; 958 my $test_case = 0; 959 my $if = 0; 960 my $if_set = 0; 961 my $override = 0; 962 963 my %overrides; 964 965 while (<$in>) { 966 967 # ignore blank lines and comments 968 next if (/^\s*$/ || /\s*\#/); 969 970 if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) { 971 972 my $type = $1; 973 $rest = $2; 974 $line = $2; 975 976 my $old_test_num; 977 my $old_repeat; 978 $override = 0; 979 980 if ($type eq "TEST_START") { 981 982 if ($num_tests_set) { 983 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n"; 984 } 985 986 $old_test_num = $test_num; 987 $old_repeat = $repeat; 988 989 $test_num += $repeat; 990 $default = 0; 991 $repeat = 1; 992 } else { 993 $default = 1; 994 } 995 996 # If SKIP is anywhere in the line, the command will be skipped 997 if ($rest =~ s/\s+SKIP\b//) { 998 $skip = 1; 999 } else { 1000 $test_case = 1; 1001 $skip = 0; 1002 } 1003 1004 if ($rest =~ s/\sELSE\b//) { 1005 if (!$if) { 1006 die "$name: $.: ELSE found with out matching IF section\n$_"; 1007 } 1008 $if = 0; 1009 1010 if ($if_set) { 1011 $skip = 1; 1012 } else { 1013 $skip = 0; 1014 } 1015 } 1016 1017 if ($rest =~ s/\sIF\s+(.*)//) { 1018 if (process_if($name, $1)) { 1019 $if_set = 1; 1020 } else { 1021 $skip = 1; 1022 } 1023 $if = 1; 1024 } else { 1025 $if = 0; 1026 $if_set = 0; 1027 } 1028 1029 if (!$skip) { 1030 if ($type eq "TEST_START") { 1031 if ($rest =~ s/\s+ITERATE\s+(\d+)//) { 1032 $repeat = $1; 1033 $repeat_tests{"$test_num"} = $repeat; 1034 } 1035 } elsif ($rest =~ s/\sOVERRIDE\b//) { 1036 # DEFAULT only 1037 $override = 1; 1038 # Clear previous overrides 1039 %overrides = (); 1040 } 1041 } 1042 1043 if (!$skip && $rest !~ /^\s*$/) { 1044 die "$name: $.: Garbage found after $type\n$_"; 1045 } 1046 1047 if ($skip && $type eq "TEST_START") { 1048 $test_num = $old_test_num; 1049 $repeat = $old_repeat; 1050 } 1051 1052 } elsif (/^\s*ELSE\b(.*)$/) { 1053 if (!$if) { 1054 die "$name: $.: ELSE found with out matching IF section\n$_"; 1055 } 1056 $rest = $1; 1057 if ($if_set) { 1058 $skip = 1; 1059 $rest = ""; 1060 } else { 1061 $skip = 0; 1062 1063 if ($rest =~ /\sIF\s+(.*)/) { 1064 # May be a ELSE IF section. 1065 if (process_if($name, $1)) { 1066 $if_set = 1; 1067 } else { 1068 $skip = 1; 1069 } 1070 $rest = ""; 1071 } else { 1072 $if = 0; 1073 } 1074 } 1075 1076 if ($rest !~ /^\s*$/) { 1077 die "$name: $.: Garbage found after DEFAULTS\n$_"; 1078 } 1079 1080 } elsif (/^\s*INCLUDE\s+(\S+)/) { 1081 1082 next if ($skip); 1083 1084 if (!$default) { 1085 die "$name: $.: INCLUDE can only be done in default sections\n$_"; 1086 } 1087 1088 my $file = process_variables($1); 1089 1090 if ($file !~ m,^/,) { 1091 # check the path of the config file first 1092 if ($config =~ m,(.*)/,) { 1093 if (-f "$1/$file") { 1094 $file = "$1/$file"; 1095 } 1096 } 1097 } 1098 1099 if ( ! -r $file ) { 1100 die "$name: $.: Can't read file $file\n$_"; 1101 } 1102 1103 if (__read_config($file, \$test_num)) { 1104 $test_case = 1; 1105 } 1106 1107 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=~\s*(.*?)\s*$/) { 1108 1109 next if ($skip); 1110 1111 my $lvalue = $1; 1112 my $rvalue = $2; 1113 1114 if ($default || $lvalue =~ /\[\d+\]$/) { 1115 set_eval($lvalue, $rvalue, $name); 1116 } else { 1117 my $val = "$lvalue\[$test_num\]"; 1118 set_eval($val, $rvalue, $name); 1119 } 1120 1121 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) { 1122 1123 next if ($skip); 1124 1125 my $lvalue = $1; 1126 my $rvalue = $2; 1127 1128 if (!$default && 1129 ($lvalue eq "NUM_TESTS" || 1130 $lvalue eq "LOG_FILE" || 1131 $lvalue eq "CLEAR_LOG")) { 1132 die "$name: $.: $lvalue must be set in DEFAULTS section\n"; 1133 } 1134 1135 if ($lvalue eq "NUM_TESTS") { 1136 if ($test_num) { 1137 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n"; 1138 } 1139 if (!$default) { 1140 die "$name: $.: NUM_TESTS must be set in default section\n"; 1141 } 1142 $num_tests_set = 1; 1143 } 1144 1145 if ($default || $lvalue =~ /\[\d+\]$/) { 1146 set_value($lvalue, $rvalue, $override, \%overrides, $name); 1147 } else { 1148 my $val = "$lvalue\[$test_num\]"; 1149 set_value($val, $rvalue, $override, \%overrides, $name); 1150 1151 if ($repeat > 1) { 1152 $repeats{$val} = $repeat; 1153 } 1154 } 1155 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) { 1156 next if ($skip); 1157 1158 my $lvalue = $1; 1159 my $rvalue = $2; 1160 1161 # process config variables. 1162 # Config variables are only active while reading the 1163 # config and can be defined anywhere. They also ignore 1164 # TEST_START and DEFAULTS, but are skipped if they are in 1165 # on of these sections that have SKIP defined. 1166 # The save variable can be 1167 # defined multiple times and the new one simply overrides 1168 # the previous one. 1169 set_variable($lvalue, $rvalue); 1170 1171 } else { 1172 die "$name: $.: Garbage found in config\n$_"; 1173 } 1174 } 1175 1176 if ($test_num) { 1177 $test_num += $repeat - 1; 1178 $opt{"NUM_TESTS"} = $test_num; 1179 } 1180 1181 close($in); 1182 1183 $$current_test_num = $test_num; 1184 1185 return $test_case; 1186} 1187 1188sub get_test_case { 1189 print "What test case would you like to run?\n"; 1190 print " (build, install or boot)\n"; 1191 print " Other tests are available but require editing ktest.conf\n"; 1192 print " (see tools/testing/ktest/sample.conf)\n"; 1193 my $ans = <STDIN>; 1194 chomp $ans; 1195 $default{"TEST_TYPE"} = $ans; 1196} 1197 1198sub read_config { 1199 my ($config) = @_; 1200 1201 my $test_case; 1202 my $test_num = 0; 1203 1204 $test_case = __read_config $config, \$test_num; 1205 1206 # make sure we have all mandatory configs 1207 get_mandatory_configs; 1208 1209 # was a test specified? 1210 if (!$test_case) { 1211 print "No test case specified.\n"; 1212 get_test_case; 1213 } 1214 1215 # set any defaults 1216 1217 foreach my $default (keys %default) { 1218 if (!defined($opt{$default})) { 1219 $opt{$default} = $default{$default}; 1220 } 1221 } 1222 1223 if ($opt{"IGNORE_UNUSED"} == 1) { 1224 return; 1225 } 1226 1227 my %not_used; 1228 1229 # check if there are any stragglers (typos?) 1230 foreach my $option (keys %opt) { 1231 my $op = $option; 1232 # remove per test labels. 1233 $op =~ s/\[.*\]//; 1234 if (!exists($option_map{$op}) && 1235 !exists($default{$op}) && 1236 !exists($used_options{$op})) { 1237 $not_used{$op} = 1; 1238 } 1239 } 1240 1241 if (%not_used) { 1242 my $s = "s are"; 1243 $s = " is" if (keys %not_used == 1); 1244 print "The following option$s not used; could be a typo:\n"; 1245 foreach my $option (keys %not_used) { 1246 print "$option\n"; 1247 } 1248 print "Set IGNORE_UNUSED = 1 to have ktest ignore unused variables\n"; 1249 if (!read_yn "Do you want to continue?") { 1250 exit -1; 1251 } 1252 } 1253} 1254 1255sub __eval_option { 1256 my ($name, $option, $i) = @_; 1257 1258 # Add space to evaluate the character before $ 1259 $option = " $option"; 1260 my $retval = ""; 1261 my $repeated = 0; 1262 my $parent = 0; 1263 1264 foreach my $test (keys %repeat_tests) { 1265 if ($i >= $test && 1266 $i < $test + $repeat_tests{$test}) { 1267 1268 $repeated = 1; 1269 $parent = $test; 1270 last; 1271 } 1272 } 1273 1274 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) { 1275 my $start = $1; 1276 my $var = $2; 1277 my $end = $3; 1278 1279 # Append beginning of line 1280 $retval = "$retval$start"; 1281 1282 # If the iteration option OPT[$i] exists, then use that. 1283 # otherwise see if the default OPT (without [$i]) exists. 1284 1285 my $o = "$var\[$i\]"; 1286 my $parento = "$var\[$parent\]"; 1287 1288 # If a variable contains itself, use the default var 1289 if (($var eq $name) && defined($opt{$var})) { 1290 $o = $opt{$var}; 1291 $retval = "$retval$o"; 1292 } elsif (defined($opt{$o})) { 1293 $o = $opt{$o}; 1294 $retval = "$retval$o"; 1295 } elsif ($repeated && defined($opt{$parento})) { 1296 $o = $opt{$parento}; 1297 $retval = "$retval$o"; 1298 } elsif (defined($opt{$var})) { 1299 $o = $opt{$var}; 1300 $retval = "$retval$o"; 1301 } elsif ($var eq "KERNEL_VERSION" && defined($make)) { 1302 # special option KERNEL_VERSION uses kernel version 1303 get_version(); 1304 $retval = "$retval$version"; 1305 } else { 1306 $retval = "$retval\$\{$var\}"; 1307 } 1308 1309 $option = $end; 1310 } 1311 1312 $retval = "$retval$option"; 1313 1314 $retval =~ s/^ //; 1315 1316 return $retval; 1317} 1318 1319sub process_evals { 1320 my ($name, $option, $i) = @_; 1321 1322 my $option_name = "$name\[$i\]"; 1323 my $ev; 1324 1325 my $old_option = $option; 1326 1327 if (defined($evals{$option_name})) { 1328 $ev = $evals{$option_name}; 1329 } elsif (defined($evals{$name})) { 1330 $ev = $evals{$name}; 1331 } else { 1332 return $option; 1333 } 1334 1335 for my $e (@{$ev}) { 1336 eval "\$option =~ $e"; 1337 } 1338 1339 if ($option ne $old_option) { 1340 doprint("$name changed from '$old_option' to '$option'\n"); 1341 } 1342 1343 return $option; 1344} 1345 1346sub eval_option { 1347 my ($name, $option, $i) = @_; 1348 1349 my $prev = ""; 1350 1351 # Since an option can evaluate to another option, 1352 # keep iterating until we do not evaluate any more 1353 # options. 1354 my $r = 0; 1355 while ($prev ne $option) { 1356 # Check for recursive evaluations. 1357 # 100 deep should be more than enough. 1358 if ($r++ > 100) { 1359 die "Over 100 evaluations occurred with $option\n" . 1360 "Check for recursive variables\n"; 1361 } 1362 $prev = $option; 1363 $option = __eval_option($name, $option, $i); 1364 } 1365 1366 $option = process_evals($name, $option, $i); 1367 1368 return $option; 1369} 1370 1371sub run_command; 1372sub start_monitor; 1373sub end_monitor; 1374sub wait_for_monitor; 1375 1376sub reboot { 1377 my ($time) = @_; 1378 my $powercycle = 0; 1379 1380 # test if the machine can be connected to within a few seconds 1381 my $stat = run_ssh("echo check machine status", $connect_timeout); 1382 if (!$stat) { 1383 doprint("power cycle\n"); 1384 $powercycle = 1; 1385 } 1386 1387 if ($powercycle) { 1388 run_command "$power_cycle"; 1389 1390 start_monitor; 1391 # flush out current monitor 1392 # May contain the reboot success line 1393 wait_for_monitor 1; 1394 1395 } else { 1396 # Make sure everything has been written to disk 1397 run_ssh("sync", 10); 1398 1399 if (defined($time)) { 1400 start_monitor; 1401 # flush out current monitor 1402 # May contain the reboot success line 1403 wait_for_monitor 1; 1404 } 1405 1406 # try to reboot normally 1407 if (run_command $reboot) { 1408 if (defined($powercycle_after_reboot)) { 1409 sleep $powercycle_after_reboot; 1410 run_command "$power_cycle"; 1411 } 1412 } else { 1413 # nope? power cycle it. 1414 run_command "$power_cycle"; 1415 } 1416 } 1417 1418 if (defined($time)) { 1419 1420 # We only want to get to the new kernel, don't fail 1421 # if we stumble over a call trace. 1422 my $save_ignore_errors = $ignore_errors; 1423 $ignore_errors = 1; 1424 1425 # Look for the good kernel to boot 1426 if (wait_for_monitor($time, "Linux version")) { 1427 # reboot got stuck? 1428 doprint "Reboot did not finish. Forcing power cycle\n"; 1429 run_command "$power_cycle"; 1430 } 1431 1432 $ignore_errors = $save_ignore_errors; 1433 1434 # Still need to wait for the reboot to finish 1435 wait_for_monitor($time, $reboot_success_line); 1436 1437 end_monitor; 1438 } 1439} 1440 1441sub reboot_to_good { 1442 my ($time) = @_; 1443 1444 if (defined($switch_to_good)) { 1445 run_command $switch_to_good; 1446 } 1447 1448 reboot $time; 1449} 1450 1451sub do_not_reboot { 1452 my $i = $iteration; 1453 1454 return $test_type eq "build" || $no_reboot || 1455 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") || 1456 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build") || 1457 ($test_type eq "config_bisect" && $opt{"CONFIG_BISECT_TYPE[$i]"} eq "build"); 1458} 1459 1460my $in_die = 0; 1461 1462sub get_test_name() { 1463 my $name; 1464 1465 if (defined($test_name)) { 1466 $name = "$test_name:$test_type"; 1467 } else { 1468 $name = $test_type; 1469 } 1470 return $name; 1471} 1472 1473sub dodie { 1474 1475 # avoid recursion 1476 return if ($in_die); 1477 $in_die = 1; 1478 1479 my $i = $iteration; 1480 1481 doprint "CRITICAL FAILURE... [TEST $i] ", @_, "\n"; 1482 1483 if ($reboot_on_error && !do_not_reboot) { 1484 1485 doprint "REBOOTING\n"; 1486 reboot_to_good; 1487 1488 } elsif ($poweroff_on_error && defined($power_off)) { 1489 doprint "POWERING OFF\n"; 1490 `$power_off`; 1491 } 1492 1493 if (defined($opt{"LOG_FILE"})) { 1494 print " See $opt{LOG_FILE} for more info.\n"; 1495 } 1496 1497 if ($email_on_error) { 1498 my $name = get_test_name; 1499 my $log_file; 1500 1501 if (defined($opt{"LOG_FILE"})) { 1502 my $whence = 0; # beginning of file 1503 my $pos = $test_log_start; 1504 1505 if (defined($mail_max_size)) { 1506 my $log_size = tell LOG; 1507 $log_size -= $test_log_start; 1508 if ($log_size > $mail_max_size) { 1509 $whence = 2; # end of file 1510 $pos = - $mail_max_size; 1511 } 1512 } 1513 $log_file = "$tmpdir/log"; 1514 open (L, "$opt{LOG_FILE}") or die "Can't open $opt{LOG_FILE} to read)"; 1515 open (O, "> $tmpdir/log") or die "Can't open $tmpdir/log\n"; 1516 seek(L, $pos, $whence); 1517 while (<L>) { 1518 print O; 1519 } 1520 close O; 1521 close L; 1522 } 1523 send_email("KTEST: critical failure for test $i [$name]", 1524 "Your test started at $script_start_time has failed with:\n@_\n", $log_file); 1525 } 1526 1527 if ($monitor_cnt) { 1528 # restore terminal settings 1529 system("stty $stty_orig"); 1530 } 1531 1532 if (defined($post_test)) { 1533 run_command $post_test; 1534 } 1535 1536 die @_, "\n"; 1537} 1538 1539sub create_pty { 1540 my ($ptm, $pts) = @_; 1541 my $tmp; 1542 my $TIOCSPTLCK = 0x40045431; 1543 my $TIOCGPTN = 0x80045430; 1544 1545 sysopen($ptm, "/dev/ptmx", O_RDWR | O_NONBLOCK) or 1546 dodie "Can't open /dev/ptmx"; 1547 1548 # unlockpt() 1549 $tmp = pack("i", 0); 1550 ioctl($ptm, $TIOCSPTLCK, $tmp) or 1551 dodie "ioctl TIOCSPTLCK for /dev/ptmx failed"; 1552 1553 # ptsname() 1554 ioctl($ptm, $TIOCGPTN, $tmp) or 1555 dodie "ioctl TIOCGPTN for /dev/ptmx failed"; 1556 $tmp = unpack("i", $tmp); 1557 1558 sysopen($pts, "/dev/pts/$tmp", O_RDWR | O_NONBLOCK) or 1559 dodie "Can't open /dev/pts/$tmp"; 1560} 1561 1562sub exec_console { 1563 my ($ptm, $pts) = @_; 1564 1565 close($ptm); 1566 1567 close(\*STDIN); 1568 close(\*STDOUT); 1569 close(\*STDERR); 1570 1571 open(\*STDIN, '<&', $pts); 1572 open(\*STDOUT, '>&', $pts); 1573 open(\*STDERR, '>&', $pts); 1574 1575 close($pts); 1576 1577 exec $console or 1578 dodie "Can't open console $console"; 1579} 1580 1581sub open_console { 1582 my ($ptm) = @_; 1583 my $pts = \*PTSFD; 1584 my $pid; 1585 1586 # save terminal settings 1587 $stty_orig = `stty -g`; 1588 1589 # place terminal in cbreak mode so that stdin can be read one character at 1590 # a time without having to wait for a newline 1591 system("stty -icanon -echo -icrnl"); 1592 1593 create_pty($ptm, $pts); 1594 1595 $pid = fork; 1596 1597 if (!$pid) { 1598 # child 1599 exec_console($ptm, $pts) 1600 } 1601 1602 # parent 1603 close($pts); 1604 1605 return $pid; 1606 1607 open(PTSFD, "Stop perl from warning about single use of PTSFD"); 1608} 1609 1610sub close_console { 1611 my ($fp, $pid) = @_; 1612 1613 doprint "kill child process $pid\n"; 1614 kill $close_console_signal, $pid; 1615 1616 doprint "wait for child process $pid to exit\n"; 1617 waitpid($pid, 0); 1618 1619 print "closing!\n"; 1620 close($fp); 1621 1622 # restore terminal settings 1623 system("stty $stty_orig"); 1624} 1625 1626sub start_monitor { 1627 if ($monitor_cnt++) { 1628 return; 1629 } 1630 $monitor_fp = \*MONFD; 1631 $monitor_pid = open_console $monitor_fp; 1632 1633 return; 1634 1635 open(MONFD, "Stop perl from warning about single use of MONFD"); 1636} 1637 1638sub end_monitor { 1639 return if (!defined $console); 1640 if (--$monitor_cnt) { 1641 return; 1642 } 1643 close_console($monitor_fp, $monitor_pid); 1644} 1645 1646sub wait_for_monitor { 1647 my ($time, $stop) = @_; 1648 my $full_line = ""; 1649 my $line; 1650 my $booted = 0; 1651 my $start_time = time; 1652 my $skip_call_trace = 0; 1653 my $bug = 0; 1654 my $bug_ignored = 0; 1655 my $now; 1656 1657 doprint "** Wait for monitor to settle down **\n"; 1658 1659 # read the monitor and wait for the system to calm down 1660 while (!$booted) { 1661 $line = wait_for_input($monitor_fp, $time); 1662 last if (!defined($line)); 1663 print "$line"; 1664 $full_line .= $line; 1665 1666 if (defined($stop) && $full_line =~ /$stop/) { 1667 doprint "wait for monitor detected $stop\n"; 1668 $booted = 1; 1669 } 1670 1671 if ($full_line =~ /\[ backtrace testing \]/) { 1672 $skip_call_trace = 1; 1673 } 1674 1675 if ($full_line =~ /call trace:/i) { 1676 if (!$bug && !$skip_call_trace) { 1677 if ($ignore_errors) { 1678 $bug_ignored = 1; 1679 } else { 1680 $bug = 1; 1681 } 1682 } 1683 } 1684 1685 if ($full_line =~ /\[ end of backtrace testing \]/) { 1686 $skip_call_trace = 0; 1687 } 1688 1689 if ($full_line =~ /Kernel panic -/) { 1690 $bug = 1; 1691 } 1692 1693 if ($line =~ /\n/) { 1694 $full_line = ""; 1695 } 1696 $now = time; 1697 if ($now - $start_time >= $max_monitor_wait) { 1698 doprint "Exiting monitor flush due to hitting MAX_MONITOR_WAIT\n"; 1699 return 1; 1700 } 1701 } 1702 print "** Monitor flushed **\n"; 1703 1704 # if stop is defined but wasn't hit, return error 1705 # used by reboot (which wants to see a reboot) 1706 if (defined($stop) && !$booted) { 1707 $bug = 1; 1708 } 1709 return $bug; 1710} 1711 1712sub save_logs { 1713 my ($result, $basedir) = @_; 1714 my @t = localtime; 1715 my $date = sprintf "%04d%02d%02d%02d%02d%02d", 1716 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0]; 1717 1718 my $type = $build_type; 1719 if ($type =~ /useconfig/) { 1720 $type = "useconfig"; 1721 } 1722 1723 my $dir = "$machine-$test_type-$type-$result-$date"; 1724 1725 $dir = "$basedir/$dir"; 1726 1727 if (!-d $dir) { 1728 mkpath($dir) or 1729 dodie "can't create $dir"; 1730 } 1731 1732 my %files = ( 1733 "config" => $output_config, 1734 "buildlog" => $buildlog, 1735 "dmesg" => $dmesg, 1736 "testlog" => $testlog, 1737 ); 1738 1739 while (my ($name, $source) = each(%files)) { 1740 if (-f "$source") { 1741 cp "$source", "$dir/$name" or 1742 dodie "failed to copy $source"; 1743 } 1744 } 1745 1746 doprint "*** Saved info to $dir ***\n"; 1747} 1748 1749sub fail { 1750 1751 if ($die_on_failure) { 1752 dodie @_; 1753 } 1754 1755 doprint "FAILED\n"; 1756 1757 my $i = $iteration; 1758 1759 # no need to reboot for just building. 1760 if (!do_not_reboot) { 1761 doprint "REBOOTING\n"; 1762 reboot_to_good $sleep_time; 1763 } 1764 1765 my $name = ""; 1766 1767 if (defined($test_name)) { 1768 $name = " ($test_name)"; 1769 } 1770 1771 print_times; 1772 1773 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n"; 1774 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n"; 1775 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n"; 1776 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n"; 1777 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n"; 1778 1779 if (defined($store_failures)) { 1780 save_logs "fail", $store_failures; 1781 } 1782 1783 if (defined($post_test)) { 1784 run_command $post_test; 1785 } 1786 1787 return 1; 1788} 1789 1790sub run_command { 1791 my ($command, $redirect, $timeout) = @_; 1792 my $start_time; 1793 my $end_time; 1794 my $dolog = 0; 1795 my $dord = 0; 1796 my $dostdout = 0; 1797 my $pid; 1798 my $command_orig = $command; 1799 1800 $command =~ s/\$SSH_USER/$ssh_user/g; 1801 $command =~ s/\$MACHINE/$machine/g; 1802 1803 doprint("$command ... "); 1804 $start_time = time; 1805 1806 $pid = open(CMD, "$command 2>&1 |") or 1807 (fail "unable to exec $command" and return 0); 1808 1809 if (defined($opt{"LOG_FILE"})) { 1810 $dolog = 1; 1811 } 1812 1813 if (defined($redirect)) { 1814 if ($redirect eq 1) { 1815 $dostdout = 1; 1816 # Have the output of the command on its own line 1817 doprint "\n"; 1818 } else { 1819 open (RD, ">$redirect") or 1820 dodie "failed to write to redirect $redirect"; 1821 $dord = 1; 1822 } 1823 } 1824 1825 my $hit_timeout = 0; 1826 1827 while (1) { 1828 my $fp = \*CMD; 1829 if (defined($timeout)) { 1830 doprint "timeout = $timeout\n"; 1831 } 1832 my $line = wait_for_input($fp, $timeout); 1833 if (!defined($line)) { 1834 my $now = time; 1835 if (defined($timeout) && (($now - $start_time) >= $timeout)) { 1836 doprint "Hit timeout of $timeout, killing process\n"; 1837 $hit_timeout = 1; 1838 kill 9, $pid; 1839 } 1840 last; 1841 } 1842 print LOG $line if ($dolog); 1843 print RD $line if ($dord); 1844 print $line if ($dostdout); 1845 } 1846 1847 waitpid($pid, 0); 1848 # shift 8 for real exit status 1849 $run_command_status = $? >> 8; 1850 1851 if ($command_orig eq $default{REBOOT} && 1852 $run_command_status == $reboot_return_code) { 1853 $run_command_status = 0; 1854 } 1855 1856 close(CMD); 1857 close(RD) if ($dord); 1858 1859 $end_time = time; 1860 my $delta = $end_time - $start_time; 1861 1862 if ($delta == 1) { 1863 doprint "[1 second] "; 1864 } else { 1865 doprint "[$delta seconds] "; 1866 } 1867 1868 if ($hit_timeout) { 1869 $run_command_status = 1; 1870 } 1871 1872 if ($run_command_status) { 1873 doprint "FAILED!\n"; 1874 } else { 1875 doprint "SUCCESS\n"; 1876 } 1877 1878 return !$run_command_status; 1879} 1880 1881sub run_ssh { 1882 my ($cmd, $timeout) = @_; 1883 my $cp_exec = $ssh_exec; 1884 1885 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g; 1886 return run_command "$cp_exec", undef , $timeout; 1887} 1888 1889sub run_scp { 1890 my ($src, $dst, $cp_scp) = @_; 1891 1892 $cp_scp =~ s/\$SRC_FILE/$src/g; 1893 $cp_scp =~ s/\$DST_FILE/$dst/g; 1894 1895 return run_command "$cp_scp"; 1896} 1897 1898sub run_scp_install { 1899 my ($src, $dst) = @_; 1900 1901 my $cp_scp = $scp_to_target_install; 1902 1903 return run_scp($src, $dst, $cp_scp); 1904} 1905 1906sub run_scp_mod { 1907 my ($src, $dst) = @_; 1908 1909 my $cp_scp = $scp_to_target; 1910 1911 return run_scp($src, $dst, $cp_scp); 1912} 1913 1914sub _get_grub_index { 1915 1916 my ($command, $target, $skip) = @_; 1917 1918 return if (defined($grub_number) && defined($last_grub_menu) && 1919 $last_grub_menu eq $grub_menu && defined($last_machine) && 1920 $last_machine eq $machine); 1921 1922 doprint "Find $reboot_type menu ... "; 1923 $grub_number = -1; 1924 1925 my $ssh_grub = $ssh_exec; 1926 $ssh_grub =~ s,\$SSH_COMMAND,$command,g; 1927 1928 open(IN, "$ssh_grub |") 1929 or dodie "unable to execute $command"; 1930 1931 my $found = 0; 1932 1933 while (<IN>) { 1934 if (/$target/) { 1935 $grub_number++; 1936 $found = 1; 1937 last; 1938 } elsif (/$skip/) { 1939 $grub_number++; 1940 } 1941 } 1942 close(IN); 1943 1944 dodie "Could not find '$grub_menu' through $command on $machine" 1945 if (!$found); 1946 doprint "$grub_number\n"; 1947 $last_grub_menu = $grub_menu; 1948 $last_machine = $machine; 1949} 1950 1951sub get_grub_index { 1952 1953 my $command; 1954 my $target; 1955 my $skip; 1956 my $grub_menu_qt; 1957 1958 if ($reboot_type !~ /^grub/) { 1959 return; 1960 } 1961 1962 $grub_menu_qt = quotemeta($grub_menu); 1963 1964 if ($reboot_type eq "grub") { 1965 $command = "cat /boot/grub/menu.lst"; 1966 $target = '^\s*title\s+' . $grub_menu_qt . '\s*$'; 1967 $skip = '^\s*title\s'; 1968 } elsif ($reboot_type eq "grub2") { 1969 $command = "cat $grub_file"; 1970 $target = '^menuentry.*' . $grub_menu_qt; 1971 $skip = '^menuentry\s|^submenu\s'; 1972 } elsif ($reboot_type eq "grub2bls") { 1973 $command = $grub_bls_get; 1974 $target = '^title=.*' . $grub_menu_qt; 1975 $skip = '^title='; 1976 } else { 1977 return; 1978 } 1979 1980 _get_grub_index($command, $target, $skip); 1981} 1982 1983sub wait_for_input 1984{ 1985 my ($fp, $time) = @_; 1986 my $start_time; 1987 my $rin; 1988 my $rout; 1989 my $nr; 1990 my $buf; 1991 my $line; 1992 my $ch; 1993 1994 if (!defined($time)) { 1995 $time = $timeout; 1996 } 1997 1998 $rin = ''; 1999 vec($rin, fileno($fp), 1) = 1; 2000 vec($rin, fileno(\*STDIN), 1) = 1; 2001 2002 $start_time = time; 2003 2004 while (1) { 2005 $nr = select($rout=$rin, undef, undef, $time); 2006 2007 last if ($nr <= 0); 2008 2009 # copy data from stdin to the console 2010 if (vec($rout, fileno(\*STDIN), 1) == 1) { 2011 $nr = sysread(\*STDIN, $buf, 1000); 2012 syswrite($fp, $buf, $nr) if ($nr > 0); 2013 } 2014 2015 # The timeout is based on time waiting for the fp data 2016 if (vec($rout, fileno($fp), 1) != 1) { 2017 last if (defined($time) && (time - $start_time > $time)); 2018 next; 2019 } 2020 2021 $line = ""; 2022 2023 # try to read one char at a time 2024 while (sysread $fp, $ch, 1) { 2025 $line .= $ch; 2026 last if ($ch eq "\n"); 2027 } 2028 2029 last if (!length($line)); 2030 2031 return $line; 2032 } 2033 return undef; 2034} 2035 2036sub reboot_to { 2037 if (defined($switch_to_test)) { 2038 run_command $switch_to_test; 2039 } 2040 2041 if ($reboot_type eq "grub") { 2042 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'"; 2043 } elsif (($reboot_type eq "grub2") or ($reboot_type eq "grub2bls")) { 2044 run_ssh "$grub_reboot $grub_number"; 2045 } elsif ($reboot_type eq "syslinux") { 2046 run_ssh "$syslinux --once \\\"$syslinux_label\\\" $syslinux_path"; 2047 } elsif (defined $reboot_script) { 2048 run_command "$reboot_script"; 2049 } 2050 reboot; 2051} 2052 2053sub get_sha1 { 2054 my ($commit) = @_; 2055 2056 doprint "git rev-list --max-count=1 $commit ... "; 2057 my $sha1 = `git rev-list --max-count=1 $commit`; 2058 my $ret = $?; 2059 2060 logit $sha1; 2061 2062 if ($ret) { 2063 doprint "FAILED\n"; 2064 dodie "Failed to get git $commit"; 2065 } 2066 2067 print "SUCCESS\n"; 2068 2069 chomp $sha1; 2070 2071 return $sha1; 2072} 2073 2074sub monitor { 2075 my $booted = 0; 2076 my $bug = 0; 2077 my $bug_ignored = 0; 2078 my $skip_call_trace = 0; 2079 my $loops; 2080 2081 my $start_time = time; 2082 2083 wait_for_monitor 5; 2084 2085 my $line; 2086 my $full_line = ""; 2087 2088 open(DMESG, "> $dmesg") or 2089 dodie "unable to write to $dmesg"; 2090 2091 reboot_to; 2092 2093 my $success_start; 2094 my $failure_start; 2095 my $monitor_start = time; 2096 my $done = 0; 2097 my $version_found = 0; 2098 2099 while (!$done) { 2100 2101 if ($bug && defined($stop_after_failure) && 2102 $stop_after_failure >= 0) { 2103 my $time = $stop_after_failure - (time - $failure_start); 2104 $line = wait_for_input($monitor_fp, $time); 2105 if (!defined($line)) { 2106 doprint "bug timed out after $booted_timeout seconds\n"; 2107 doprint "Test forced to stop after $stop_after_failure seconds after failure\n"; 2108 last; 2109 } 2110 } elsif ($booted) { 2111 $line = wait_for_input($monitor_fp, $booted_timeout); 2112 if (!defined($line)) { 2113 my $s = $booted_timeout == 1 ? "" : "s"; 2114 doprint "Successful boot found: break after $booted_timeout second$s\n"; 2115 last; 2116 } 2117 } else { 2118 $line = wait_for_input($monitor_fp); 2119 if (!defined($line)) { 2120 my $s = $timeout == 1 ? "" : "s"; 2121 doprint "Timed out after $timeout second$s\n"; 2122 last; 2123 } 2124 } 2125 2126 doprint $line; 2127 print DMESG $line; 2128 2129 # we are not guaranteed to get a full line 2130 $full_line .= $line; 2131 2132 if ($full_line =~ /$success_line/) { 2133 $booted = 1; 2134 $success_start = time; 2135 } 2136 2137 if ($booted && defined($stop_after_success) && 2138 $stop_after_success >= 0) { 2139 my $now = time; 2140 if ($now - $success_start >= $stop_after_success) { 2141 doprint "Test forced to stop after $stop_after_success seconds after success\n"; 2142 last; 2143 } 2144 } 2145 2146 if ($full_line =~ /\[ backtrace testing \]/) { 2147 $skip_call_trace = 1; 2148 } 2149 2150 if ($full_line =~ /call trace:/i) { 2151 if (!$bug && !$skip_call_trace) { 2152 if ($ignore_errors) { 2153 $bug_ignored = 1; 2154 } else { 2155 $bug = 1; 2156 $failure_start = time; 2157 } 2158 } 2159 } 2160 2161 if ($bug && defined($stop_after_failure) && 2162 $stop_after_failure >= 0) { 2163 my $now = time; 2164 if ($now - $failure_start >= $stop_after_failure) { 2165 doprint "Test forced to stop after $stop_after_failure seconds after failure\n"; 2166 last; 2167 } 2168 } 2169 2170 if ($full_line =~ /\[ end of backtrace testing \]/) { 2171 $skip_call_trace = 0; 2172 } 2173 2174 if ($full_line =~ /Kernel panic -/) { 2175 $failure_start = time; 2176 $bug = 1; 2177 } 2178 2179 # Detect triple faults by testing the banner 2180 if ($full_line =~ /\bLinux version (\S+).*\n/) { 2181 if ($1 eq $version) { 2182 $version_found = 1; 2183 } elsif ($version_found && $detect_triplefault) { 2184 # We already booted into the kernel we are testing, 2185 # but now we booted into another kernel? 2186 # Consider this a triple fault. 2187 doprint "Already booted in Linux kernel $version, but now\n"; 2188 doprint "we booted into Linux kernel $1.\n"; 2189 doprint "Assuming that this is a triple fault.\n"; 2190 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n"; 2191 last; 2192 } 2193 } 2194 2195 if ($line =~ /\n/) { 2196 $full_line = ""; 2197 } 2198 2199 if ($stop_test_after > 0 && !$booted && !$bug) { 2200 if (time - $monitor_start > $stop_test_after) { 2201 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n"; 2202 $done = 1; 2203 } 2204 } 2205 } 2206 2207 my $end_time = time; 2208 $reboot_time = $end_time - $start_time; 2209 2210 close(DMESG); 2211 2212 if ($bug) { 2213 return 0 if ($in_bisect); 2214 fail "failed - got a bug report" and return 0; 2215 } 2216 2217 if (!$booted) { 2218 return 0 if ($in_bisect); 2219 fail "failed - never got a boot prompt." and return 0; 2220 } 2221 2222 if ($bug_ignored) { 2223 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n"; 2224 } 2225 2226 return 1; 2227} 2228 2229sub eval_kernel_version { 2230 my ($option) = @_; 2231 2232 $option =~ s/\$KERNEL_VERSION/$version/g; 2233 2234 return $option; 2235} 2236 2237sub do_post_install { 2238 2239 return if (!defined($post_install)); 2240 2241 my $cp_post_install = eval_kernel_version $post_install; 2242 run_command "$cp_post_install" or 2243 dodie "Failed to run post install"; 2244} 2245 2246# Sometimes the reboot fails, and will hang. We try to ssh to the box 2247# and if we fail, we force another reboot, that should powercycle it. 2248sub test_booted { 2249 if (!run_ssh "echo testing connection") { 2250 reboot $sleep_time; 2251 } 2252} 2253 2254sub install { 2255 2256 return if ($no_install); 2257 2258 my $start_time = time; 2259 2260 if (defined($pre_install)) { 2261 my $cp_pre_install = eval_kernel_version $pre_install; 2262 run_command "$cp_pre_install" or 2263 dodie "Failed to run pre install"; 2264 } 2265 2266 my $cp_target = eval_kernel_version $target_image; 2267 2268 test_booted; 2269 2270 run_scp_install "$outputdir/$build_target", "$cp_target" or 2271 dodie "failed to copy image"; 2272 2273 my $install_mods = 0; 2274 2275 # should we process modules? 2276 $install_mods = 0; 2277 open(IN, "$output_config") or dodie("Can't read config file"); 2278 while (<IN>) { 2279 if (/CONFIG_MODULES(=y)?/) { 2280 if (defined($1)) { 2281 $install_mods = 1; 2282 last; 2283 } 2284 } 2285 } 2286 close(IN); 2287 2288 if (!$install_mods) { 2289 do_post_install; 2290 doprint "No modules needed\n"; 2291 my $end_time = time; 2292 $install_time = $end_time - $start_time; 2293 return; 2294 } 2295 2296 run_command "$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or 2297 dodie "Failed to install modules"; 2298 2299 my $modlib = "/lib/modules/$version"; 2300 my $modtar = "ktest-mods.tar.bz2"; 2301 2302 run_ssh "rm -rf $modlib" or 2303 dodie "failed to remove old mods: $modlib"; 2304 2305 # would be nice if scp -r did not follow symbolic links 2306 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or 2307 dodie "making tarball"; 2308 2309 run_scp_mod "$tmpdir/$modtar", "/tmp" or 2310 dodie "failed to copy modules"; 2311 2312 unlink "$tmpdir/$modtar"; 2313 2314 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or 2315 dodie "failed to tar modules"; 2316 2317 run_ssh "rm -f /tmp/$modtar"; 2318 2319 do_post_install; 2320 2321 my $end_time = time; 2322 $install_time = $end_time - $start_time; 2323} 2324 2325sub get_version { 2326 # get the release name 2327 return if ($have_version); 2328 doprint "$make kernelrelease ... "; 2329 $version = `$make -s kernelrelease | tail -1`; 2330 chomp($version); 2331 doprint "$version\n"; 2332 $have_version = 1; 2333} 2334 2335sub start_monitor_and_install { 2336 # Make sure the stable kernel has finished booting 2337 2338 # Install bisects, don't need console 2339 if (defined $console) { 2340 start_monitor; 2341 wait_for_monitor 5; 2342 end_monitor; 2343 } 2344 2345 get_grub_index; 2346 get_version; 2347 install; 2348 2349 start_monitor if (defined $console); 2350 return monitor; 2351} 2352 2353my $check_build_re = ".*:.*(warning|error|Error):.*"; 2354my $utf8_quote = "\\x{e2}\\x{80}(\\x{98}|\\x{99})"; 2355 2356sub process_warning_line { 2357 my ($line) = @_; 2358 2359 chomp $line; 2360 2361 # for distcc heterogeneous systems, some compilers 2362 # do things differently causing warning lines 2363 # to be slightly different. This makes an attempt 2364 # to fixe those issues. 2365 2366 # chop off the index into the line 2367 # using distcc, some compilers give different indexes 2368 # depending on white space 2369 $line =~ s/^(\s*\S+:\d+:)\d+/$1/; 2370 2371 # Some compilers use UTF-8 extended for quotes and some don't. 2372 $line =~ s/$utf8_quote/'/g; 2373 2374 return $line; 2375} 2376 2377# Read buildlog and check against warnings file for any 2378# new warnings. 2379# 2380# Returns 1 if OK 2381# 0 otherwise 2382sub check_buildlog { 2383 return 1 if (!defined $warnings_file); 2384 2385 my %warnings_list; 2386 2387 # Failed builds should not reboot the target 2388 my $save_no_reboot = $no_reboot; 2389 $no_reboot = 1; 2390 2391 if (-f $warnings_file) { 2392 open(IN, $warnings_file) or 2393 dodie "Error opening $warnings_file"; 2394 2395 while (<IN>) { 2396 if (/$check_build_re/) { 2397 my $warning = process_warning_line $_; 2398 2399 $warnings_list{$warning} = 1; 2400 } 2401 } 2402 close(IN); 2403 } 2404 2405 # If warnings file didn't exist, and WARNINGS_FILE exist, 2406 # then we fail on any warning! 2407 2408 open(IN, $buildlog) or dodie "Can't open $buildlog"; 2409 while (<IN>) { 2410 if (/$check_build_re/) { 2411 my $warning = process_warning_line $_; 2412 2413 if (!defined $warnings_list{$warning}) { 2414 fail "New warning found (not in $warnings_file)\n$_\n"; 2415 $no_reboot = $save_no_reboot; 2416 return 0; 2417 } 2418 } 2419 } 2420 $no_reboot = $save_no_reboot; 2421 close(IN); 2422} 2423 2424sub check_patch_buildlog { 2425 my ($patch) = @_; 2426 2427 my @files = `git show $patch | diffstat -l`; 2428 2429 foreach my $file (@files) { 2430 chomp $file; 2431 } 2432 2433 open(IN, "git show $patch |") or 2434 dodie "failed to show $patch"; 2435 while (<IN>) { 2436 if (m,^--- a/(.*),) { 2437 chomp $1; 2438 $files[$#files] = $1; 2439 } 2440 } 2441 close(IN); 2442 2443 open(IN, $buildlog) or dodie "Can't open $buildlog"; 2444 while (<IN>) { 2445 if (/^\s*(.*?):.*(warning|error)/) { 2446 my $err = $1; 2447 foreach my $file (@files) { 2448 my $fullpath = "$builddir/$file"; 2449 if ($file eq $err || $fullpath eq $err) { 2450 fail "$file built with warnings" and return 0; 2451 } 2452 } 2453 } 2454 } 2455 close(IN); 2456 2457 return 1; 2458} 2459 2460sub apply_min_config { 2461 my $outconfig = "$output_config.new"; 2462 2463 # Read the config file and remove anything that 2464 # is in the force_config hash (from minconfig and others) 2465 # then add the force config back. 2466 2467 doprint "Applying minimum configurations into $output_config.new\n"; 2468 2469 open (OUT, ">$outconfig") or 2470 dodie "Can't create $outconfig"; 2471 2472 if (-f $output_config) { 2473 open (IN, $output_config) or 2474 dodie "Failed to open $output_config"; 2475 while (<IN>) { 2476 if (/^(# )?(CONFIG_[^\s=]*)/) { 2477 next if (defined($force_config{$2})); 2478 } 2479 print OUT; 2480 } 2481 close IN; 2482 } 2483 foreach my $config (keys %force_config) { 2484 print OUT "$force_config{$config}\n"; 2485 } 2486 close OUT; 2487 2488 run_command "mv $outconfig $output_config"; 2489} 2490 2491sub make_oldconfig { 2492 2493 my @force_list = keys %force_config; 2494 2495 if ($#force_list >= 0) { 2496 apply_min_config; 2497 } 2498 2499 if (!run_command "$make olddefconfig") { 2500 # Perhaps olddefconfig doesn't exist in this version of the kernel 2501 # try oldnoconfig 2502 doprint "olddefconfig failed, trying make oldnoconfig\n"; 2503 if (!run_command "$make oldnoconfig") { 2504 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n"; 2505 # try a yes '' | oldconfig 2506 run_command "yes '' | $make oldconfig" or 2507 dodie "failed make config oldconfig"; 2508 } 2509 } 2510} 2511 2512# read a config file and use this to force new configs. 2513sub load_force_config { 2514 my ($config) = @_; 2515 2516 doprint "Loading force configs from $config\n"; 2517 open(IN, $config) or 2518 dodie "failed to read $config"; 2519 while (<IN>) { 2520 chomp; 2521 if (/^(CONFIG[^\s=]*)(\s*=.*)/) { 2522 $force_config{$1} = $_; 2523 } elsif (/^# (CONFIG_\S*) is not set/) { 2524 $force_config{$1} = $_; 2525 } 2526 } 2527 close IN; 2528} 2529 2530sub build { 2531 my ($type) = @_; 2532 2533 unlink $buildlog; 2534 2535 my $start_time = time; 2536 2537 # Failed builds should not reboot the target 2538 my $save_no_reboot = $no_reboot; 2539 $no_reboot = 1; 2540 2541 # Calculate a new version from here. 2542 $have_version = 0; 2543 2544 if (defined($pre_build)) { 2545 my $ret = run_command $pre_build; 2546 if (!$ret && defined($pre_build_die) && 2547 $pre_build_die) { 2548 dodie "failed to pre_build\n"; 2549 } 2550 } 2551 2552 if ($type =~ /^useconfig:(.*)/) { 2553 run_command "cp $1 $output_config" or 2554 dodie "could not copy $1 to .config"; 2555 2556 $type = "oldconfig"; 2557 } 2558 2559 # old config can ask questions 2560 if ($type eq "oldconfig") { 2561 $type = "olddefconfig"; 2562 2563 # allow for empty configs 2564 run_command "touch $output_config"; 2565 2566 if (!$noclean) { 2567 run_command "mv $output_config $outputdir/config_temp" or 2568 dodie "moving .config"; 2569 2570 run_command "$make mrproper" or dodie "make mrproper"; 2571 2572 run_command "mv $outputdir/config_temp $output_config" or 2573 dodie "moving config_temp"; 2574 } 2575 2576 } elsif (!$noclean) { 2577 unlink "$output_config"; 2578 run_command "$make mrproper" or 2579 dodie "make mrproper"; 2580 } 2581 2582 # add something to distinguish this build 2583 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file"); 2584 print OUT "$localversion\n"; 2585 close(OUT); 2586 2587 if (defined($minconfig)) { 2588 load_force_config($minconfig); 2589 } 2590 2591 if ($type ne "olddefconfig") { 2592 run_command "$make $type" or 2593 dodie "failed make config"; 2594 } 2595 # Run old config regardless, to enforce min configurations 2596 make_oldconfig; 2597 2598 my $build_ret = run_command "$make $build_options", $buildlog; 2599 2600 if (defined($post_build)) { 2601 # Because a post build may change the kernel version 2602 # do it now. 2603 get_version; 2604 my $ret = run_command $post_build; 2605 if (!$ret && defined($post_build_die) && 2606 $post_build_die) { 2607 dodie "failed to post_build\n"; 2608 } 2609 } 2610 2611 if (!$build_ret) { 2612 # bisect may need this to pass 2613 if ($in_bisect) { 2614 $no_reboot = $save_no_reboot; 2615 return 0; 2616 } 2617 fail "failed build" and return 0; 2618 } 2619 2620 $no_reboot = $save_no_reboot; 2621 2622 my $end_time = time; 2623 $build_time = $end_time - $start_time; 2624 2625 return 1; 2626} 2627 2628sub halt { 2629 if (!run_ssh "halt" or defined($power_off)) { 2630 if (defined($poweroff_after_halt)) { 2631 sleep $poweroff_after_halt; 2632 run_command "$power_off"; 2633 } 2634 } else { 2635 # nope? the zap it! 2636 run_command "$power_off"; 2637 } 2638} 2639 2640sub success { 2641 my ($i) = @_; 2642 2643 $successes++; 2644 2645 my $name = ""; 2646 2647 if (defined($test_name)) { 2648 $name = " ($test_name)"; 2649 } 2650 2651 print_times; 2652 2653 doprint "\n\n*******************************************\n"; 2654 doprint "*******************************************\n"; 2655 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n"; 2656 doprint "*******************************************\n"; 2657 doprint "*******************************************\n"; 2658 2659 if (defined($store_successes)) { 2660 save_logs "success", $store_successes; 2661 } 2662 2663 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) { 2664 doprint "Reboot and wait $sleep_time seconds\n"; 2665 reboot_to_good $sleep_time; 2666 } 2667 2668 if (defined($post_test)) { 2669 run_command $post_test; 2670 } 2671} 2672 2673sub answer_bisect { 2674 for (;;) { 2675 doprint "Pass, fail, or skip? [p/f/s]"; 2676 my $ans = <STDIN>; 2677 chomp $ans; 2678 if ($ans eq "p" || $ans eq "P") { 2679 return 1; 2680 } elsif ($ans eq "f" || $ans eq "F") { 2681 return 0; 2682 } elsif ($ans eq "s" || $ans eq "S") { 2683 return -1; 2684 } else { 2685 print "Please answer 'p', 'f', or 's'\n"; 2686 } 2687 } 2688} 2689 2690sub child_run_test { 2691 2692 # child should have no power 2693 $reboot_on_error = 0; 2694 $poweroff_on_error = 0; 2695 $die_on_failure = 1; 2696 2697 run_command $run_test, $testlog; 2698 2699 exit $run_command_status; 2700} 2701 2702my $child_done; 2703 2704sub child_finished { 2705 $child_done = 1; 2706} 2707 2708sub do_run_test { 2709 my $child_pid; 2710 my $child_exit; 2711 my $line; 2712 my $full_line; 2713 my $bug = 0; 2714 my $bug_ignored = 0; 2715 2716 my $start_time = time; 2717 2718 wait_for_monitor 1; 2719 2720 doprint "run test $run_test\n"; 2721 2722 $child_done = 0; 2723 2724 $SIG{CHLD} = qw(child_finished); 2725 2726 $child_pid = fork; 2727 2728 child_run_test if (!$child_pid); 2729 2730 $full_line = ""; 2731 2732 do { 2733 $line = wait_for_input($monitor_fp, 1); 2734 if (defined($line)) { 2735 2736 # we are not guaranteed to get a full line 2737 $full_line .= $line; 2738 doprint $line; 2739 2740 if ($full_line =~ /call trace:/i) { 2741 if ($ignore_errors) { 2742 $bug_ignored = 1; 2743 } else { 2744 $bug = 1; 2745 } 2746 } 2747 2748 if ($full_line =~ /Kernel panic -/) { 2749 $bug = 1; 2750 } 2751 2752 if ($line =~ /\n/) { 2753 $full_line = ""; 2754 } 2755 } 2756 } while (!$child_done && !$bug); 2757 2758 if (!$bug && $bug_ignored) { 2759 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n"; 2760 } 2761 2762 if ($bug) { 2763 my $failure_start = time; 2764 my $now; 2765 do { 2766 $line = wait_for_input($monitor_fp, 1); 2767 if (defined($line)) { 2768 doprint $line; 2769 } 2770 $now = time; 2771 if ($now - $failure_start >= $stop_after_failure) { 2772 last; 2773 } 2774 } while (defined($line)); 2775 2776 doprint "Detected kernel crash!\n"; 2777 # kill the child with extreme prejudice 2778 kill 9, $child_pid; 2779 } 2780 2781 waitpid $child_pid, 0; 2782 $child_exit = $? >> 8; 2783 2784 my $end_time = time; 2785 $test_time = $end_time - $start_time; 2786 2787 if (!$bug && $in_bisect) { 2788 if (defined($bisect_ret_good)) { 2789 if ($child_exit == $bisect_ret_good) { 2790 return 1; 2791 } 2792 } 2793 if (defined($bisect_ret_skip)) { 2794 if ($child_exit == $bisect_ret_skip) { 2795 return -1; 2796 } 2797 } 2798 if (defined($bisect_ret_abort)) { 2799 if ($child_exit == $bisect_ret_abort) { 2800 fail "test abort" and return -2; 2801 } 2802 } 2803 if (defined($bisect_ret_bad)) { 2804 if ($child_exit == $bisect_ret_skip) { 2805 return 0; 2806 } 2807 } 2808 if (defined($bisect_ret_default)) { 2809 if ($bisect_ret_default eq "good") { 2810 return 1; 2811 } elsif ($bisect_ret_default eq "bad") { 2812 return 0; 2813 } elsif ($bisect_ret_default eq "skip") { 2814 return -1; 2815 } elsif ($bisect_ret_default eq "abort") { 2816 return -2; 2817 } else { 2818 fail "unknown default action: $bisect_ret_default" 2819 and return -2; 2820 } 2821 } 2822 } 2823 2824 if ($bug || $child_exit) { 2825 return 0 if $in_bisect; 2826 fail "test failed" and return 0; 2827 } 2828 return 1; 2829} 2830 2831sub run_git_bisect { 2832 my ($command) = @_; 2833 2834 doprint "$command ... "; 2835 2836 my $output = `$command 2>&1`; 2837 my $ret = $?; 2838 2839 logit $output; 2840 2841 if ($ret) { 2842 doprint "FAILED\n"; 2843 dodie "Failed to git bisect"; 2844 } 2845 2846 doprint "SUCCESS\n"; 2847 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) { 2848 doprint "$1 [$2]\n"; 2849 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) { 2850 $bisect_bad_commit = $1; 2851 doprint "Found bad commit... $1\n"; 2852 return 0; 2853 } else { 2854 # we already logged it, just print it now. 2855 print $output; 2856 } 2857 2858 return 1; 2859} 2860 2861sub bisect_reboot { 2862 doprint "Reboot and sleep $bisect_sleep_time seconds\n"; 2863 reboot_to_good $bisect_sleep_time; 2864} 2865 2866# returns 1 on success, 0 on failure, -1 on skip 2867sub run_bisect_test { 2868 my ($type, $buildtype) = @_; 2869 2870 my $failed = 0; 2871 my $result; 2872 my $output; 2873 my $ret; 2874 2875 $in_bisect = 1; 2876 2877 build $buildtype or $failed = 1; 2878 2879 if ($type ne "build") { 2880 if ($failed && $bisect_skip) { 2881 $in_bisect = 0; 2882 return -1; 2883 } 2884 dodie "Failed on build" if $failed; 2885 2886 # Now boot the box 2887 start_monitor_and_install or $failed = 1; 2888 2889 if ($type ne "boot") { 2890 if ($failed && $bisect_skip) { 2891 end_monitor; 2892 bisect_reboot; 2893 $in_bisect = 0; 2894 return -1; 2895 } 2896 dodie "Failed on boot" if $failed; 2897 2898 do_run_test or $failed = 1; 2899 } 2900 end_monitor; 2901 } 2902 2903 if ($failed) { 2904 $result = 0; 2905 } else { 2906 $result = 1; 2907 } 2908 2909 # reboot the box to a kernel we can ssh to 2910 if ($type ne "build") { 2911 bisect_reboot; 2912 } 2913 $in_bisect = 0; 2914 2915 return $result; 2916} 2917 2918sub run_bisect { 2919 my ($type) = @_; 2920 my $buildtype = "oldconfig"; 2921 2922 # We should have a minconfig to use? 2923 if (defined($minconfig)) { 2924 $buildtype = "useconfig:$minconfig"; 2925 } 2926 2927 # If the user sets bisect_tries to less than 1, then no tries 2928 # is a success. 2929 my $ret = 1; 2930 2931 # Still let the user manually decide that though. 2932 if ($bisect_tries < 1 && $bisect_manual) { 2933 $ret = answer_bisect; 2934 } 2935 2936 for (my $i = 0; $i < $bisect_tries; $i++) { 2937 if ($bisect_tries > 1) { 2938 my $t = $i + 1; 2939 doprint("Running bisect trial $t of $bisect_tries:\n"); 2940 } 2941 $ret = run_bisect_test $type, $buildtype; 2942 2943 if ($bisect_manual) { 2944 $ret = answer_bisect; 2945 } 2946 2947 last if (!$ret); 2948 } 2949 2950 # Are we looking for where it worked, not failed? 2951 if ($reverse_bisect && $ret >= 0) { 2952 $ret = !$ret; 2953 } 2954 2955 if ($ret > 0) { 2956 return "good"; 2957 } elsif ($ret == 0) { 2958 return "bad"; 2959 } elsif ($bisect_skip) { 2960 doprint "HIT A BAD COMMIT ... SKIPPING\n"; 2961 return "skip"; 2962 } 2963} 2964 2965sub update_bisect_replay { 2966 my $tmp_log = "$tmpdir/ktest_bisect_log"; 2967 run_command "git bisect log > $tmp_log" or 2968 dodie "can't create bisect log"; 2969 return $tmp_log; 2970} 2971 2972sub bisect { 2973 my ($i) = @_; 2974 2975 my $result; 2976 2977 dodie "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good)); 2978 dodie "BISECT_BAD[$i] not defined\n" if (!defined($bisect_bad)); 2979 dodie "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type)); 2980 2981 my $good = $bisect_good; 2982 my $bad = $bisect_bad; 2983 my $type = $bisect_type; 2984 my $start = $bisect_start; 2985 my $replay = $bisect_replay; 2986 my $start_files = $bisect_files; 2987 2988 if (defined($start_files)) { 2989 $start_files = " -- " . $start_files; 2990 } else { 2991 $start_files = ""; 2992 } 2993 2994 # convert to true sha1's 2995 $good = get_sha1($good); 2996 $bad = get_sha1($bad); 2997 2998 if (defined($bisect_reverse) && $bisect_reverse == 1) { 2999 doprint "Performing a reverse bisect (bad is good, good is bad!)\n"; 3000 $reverse_bisect = 1; 3001 } else { 3002 $reverse_bisect = 0; 3003 } 3004 3005 # Can't have a test without having a test to run 3006 if ($type eq "test" && !defined($run_test)) { 3007 $type = "boot"; 3008 } 3009 3010 # Check if a bisect was running 3011 my $bisect_start_file = "$builddir/.git/BISECT_START"; 3012 3013 my $check = $bisect_check; 3014 my $do_check = defined($check) && $check ne "0"; 3015 3016 if ( -f $bisect_start_file ) { 3017 print "Bisect in progress found\n"; 3018 if ($do_check) { 3019 print " If you say yes, then no checks of good or bad will be done\n"; 3020 } 3021 if (defined($replay)) { 3022 print "** BISECT_REPLAY is defined in config file **"; 3023 print " Ignore config option and perform new git bisect log?\n"; 3024 if (read_ync " (yes, no, or cancel) ") { 3025 $replay = update_bisect_replay; 3026 $do_check = 0; 3027 } 3028 } elsif (read_yn "read git log and continue?") { 3029 $replay = update_bisect_replay; 3030 $do_check = 0; 3031 } 3032 } 3033 3034 if ($do_check) { 3035 3036 # get current HEAD 3037 my $head = get_sha1("HEAD"); 3038 3039 if ($check ne "good") { 3040 doprint "TESTING BISECT BAD [$bad]\n"; 3041 run_command "git checkout $bad" or 3042 dodie "Failed to checkout $bad"; 3043 3044 $result = run_bisect $type; 3045 3046 if ($result ne "bad") { 3047 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0; 3048 } 3049 } 3050 3051 if ($check ne "bad") { 3052 doprint "TESTING BISECT GOOD [$good]\n"; 3053 run_command "git checkout $good" or 3054 dodie "Failed to checkout $good"; 3055 3056 $result = run_bisect $type; 3057 3058 if ($result ne "good") { 3059 fail "Tested BISECT_GOOD [$good] and it failed" and return 0; 3060 } 3061 } 3062 3063 # checkout where we started 3064 run_command "git checkout $head" or 3065 dodie "Failed to checkout $head"; 3066 } 3067 3068 run_command "git bisect start$start_files" or 3069 dodie "could not start bisect"; 3070 3071 if (defined($replay)) { 3072 run_command "git bisect replay $replay" or 3073 dodie "failed to run replay"; 3074 } else { 3075 3076 run_command "git bisect good $good" or 3077 dodie "could not set bisect good to $good"; 3078 3079 run_git_bisect "git bisect bad $bad" or 3080 dodie "could not set bisect bad to $bad"; 3081 3082 } 3083 3084 if (defined($start)) { 3085 run_command "git checkout $start" or 3086 dodie "failed to checkout $start"; 3087 } 3088 3089 my $test; 3090 do { 3091 $result = run_bisect $type; 3092 $test = run_git_bisect "git bisect $result"; 3093 print_times; 3094 } while ($test); 3095 3096 run_command "git bisect log" or 3097 dodie "could not capture git bisect log"; 3098 3099 run_command "git bisect reset" or 3100 dodie "could not reset git bisect"; 3101 3102 doprint "Bad commit was [$bisect_bad_commit]\n"; 3103 3104 success $i; 3105} 3106 3107# config_ignore holds the configs that were set (or unset) for 3108# a good config and we will ignore these configs for the rest 3109# of a config bisect. These configs stay as they were. 3110my %config_ignore; 3111 3112# config_set holds what all configs were set as. 3113my %config_set; 3114 3115# config_off holds the set of configs that the bad config had disabled. 3116# We need to record them and set them in the .config when running 3117# olddefconfig, because olddefconfig keeps the defaults. 3118my %config_off; 3119 3120# config_off_tmp holds a set of configs to turn off for now 3121my @config_off_tmp; 3122 3123# config_list is the set of configs that are being tested 3124my %config_list; 3125my %null_config; 3126 3127my %dependency; 3128 3129sub assign_configs { 3130 my ($hash, $config) = @_; 3131 3132 doprint "Reading configs from $config\n"; 3133 3134 open (IN, $config) 3135 or dodie "Failed to read $config"; 3136 3137 while (<IN>) { 3138 chomp; 3139 if (/^((CONFIG\S*)=.*)/) { 3140 ${$hash}{$2} = $1; 3141 } elsif (/^(# (CONFIG\S*) is not set)/) { 3142 ${$hash}{$2} = $1; 3143 } 3144 } 3145 3146 close(IN); 3147} 3148 3149sub process_config_ignore { 3150 my ($config) = @_; 3151 3152 assign_configs \%config_ignore, $config; 3153} 3154 3155sub get_dependencies { 3156 my ($config) = @_; 3157 3158 my $arr = $dependency{$config}; 3159 if (!defined($arr)) { 3160 return (); 3161 } 3162 3163 my @deps = @{$arr}; 3164 3165 foreach my $dep (@{$arr}) { 3166 print "ADD DEP $dep\n"; 3167 @deps = (@deps, get_dependencies $dep); 3168 } 3169 3170 return @deps; 3171} 3172 3173sub save_config { 3174 my ($pc, $file) = @_; 3175 3176 my %configs = %{$pc}; 3177 3178 doprint "Saving configs into $file\n"; 3179 3180 open(OUT, ">$file") or dodie "Can not write to $file"; 3181 3182 foreach my $config (keys %configs) { 3183 print OUT "$configs{$config}\n"; 3184 } 3185 close(OUT); 3186} 3187 3188sub create_config { 3189 my ($name, $pc) = @_; 3190 3191 doprint "Creating old config from $name configs\n"; 3192 3193 save_config $pc, $output_config; 3194 3195 make_oldconfig; 3196} 3197 3198sub run_config_bisect_test { 3199 my ($type) = @_; 3200 3201 my $ret = run_bisect_test $type, "oldconfig"; 3202 3203 if ($bisect_manual) { 3204 $ret = answer_bisect; 3205 } 3206 3207 return $ret; 3208} 3209 3210sub config_bisect_end { 3211 my ($good, $bad) = @_; 3212 my $diffexec = "diff -u"; 3213 3214 if (-f "$builddir/scripts/diffconfig") { 3215 $diffexec = "$builddir/scripts/diffconfig"; 3216 } 3217 doprint "\n\n***************************************\n"; 3218 doprint "No more config bisecting possible.\n"; 3219 run_command "$diffexec $good $bad", 1; 3220 doprint "***************************************\n\n"; 3221} 3222 3223my $pass = 1; 3224 3225sub run_config_bisect { 3226 my ($good, $bad, $last_result) = @_; 3227 my $reset = ""; 3228 my $cmd; 3229 my $ret; 3230 3231 if (!length($last_result)) { 3232 $reset = "-r"; 3233 } 3234 run_command "$config_bisect_exec $reset -b $outputdir $good $bad $last_result", 1; 3235 3236 # config-bisect returns: 3237 # 0 if there is more to bisect 3238 # 1 for finding a good config 3239 # 2 if it can not find any more configs 3240 # -1 (255) on error 3241 if ($run_command_status) { 3242 return $run_command_status; 3243 } 3244 3245 $ret = run_config_bisect_test $config_bisect_type; 3246 if ($ret) { 3247 doprint "NEW GOOD CONFIG ($pass)\n"; 3248 system("cp $output_config $tmpdir/good_config.tmp.$pass"); 3249 $pass++; 3250 # Return 3 for good config 3251 return 3; 3252 } else { 3253 doprint "NEW BAD CONFIG ($pass)\n"; 3254 system("cp $output_config $tmpdir/bad_config.tmp.$pass"); 3255 $pass++; 3256 # Return 4 for bad config 3257 return 4; 3258 } 3259} 3260 3261sub config_bisect { 3262 my ($i) = @_; 3263 3264 my $good_config; 3265 my $bad_config; 3266 3267 my $type = $config_bisect_type; 3268 my $ret; 3269 3270 $bad_config = $config_bisect; 3271 3272 if (defined($config_bisect_good)) { 3273 $good_config = $config_bisect_good; 3274 } elsif (defined($minconfig)) { 3275 $good_config = $minconfig; 3276 } else { 3277 doprint "No config specified, checking if defconfig works"; 3278 $ret = run_bisect_test $type, "defconfig"; 3279 if (!$ret) { 3280 fail "Have no good config to compare with, please set CONFIG_BISECT_GOOD"; 3281 return 1; 3282 } 3283 $good_config = $output_config; 3284 } 3285 3286 if (!defined($config_bisect_exec)) { 3287 # First check the location that ktest.pl ran 3288 my @locations = ( "$pwd/config-bisect.pl", 3289 "$dirname/config-bisect.pl", 3290 "$builddir/tools/testing/ktest/config-bisect.pl", 3291 undef ); 3292 foreach my $loc (@locations) { 3293 doprint "loc = $loc\n"; 3294 $config_bisect_exec = $loc; 3295 last if (defined($config_bisect_exec && -x $config_bisect_exec)); 3296 } 3297 if (!defined($config_bisect_exec)) { 3298 fail "Could not find an executable config-bisect.pl\n", 3299 " Set CONFIG_BISECT_EXEC to point to config-bisect.pl"; 3300 return 1; 3301 } 3302 } 3303 3304 # we don't want min configs to cause issues here. 3305 doprint "Disabling 'MIN_CONFIG' for this test\n"; 3306 undef $minconfig; 3307 3308 my %good_configs; 3309 my %bad_configs; 3310 my %tmp_configs; 3311 3312 if (-f "$tmpdir/good_config.tmp" || -f "$tmpdir/bad_config.tmp") { 3313 if (read_yn "Interrupted config-bisect. Continue (n - will start new)?") { 3314 if (-f "$tmpdir/good_config.tmp") { 3315 $good_config = "$tmpdir/good_config.tmp"; 3316 } else { 3317 $good_config = "$tmpdir/good_config"; 3318 } 3319 if (-f "$tmpdir/bad_config.tmp") { 3320 $bad_config = "$tmpdir/bad_config.tmp"; 3321 } else { 3322 $bad_config = "$tmpdir/bad_config"; 3323 } 3324 } 3325 } 3326 doprint "Run good configs through make oldconfig\n"; 3327 assign_configs \%tmp_configs, $good_config; 3328 create_config "$good_config", \%tmp_configs; 3329 $good_config = "$tmpdir/good_config"; 3330 system("cp $output_config $good_config") == 0 or dodie "cp good config"; 3331 3332 doprint "Run bad configs through make oldconfig\n"; 3333 assign_configs \%tmp_configs, $bad_config; 3334 create_config "$bad_config", \%tmp_configs; 3335 $bad_config = "$tmpdir/bad_config"; 3336 system("cp $output_config $bad_config") == 0 or dodie "cp bad config"; 3337 3338 if (defined($config_bisect_check) && $config_bisect_check ne "0") { 3339 if ($config_bisect_check ne "good") { 3340 doprint "Testing bad config\n"; 3341 3342 $ret = run_bisect_test $type, "useconfig:$bad_config"; 3343 if ($ret) { 3344 fail "Bad config succeeded when expected to fail!"; 3345 return 0; 3346 } 3347 } 3348 if ($config_bisect_check ne "bad") { 3349 doprint "Testing good config\n"; 3350 3351 $ret = run_bisect_test $type, "useconfig:$good_config"; 3352 if (!$ret) { 3353 fail "Good config failed when expected to succeed!"; 3354 return 0; 3355 } 3356 } 3357 } 3358 3359 my $last_run = ""; 3360 3361 do { 3362 $ret = run_config_bisect $good_config, $bad_config, $last_run; 3363 if ($ret == 3) { 3364 $last_run = "good"; 3365 } elsif ($ret == 4) { 3366 $last_run = "bad"; 3367 } 3368 print_times; 3369 } while ($ret == 3 || $ret == 4); 3370 3371 if ($ret == 2) { 3372 config_bisect_end "$good_config.tmp", "$bad_config.tmp"; 3373 } 3374 3375 return $ret if ($ret < 0); 3376 3377 success $i; 3378} 3379 3380sub patchcheck_reboot { 3381 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n"; 3382 reboot_to_good $patchcheck_sleep_time; 3383} 3384 3385sub patchcheck { 3386 my ($i) = @_; 3387 3388 dodie "PATCHCHECK_START[$i] not defined\n" 3389 if (!defined($patchcheck_start)); 3390 dodie "PATCHCHECK_TYPE[$i] not defined\n" 3391 if (!defined($patchcheck_type)); 3392 3393 my $start = $patchcheck_start; 3394 3395 my $cherry = $patchcheck_cherry; 3396 if (!defined($cherry)) { 3397 $cherry = 0; 3398 } 3399 3400 my $end = "HEAD"; 3401 if (defined($patchcheck_end)) { 3402 $end = $patchcheck_end; 3403 } elsif ($cherry) { 3404 dodie "PATCHCHECK_END must be defined with PATCHCHECK_CHERRY\n"; 3405 } 3406 3407 # Get the true sha1's since we can use things like HEAD~3 3408 $start = get_sha1($start); 3409 $end = get_sha1($end); 3410 3411 my $type = $patchcheck_type; 3412 3413 # Can't have a test without having a test to run 3414 if ($type eq "test" && !defined($run_test)) { 3415 $type = "boot"; 3416 } 3417 3418 if ($cherry) { 3419 open (IN, "git cherry -v $start $end|") or 3420 dodie "could not get git list"; 3421 } else { 3422 open (IN, "git log --pretty=oneline $end|") or 3423 dodie "could not get git list"; 3424 } 3425 3426 my @list; 3427 3428 while (<IN>) { 3429 chomp; 3430 # git cherry adds a '+' we want to remove 3431 s/^\+ //; 3432 $list[$#list+1] = $_; 3433 last if (/^$start/); 3434 } 3435 close(IN); 3436 3437 if (!$cherry) { 3438 if ($list[$#list] !~ /^$start/) { 3439 fail "SHA1 $start not found"; 3440 } 3441 3442 # go backwards in the list 3443 @list = reverse @list; 3444 } 3445 3446 doprint("Going to test the following commits:\n"); 3447 foreach my $l (@list) { 3448 doprint "$l\n"; 3449 } 3450 3451 my $save_clean = $noclean; 3452 my %ignored_warnings; 3453 3454 if (defined($ignore_warnings)) { 3455 foreach my $sha1 (split /\s+/, $ignore_warnings) { 3456 $ignored_warnings{$sha1} = 1; 3457 } 3458 } 3459 3460 $in_patchcheck = 1; 3461 foreach my $item (@list) { 3462 my $sha1 = $item; 3463 $sha1 =~ s/^([[:xdigit:]]+).*/$1/; 3464 3465 doprint "\nProcessing commit \"$item\"\n\n"; 3466 3467 run_command "git checkout $sha1" or 3468 dodie "Failed to checkout $sha1"; 3469 3470 # only clean on the first and last patch 3471 if ($item eq $list[0] || 3472 $item eq $list[$#list]) { 3473 $noclean = $save_clean; 3474 } else { 3475 $noclean = 1; 3476 } 3477 3478 if (defined($minconfig)) { 3479 build "useconfig:$minconfig" or return 0; 3480 } else { 3481 # ?? no config to use? 3482 build "oldconfig" or return 0; 3483 } 3484 3485 # No need to do per patch checking if warnings file exists 3486 if (!defined($warnings_file) && !defined($ignored_warnings{$sha1})) { 3487 check_patch_buildlog $sha1 or return 0; 3488 } 3489 3490 check_buildlog or return 0; 3491 3492 next if ($type eq "build"); 3493 3494 my $failed = 0; 3495 3496 start_monitor_and_install or $failed = 1; 3497 3498 if (!$failed && $type ne "boot"){ 3499 do_run_test or $failed = 1; 3500 } 3501 end_monitor; 3502 if ($failed) { 3503 print_times; 3504 return 0; 3505 } 3506 patchcheck_reboot; 3507 print_times; 3508 } 3509 $in_patchcheck = 0; 3510 success $i; 3511 3512 return 1; 3513} 3514 3515my %depends; 3516my %depcount; 3517my $iflevel = 0; 3518my @ifdeps; 3519 3520# prevent recursion 3521my %read_kconfigs; 3522 3523sub add_dep { 3524 # $config depends on $dep 3525 my ($config, $dep) = @_; 3526 3527 if (defined($depends{$config})) { 3528 $depends{$config} .= " " . $dep; 3529 } else { 3530 $depends{$config} = $dep; 3531 } 3532 3533 # record the number of configs depending on $dep 3534 if (defined $depcount{$dep}) { 3535 $depcount{$dep}++; 3536 } else { 3537 $depcount{$dep} = 1; 3538 } 3539} 3540 3541# taken from streamline_config.pl 3542sub read_kconfig { 3543 my ($kconfig) = @_; 3544 3545 my $state = "NONE"; 3546 my $config; 3547 my @kconfigs; 3548 3549 my $cont = 0; 3550 my $line; 3551 3552 3553 if (! -f $kconfig) { 3554 doprint "file $kconfig does not exist, skipping\n"; 3555 return; 3556 } 3557 3558 open(KIN, "$kconfig") 3559 or dodie "Can't open $kconfig"; 3560 while (<KIN>) { 3561 chomp; 3562 3563 # Make sure that lines ending with \ continue 3564 if ($cont) { 3565 $_ = $line . " " . $_; 3566 } 3567 3568 if (s/\\$//) { 3569 $cont = 1; 3570 $line = $_; 3571 next; 3572 } 3573 3574 $cont = 0; 3575 3576 # collect any Kconfig sources 3577 if (/^source\s*"(.*)"/) { 3578 $kconfigs[$#kconfigs+1] = $1; 3579 } 3580 3581 # configs found 3582 if (/^\s*(menu)?config\s+(\S+)\s*$/) { 3583 $state = "NEW"; 3584 $config = $2; 3585 3586 for (my $i = 0; $i < $iflevel; $i++) { 3587 add_dep $config, $ifdeps[$i]; 3588 } 3589 3590 # collect the depends for the config 3591 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) { 3592 3593 add_dep $config, $1; 3594 3595 # Get the configs that select this config 3596 } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) { 3597 3598 # selected by depends on config 3599 add_dep $1, $config; 3600 3601 # Check for if statements 3602 } elsif (/^if\s+(.*\S)\s*$/) { 3603 my $deps = $1; 3604 # remove beginning and ending non text 3605 $deps =~ s/^[^a-zA-Z0-9_]*//; 3606 $deps =~ s/[^a-zA-Z0-9_]*$//; 3607 3608 my @deps = split /[^a-zA-Z0-9_]+/, $deps; 3609 3610 $ifdeps[$iflevel++] = join ':', @deps; 3611 3612 } elsif (/^endif/) { 3613 3614 $iflevel-- if ($iflevel); 3615 3616 # stop on "help" 3617 } elsif (/^\s*help\s*$/) { 3618 $state = "NONE"; 3619 } 3620 } 3621 close(KIN); 3622 3623 # read in any configs that were found. 3624 foreach $kconfig (@kconfigs) { 3625 if (!defined($read_kconfigs{$kconfig})) { 3626 $read_kconfigs{$kconfig} = 1; 3627 read_kconfig("$builddir/$kconfig"); 3628 } 3629 } 3630} 3631 3632sub read_depends { 3633 # find out which arch this is by the kconfig file 3634 open (IN, $output_config) 3635 or dodie "Failed to read $output_config"; 3636 my $arch; 3637 while (<IN>) { 3638 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) { 3639 $arch = $1; 3640 last; 3641 } 3642 } 3643 close IN; 3644 3645 if (!defined($arch)) { 3646 doprint "Could not find arch from config file\n"; 3647 doprint "no dependencies used\n"; 3648 return; 3649 } 3650 3651 # arch is really the subarch, we need to know 3652 # what directory to look at. 3653 if ($arch eq "i386" || $arch eq "x86_64") { 3654 $arch = "x86"; 3655 } 3656 3657 my $kconfig = "$builddir/arch/$arch/Kconfig"; 3658 3659 if (! -f $kconfig && $arch =~ /\d$/) { 3660 my $orig = $arch; 3661 # some subarchs have numbers, truncate them 3662 $arch =~ s/\d*$//; 3663 $kconfig = "$builddir/arch/$arch/Kconfig"; 3664 if (! -f $kconfig) { 3665 doprint "No idea what arch dir $orig is for\n"; 3666 doprint "no dependencies used\n"; 3667 return; 3668 } 3669 } 3670 3671 read_kconfig($kconfig); 3672} 3673 3674sub make_new_config { 3675 my @configs = @_; 3676 3677 open (OUT, ">$output_config") 3678 or dodie "Failed to write $output_config"; 3679 3680 foreach my $config (@configs) { 3681 print OUT "$config\n"; 3682 } 3683 close OUT; 3684} 3685 3686sub chomp_config { 3687 my ($config) = @_; 3688 3689 $config =~ s/CONFIG_//; 3690 3691 return $config; 3692} 3693 3694sub get_depends { 3695 my ($dep) = @_; 3696 3697 my $kconfig = chomp_config $dep; 3698 3699 $dep = $depends{"$kconfig"}; 3700 3701 # the dep string we have saves the dependencies as they 3702 # were found, including expressions like ! && ||. We 3703 # want to split this out into just an array of configs. 3704 3705 my $valid = "A-Za-z_0-9"; 3706 3707 my @configs; 3708 3709 while ($dep =~ /[$valid]/) { 3710 3711 if ($dep =~ /^[^$valid]*([$valid]+)/) { 3712 my $conf = "CONFIG_" . $1; 3713 3714 $configs[$#configs + 1] = $conf; 3715 3716 $dep =~ s/^[^$valid]*[$valid]+//; 3717 } else { 3718 dodie "this should never happen"; 3719 } 3720 } 3721 3722 return @configs; 3723} 3724 3725my %min_configs; 3726my %keep_configs; 3727my %save_configs; 3728my %processed_configs; 3729my %nochange_config; 3730 3731sub test_this_config { 3732 my ($config) = @_; 3733 3734 my $found; 3735 3736 # if we already processed this config, skip it 3737 if (defined($processed_configs{$config})) { 3738 return undef; 3739 } 3740 $processed_configs{$config} = 1; 3741 3742 # if this config failed during this round, skip it 3743 if (defined($nochange_config{$config})) { 3744 return undef; 3745 } 3746 3747 my $kconfig = chomp_config $config; 3748 3749 # Test dependencies first 3750 if (defined($depends{"$kconfig"})) { 3751 my @parents = get_depends $config; 3752 foreach my $parent (@parents) { 3753 # if the parent is in the min config, check it first 3754 next if (!defined($min_configs{$parent})); 3755 $found = test_this_config($parent); 3756 if (defined($found)) { 3757 return $found; 3758 } 3759 } 3760 } 3761 3762 # Remove this config from the list of configs 3763 # do a make olddefconfig and then read the resulting 3764 # .config to make sure it is missing the config that 3765 # we had before 3766 my %configs = %min_configs; 3767 delete $configs{$config}; 3768 make_new_config ((values %configs), (values %keep_configs)); 3769 make_oldconfig; 3770 undef %configs; 3771 assign_configs \%configs, $output_config; 3772 3773 if (!defined($configs{$config}) || $configs{$config} =~ /^#/) { 3774 return $config; 3775 } 3776 3777 doprint "disabling config $config did not change .config\n"; 3778 3779 $nochange_config{$config} = 1; 3780 3781 return undef; 3782} 3783 3784sub make_min_config { 3785 my ($i) = @_; 3786 3787 my $type = $minconfig_type; 3788 if ($type ne "boot" && $type ne "test") { 3789 fail "Invalid MIN_CONFIG_TYPE '$minconfig_type'\n" . 3790 " make_min_config works only with 'boot' and 'test'\n" and return; 3791 } 3792 3793 if (!defined($output_minconfig)) { 3794 fail "OUTPUT_MIN_CONFIG not defined" and return; 3795 } 3796 3797 # If output_minconfig exists, and the start_minconfig 3798 # came from min_config, than ask if we should use 3799 # that instead. 3800 if (-f $output_minconfig && !$start_minconfig_defined) { 3801 print "$output_minconfig exists\n"; 3802 if (!defined($use_output_minconfig)) { 3803 if (read_yn " Use it as minconfig?") { 3804 $start_minconfig = $output_minconfig; 3805 } 3806 } elsif ($use_output_minconfig > 0) { 3807 doprint "Using $output_minconfig as MIN_CONFIG\n"; 3808 $start_minconfig = $output_minconfig; 3809 } else { 3810 doprint "Set to still use MIN_CONFIG as starting point\n"; 3811 } 3812 } 3813 3814 if (!defined($start_minconfig)) { 3815 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return; 3816 } 3817 3818 my $temp_config = "$tmpdir/temp_config"; 3819 3820 # First things first. We build an allnoconfig to find 3821 # out what the defaults are that we can't touch. 3822 # Some are selections, but we really can't handle selections. 3823 3824 my $save_minconfig = $minconfig; 3825 undef $minconfig; 3826 3827 run_command "$make allnoconfig" or return 0; 3828 3829 read_depends; 3830 3831 process_config_ignore $output_config; 3832 3833 undef %save_configs; 3834 undef %min_configs; 3835 3836 if (defined($ignore_config)) { 3837 # make sure the file exists 3838 `touch $ignore_config`; 3839 assign_configs \%save_configs, $ignore_config; 3840 } 3841 3842 %keep_configs = %save_configs; 3843 3844 doprint "Load initial configs from $start_minconfig\n"; 3845 3846 # Look at the current min configs, and save off all the 3847 # ones that were set via the allnoconfig 3848 assign_configs \%min_configs, $start_minconfig; 3849 3850 my @config_keys = keys %min_configs; 3851 3852 # All configs need a depcount 3853 foreach my $config (@config_keys) { 3854 my $kconfig = chomp_config $config; 3855 if (!defined $depcount{$kconfig}) { 3856 $depcount{$kconfig} = 0; 3857 } 3858 } 3859 3860 # Remove anything that was set by the make allnoconfig 3861 # we shouldn't need them as they get set for us anyway. 3862 foreach my $config (@config_keys) { 3863 # Remove anything in the ignore_config 3864 if (defined($keep_configs{$config})) { 3865 my $file = $ignore_config; 3866 $file =~ s,.*/(.*?)$,$1,; 3867 doprint "$config set by $file ... ignored\n"; 3868 delete $min_configs{$config}; 3869 next; 3870 } 3871 # But make sure the settings are the same. If a min config 3872 # sets a selection, we do not want to get rid of it if 3873 # it is not the same as what we have. Just move it into 3874 # the keep configs. 3875 if (defined($config_ignore{$config})) { 3876 if ($config_ignore{$config} ne $min_configs{$config}) { 3877 doprint "$config is in allnoconfig as '$config_ignore{$config}'"; 3878 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n"; 3879 $keep_configs{$config} = $min_configs{$config}; 3880 } else { 3881 doprint "$config set by allnoconfig ... ignored\n"; 3882 } 3883 delete $min_configs{$config}; 3884 } 3885 } 3886 3887 my $done = 0; 3888 my $take_two = 0; 3889 3890 while (!$done) { 3891 3892 my $config; 3893 my $found; 3894 3895 # Now disable each config one by one and do a make oldconfig 3896 # till we find a config that changes our list. 3897 3898 my @test_configs = keys %min_configs; 3899 3900 # Sort keys by who is most dependent on 3901 @test_configs = sort { $depcount{chomp_config($b)} <=> $depcount{chomp_config($a)} } 3902 @test_configs ; 3903 3904 # Put configs that did not modify the config at the end. 3905 my $reset = 1; 3906 for (my $i = 0; $i < $#test_configs; $i++) { 3907 if (!defined($nochange_config{$test_configs[0]})) { 3908 $reset = 0; 3909 last; 3910 } 3911 # This config didn't change the .config last time. 3912 # Place it at the end 3913 my $config = shift @test_configs; 3914 push @test_configs, $config; 3915 } 3916 3917 # if every test config has failed to modify the .config file 3918 # in the past, then reset and start over. 3919 if ($reset) { 3920 undef %nochange_config; 3921 } 3922 3923 undef %processed_configs; 3924 3925 foreach my $config (@test_configs) { 3926 3927 $found = test_this_config $config; 3928 3929 last if (defined($found)); 3930 3931 # oh well, try another config 3932 } 3933 3934 if (!defined($found)) { 3935 # we could have failed due to the nochange_config hash 3936 # reset and try again 3937 if (!$take_two) { 3938 undef %nochange_config; 3939 $take_two = 1; 3940 next; 3941 } 3942 doprint "No more configs found that we can disable\n"; 3943 $done = 1; 3944 last; 3945 } 3946 $take_two = 0; 3947 3948 $config = $found; 3949 3950 doprint "Test with $config disabled\n"; 3951 3952 # set in_bisect to keep build and monitor from dieing 3953 $in_bisect = 1; 3954 3955 my $failed = 0; 3956 build "oldconfig" or $failed = 1; 3957 if (!$failed) { 3958 start_monitor_and_install or $failed = 1; 3959 3960 if ($type eq "test" && !$failed) { 3961 do_run_test or $failed = 1; 3962 } 3963 3964 end_monitor; 3965 } 3966 3967 $in_bisect = 0; 3968 3969 if ($failed) { 3970 doprint "$min_configs{$config} is needed to boot the box... keeping\n"; 3971 # this config is needed, add it to the ignore list. 3972 $keep_configs{$config} = $min_configs{$config}; 3973 $save_configs{$config} = $min_configs{$config}; 3974 delete $min_configs{$config}; 3975 3976 # update new ignore configs 3977 if (defined($ignore_config)) { 3978 open (OUT, ">$temp_config") 3979 or dodie "Can't write to $temp_config"; 3980 foreach my $config (keys %save_configs) { 3981 print OUT "$save_configs{$config}\n"; 3982 } 3983 close OUT; 3984 run_command "mv $temp_config $ignore_config" or 3985 dodie "failed to copy update to $ignore_config"; 3986 } 3987 3988 } else { 3989 # We booted without this config, remove it from the minconfigs. 3990 doprint "$config is not needed, disabling\n"; 3991 3992 delete $min_configs{$config}; 3993 3994 # Also disable anything that is not enabled in this config 3995 my %configs; 3996 assign_configs \%configs, $output_config; 3997 my @config_keys = keys %min_configs; 3998 foreach my $config (@config_keys) { 3999 if (!defined($configs{$config})) { 4000 doprint "$config is not set, disabling\n"; 4001 delete $min_configs{$config}; 4002 } 4003 } 4004 4005 # Save off all the current mandatory configs 4006 open (OUT, ">$temp_config") 4007 or dodie "Can't write to $temp_config"; 4008 foreach my $config (keys %keep_configs) { 4009 print OUT "$keep_configs{$config}\n"; 4010 } 4011 foreach my $config (keys %min_configs) { 4012 print OUT "$min_configs{$config}\n"; 4013 } 4014 close OUT; 4015 4016 run_command "mv $temp_config $output_minconfig" or 4017 dodie "failed to copy update to $output_minconfig"; 4018 } 4019 4020 doprint "Reboot and wait $sleep_time seconds\n"; 4021 reboot_to_good $sleep_time; 4022 } 4023 4024 success $i; 4025 return 1; 4026} 4027 4028sub make_warnings_file { 4029 my ($i) = @_; 4030 4031 if (!defined($warnings_file)) { 4032 dodie "Must define WARNINGS_FILE for make_warnings_file test"; 4033 } 4034 4035 if ($build_type eq "nobuild") { 4036 dodie "BUILD_TYPE can not be 'nobuild' for make_warnings_file test"; 4037 } 4038 4039 build $build_type or dodie "Failed to build"; 4040 4041 open(OUT, ">$warnings_file") or dodie "Can't create $warnings_file"; 4042 4043 open(IN, $buildlog) or dodie "Can't open $buildlog"; 4044 while (<IN>) { 4045 4046 # Some compilers use UTF-8 extended for quotes 4047 # for distcc heterogeneous systems, this causes issues 4048 s/$utf8_quote/'/g; 4049 4050 if (/$check_build_re/) { 4051 print OUT; 4052 } 4053 } 4054 close(IN); 4055 4056 close(OUT); 4057 4058 success $i; 4059} 4060 4061$#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl [config-file]\n"; 4062 4063if ($#ARGV == 0) { 4064 $ktest_config = $ARGV[0]; 4065 if (! -f $ktest_config) { 4066 print "$ktest_config does not exist.\n"; 4067 if (!read_yn "Create it?") { 4068 exit 0; 4069 } 4070 } 4071} 4072 4073if (! -f $ktest_config) { 4074 $newconfig = 1; 4075 get_test_case; 4076 open(OUT, ">$ktest_config") or die "Can not create $ktest_config"; 4077 print OUT << "EOF" 4078# Generated by ktest.pl 4079# 4080 4081# PWD is a ktest.pl variable that will result in the process working 4082# directory that ktest.pl is executed in. 4083 4084# THIS_DIR is automatically assigned the PWD of the path that generated 4085# the config file. It is best to use this variable when assigning other 4086# directory paths within this directory. This allows you to easily 4087# move the test cases to other locations or to other machines. 4088# 4089THIS_DIR := $variable{"PWD"} 4090 4091# Define each test with TEST_START 4092# The config options below it will override the defaults 4093TEST_START 4094TEST_TYPE = $default{"TEST_TYPE"} 4095 4096DEFAULTS 4097EOF 4098; 4099 close(OUT); 4100} 4101read_config $ktest_config; 4102 4103if (defined($opt{"LOG_FILE"})) { 4104 $opt{"LOG_FILE"} = eval_option("LOG_FILE", $opt{"LOG_FILE"}, -1); 4105} 4106 4107# Append any configs entered in manually to the config file. 4108my @new_configs = keys %entered_configs; 4109if ($#new_configs >= 0) { 4110 print "\nAppending entered in configs to $ktest_config\n"; 4111 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config"; 4112 foreach my $config (@new_configs) { 4113 print OUT "$config = $entered_configs{$config}\n"; 4114 $opt{$config} = process_variables($entered_configs{$config}); 4115 } 4116} 4117 4118if (defined($opt{"LOG_FILE"})) { 4119 if ($opt{"CLEAR_LOG"}) { 4120 unlink $opt{"LOG_FILE"}; 4121 } 4122 open(LOG, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}"; 4123 LOG->autoflush(1); 4124} 4125 4126doprint "\n\nSTARTING AUTOMATED TESTS\n\n"; 4127 4128for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) { 4129 4130 if (!$i) { 4131 doprint "DEFAULT OPTIONS:\n"; 4132 } else { 4133 doprint "\nTEST $i OPTIONS"; 4134 if (defined($repeat_tests{$i})) { 4135 $repeat = $repeat_tests{$i}; 4136 doprint " ITERATE $repeat"; 4137 } 4138 doprint "\n"; 4139 } 4140 4141 foreach my $option (sort keys %opt) { 4142 4143 if ($option =~ /\[(\d+)\]$/) { 4144 next if ($i != $1); 4145 } else { 4146 next if ($i); 4147 } 4148 4149 doprint "$option = $opt{$option}\n"; 4150 } 4151} 4152 4153sub option_defined { 4154 my ($option) = @_; 4155 4156 if (defined($opt{$option}) && $opt{$option} !~ /^\s*$/) { 4157 return 1; 4158 } 4159 4160 return 0; 4161} 4162 4163sub __set_test_option { 4164 my ($name, $i) = @_; 4165 4166 my $option = "$name\[$i\]"; 4167 4168 if (option_defined($option)) { 4169 return $opt{$option}; 4170 } 4171 4172 foreach my $test (keys %repeat_tests) { 4173 if ($i >= $test && 4174 $i < $test + $repeat_tests{$test}) { 4175 $option = "$name\[$test\]"; 4176 if (option_defined($option)) { 4177 return $opt{$option}; 4178 } 4179 } 4180 } 4181 4182 if (option_defined($name)) { 4183 return $opt{$name}; 4184 } 4185 4186 return undef; 4187} 4188 4189sub set_test_option { 4190 my ($name, $i) = @_; 4191 4192 my $option = __set_test_option($name, $i); 4193 return $option if (!defined($option)); 4194 4195 return eval_option($name, $option, $i); 4196} 4197 4198sub find_mailer { 4199 my ($mailer) = @_; 4200 4201 my @paths = split /:/, $ENV{PATH}; 4202 4203 # sendmail is usually in /usr/sbin 4204 $paths[$#paths + 1] = "/usr/sbin"; 4205 4206 foreach my $path (@paths) { 4207 if (-x "$path/$mailer") { 4208 return $path; 4209 } 4210 } 4211 4212 return undef; 4213} 4214 4215sub do_send_mail { 4216 my ($subject, $message, $file) = @_; 4217 4218 if (!defined($mail_path)) { 4219 # find the mailer 4220 $mail_path = find_mailer $mailer; 4221 if (!defined($mail_path)) { 4222 die "\nCan not find $mailer in PATH\n"; 4223 } 4224 } 4225 4226 my $header_file = "$tmpdir/header"; 4227 open (HEAD, ">$header_file") or die "Can not create $header_file\n"; 4228 print HEAD "To: $mailto\n"; 4229 print HEAD "Subject: $subject\n\n"; 4230 print HEAD "$message\n"; 4231 close HEAD; 4232 4233 if (!defined($mail_command)) { 4234 if ($mailer eq "mail" || $mailer eq "mailx") { 4235 $mail_command = "cat \$HEADER_FILE \$BODY_FILE | \$MAIL_PATH/\$MAILER -s \'\$SUBJECT\' \$MAILTO"; 4236 } elsif ($mailer eq "sendmail" ) { 4237 $mail_command = "cat \$HEADER_FILE \$BODY_FILE | \$MAIL_PATH/\$MAILER -t \$MAILTO"; 4238 } else { 4239 die "\nYour mailer: $mailer is not supported.\n"; 4240 } 4241 } 4242 4243 if (defined($file)) { 4244 $mail_command =~ s/\$BODY_FILE/$file/g; 4245 } else { 4246 $mail_command =~ s/\$BODY_FILE//g; 4247 } 4248 4249 $mail_command =~ s/\$HEADER_FILE/$header_file/g; 4250 $mail_command =~ s/\$MAILER/$mailer/g; 4251 $mail_command =~ s/\$MAIL_PATH/$mail_path/g; 4252 $mail_command =~ s/\$MAILTO/$mailto/g; 4253 $mail_command =~ s/\$SUBJECT/$subject/g; 4254 $mail_command =~ s/\$MESSAGE/$message/g; 4255 4256 run_command $mail_command; 4257} 4258 4259sub send_email { 4260 4261 if (defined($mailto)) { 4262 if (!defined($mailer)) { 4263 doprint "No email sent: email or mailer not specified in config.\n"; 4264 return; 4265 } 4266 do_send_mail @_; 4267 } 4268} 4269 4270sub cancel_test { 4271 if ($email_when_canceled) { 4272 my $name = get_test_name; 4273 send_email("KTEST: Your [$name] test was cancelled", 4274 "Your test started at $script_start_time was cancelled: sig int"); 4275 } 4276 die "\nCaught Sig Int, test interrupted: $!\n" 4277} 4278 4279$SIG{INT} = qw(cancel_test); 4280 4281# First we need to do is the builds 4282for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) { 4283 4284 # Do not reboot on failing test options 4285 $no_reboot = 1; 4286 $reboot_success = 0; 4287 4288 $have_version = 0; 4289 4290 $iteration = $i; 4291 4292 $build_time = 0; 4293 $install_time = 0; 4294 $reboot_time = 0; 4295 $test_time = 0; 4296 4297 undef %force_config; 4298 4299 my $makecmd = set_test_option("MAKE_CMD", $i); 4300 4301 $outputdir = set_test_option("OUTPUT_DIR", $i); 4302 $builddir = set_test_option("BUILD_DIR", $i); 4303 4304 chdir $builddir || dodie "can't change directory to $builddir"; 4305 4306 if (!-d $outputdir) { 4307 mkpath($outputdir) or 4308 dodie "can't create $outputdir"; 4309 } 4310 4311 $make = "$makecmd O=$outputdir"; 4312 4313 # Load all the options into their mapped variable names 4314 foreach my $opt (keys %option_map) { 4315 ${$option_map{$opt}} = set_test_option($opt, $i); 4316 } 4317 4318 $start_minconfig_defined = 1; 4319 4320 # The first test may override the PRE_KTEST option 4321 if ($i == 1) { 4322 if (defined($pre_ktest)) { 4323 doprint "\n"; 4324 run_command $pre_ktest; 4325 } 4326 if ($email_when_started) { 4327 my $name = get_test_name; 4328 send_email("KTEST: Your [$name] test was started", 4329 "Your test was started on $script_start_time"); 4330 } 4331 } 4332 4333 # Any test can override the POST_KTEST option 4334 # The last test takes precedence. 4335 if (defined($post_ktest)) { 4336 $final_post_ktest = $post_ktest; 4337 } 4338 4339 if (!defined($start_minconfig)) { 4340 $start_minconfig_defined = 0; 4341 $start_minconfig = $minconfig; 4342 } 4343 4344 if (!-d $tmpdir) { 4345 mkpath($tmpdir) or 4346 dodie "can't create $tmpdir"; 4347 } 4348 4349 $ENV{"SSH_USER"} = $ssh_user; 4350 $ENV{"MACHINE"} = $machine; 4351 4352 $buildlog = "$tmpdir/buildlog-$machine"; 4353 $testlog = "$tmpdir/testlog-$machine"; 4354 $dmesg = "$tmpdir/dmesg-$machine"; 4355 $output_config = "$outputdir/.config"; 4356 4357 if (!$buildonly) { 4358 $target = "$ssh_user\@$machine"; 4359 if (($reboot_type eq "grub") or ($reboot_type eq "grub2bls")) { 4360 dodie "GRUB_MENU not defined" if (!defined($grub_menu)); 4361 } elsif ($reboot_type eq "grub2") { 4362 dodie "GRUB_MENU not defined" if (!defined($grub_menu)); 4363 dodie "GRUB_FILE not defined" if (!defined($grub_file)); 4364 } elsif ($reboot_type eq "syslinux") { 4365 dodie "SYSLINUX_LABEL not defined" if (!defined($syslinux_label)); 4366 } 4367 } 4368 4369 my $run_type = $build_type; 4370 if ($test_type eq "patchcheck") { 4371 $run_type = $patchcheck_type; 4372 } elsif ($test_type eq "bisect") { 4373 $run_type = $bisect_type; 4374 } elsif ($test_type eq "config_bisect") { 4375 $run_type = $config_bisect_type; 4376 } elsif ($test_type eq "make_min_config") { 4377 $run_type = ""; 4378 } elsif ($test_type eq "make_warnings_file") { 4379 $run_type = ""; 4380 } 4381 4382 # mistake in config file? 4383 if (!defined($run_type)) { 4384 $run_type = "ERROR"; 4385 } 4386 4387 my $installme = ""; 4388 $installme = " no_install" if ($no_install); 4389 4390 my $name = ""; 4391 4392 if (defined($test_name)) { 4393 $name = " ($test_name)"; 4394 } 4395 4396 doprint "\n\n"; 4397 4398 if (defined($opt{"LOG_FILE"})) { 4399 $test_log_start = tell(LOG); 4400 } 4401 4402 doprint "RUNNING TEST $i of $opt{NUM_TESTS}$name with option $test_type $run_type$installme\n\n"; 4403 4404 if (defined($pre_test)) { 4405 my $ret = run_command $pre_test; 4406 if (!$ret && defined($pre_test_die) && 4407 $pre_test_die) { 4408 dodie "failed to pre_test\n"; 4409 } 4410 } 4411 4412 unlink $dmesg; 4413 unlink $buildlog; 4414 unlink $testlog; 4415 4416 if (defined($addconfig)) { 4417 my $min = $minconfig; 4418 if (!defined($minconfig)) { 4419 $min = ""; 4420 } 4421 run_command "cat $addconfig $min > $tmpdir/add_config" or 4422 dodie "Failed to create temp config"; 4423 $minconfig = "$tmpdir/add_config"; 4424 } 4425 4426 if (defined($checkout)) { 4427 run_command "git checkout $checkout" or 4428 dodie "failed to checkout $checkout"; 4429 } 4430 4431 $no_reboot = 0; 4432 4433 # A test may opt to not reboot the box 4434 if ($reboot_on_success) { 4435 $reboot_success = 1; 4436 } 4437 4438 if ($test_type eq "bisect") { 4439 bisect $i; 4440 next; 4441 } elsif ($test_type eq "config_bisect") { 4442 config_bisect $i; 4443 next; 4444 } elsif ($test_type eq "patchcheck") { 4445 patchcheck $i; 4446 next; 4447 } elsif ($test_type eq "make_min_config") { 4448 make_min_config $i; 4449 next; 4450 } elsif ($test_type eq "make_warnings_file") { 4451 $no_reboot = 1; 4452 make_warnings_file $i; 4453 next; 4454 } 4455 4456 if ($build_type ne "nobuild") { 4457 build $build_type or next; 4458 check_buildlog or next; 4459 } 4460 4461 if ($test_type eq "install") { 4462 get_version; 4463 install; 4464 success $i; 4465 next; 4466 } 4467 4468 if ($test_type ne "build") { 4469 my $failed = 0; 4470 start_monitor_and_install or $failed = 1; 4471 4472 if (!$failed && $test_type ne "boot" && defined($run_test)) { 4473 do_run_test or $failed = 1; 4474 } 4475 end_monitor; 4476 if ($failed) { 4477 print_times; 4478 next; 4479 } 4480 } 4481 4482 print_times; 4483 4484 success $i; 4485} 4486 4487if (defined($final_post_ktest)) { 4488 4489 my $cp_final_post_ktest = eval_kernel_version $final_post_ktest; 4490 run_command $cp_final_post_ktest; 4491} 4492 4493if ($opt{"POWEROFF_ON_SUCCESS"}) { 4494 halt; 4495} elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot && $reboot_success) { 4496 reboot_to_good; 4497} elsif (defined($switch_to_good)) { 4498 # still need to get to the good kernel 4499 run_command $switch_to_good; 4500} 4501 4502 4503doprint "\n $successes of $opt{NUM_TESTS} tests were successful\n\n"; 4504 4505if ($email_when_finished) { 4506 send_email("KTEST: Your test has finished!", 4507 "$successes of $opt{NUM_TESTS} tests started at $script_start_time were successful!"); 4508} 4509 4510if (defined($opt{"LOG_FILE"})) { 4511 print "\n See $opt{LOG_FILE} for the record of results.\n\n"; 4512 close LOG; 4513} 4514 4515exit 0; 4516