tools/testing/ktest/ktest.pl

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