Pileus Git - ~andy/linux/blob - tools/testing/ktest/ktest.pl

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