tools/testing/ktest/ktest.pl

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