#!/usr/bin/perl -w

  #

  # Copyright 2010 - Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.

  # Licensed under the terms of the GNU GPL License version 2
  #

  
  use strict;
  use IPC::Open2;
  use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);

  use File::Path qw(mkpath);
  use File::Copy qw(cp);

  use FileHandle;

  my $VERSION = "0.2";

  $| = 1;
  
  my %opt;

  my %repeat_tests;
  my %repeats;

  
  #default opts

  my %default = (
      "NUM_TESTS"			=> 1,
      "TEST_TYPE"			=> "build",
      "BUILD_TYPE"		=> "randconfig",
      "MAKE_CMD"			=> "make",
      "TIMEOUT"			=> 120,
      "TMP_DIR"			=> "/tmp/ktest/\${MACHINE}",
      "SLEEP_TIME"		=> 60,	# sleep time between tests
      "BUILD_NOCLEAN"		=> 0,
      "REBOOT_ON_ERROR"		=> 0,
      "POWEROFF_ON_ERROR"		=> 0,
      "REBOOT_ON_SUCCESS"		=> 1,
      "POWEROFF_ON_SUCCESS"	=> 0,
      "BUILD_OPTIONS"		=> "",
      "BISECT_SLEEP_TIME"		=> 60,   # sleep time between bisects
      "PATCHCHECK_SLEEP_TIME"	=> 60, # sleep time between patch checks
      "CLEAR_LOG"			=> 0,
      "BISECT_MANUAL"		=> 0,
      "BISECT_SKIP"		=> 1,
      "SUCCESS_LINE"		=> "login:",
      "DETECT_TRIPLE_FAULT"	=> 1,
      "NO_INSTALL"		=> 0,
      "BOOTED_TIMEOUT"		=> 1,
      "DIE_ON_FAILURE"		=> 1,
      "SSH_EXEC"			=> "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND",
      "SCP_TO_TARGET"		=> "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE",
      "REBOOT"			=> "ssh \$SSH_USER\@\$MACHINE reboot",
      "STOP_AFTER_SUCCESS"	=> 10,
      "STOP_AFTER_FAILURE"	=> 60,
      "STOP_TEST_AFTER"		=> 600,

  
  # required, and we will ask users if they don't have them but we keep the default
  # value something that is common.

      "REBOOT_TYPE"		=> "grub",
      "LOCALVERSION"		=> "-test",
      "SSH_USER"			=> "root",
      "BUILD_TARGET"	 	=> "arch/x86/boot/bzImage",
      "TARGET_IMAGE"		=> "/boot/vmlinuz-test",

  
      "LOG_FILE"			=> undef,
      "IGNORE_UNUSED"		=> 0,

  );

  my $ktest_config;

  my $version;

  my $machine;

  my $ssh_user;

  my $tmpdir;
  my $builddir;
  my $outputdir;

  my $output_config;

  my $test_type;

  my $build_type;

  my $build_options;

  my $pre_build;
  my $post_build;
  my $pre_build_die;
  my $post_build_die;

  my $reboot_type;
  my $reboot_script;
  my $power_cycle;

  my $reboot;

  my $reboot_on_error;

  my $switch_to_good;
  my $switch_to_test;

  my $poweroff_on_error;
  my $die_on_failure;

  my $powercycle_after_reboot;
  my $poweroff_after_halt;

  my $ssh_exec;
  my $scp_to_target;

  my $power_off;
  my $grub_menu;

  my $grub_number;
  my $target;
  my $make;

  my $post_install;

  my $no_install;

  my $noclean;

  my $minconfig;

  my $start_minconfig;

  my $start_minconfig_defined;

  my $output_minconfig;
  my $ignore_config;

  my $ignore_errors;

  my $addconfig;

  my $in_bisect = 0;

  my $bisect_bad_commit = "";

  my $reverse_bisect;

  my $bisect_manual;

  my $bisect_skip;

  my $config_bisect_good;

  my $bisect_ret_good;
  my $bisect_ret_bad;
  my $bisect_ret_skip;
  my $bisect_ret_abort;
  my $bisect_ret_default;

  my $in_patchcheck = 0;

  my $run_test;

  my $redirect;

  my $buildlog;

  my $testlog;

  my $dmesg;
  my $monitor_fp;
  my $monitor_pid;
  my $monitor_cnt = 0;

  my $sleep_time;
  my $bisect_sleep_time;

  my $patchcheck_sleep_time;

  my $ignore_warnings;

  my $store_failures;

  my $store_successes;

  my $test_name;

  my $timeout;
  my $booted_timeout;

  my $detect_triplefault;

  my $console;

  my $reboot_success_line;

  my $success_line;

  my $stop_after_success;
  my $stop_after_failure;

  my $stop_test_after;

  my $build_target;
  my $target_image;

  my $checkout;

  my $localversion;

  my $iteration = 0;

  my $successes = 0;

  my $bisect_good;
  my $bisect_bad;
  my $bisect_type;
  my $bisect_start;
  my $bisect_replay;
  my $bisect_files;
  my $bisect_reverse;
  my $bisect_check;
  
  my $config_bisect;
  my $config_bisect_type;
  
  my $patchcheck_type;
  my $patchcheck_start;
  my $patchcheck_end;

  # set when a test is something other that just building or install

  # which would require more options.
  my $buildonly = 1;

  # set when creating a new config
  my $newconfig = 0;

  my %entered_configs;
  my %config_help;

  my %variable;

  my %force_config;

  # do not force reboots on config problems
  my $no_reboot = 1;

  my %option_map = (
      "MACHINE"			=> \$machine,
      "SSH_USER"			=> \$ssh_user,
      "TMP_DIR"			=> \$tmpdir,
      "OUTPUT_DIR"		=> \$outputdir,
      "BUILD_DIR"			=> \$builddir,
      "TEST_TYPE"			=> \$test_type,
      "BUILD_TYPE"		=> \$build_type,
      "BUILD_OPTIONS"		=> \$build_options,
      "PRE_BUILD"			=> \$pre_build,
      "POST_BUILD"		=> \$post_build,
      "PRE_BUILD_DIE"		=> \$pre_build_die,
      "POST_BUILD_DIE"		=> \$post_build_die,
      "POWER_CYCLE"		=> \$power_cycle,
      "REBOOT"			=> \$reboot,
      "BUILD_NOCLEAN"		=> \$noclean,
      "MIN_CONFIG"		=> \$minconfig,
      "OUTPUT_MIN_CONFIG"		=> \$output_minconfig,
      "START_MIN_CONFIG"		=> \$start_minconfig,
      "IGNORE_CONFIG"		=> \$ignore_config,
      "TEST"			=> \$run_test,
      "ADD_CONFIG"		=> \$addconfig,
      "REBOOT_TYPE"		=> \$reboot_type,
      "GRUB_MENU"			=> \$grub_menu,
      "POST_INSTALL"		=> \$post_install,
      "NO_INSTALL"		=> \$no_install,
      "REBOOT_SCRIPT"		=> \$reboot_script,
      "REBOOT_ON_ERROR"		=> \$reboot_on_error,
      "SWITCH_TO_GOOD"		=> \$switch_to_good,
      "SWITCH_TO_TEST"		=> \$switch_to_test,
      "POWEROFF_ON_ERROR"		=> \$poweroff_on_error,
      "DIE_ON_FAILURE"		=> \$die_on_failure,
      "POWER_OFF"			=> \$power_off,
      "POWERCYCLE_AFTER_REBOOT"	=> \$powercycle_after_reboot,
      "POWEROFF_AFTER_HALT"	=> \$poweroff_after_halt,
      "SLEEP_TIME"		=> \$sleep_time,
      "BISECT_SLEEP_TIME"		=> \$bisect_sleep_time,
      "PATCHCHECK_SLEEP_TIME"	=> \$patchcheck_sleep_time,
      "IGNORE_WARNINGS"		=> \$ignore_warnings,

      "IGNORE_ERRORS"		=> \$ignore_errors,

      "BISECT_MANUAL"		=> \$bisect_manual,
      "BISECT_SKIP"		=> \$bisect_skip,
      "CONFIG_BISECT_GOOD"	=> \$config_bisect_good,
      "BISECT_RET_GOOD"		=> \$bisect_ret_good,
      "BISECT_RET_BAD"		=> \$bisect_ret_bad,
      "BISECT_RET_SKIP"		=> \$bisect_ret_skip,
      "BISECT_RET_ABORT"		=> \$bisect_ret_abort,
      "BISECT_RET_DEFAULT"	=> \$bisect_ret_default,
      "STORE_FAILURES"		=> \$store_failures,
      "STORE_SUCCESSES"		=> \$store_successes,
      "TEST_NAME"			=> \$test_name,
      "TIMEOUT"			=> \$timeout,
      "BOOTED_TIMEOUT"		=> \$booted_timeout,
      "CONSOLE"			=> \$console,
      "DETECT_TRIPLE_FAULT"	=> \$detect_triplefault,
      "SUCCESS_LINE"		=> \$success_line,
      "REBOOT_SUCCESS_LINE"	=> \$reboot_success_line,
      "STOP_AFTER_SUCCESS"	=> \$stop_after_success,
      "STOP_AFTER_FAILURE"	=> \$stop_after_failure,
      "STOP_TEST_AFTER"		=> \$stop_test_after,
      "BUILD_TARGET"		=> \$build_target,
      "SSH_EXEC"			=> \$ssh_exec,
      "SCP_TO_TARGET"		=> \$scp_to_target,
      "CHECKOUT"			=> \$checkout,
      "TARGET_IMAGE"		=> \$target_image,
      "LOCALVERSION"		=> \$localversion,
  
      "BISECT_GOOD"		=> \$bisect_good,
      "BISECT_BAD"		=> \$bisect_bad,
      "BISECT_TYPE"		=> \$bisect_type,
      "BISECT_START"		=> \$bisect_start,
      "BISECT_REPLAY"		=> \$bisect_replay,
      "BISECT_FILES"		=> \$bisect_files,
      "BISECT_REVERSE"		=> \$bisect_reverse,
      "BISECT_CHECK"		=> \$bisect_check,
  
      "CONFIG_BISECT"		=> \$config_bisect,
      "CONFIG_BISECT_TYPE"	=> \$config_bisect_type,
  
      "PATCHCHECK_TYPE"		=> \$patchcheck_type,
      "PATCHCHECK_START"		=> \$patchcheck_start,
      "PATCHCHECK_END"		=> \$patchcheck_end,
  );
  
  # Options may be used by other options, record them.
  my %used_options;

  # default variables that can be used
  chomp ($variable{"PWD"} = `pwd`);

  $config_help{"MACHINE"} = << "EOF"
   The machine hostname that you will test.

   For build only tests, it is still needed to differentiate log files.

  EOF
      ;
  $config_help{"SSH_USER"} = << "EOF"
   The box is expected to have ssh on normal bootup, provide the user
    (most likely root, since you need privileged operations)
  EOF
      ;
  $config_help{"BUILD_DIR"} = << "EOF"
   The directory that contains the Linux source code (full path).

   You can use \${PWD} that will be the path where ktest.pl is run, or use
   \${THIS_DIR} which is assigned \${PWD} but may be changed later.

  EOF
      ;
  $config_help{"OUTPUT_DIR"} = << "EOF"
   The directory that the objects will be built (full path).
   (can not be same as BUILD_DIR)

   You can use \${PWD} that will be the path where ktest.pl is run, or use
   \${THIS_DIR} which is assigned \${PWD} but may be changed later.

  EOF
      ;
  $config_help{"BUILD_TARGET"} = << "EOF"
   The location of the compiled file to copy to the target.
   (relative to OUTPUT_DIR)
  EOF
      ;

  $config_help{"BUILD_OPTIONS"} = << "EOF"
   Options to add to \"make\" when building.
   i.e.  -j20
  EOF
      ;

  $config_help{"TARGET_IMAGE"} = << "EOF"
   The place to put your image on the test machine.
  EOF
      ;
  $config_help{"POWER_CYCLE"} = << "EOF"
   A script or command to reboot the box.
  
   Here is a digital loggers power switch example
   POWER_CYCLE = wget --no-proxy -O /dev/null -q  --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL'
  
   Here is an example to reboot a virtual box on the current host
   with the name "Guest".
   POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest
  EOF
      ;
  $config_help{"CONSOLE"} = << "EOF"
   The script or command that reads the console
  
    If you use ttywatch server, something like the following would work.
  CONSOLE = nc -d localhost 3001
  
   For a virtual machine with guest name "Guest".
  CONSOLE =  virsh console Guest
  EOF
      ;
  $config_help{"LOCALVERSION"} = << "EOF"
   Required version ending to differentiate the test
   from other linux builds on the system.
  EOF
      ;
  $config_help{"REBOOT_TYPE"} = << "EOF"
   Way to reboot the box to the test kernel.
   Only valid options so far are "grub" and "script".
  
   If you specify grub, it will assume grub version 1
   and will search in /boot/grub/menu.lst for the title \$GRUB_MENU
   and select that target to reboot to the kernel. If this is not
   your setup, then specify "script" and have a command or script
   specified in REBOOT_SCRIPT to boot to the target.
  
   The entry in /boot/grub/menu.lst must be entered in manually.
   The test will not modify that file.
  EOF
      ;
  $config_help{"GRUB_MENU"} = << "EOF"
   The grub title name for the test kernel to boot
   (Only mandatory if REBOOT_TYPE = grub)
  
   Note, ktest.pl will not update the grub menu.lst, you need to
   manually add an option for the test. ktest.pl will search
   the grub menu.lst for this option to find what kernel to
   reboot into.
  
   For example, if in the /boot/grub/menu.lst the test kernel title has:
   title Test Kernel
   kernel vmlinuz-test
   GRUB_MENU = Test Kernel
  EOF
      ;
  $config_help{"REBOOT_SCRIPT"} = << "EOF"
   A script to reboot the target into the test kernel
   (Only mandatory if REBOOT_TYPE = script)
  EOF
      ;

  sub read_prompt {
      my ($cancel, $prompt) = @_;

  
      my $ans;
  
      for (;;) {

  	if ($cancel) {
  	    print "$prompt [y/n/C] ";
  	} else {
  	    print "$prompt [Y/n] ";
  	}

  	$ans = <STDIN>;
  	chomp $ans;
  	if ($ans =~ /^\s*$/) {

  	    if ($cancel) {
  		$ans = "c";
  	    } else {
  		$ans = "y";
  	    }

  	}
  	last if ($ans =~ /^y$/i || $ans =~ /^n$/i);

  	if ($cancel) {
  	    last if ($ans =~ /^c$/i);
  	    print "Please answer either 'y', 'n' or 'c'.
  ";
  	} else {
  	    print "Please answer either 'y' or 'n'.
  ";
  	}
      }
      if ($ans =~ /^c/i) {
  	exit;

      }
      if ($ans !~ /^y$/i) {
  	return 0;
      }
      return 1;
  }

  sub read_yn {
      my ($prompt) = @_;
  
      return read_prompt 0, $prompt;
  }
  
  sub read_ync {
      my ($prompt) = @_;
  
      return read_prompt 1, $prompt;
  }

  sub get_ktest_config {
      my ($config) = @_;

      my $ans;

  
      return if (defined($opt{$config}));
  
      if (defined($config_help{$config})) {
  	print "
  ";
  	print $config_help{$config};
      }
  
      for (;;) {
  	print "$config = ";

  	if (defined($default{$config}) && length($default{$config})) {

  	    print "\[$default{$config}\] ";
  	}

  	$ans = <STDIN>;
  	$ans =~ s/^\s*(.*\S)\s*$/$1/;
  	if ($ans =~ /^\s*$/) {

  	    if ($default{$config}) {

  		$ans = $default{$config};

  	    } else {
  		print "Your answer can not be blank
  ";
  		next;
  	    }
  	}

  	$entered_configs{$config} = ${ans};

  	last;
      }
  }
  
  sub get_ktest_configs {
      get_ktest_config("MACHINE");

      get_ktest_config("BUILD_DIR");
      get_ktest_config("OUTPUT_DIR");

      if ($newconfig) {
  	get_ktest_config("BUILD_OPTIONS");
      }

      # options required for other than just building a kernel
      if (!$buildonly) {

  	get_ktest_config("POWER_CYCLE");
  	get_ktest_config("CONSOLE");
      }
  
      # options required for install and more
      if ($buildonly != 1) {

  	get_ktest_config("SSH_USER");
  	get_ktest_config("BUILD_TARGET");
  	get_ktest_config("TARGET_IMAGE");

      }

      get_ktest_config("LOCALVERSION");

      return if ($buildonly);

      my $rtype = $opt{"REBOOT_TYPE"};
  
      if (!defined($rtype)) {
  	if (!defined($opt{"GRUB_MENU"})) {
  	    get_ktest_config("REBOOT_TYPE");
  	    $rtype = $entered_configs{"REBOOT_TYPE"};
  	} else {
  	    $rtype = "grub";
  	}
      }
  
      if ($rtype eq "grub") {
  	get_ktest_config("GRUB_MENU");

      }
  }

  sub process_variables {

      my ($value, $remove_undef) = @_;

      my $retval = "";
  
      # We want to check for '\', and it is just easier
      # to check the previous characet of '$' and not need
      # to worry if '$' is the first character. By adding
      # a space to $value, we can just check [^\\]\$ and
      # it will still work.
      $value = " $value";
  
      while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
  	my $begin = $1;
  	my $var = $2;
  	my $end = $3;
  	# append beginning of value to retval
  	$retval = "$retval$begin";
  	if (defined($variable{$var})) {
  	    $retval = "$retval$variable{$var}";

  	} elsif (defined($remove_undef) && $remove_undef) {
  	    # for if statements, any variable that is not defined,
  	    # we simple convert to 0
  	    $retval = "${retval}0";

  	} else {
  	    # put back the origin piece.
  	    $retval = "$retval\$\{$var\}";

  	    # This could be an option that is used later, save
  	    # it so we don't warn if this option is not one of
  	    # ktests options.
  	    $used_options{$var} = 1;

  	}
  	$value = $end;
      }
      $retval = "$retval$value";
  
      # remove the space added in the beginning
      $retval =~ s/ //;
  
      return "$retval"
  }

  sub set_value {

      my ($lvalue, $rvalue, $override, $overrides, $name) = @_;

      my $prvalue = process_variables($rvalue);
  
      if ($buildonly && $lvalue =~ /^TEST_TYPE(\[.*\])?$/ && $prvalue ne "build") {

  	# Note if a test is something other than build, then we
  	# will need other manditory options.

  	if ($prvalue ne "install") {

  	    $buildonly = 0;
  	} else {
  	    # install still limits some manditory options.
  	    $buildonly = 2;
  	}

      }

      if (defined($opt{$lvalue})) {

  	if (!$override || defined(${$overrides}{$lvalue})) {
  	    my $extra = "";
  	    if ($override) {
  		$extra = "In the same override section!
  ";
  	    }
  	    die "$name: $.: Option $lvalue defined more than once!
  $extra";
  	}

  	${$overrides}{$lvalue} = $prvalue;

      }

      if ($rvalue =~ /^\s*$/) {
  	delete $opt{$lvalue};
      } else {

  	$opt{$lvalue} = $prvalue;

      }

  }

  sub set_variable {
      my ($lvalue, $rvalue) = @_;
  
      if ($rvalue =~ /^\s*$/) {
  	delete $variable{$lvalue};
      } else {
  	$rvalue = process_variables($rvalue);
  	$variable{$lvalue} = $rvalue;
      }
  }

  sub process_compare {
      my ($lval, $cmp, $rval) = @_;
  
      # remove whitespace
  
      $lval =~ s/^\s*//;
      $lval =~ s/\s*$//;
  
      $rval =~ s/^\s*//;
      $rval =~ s/\s*$//;
  
      if ($cmp eq "==") {
  	return $lval eq $rval;
      } elsif ($cmp eq "!=") {
  	return $lval ne $rval;
      }
  
      my $statement = "$lval $cmp $rval";
      my $ret = eval $statement;
  
      # $@ stores error of eval
      if ($@) {
  	return -1;
      }
  
      return $ret;
  }

  sub value_defined {
      my ($val) = @_;
  
      return defined($variable{$2}) ||
  	defined($opt{$2});
  }

  my $d = 0;
  sub process_expression {
      my ($name, $val) = @_;
  
      my $c = $d++;
  
      while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
  	my $express = $1;
  
  	if (process_expression($name, $express)) {
  	    $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
  	} else {
  	    $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
  	}
      }
  
      $d--;
      my $OR = "\\|\\|";
      my $AND = "\\&\\&";

      while ($val =~ s/^(.*?)($OR|$AND)//) {
  	my $express = $1;
  	my $op = $2;
  
  	if (process_expression($name, $express)) {
  	    if ($op eq "||") {
  		return 1;
  	    }
  	} else {
  	    if ($op eq "&&") {
  		return 0;
  	    }
  	}
      }

      if ($val =~ /(.*)(==|\!=|>=|<=|>|<)(.*)/) {
  	my $ret = process_compare($1, $2, $3);
  	if ($ret < 0) {
  	    die "$name: $.: Unable to process comparison
  ";
  	}
  	return $ret;
      }

      if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
  	if (defined $1) {
  	    return !value_defined($2);
  	} else {
  	    return value_defined($2);
  	}
      }

      if ($val =~ /^\s*0\s*$/) {
  	return 0;
      } elsif ($val =~ /^\s*\d+\s*$/) {
  	return 1;
      }

      die ("$name: $.: Undefined content $val in if statement
  ");

  }
  
  sub process_if {
      my ($name, $value) = @_;
  
      # Convert variables and replace undefined ones with 0
      my $val = process_variables($value, 1);
      my $ret = process_expression $name, $val;
  
      return $ret;

  }

  sub __read_config {
      my ($config, $current_test_num) = @_;

      my $in;
      open($in, $config) || die "can't read file $config";

      my $name = $config;
      $name =~ s,.*/(.*),$1,;

      my $test_num = $$current_test_num;

      my $default = 1;
      my $repeat = 1;
      my $num_tests_set = 0;
      my $skip = 0;
      my $rest;

      my $line;

      my $test_case = 0;

      my $if = 0;
      my $if_set = 0;

      my $override = 0;
  
      my %overrides;

      while (<$in>) {

  
  	# ignore blank lines and comments
  	next if (/^\s*$/ || /\s*\#/);

  	if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {

  	    my $type = $1;
  	    $rest = $2;

  	    $line = $2;

  	    my $old_test_num;
  	    my $old_repeat;

  	    $override = 0;

  
  	    if ($type eq "TEST_START") {
  
  		if ($num_tests_set) {
  		    die "$name: $.: Can not specify both NUM_TESTS and TEST_START
  ";
  		}

  		$old_test_num = $test_num;
  		$old_repeat = $repeat;

  		$test_num += $repeat;
  		$default = 0;
  		$repeat = 1;
  	    } else {
  		$default = 1;
  	    }

  	    # If SKIP is anywhere in the line, the command will be skipped
  	    if ($rest =~ s/\s+SKIP\b//) {

  		$skip = 1;
  	    } else {

  		$test_case = 1;

  		$skip = 0;
  	    }

  	    if ($rest =~ s/\sELSE\b//) {
  		if (!$if) {
  		    die "$name: $.: ELSE found with out matching IF section
  $_";
  		}
  		$if = 0;
  
  		if ($if_set) {
  		    $skip = 1;
  		} else {
  		    $skip = 0;

  		}

  	    }

  	    if ($rest =~ s/\sIF\s+(.*)//) {

  		if (process_if($name, $1)) {
  		    $if_set = 1;
  		} else {
  		    $skip = 1;
  		}
  		$if = 1;
  	    } else {
  		$if = 0;

  		$if_set = 0;
  	    }
  
  	    if (!$skip) {
  		if ($type eq "TEST_START") {
  		    if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
  			$repeat = $1;
  			$repeat_tests{"$test_num"} = $repeat;
  		    }
  		} elsif ($rest =~ s/\sOVERRIDE\b//) {
  		    # DEFAULT only
  		    $override = 1;
  		    # Clear previous overrides
  		    %overrides = ();
  		}

  	    }

  	    if (!$skip && $rest !~ /^\s*$/) {

  		die "$name: $.: Gargbage found after $type
  $_";

  	    }

  	    if ($skip && $type eq "TEST_START") {

  		$test_num = $old_test_num;

  		$repeat = $old_repeat;

  	    }

  	} elsif (/^\s*ELSE\b(.*)$/) {

  	    if (!$if) {
  		die "$name: $.: ELSE found with out matching IF section
  $_";
  	    }
  	    $rest = $1;
  	    if ($if_set) {
  		$skip = 1;

  		$rest = "";

  	    } else {
  		$skip = 0;

  		if ($rest =~ /\sIF\s+(.*)/) {

  		    # May be a ELSE IF section.
  		    if (!process_if($name, $1)) {
  			$skip = 1;
  		    }

  		    $rest = "";

  		} else {
  		    $if = 0;
  		}
  	    }

  	    if ($rest !~ /^\s*$/) {
  		die "$name: $.: Gargbage found after DEFAULTS
  $_";
  	    }

  	} elsif (/^\s*INCLUDE\s+(\S+)/) {
  
  	    next if ($skip);
  
  	    if (!$default) {
  		die "$name: $.: INCLUDE can only be done in default sections
  $_";
  	    }
  
  	    my $file = process_variables($1);
  
  	    if ($file !~ m,^/,) {
  		# check the path of the config file first
  		if ($config =~ m,(.*)/,) {
  		    if (-f "$1/$file") {
  			$file = "$1/$file";
  		    }
  		}
  	    }
  		
  	    if ( ! -r $file ) {
  		die "$name: $.: Can't read file $file
  $_";
  	    }
  
  	    if (__read_config($file, \$test_num)) {
  		$test_case = 1;
  	    }

  	} elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
  
  	    next if ($skip);

  	    my $lvalue = $1;
  	    my $rvalue = $2;

  	    if (!$default &&
  		($lvalue eq "NUM_TESTS" ||
  		 $lvalue eq "LOG_FILE" ||
  		 $lvalue eq "CLEAR_LOG")) {
  		die "$name: $.: $lvalue must be set in DEFAULTS section
  ";
  	    }
  
  	    if ($lvalue eq "NUM_TESTS") {
  		if ($test_num) {
  		    die "$name: $.: Can not specify both NUM_TESTS and TEST_START
  ";
  		}
  		if (!$default) {
  		    die "$name: $.: NUM_TESTS must be set in default section
  ";
  		}
  		$num_tests_set = 1;
  	    }
  
  	    if ($default || $lvalue =~ /\[\d+\]$/) {

  		set_value($lvalue, $rvalue, $override, \%overrides, $name);

  	    } else {
  		my $val = "$lvalue\[$test_num\]";

  		set_value($val, $rvalue, $override, \%overrides, $name);

  
  		if ($repeat > 1) {
  		    $repeats{$val} = $repeat;
  		}

  	    }

  	} elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
  	    next if ($skip);
  
  	    my $lvalue = $1;
  	    my $rvalue = $2;
  
  	    # process config variables.
  	    # Config variables are only active while reading the
  	    # config and can be defined anywhere. They also ignore
  	    # TEST_START and DEFAULTS, but are skipped if they are in
  	    # on of these sections that have SKIP defined.
  	    # The save variable can be
  	    # defined multiple times and the new one simply overrides
  	    # the prevous one.
  	    set_variable($lvalue, $rvalue);

  	} else {
  	    die "$name: $.: Garbage found in config
  $_";

  	}
      }

      if ($test_num) {
  	$test_num += $repeat - 1;
  	$opt{"NUM_TESTS"} = $test_num;
      }

      close($in);
  
      $$current_test_num = $test_num;
  
      return $test_case;
  }

  sub get_test_case {
  	print "What test case would you like to run?
  ";
  	print " (build, install or boot)
  ";
  	print " Other tests are available but require editing the config file
  ";
  	my $ans = <STDIN>;
  	chomp $ans;
  	$default{"TEST_TYPE"} = $ans;
  }

  sub read_config {
      my ($config) = @_;
  
      my $test_case;
      my $test_num = 0;
  
      $test_case = __read_config $config, \$test_num;

      # make sure we have all mandatory configs
      get_ktest_configs;

      # was a test specified?
      if (!$test_case) {
  	print "No test case specified.
  ";

  	get_test_case;

      }

      # set any defaults
  
      foreach my $default (keys %default) {
  	if (!defined($opt{$default})) {
  	    $opt{$default} = $default{$default};
  	}
      }

  
      if ($opt{"IGNORE_UNUSED"} == 1) {
  	return;
      }
  
      my %not_used;
  
      # check if there are any stragglers (typos?)
      foreach my $option (keys %opt) {
  	my $op = $option;
  	# remove per test labels.
  	$op =~ s/\[.*\]//;
  	if (!exists($option_map{$op}) &&
  	    !exists($default{$op}) &&
  	    !exists($used_options{$op})) {
  	    $not_used{$op} = 1;
  	}
      }
  
      if (%not_used) {
  	my $s = "s are";
  	$s = " is" if (keys %not_used == 1);
  	print "The following option$s not used; could be a typo:
  ";
  	foreach my $option (keys %not_used) {
  	    print "$option
  ";
  	}
  	print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables
  ";
  	if (!read_yn "Do you want to continue?") {
  	    exit -1;
  	}
      }

  }

  sub __eval_option {
      my ($option, $i) = @_;
  
      # Add space to evaluate the character before $
      $option = " $option";
      my $retval = "";

      my $repeated = 0;
      my $parent = 0;
  
      foreach my $test (keys %repeat_tests) {
  	if ($i >= $test &&
  	    $i < $test + $repeat_tests{$test}) {
  
  	    $repeated = 1;
  	    $parent = $test;
  	    last;
  	}
      }

  
      while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
  	my $start = $1;
  	my $var = $2;
  	my $end = $3;
  
  	# Append beginning of line
  	$retval = "$retval$start";
  
  	# If the iteration option OPT[$i] exists, then use that.
  	# otherwise see if the default OPT (without [$i]) exists.
  
  	my $o = "$var\[$i\]";

  	my $parento = "$var\[$parent\]";

  
  	if (defined($opt{$o})) {
  	    $o = $opt{$o};
  	    $retval = "$retval$o";

  	} elsif ($repeated && defined($opt{$parento})) {
  	    $o = $opt{$parento};
  	    $retval = "$retval$o";

  	} elsif (defined($opt{$var})) {
  	    $o = $opt{$var};
  	    $retval = "$retval$o";
  	} else {
  	    $retval = "$retval\$\{$var\}";
  	}
  
  	$option = $end;
      }
  
      $retval = "$retval$option";
  
      $retval =~ s/^ //;
  
      return $retval;
  }
  
  sub eval_option {
      my ($option, $i) = @_;
  
      my $prev = "";
  
      # Since an option can evaluate to another option,
      # keep iterating until we do not evaluate any more
      # options.
      my $r = 0;
      while ($prev ne $option) {
  	# Check for recursive evaluations.
  	# 100 deep should be more than enough.
  	if ($r++ > 100) {
  	    die "Over 100 evaluations accurred with $option
  " .
  		"Check for recursive variables
  ";
  	}
  	$prev = $option;
  	$option = __eval_option($option, $i);
      }
  
      return $option;
  }

  sub _logit {

      if (defined($opt{"LOG_FILE"})) {
  	open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
  	print OUT @_;
  	close(OUT);
      }
  }

  sub logit {
      if (defined($opt{"LOG_FILE"})) {
  	_logit @_;
      } else {
  	print @_;
      }
  }

  sub doprint {
      print @_;

      _logit @_;

  }

  sub run_command;

  sub start_monitor;
  sub end_monitor;
  sub wait_for_monitor;

  
  sub reboot {

      my ($time) = @_;

      if (defined($time)) {
  	start_monitor;
  	# flush out current monitor
  	# May contain the reboot success line
  	wait_for_monitor 1;
      }

      # try to reboot normally

      if (run_command $reboot) {

  	if (defined($powercycle_after_reboot)) {
  	    sleep $powercycle_after_reboot;
  	    run_command "$power_cycle";
  	}
      } else {

  	# nope? power cycle it.

  	run_command "$power_cycle";

      }

  
      if (defined($time)) {

  	wait_for_monitor($time, $reboot_success_line);

  	end_monitor;
      }

  }

  sub reboot_to_good {
      my ($time) = @_;
  
      if (defined($switch_to_good)) {
  	run_command $switch_to_good;
  	return;
      }
  
      reboot $time;
  }

  sub do_not_reboot {
      my $i = $iteration;

      return $test_type eq "build" || $no_reboot ||

  	($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
  	($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
  }

  sub dodie {

      doprint "CRITICAL FAILURE... ", @_, "
  ";

      my $i = $iteration;
  
      if ($reboot_on_error && !do_not_reboot) {

  	doprint "REBOOTING
  ";

  	reboot_to_good;

      } elsif ($poweroff_on_error && defined($power_off)) {

  	doprint "POWERING OFF
  ";

  	`$power_off`;

      }

      if (defined($opt{"LOG_FILE"})) {
  	print " See $opt{LOG_FILE} for more info.
  ";
      }

      die @_, "
  ";

  }

  sub open_console {
      my ($fp) = @_;
  
      my $flags;

      my $pid = open($fp, "$console|") or
  	dodie "Can't open console $console";

  
      $flags = fcntl($fp, F_GETFL, 0) or

  	dodie "Can't get flags for the socket: $!";

      $flags = fcntl($fp, F_SETFL, $flags | O_NONBLOCK) or

  	dodie "Can't set flags for the socket: $!";

  
      return $pid;
  }
  
  sub close_console {
      my ($fp, $pid) = @_;
  
      doprint "kill child process $pid
  ";
      kill 2, $pid;
  
      print "closing!
  ";
      close($fp);
  }
  
  sub start_monitor {
      if ($monitor_cnt++) {
  	return;
      }
      $monitor_fp = \*MONFD;
      $monitor_pid = open_console $monitor_fp;

  
      return;
  
      open(MONFD, "Stop perl from warning about single use of MONFD");

  }
  
  sub end_monitor {
      if (--$monitor_cnt) {
  	return;
      }
      close_console($monitor_fp, $monitor_pid);
  }
  
  sub wait_for_monitor {

      my ($time, $stop) = @_;
      my $full_line = "";

      my $line;

      my $booted = 0;

      doprint "** Wait for monitor to settle down **
  ";

  
      # read the monitor and wait for the system to calm down

      while (!$booted) {

  	$line = wait_for_input($monitor_fp, $time);

  	last if (!defined($line));
  	print "$line";
  	$full_line .= $line;
  
  	if (defined($stop) && $full_line =~ /$stop/) {
  	    doprint "wait for monitor detected $stop
  ";
  	    $booted = 1;
  	}
  
  	if ($line =~ /
  /) {
  	    $full_line = "";
  	}
      }

      print "** Monitor flushed **
  ";

  }

  sub save_logs {
  	my ($result, $basedir) = @_;
  	my @t = localtime;
  	my $date = sprintf "%04d%02d%02d%02d%02d%02d",
  		1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
  
  	my $type = $build_type;
  	if ($type =~ /useconfig/) {
  	    $type = "useconfig";
  	}
  
  	my $dir = "$machine-$test_type-$type-$result-$date";
  
  	$dir = "$basedir/$dir";
  
  	if (!-d $dir) {
  	    mkpath($dir) or
  		die "can't create $dir";
  	}
  
  	my %files = (
  		"config" => $output_config,
  		"buildlog" => $buildlog,
  		"dmesg" => $dmesg,
  		"testlog" => $testlog,
  	);
  
  	while (my ($name, $source) = each(%files)) {
  		if (-f "$source") {
  			cp "$source", "$dir/$name" or
  				die "failed to copy $source";
  		}
  	}
  
  	doprint "*** Saved info to $dir ***
  ";
  }

  sub fail {

  	if ($die_on_failure) {

  		dodie @_;
  	}

  	doprint "FAILED
  ";

  	my $i = $iteration;

  	# no need to reboot for just building.

  	if (!do_not_reboot) {

  	    doprint "REBOOTING
  ";

  	    reboot_to_good $sleep_time;

  	}

  	my $name = "";
  
  	if (defined($test_name)) {
  	    $name = " ($test_name)";
  	}

  	doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  ";
  	doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  ";

  	doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "
  ";

  	doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  ";
  	doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  ";

  	if (defined($store_failures)) {
  	    save_logs "fail", $store_failures;
          }

  	return 1;
  }

  sub run_command {
      my ($command) = @_;

      my $dolog = 0;
      my $dord = 0;
      my $pid;

      $command =~ s/\$SSH_USER/$ssh_user/g;
      $command =~ s/\$MACHINE/$machine/g;

      doprint("$command ... ");
  
      $pid = open(CMD, "$command 2>&1 |") or

  	(fail "unable to exec $command" and return 0);

  
      if (defined($opt{"LOG_FILE"})) {

  	open(LOG, ">>$opt{LOG_FILE}") or
  	    dodie "failed to write to log";
  	$dolog = 1;

      }
  
      if (defined($redirect)) {

  	open (RD, ">$redirect") or
  	    dodie "failed to write to redirect $redirect";
  	$dord = 1;

      }

      while (<CMD>) {
  	print LOG if ($dolog);
  	print RD  if ($dord);
      }

      waitpid($pid, 0);

      my $failed = $?;

      close(CMD);
      close(LOG) if ($dolog);
      close(RD)  if ($dord);

      if ($failed) {
  	doprint "FAILED!
  ";
      } else {
  	doprint "SUCCESS
  ";
      }

      return !$failed;
  }

  sub run_ssh {
      my ($cmd) = @_;
      my $cp_exec = $ssh_exec;
  
      $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
      return run_command "$cp_exec";
  }
  
  sub run_scp {
      my ($src, $dst) = @_;
      my $cp_scp = $scp_to_target;
  
      $cp_scp =~ s/\$SRC_FILE/$src/g;
      $cp_scp =~ s/\$DST_FILE/$dst/g;
  
      return run_command "$cp_scp";
  }

  sub get_grub_index {

      if ($reboot_type ne "grub") {
  	return;
      }

      return if (defined($grub_number));

  
      doprint "Find grub menu ... ";
      $grub_number = -1;

  
      my $ssh_grub = $ssh_exec;
      $ssh_grub =~ s,\$SSH_COMMAND,cat /boot/grub/menu.lst,g;
  
      open(IN, "$ssh_grub |")

  	or die "unable to get menu.lst";

      my $found = 0;

      while (<IN>) {

  	if (/^\s*title\s+$grub_menu\s*$/) {

  	    $grub_number++;

  	    $found = 1;

  	    last;
  	} elsif (/^\s*title\s/) {
  	    $grub_number++;
  	}
      }
      close(IN);

      die "Could not find '$grub_menu' in /boot/grub/menu on $machine"

  	if (!$found);

      doprint "$grub_number
  ";

  }

  sub wait_for_input
  {
      my ($fp, $time) = @_;
      my $rin;
      my $ready;
      my $line;
      my $ch;
  
      if (!defined($time)) {
  	$time = $timeout;
      }
  
      $rin = '';
      vec($rin, fileno($fp), 1) = 1;
      $ready = select($rin, undef, undef, $time);
  
      $line = "";
  
      # try to read one char at a time
      while (sysread $fp, $ch, 1) {
  	$line .= $ch;
  	last if ($ch eq "
  ");
      }
  
      if (!length($line)) {
  	return undef;
      }
  
      return $line;
  }

  sub reboot_to {

      if (defined($switch_to_test)) {
  	run_command $switch_to_test;
      }

      if ($reboot_type eq "grub") {

  	run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";

      } elsif (defined $reboot_script) {
  	run_command "$reboot_script";

      }

      reboot;

  }

  sub get_sha1 {
      my ($commit) = @_;
  
      doprint "git rev-list --max-count=1 $commit ... ";
      my $sha1 = `git rev-list --max-count=1 $commit`;
      my $ret = $?;
  
      logit $sha1;
  
      if ($ret) {
  	doprint "FAILED
  ";
  	dodie "Failed to get git $commit";
      }
  
      print "SUCCESS
  ";
  
      chomp $sha1;
  
      return $sha1;
  }

  sub monitor {

      my $booted = 0;
      my $bug = 0;

      my $skip_call_trace = 0;

      my $loops;

      wait_for_monitor 5;

  
      my $line;
      my $full_line = "";

      open(DMESG, "> $dmesg") or
  	die "unable to write to $dmesg";

      reboot_to;

      my $success_start;
      my $failure_start;

      my $monitor_start = time;
      my $done = 0;

      my $version_found = 0;

      while (!$done) {

  	if ($bug && defined($stop_after_failure) &&
  	    $stop_after_failure >= 0) {
  	    my $time = $stop_after_failure - (time - $failure_start);
  	    $line = wait_for_input($monitor_fp, $time);
  	    if (!defined($line)) {
  		doprint "bug timed out after $booted_timeout seconds
  ";
  		doprint "Test forced to stop after $stop_after_failure seconds after failure
  ";
  		last;
  	    }
  	} elsif ($booted) {

  	    $line = wait_for_input($monitor_fp, $booted_timeout);

  	    if (!defined($line)) {
  		my $s = $booted_timeout == 1 ? "" : "s";
  		doprint "Successful boot found: break after $booted_timeout second$s
  ";
  		last;
  	    }

  	} else {

  	    $line = wait_for_input($monitor_fp);

  	    if (!defined($line)) {
  		my $s = $timeout == 1 ? "" : "s";
  		doprint "Timed out after $timeout second$s
  ";
  		last;
  	    }

  	}

  	doprint $line;

  	print DMESG $line;

  
  	# we are not guaranteed to get a full line
  	$full_line .= $line;

  	if ($full_line =~ /$success_line/) {

  	    $booted = 1;

  	    $success_start = time;
  	}
  
  	if ($booted && defined($stop_after_success) &&
  	    $stop_after_success >= 0) {
  	    my $now = time;
  	    if ($now - $success_start >= $stop_after_success) {
  		doprint "Test forced to stop after $stop_after_success seconds after success
  ";
  		last;
  	    }

  	}

  	if ($full_line =~ /\[ backtrace testing \]/) {
  	    $skip_call_trace = 1;
  	}

  	if ($full_line =~ /call trace:/i) {

  	    if (!$ignore_errors && !$bug && !$skip_call_trace) {

  		$bug = 1;
  		$failure_start = time;
  	    }
  	}
  
  	if ($bug && defined($stop_after_failure) &&
  	    $stop_after_failure >= 0) {
  	    my $now = time;
  	    if ($now - $failure_start >= $stop_after_failure) {
  		doprint "Test forced to stop after $stop_after_failure seconds after failure
  ";
  		last;
  	    }

  	}
  
  	if ($full_line =~ /\[ end of backtrace testing \]/) {
  	    $skip_call_trace = 0;
  	}
  
  	if ($full_line =~ /Kernel panic -/) {

  	    $failure_start = time;

  	    $bug = 1;
  	}

  	# Detect triple faults by testing the banner
  	if ($full_line =~ /\bLinux version (\S+).*
  /) {
  	    if ($1 eq $version) {
  		$version_found = 1;
  	    } elsif ($version_found && $detect_triplefault) {
  		# We already booted into the kernel we are testing,
  		# but now we booted into another kernel?
  		# Consider this a triple fault.
  		doprint "Aleady booted in Linux kernel $version, but now
  ";
  		doprint "we booted into Linux kernel $1.
  ";
  		doprint "Assuming that this is a triple fault.
  ";
  		doprint "To disable this: set DETECT_TRIPLE_FAULT to 0
  ";
  		last;
  	    }
  	}

  	if ($line =~ /
  /) {
  	    $full_line = "";
  	}

  
  	if ($stop_test_after > 0 && !$booted && !$bug) {
  	    if (time - $monitor_start > $stop_test_after) {

  		doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out
  ";

  		$done = 1;
  	    }
  	}

      }

      close(DMESG);

      if ($bug) {

  	return 0 if ($in_bisect);

  	fail "failed - got a bug report" and return 0;

      }

      if (!$booted) {

  	return 0 if ($in_bisect);

  	fail "failed - never got a boot prompt." and return 0;

      }

      return 1;

  }

  sub eval_kernel_version {
      my ($option) = @_;
  
      $option =~ s/\$KERNEL_VERSION/$version/g;
  
      return $option;
  }

  sub do_post_install {
  
      return if (!defined($post_install));

      my $cp_post_install = eval_kernel_version $post_install;

      run_command "$cp_post_install" or
  	dodie "Failed to run post install";
  }

  sub install {

      return if ($no_install);

      my $cp_target = eval_kernel_version $target_image;
  
      run_scp "$outputdir/$build_target", "$cp_target" or

  	dodie "failed to copy image";

      my $install_mods = 0;

      # should we process modules?
      $install_mods = 0;

      open(IN, "$output_config") or dodie("Can't read config file");

      while (<IN>) {
  	if (/CONFIG_MODULES(=y)?/) {
  	    $install_mods = 1 if (defined($1));
  	    last;

  	}

      }
      close(IN);

      if (!$install_mods) {

  	do_post_install;

  	doprint "No modules needed
  ";
  	return;
      }

      run_command "$make INSTALL_MOD_PATH=$tmpdir modules_install" or

  	dodie "Failed to install modules";

      my $modlib = "/lib/modules/$version";

      my $modtar = "ktest-mods.tar.bz2";

      run_ssh "rm -rf $modlib" or

  	dodie "failed to remove old mods: $modlib";

      # would be nice if scp -r did not follow symbolic links

      run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or

  	dodie "making tarball";

      run_scp "$tmpdir/$modtar", "/tmp" or

  	dodie "failed to copy modules";

      unlink "$tmpdir/$modtar";

      run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or

  	dodie "failed to tar modules";

      run_ssh "rm -f /tmp/$modtar";

      do_post_install;

  }

  sub get_version {
      # get the release name
      doprint "$make kernelrelease ... ";
      $version = `$make kernelrelease | tail -1`;
      chomp($version);
      doprint "$version
  ";
  }
  
  sub start_monitor_and_boot {

      # Make sure the stable kernel has finished booting
      start_monitor;
      wait_for_monitor 5;
      end_monitor;

      get_grub_index;
      get_version;
      install;
  
      start_monitor;
      return monitor;
  }

  sub check_buildlog {
      my ($patch) = @_;

      my @files = `git show $patch | diffstat -l`;
  
      open(IN, "git show $patch |") or
  	dodie "failed to show $patch";
      while (<IN>) {
  	if (m,^--- a/(.*),) {
  	    chomp $1;
  	    $files[$#files] = $1;
  	}
      }
      close(IN);
  
      open(IN, $buildlog) or dodie "Can't open $buildlog";
      while (<IN>) {
  	if (/^\s*(.*?):.*(warning|error)/) {
  	    my $err = $1;
  	    foreach my $file (@files) {

  		my $fullpath = "$builddir/$file";

  		if ($file eq $err || $fullpath eq $err) {

  		    fail "$file built with warnings" and return 0;

  		}
  	    }
  	}
      }
      close(IN);

  
      return 1;

  }

  sub apply_min_config {
      my $outconfig = "$output_config.new";
  
      # Read the config file and remove anything that
      # is in the force_config hash (from minconfig and others)
      # then add the force config back.
  
      doprint "Applying minimum configurations into $output_config.new
  ";
  
      open (OUT, ">$outconfig") or
  	dodie "Can't create $outconfig";
  
      if (-f $output_config) {
  	open (IN, $output_config) or
  	    dodie "Failed to open $output_config";
  	while (<IN>) {
  	    if (/^(# )?(CONFIG_[^\s=]*)/) {
  		next if (defined($force_config{$2}));
  	    }
  	    print OUT;
  	}
  	close IN;
      }
      foreach my $config (keys %force_config) {
  	print OUT "$force_config{$config}
  ";
      }
      close OUT;
  
      run_command "mv $outconfig $output_config";
  }

  sub make_oldconfig {

      my @force_list = keys %force_config;
  
      if ($#force_list >= 0) {
  	apply_min_config;
      }

  
      if (!run_command "$make oldnoconfig") {

  	# Perhaps oldnoconfig doesn't exist in this version of the kernel
  	# try a yes '' | oldconfig
  	doprint "oldnoconfig failed, trying yes '' | make oldconfig
  ";

  	run_command "yes '' | $make oldconfig" or

  	    dodie "failed make config oldconfig";
      }
  }

  # read a config file and use this to force new configs.
  sub load_force_config {
      my ($config) = @_;
  
      open(IN, $config) or
  	dodie "failed to read $config";
      while (<IN>) {
  	chomp;
  	if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
  	    $force_config{$1} = $_;
  	} elsif (/^# (CONFIG_\S*) is not set/) {
  	    $force_config{$1} = $_;
  	}
      }
      close IN;
  }

  sub build {
      my ($type) = @_;

      unlink $buildlog;

      # Failed builds should not reboot the target
      my $save_no_reboot = $no_reboot;
      $no_reboot = 1;

      if (defined($pre_build)) {
  	my $ret = run_command $pre_build;
  	if (!$ret && defined($pre_build_die) &&
  	    $pre_build_die) {
  	    dodie "failed to pre_build
  ";
  	}
      }

      if ($type =~ /^useconfig:(.*)/) {

  	run_command "cp $1 $output_config" or

  	    dodie "could not copy $1 to .config";

  	$type = "oldconfig";
      }

      # old config can ask questions
      if ($type eq "oldconfig") {

  	$type = "oldnoconfig";

  
  	# allow for empty configs

  	run_command "touch $output_config";

  	if (!$noclean) {
  	    run_command "mv $output_config $outputdir/config_temp" or
  		dodie "moving .config";

  	    run_command "$make mrproper" or dodie "make mrproper";

  	    run_command "mv $outputdir/config_temp $output_config" or
  		dodie "moving config_temp";
  	}

  
      } elsif (!$noclean) {

  	unlink "$output_config";

  	run_command "$make mrproper" or

  	    dodie "make mrproper";

      }

  
      # add something to distinguish this build

      open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
      print OUT "$localversion
  ";

      close(OUT);

      if (defined($minconfig)) {

  	load_force_config($minconfig);

      }

      if ($type ne "oldnoconfig") {
  	run_command "$make $type" or

  	    dodie "failed make config";
      }

      # Run old config regardless, to enforce min configurations
      make_oldconfig;

      $redirect = "$buildlog";

      my $build_ret = run_command "$make $build_options";
      undef $redirect;
  
      if (defined($post_build)) {
  	my $ret = run_command $post_build;
  	if (!$ret && defined($post_build_die) &&
  	    $post_build_die) {
  	    dodie "failed to post_build
  ";
  	}
      }
  
      if (!$build_ret) {

  	# bisect may need this to pass

  	if ($in_bisect) {
  	    $no_reboot = $save_no_reboot;
  	    return 0;
  	}

  	fail "failed build" and return 0;

      }

      $no_reboot = $save_no_reboot;

      return 1;

  }

  sub halt {

      if (!run_ssh "halt" or defined($power_off)) {

  	if (defined($poweroff_after_halt)) {
  	    sleep $poweroff_after_halt;
  	    run_command "$power_off";
  	}
      } else {

  	# nope? the zap it!

  	run_command "$power_off";

      }
  }

  sub success {
      my ($i) = @_;

      $successes++;

      my $name = "";
  
      if (defined($test_name)) {
  	$name = " ($test_name)";
      }

      doprint "
  
  *******************************************
  ";
      doprint     "*******************************************
  ";

      doprint     "KTEST RESULT: TEST $i$name SUCCESS!!!!         **
  ";

      doprint     "*******************************************
  ";
      doprint     "*******************************************
  ";

      if (defined($store_successes)) {
          save_logs "success", $store_successes;
      }

      if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {

  	doprint "Reboot and wait $sleep_time seconds
  ";

  	reboot_to_good $sleep_time;

      }
  }

  sub answer_bisect {
      for (;;) {
  	doprint "Pass or fail? [p/f]";
  	my $ans = <STDIN>;
  	chomp $ans;
  	if ($ans eq "p" || $ans eq "P") {
  	    return 1;
  	} elsif ($ans eq "f" || $ans eq "F") {
  	    return 0;
  	} else {
  	    print "Please answer 'P' or 'F'
  ";
  	}
      }
  }

  sub child_run_test {

      my $failed = 0;

      # child should have no power

      $reboot_on_error = 0;
      $poweroff_on_error = 0;
      $die_on_failure = 1;

      $redirect = "$testlog";

      run_command $run_test or $failed = 1;

      undef $redirect;

      exit $failed;
  }
  
  my $child_done;
  
  sub child_finished {
      $child_done = 1;
  }
  
  sub do_run_test {
      my $child_pid;
      my $child_exit;

      my $line;
      my $full_line;
      my $bug = 0;

      wait_for_monitor 1;

      doprint "run test $run_test
  ";

  
      $child_done = 0;
  
      $SIG{CHLD} = qw(child_finished);
  
      $child_pid = fork;
  
      child_run_test if (!$child_pid);
  
      $full_line = "";
  
      do {

  	$line = wait_for_input($monitor_fp, 1);

  	if (defined($line)) {
  
  	    # we are not guaranteed to get a full line
  	    $full_line .= $line;

  	    doprint $line;

  
  	    if ($full_line =~ /call trace:/i) {
  		$bug = 1;
  	    }
  
  	    if ($full_line =~ /Kernel panic -/) {
  		$bug = 1;
  	    }
  
  	    if ($line =~ /
  /) {
  		$full_line = "";
  	    }
  	}
      } while (!$child_done && !$bug);
  
      if ($bug) {

  	my $failure_start = time;
  	my $now;
  	do {
  	    $line = wait_for_input($monitor_fp, 1);
  	    if (defined($line)) {
  		doprint $line;
  	    }
  	    $now = time;
  	    if ($now - $failure_start >= $stop_after_failure) {
  		last;
  	    }
  	} while (defined($line));

  	doprint "Detected kernel crash!
  ";
  	# kill the child with extreme prejudice
  	kill 9, $child_pid;
      }
  
      waitpid $child_pid, 0;
      $child_exit = $?;

      if (!$bug && $in_bisect) {
  	if (defined($bisect_ret_good)) {
  	    if ($child_exit == $bisect_ret_good) {
  		return 1;
  	    }
  	}
  	if (defined($bisect_ret_skip)) {
  	    if ($child_exit == $bisect_ret_skip) {
  		return -1;
  	    }
  	}
  	if (defined($bisect_ret_abort)) {
  	    if ($child_exit == $bisect_ret_abort) {
  		fail "test abort" and return -2;
  	    }
  	}
  	if (defined($bisect_ret_bad)) {
  	    if ($child_exit == $bisect_ret_skip) {
  		return 0;
  	    }
  	}
  	if (defined($bisect_ret_default)) {
  	    if ($bisect_ret_default eq "good") {
  		return 1;
  	    } elsif ($bisect_ret_default eq "bad") {
  		return 0;
  	    } elsif ($bisect_ret_default eq "skip") {
  		return -1;
  	    } elsif ($bisect_ret_default eq "abort") {
  		return -2;
  	    } else {
  		fail "unknown default action: $bisect_ret_default"
  		    and return -2;
  	    }
  	}
      }

      if ($bug || $child_exit) {

  	return 0 if $in_bisect;
  	fail "test failed" and return 0;

      }

      return 1;

  }

  sub run_git_bisect {
      my ($command) = @_;
  
      doprint "$command ... ";
  
      my $output = `$command 2>&1`;
      my $ret = $?;
  
      logit $output;
  
      if ($ret) {
  	doprint "FAILED
  ";
  	dodie "Failed to git bisect";
      }
  
      doprint "SUCCESS
  ";
      if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
  	doprint "$1 [$2]
  ";
      } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {

  	$bisect_bad_commit = $1;

  	doprint "Found bad commit... $1
  ";
  	return 0;
      } else {
  	# we already logged it, just print it now.
  	print $output;
      }
  
      return 1;
  }

  sub bisect_reboot {
      doprint "Reboot and sleep $bisect_sleep_time seconds
  ";

      reboot_to_good $bisect_sleep_time;

  }
  
  # returns 1 on success, 0 on failure, -1 on skip

  sub run_bisect_test {
      my ($type, $buildtype) = @_;

      my $failed = 0;

      my $result;
      my $output;
      my $ret;

      $in_bisect = 1;
  
      build $buildtype or $failed = 1;

  
      if ($type ne "build") {

  	if ($failed && $bisect_skip) {
  	    $in_bisect = 0;
  	    return -1;
  	}

  	dodie "Failed on build" if $failed;

  
  	# Now boot the box

  	start_monitor_and_boot or $failed = 1;

  
  	if ($type ne "boot") {

  	    if ($failed && $bisect_skip) {
  		end_monitor;
  		bisect_reboot;
  		$in_bisect = 0;
  		return -1;
  	    }

  	    dodie "Failed on boot" if $failed;

  	    do_run_test or $failed = 1;

  	}

  	end_monitor;

      }
  
      if ($failed) {

  	$result = 0;

      } else {

  	$result = 1;
      }

  
      # reboot the box to a kernel we can ssh to
      if ($type ne "build") {
  	bisect_reboot;
      }

      $in_bisect = 0;
  
      return $result;
  }
  
  sub run_bisect {
      my ($type) = @_;
      my $buildtype = "oldconfig";
  
      # We should have a minconfig to use?
      if (defined($minconfig)) {
  	$buildtype = "useconfig:$minconfig";

      }

      my $ret = run_bisect_test $type, $buildtype;

      if ($bisect_manual) {
  	$ret = answer_bisect;
      }

      # Are we looking for where it worked, not failed?
      if ($reverse_bisect) {

  	$ret = !$ret;

      }

      if ($ret > 0) {

  	return "good";

      } elsif ($ret == 0) {

  	return  "bad";

      } elsif ($bisect_skip) {
  	doprint "HIT A BAD COMMIT ... SKIPPING
  ";
  	return "skip";

      }

  }

  sub update_bisect_replay {
      my $tmp_log = "$tmpdir/ktest_bisect_log";
      run_command "git bisect log > $tmp_log" or
  	die "can't create bisect log";
      return $tmp_log;
  }

  sub bisect {
      my ($i) = @_;
  
      my $result;

      die "BISECT_GOOD[$i] not defined
  "	if (!defined($bisect_good));
      die "BISECT_BAD[$i] not defined
  "	if (!defined($bisect_bad));
      die "BISECT_TYPE[$i] not defined
  "	if (!defined($bisect_type));

      my $good = $bisect_good;
      my $bad = $bisect_bad;
      my $type = $bisect_type;
      my $start = $bisect_start;
      my $replay = $bisect_replay;
      my $start_files = $bisect_files;

  
      if (defined($start_files)) {
  	$start_files = " -- " . $start_files;
      } else {
  	$start_files = "";
      }

      # convert to true sha1's
      $good = get_sha1($good);
      $bad = get_sha1($bad);

      if (defined($bisect_reverse) && $bisect_reverse == 1) {

  	doprint "Performing a reverse bisect (bad is good, good is bad!)
  ";
  	$reverse_bisect = 1;
      } else {
  	$reverse_bisect = 0;
      }

      # Can't have a test without having a test to run
      if ($type eq "test" && !defined($run_test)) {
  	$type = "boot";
      }

      # Check if a bisect was running
      my $bisect_start_file = "$builddir/.git/BISECT_START";

      my $check = $bisect_check;

      my $do_check = defined($check) && $check ne "0";
  
      if ( -f $bisect_start_file ) {
  	print "Bisect in progress found
  ";
  	if ($do_check) {
  	    print " If you say yes, then no checks of good or bad will be done
  ";
  	}
  	if (defined($replay)) {
  	    print "** BISECT_REPLAY is defined in config file **";
  	    print " Ignore config option and perform new git bisect log?
  ";
  	    if (read_ync " (yes, no, or cancel) ") {
  		$replay = update_bisect_replay;
  		$do_check = 0;
  	    }
  	} elsif (read_yn "read git log and continue?") {
  	    $replay = update_bisect_replay;
  	    $do_check = 0;
  	}
      }
  
      if ($do_check) {

  
  	# get current HEAD

  	my $head = get_sha1("HEAD");

  
  	if ($check ne "good") {
  	    doprint "TESTING BISECT BAD [$bad]
  ";
  	    run_command "git checkout $bad" or
  		die "Failed to checkout $bad";
  
  	    $result = run_bisect $type;
  
  	    if ($result ne "bad") {
  		fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
  	    }
  	}
  
  	if ($check ne "bad") {
  	    doprint "TESTING BISECT GOOD [$good]
  ";
  	    run_command "git checkout $good" or
  		die "Failed to checkout $good";
  
  	    $result = run_bisect $type;
  
  	    if ($result ne "good") {
  		fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
  	    }
  	}
  
  	# checkout where we started
  	run_command "git checkout $head" or
  	    die "Failed to checkout $head";
      }

      run_command "git bisect start$start_files" or

  	dodie "could not start bisect";

  
      run_command "git bisect good $good" or

  	dodie "could not set bisect good to $good";

      run_git_bisect "git bisect bad $bad" or
  	dodie "could not set bisect bad to $bad";

      if (defined($replay)) {
  	run_command "git bisect replay $replay" or
  	    dodie "failed to run replay";

      }

      if (defined($start)) {
  	run_command "git checkout $start" or
  	    dodie "failed to checkout $start";
      }
  
      my $test;

      do {
  	$result = run_bisect $type;

  	$test = run_git_bisect "git bisect $result";
      } while ($test);

  
      run_command "git bisect log" or
  	dodie "could not capture git bisect log";
  
      run_command "git bisect reset" or
  	dodie "could not reset git bisect";