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