tools/testing/ktest/ktest.pl

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