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