tools/testing/ktest/ktest.pl

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