3 # Copyright 2010 - Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
4 # Licensed under the terms of the GNU GPL License version 2
9 use Fcntl
qw(F_GETFL F_SETFL O_NONBLOCK);
10 use File
::Path
qw(mkpath);
11 use File
::Copy
qw(cp);
25 "TEST_TYPE" => "build",
26 "BUILD_TYPE" => "randconfig",
29 "TMP_DIR" => "/tmp/ktest/\${MACHINE}",
30 "SLEEP_TIME" => 60, # sleep time between tests
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
42 "MIN_CONFIG_TYPE" => "boot",
43 "SUCCESS_LINE" => "login:",
44 "DETECT_TRIPLE_FAULT" => 1,
46 "BOOTED_TIMEOUT" => 1,
47 "DIE_ON_FAILURE" => 1,
48 "SSH_EXEC" => "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND",
49 "SCP_TO_TARGET" => "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE",
50 "SCP_TO_TARGET_INSTALL" => "\${SCP_TO_TARGET}",
51 "REBOOT" => "ssh \$SSH_USER\@\$MACHINE reboot",
52 "STOP_AFTER_SUCCESS" => 10,
53 "STOP_AFTER_FAILURE" => 60,
54 "STOP_TEST_AFTER" => 600,
56 # required, and we will ask users if they don't have them but we keep the default
57 # value something that is common.
58 "REBOOT_TYPE" => "grub",
59 "LOCALVERSION" => "-test",
61 "BUILD_TARGET" => "arch/x86/boot/bzImage",
62 "TARGET_IMAGE" => "/boot/vmlinuz-test",
91 my $poweroff_on_error;
92 my $reboot_on_success;
94 my $powercycle_after_reboot;
95 my $poweroff_after_halt;
98 my $scp_to_target_install;
109 my $start_minconfig_defined;
110 my $output_minconfig;
112 my $use_output_minconfig;
117 my $bisect_bad_commit = "";
121 my $config_bisect_good;
125 my $bisect_ret_abort;
126 my $bisect_ret_default;
127 my $in_patchcheck = 0;
137 my $bisect_sleep_time;
138 my $patchcheck_sleep_time;
145 my $detect_triplefault;
147 my $reboot_success_line;
149 my $stop_after_success;
150 my $stop_after_failure;
169 my $config_bisect_type;
172 my $patchcheck_start;
175 # set when a test is something other that just building or install
176 # which would require more options.
179 # set when creating a new config
187 # do not force reboots on config problems
191 my $reboot_success = 0;
194 "MACHINE" => \
$machine,
195 "SSH_USER" => \
$ssh_user,
196 "TMP_DIR" => \
$tmpdir,
197 "OUTPUT_DIR" => \
$outputdir,
198 "BUILD_DIR" => \
$builddir,
199 "TEST_TYPE" => \
$test_type,
200 "BUILD_TYPE" => \
$build_type,
201 "BUILD_OPTIONS" => \
$build_options,
202 "PRE_BUILD" => \
$pre_build,
203 "POST_BUILD" => \
$post_build,
204 "PRE_BUILD_DIE" => \
$pre_build_die,
205 "POST_BUILD_DIE" => \
$post_build_die,
206 "POWER_CYCLE" => \
$power_cycle,
207 "REBOOT" => \
$reboot,
208 "BUILD_NOCLEAN" => \
$noclean,
209 "MIN_CONFIG" => \
$minconfig,
210 "OUTPUT_MIN_CONFIG" => \
$output_minconfig,
211 "START_MIN_CONFIG" => \
$start_minconfig,
212 "MIN_CONFIG_TYPE" => \
$minconfig_type,
213 "USE_OUTPUT_MIN_CONFIG" => \
$use_output_minconfig,
214 "IGNORE_CONFIG" => \
$ignore_config,
215 "TEST" => \
$run_test,
216 "ADD_CONFIG" => \
$addconfig,
217 "REBOOT_TYPE" => \
$reboot_type,
218 "GRUB_MENU" => \
$grub_menu,
219 "POST_INSTALL" => \
$post_install,
220 "NO_INSTALL" => \
$no_install,
221 "REBOOT_SCRIPT" => \
$reboot_script,
222 "REBOOT_ON_ERROR" => \
$reboot_on_error,
223 "SWITCH_TO_GOOD" => \
$switch_to_good,
224 "SWITCH_TO_TEST" => \
$switch_to_test,
225 "POWEROFF_ON_ERROR" => \
$poweroff_on_error,
226 "REBOOT_ON_SUCCESS" => \
$reboot_on_success,
227 "DIE_ON_FAILURE" => \
$die_on_failure,
228 "POWER_OFF" => \
$power_off,
229 "POWERCYCLE_AFTER_REBOOT" => \
$powercycle_after_reboot,
230 "POWEROFF_AFTER_HALT" => \
$poweroff_after_halt,
231 "SLEEP_TIME" => \
$sleep_time,
232 "BISECT_SLEEP_TIME" => \
$bisect_sleep_time,
233 "PATCHCHECK_SLEEP_TIME" => \
$patchcheck_sleep_time,
234 "IGNORE_WARNINGS" => \
$ignore_warnings,
235 "IGNORE_ERRORS" => \
$ignore_errors,
236 "BISECT_MANUAL" => \
$bisect_manual,
237 "BISECT_SKIP" => \
$bisect_skip,
238 "CONFIG_BISECT_GOOD" => \
$config_bisect_good,
239 "BISECT_RET_GOOD" => \
$bisect_ret_good,
240 "BISECT_RET_BAD" => \
$bisect_ret_bad,
241 "BISECT_RET_SKIP" => \
$bisect_ret_skip,
242 "BISECT_RET_ABORT" => \
$bisect_ret_abort,
243 "BISECT_RET_DEFAULT" => \
$bisect_ret_default,
244 "STORE_FAILURES" => \
$store_failures,
245 "STORE_SUCCESSES" => \
$store_successes,
246 "TEST_NAME" => \
$test_name,
247 "TIMEOUT" => \
$timeout,
248 "BOOTED_TIMEOUT" => \
$booted_timeout,
249 "CONSOLE" => \
$console,
250 "DETECT_TRIPLE_FAULT" => \
$detect_triplefault,
251 "SUCCESS_LINE" => \
$success_line,
252 "REBOOT_SUCCESS_LINE" => \
$reboot_success_line,
253 "STOP_AFTER_SUCCESS" => \
$stop_after_success,
254 "STOP_AFTER_FAILURE" => \
$stop_after_failure,
255 "STOP_TEST_AFTER" => \
$stop_test_after,
256 "BUILD_TARGET" => \
$build_target,
257 "SSH_EXEC" => \
$ssh_exec,
258 "SCP_TO_TARGET" => \
$scp_to_target,
259 "SCP_TO_TARGET_INSTALL" => \
$scp_to_target_install,
260 "CHECKOUT" => \
$checkout,
261 "TARGET_IMAGE" => \
$target_image,
262 "LOCALVERSION" => \
$localversion,
264 "BISECT_GOOD" => \
$bisect_good,
265 "BISECT_BAD" => \
$bisect_bad,
266 "BISECT_TYPE" => \
$bisect_type,
267 "BISECT_START" => \
$bisect_start,
268 "BISECT_REPLAY" => \
$bisect_replay,
269 "BISECT_FILES" => \
$bisect_files,
270 "BISECT_REVERSE" => \
$bisect_reverse,
271 "BISECT_CHECK" => \
$bisect_check,
273 "CONFIG_BISECT" => \
$config_bisect,
274 "CONFIG_BISECT_TYPE" => \
$config_bisect_type,
276 "PATCHCHECK_TYPE" => \
$patchcheck_type,
277 "PATCHCHECK_START" => \
$patchcheck_start,
278 "PATCHCHECK_END" => \
$patchcheck_end,
281 # Options may be used by other options, record them.
284 # default variables that can be used
285 chomp ($variable{"PWD"} = `pwd`);
287 $config_help{"MACHINE"} = << "EOF"
288 The machine hostname that you will test
.
289 For build only tests
, it is still needed to differentiate
log files
.
292 $config_help{"SSH_USER"} = << "EOF"
293 The box is expected to have ssh on normal bootup
, provide the user
294 (most likely root
, since you need privileged operations
)
297 $config_help{"BUILD_DIR"} = << "EOF"
298 The directory that contains the Linux source code
(full path
).
299 You can
use \
${PWD
} that will be the path where ktest
.pl is run
, or use
300 \
${THIS_DIR
} which is assigned \
${PWD
} but may be changed later
.
303 $config_help{"OUTPUT_DIR"} = << "EOF"
304 The directory that the objects will be built
(full path
).
305 (can
not be same as BUILD_DIR
)
306 You can
use \
${PWD
} that will be the path where ktest
.pl is run
, or use
307 \
${THIS_DIR
} which is assigned \
${PWD
} but may be changed later
.
310 $config_help{"BUILD_TARGET"} = << "EOF"
311 The location of the compiled file to copy to the target
.
312 (relative to OUTPUT_DIR
)
315 $config_help{"BUILD_OPTIONS"} = << "EOF"
316 Options to add to
\"make
\" when building
.
320 $config_help{"TARGET_IMAGE"} = << "EOF"
321 The place to put your image on the test machine
.
324 $config_help{"POWER_CYCLE"} = << "EOF"
325 A script
or command to reboot the box
.
327 Here is a digital loggers power switch example
328 POWER_CYCLE
= wget
--no-proxy
-O
/dev/null
-q
--auth
-no-challenge
'http://admin:admin\@power/outlet?5=CCL'
330 Here is an example to reboot a virtual box on the current host
331 with the name
"Guest".
332 POWER_CYCLE
= virsh destroy Guest
; sleep 5; virsh start Guest
335 $config_help{"CONSOLE"} = << "EOF"
336 The script
or command that reads the console
338 If you
use ttywatch server
, something like the following would work
.
339 CONSOLE
= nc
-d localhost
3001
341 For a virtual machine with guest name
"Guest".
342 CONSOLE
= virsh console Guest
345 $config_help{"LOCALVERSION"} = << "EOF"
346 Required version ending to differentiate the test
347 from other linux builds on the
system.
350 $config_help{"REBOOT_TYPE"} = << "EOF"
351 Way to reboot the box to the test kernel
.
352 Only valid options so far are
"grub" and "script".
354 If you specify grub
, it will assume grub version
1
355 and will search
in /boot/grub
/menu
.lst
for the title \
$GRUB_MENU
356 and select that target to reboot to the kernel
. If this is
not
357 your setup
, then specify
"script" and have a command
or script
358 specified
in REBOOT_SCRIPT to boot to the target
.
360 The entry
in /boot/grub
/menu
.lst must be entered
in manually
.
361 The test will
not modify that file
.
364 $config_help{"GRUB_MENU"} = << "EOF"
365 The grub title name
for the test kernel to boot
366 (Only mandatory
if REBOOT_TYPE
= grub
)
368 Note
, ktest
.pl will
not update the grub menu
.lst
, you need to
369 manually add an option
for the test
. ktest
.pl will search
370 the grub menu
.lst
for this option to find what kernel to
373 For example
, if in the
/boot/grub
/menu
.lst the test kernel title has
:
376 GRUB_MENU
= Test Kernel
379 $config_help{"REBOOT_SCRIPT"} = << "EOF"
380 A script to reboot the target into the test kernel
381 (Only mandatory
if REBOOT_TYPE
= script
)
386 my ($cancel, $prompt) = @_;
392 print "$prompt [y/n/C] ";
394 print "$prompt [Y/n] ";
398 if ($ans =~ /^\s*$/) {
405 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
407 last if ($ans =~ /^c$/i);
408 print "Please answer either 'y', 'n' or 'c'.\n";
410 print "Please answer either 'y' or 'n'.\n";
416 if ($ans !~ /^y$/i) {
425 return read_prompt
0, $prompt;
431 return read_prompt
1, $prompt;
434 sub get_ktest_config
{
438 return if (defined($opt{$config}));
440 if (defined($config_help{$config})) {
442 print $config_help{$config};
447 if (defined($default{$config}) && length($default{$config})) {
448 print "\[$default{$config}\] ";
451 $ans =~ s/^\s*(.*\S)\s*$/$1/;
452 if ($ans =~ /^\s*$/) {
453 if ($default{$config}) {
454 $ans = $default{$config};
456 print "Your answer can not be blank\n";
460 $entered_configs{$config} = ${ans
};
465 sub get_ktest_configs
{
466 get_ktest_config
("MACHINE");
467 get_ktest_config
("BUILD_DIR");
468 get_ktest_config
("OUTPUT_DIR");
471 get_ktest_config
("BUILD_OPTIONS");
474 # options required for other than just building a kernel
476 get_ktest_config
("POWER_CYCLE");
477 get_ktest_config
("CONSOLE");
480 # options required for install and more
481 if ($buildonly != 1) {
482 get_ktest_config
("SSH_USER");
483 get_ktest_config
("BUILD_TARGET");
484 get_ktest_config
("TARGET_IMAGE");
487 get_ktest_config
("LOCALVERSION");
489 return if ($buildonly);
491 my $rtype = $opt{"REBOOT_TYPE"};
493 if (!defined($rtype)) {
494 if (!defined($opt{"GRUB_MENU"})) {
495 get_ktest_config
("REBOOT_TYPE");
496 $rtype = $entered_configs{"REBOOT_TYPE"};
502 if ($rtype eq "grub") {
503 get_ktest_config
("GRUB_MENU");
507 sub process_variables
{
508 my ($value, $remove_undef) = @_;
511 # We want to check for '\', and it is just easier
512 # to check the previous characet of '$' and not need
513 # to worry if '$' is the first character. By adding
514 # a space to $value, we can just check [^\\]\$ and
515 # it will still work.
518 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
522 # append beginning of value to retval
523 $retval = "$retval$begin";
524 if (defined($variable{$var})) {
525 $retval = "$retval$variable{$var}";
526 } elsif (defined($remove_undef) && $remove_undef) {
527 # for if statements, any variable that is not defined,
528 # we simple convert to 0
529 $retval = "${retval}0";
531 # put back the origin piece.
532 $retval = "$retval\$\{$var\}";
533 # This could be an option that is used later, save
534 # it so we don't warn if this option is not one of
536 $used_options{$var} = 1;
540 $retval = "$retval$value";
542 # remove the space added in the beginning
549 my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
551 my $prvalue = process_variables
($rvalue);
553 if ($buildonly && $lvalue =~ /^TEST_TYPE(\[.*\])?$/ && $prvalue ne "build") {
554 # Note if a test is something other than build, then we
555 # will need other manditory options.
556 if ($prvalue ne "install") {
559 # install still limits some manditory options.
564 if (defined($opt{$lvalue})) {
565 if (!$override || defined(${$overrides}{$lvalue})) {
568 $extra = "In the same override section!\n";
570 die "$name: $.: Option $lvalue defined more than once!\n$extra";
572 ${$overrides}{$lvalue} = $prvalue;
574 if ($rvalue =~ /^\s*$/) {
575 delete $opt{$lvalue};
577 $opt{$lvalue} = $prvalue;
582 my ($lvalue, $rvalue) = @_;
584 if ($rvalue =~ /^\s*$/) {
585 delete $variable{$lvalue};
587 $rvalue = process_variables
($rvalue);
588 $variable{$lvalue} = $rvalue;
592 sub process_compare
{
593 my ($lval, $cmp, $rval) = @_;
604 return $lval eq $rval;
605 } elsif ($cmp eq "!=") {
606 return $lval ne $rval;
609 my $statement = "$lval $cmp $rval";
610 my $ret = eval $statement;
612 # $@ stores error of eval
623 return defined($variable{$2}) ||
628 sub process_expression
{
629 my ($name, $val) = @_;
633 while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
636 if (process_expression
($name, $express)) {
637 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
639 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
647 while ($val =~ s/^(.*?)($OR|$AND)//) {
651 if (process_expression
($name, $express)) {
662 if ($val =~ /(.*)(==|\!=|>=|<=|>|<)(.*)/) {
663 my $ret = process_compare
($1, $2, $3);
665 die "$name: $.: Unable to process comparison\n";
670 if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
672 return !value_defined
($2);
674 return value_defined
($2);
678 if ($val =~ /^\s*0\s*$/) {
680 } elsif ($val =~ /^\s*\d+\s*$/) {
684 die ("$name: $.: Undefined content $val in if statement\n");
688 my ($name, $value) = @_;
690 # Convert variables and replace undefined ones with 0
691 my $val = process_variables
($value, 1);
692 my $ret = process_expression
$name, $val;
698 my ($config, $current_test_num) = @_;
701 open($in, $config) || die "can't read file $config";
704 $name =~ s
,.*/(.*),$1,;
706 my $test_num = $$current_test_num;
709 my $num_tests_set = 0;
722 # ignore blank lines and comments
723 next if (/^\s*$/ || /\s*\#/);
725 if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
735 if ($type eq "TEST_START") {
737 if ($num_tests_set) {
738 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
741 $old_test_num = $test_num;
742 $old_repeat = $repeat;
744 $test_num += $repeat;
751 # If SKIP is anywhere in the line, the command will be skipped
752 if ($rest =~ s/\s+SKIP\b//) {
759 if ($rest =~ s/\sELSE\b//) {
761 die "$name: $.: ELSE found with out matching IF section\n$_";
772 if ($rest =~ s/\sIF\s+(.*)//) {
773 if (process_if
($name, $1)) {
785 if ($type eq "TEST_START") {
786 if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
788 $repeat_tests{"$test_num"} = $repeat;
790 } elsif ($rest =~ s/\sOVERRIDE\b//) {
793 # Clear previous overrides
798 if (!$skip && $rest !~ /^\s*$/) {
799 die "$name: $.: Gargbage found after $type\n$_";
802 if ($skip && $type eq "TEST_START") {
803 $test_num = $old_test_num;
804 $repeat = $old_repeat;
807 } elsif (/^\s*ELSE\b(.*)$/) {
809 die "$name: $.: ELSE found with out matching IF section\n$_";
818 if ($rest =~ /\sIF\s+(.*)/) {
819 # May be a ELSE IF section.
820 if (!process_if
($name, $1)) {
829 if ($rest !~ /^\s*$/) {
830 die "$name: $.: Gargbage found after DEFAULTS\n$_";
833 } elsif (/^\s*INCLUDE\s+(\S+)/) {
838 die "$name: $.: INCLUDE can only be done in default sections\n$_";
841 my $file = process_variables
($1);
843 if ($file !~ m
,^/,) {
844 # check the path of the config file first
845 if ($config =~ m
,(.*)/,) {
853 die "$name: $.: Can't read file $file\n$_";
856 if (__read_config
($file, \
$test_num)) {
860 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
868 ($lvalue eq "NUM_TESTS" ||
869 $lvalue eq "LOG_FILE" ||
870 $lvalue eq "CLEAR_LOG")) {
871 die "$name: $.: $lvalue must be set in DEFAULTS section\n";
874 if ($lvalue eq "NUM_TESTS") {
876 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
879 die "$name: $.: NUM_TESTS must be set in default section\n";
884 if ($default || $lvalue =~ /\[\d+\]$/) {
885 set_value
($lvalue, $rvalue, $override, \
%overrides, $name);
887 my $val = "$lvalue\[$test_num\]";
888 set_value
($val, $rvalue, $override, \
%overrides, $name);
891 $repeats{$val} = $repeat;
894 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
900 # process config variables.
901 # Config variables are only active while reading the
902 # config and can be defined anywhere. They also ignore
903 # TEST_START and DEFAULTS, but are skipped if they are in
904 # on of these sections that have SKIP defined.
905 # The save variable can be
906 # defined multiple times and the new one simply overrides
908 set_variable
($lvalue, $rvalue);
911 die "$name: $.: Garbage found in config\n$_";
916 $test_num += $repeat - 1;
917 $opt{"NUM_TESTS"} = $test_num;
922 $$current_test_num = $test_num;
928 print "What test case would you like to run?\n";
929 print " (build, install or boot)\n";
930 print " Other tests are available but require editing the config file\n";
933 $default{"TEST_TYPE"} = $ans;
942 $test_case = __read_config
$config, \
$test_num;
944 # make sure we have all mandatory configs
947 # was a test specified?
949 print "No test case specified.\n";
955 foreach my $default (keys %default) {
956 if (!defined($opt{$default})) {
957 $opt{$default} = $default{$default};
961 if ($opt{"IGNORE_UNUSED"} == 1) {
967 # check if there are any stragglers (typos?)
968 foreach my $option (keys %opt) {
970 # remove per test labels.
972 if (!exists($option_map{$op}) &&
973 !exists($default{$op}) &&
974 !exists($used_options{$op})) {
981 $s = " is" if (keys %not_used == 1);
982 print "The following option$s not used; could be a typo:\n";
983 foreach my $option (keys %not_used) {
986 print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";
987 if (!read_yn
"Do you want to continue?") {
994 my ($option, $i) = @_;
996 # Add space to evaluate the character before $
997 $option = " $option";
1002 foreach my $test (keys %repeat_tests) {
1004 $i < $test + $repeat_tests{$test}) {
1012 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
1017 # Append beginning of line
1018 $retval = "$retval$start";
1020 # If the iteration option OPT[$i] exists, then use that.
1021 # otherwise see if the default OPT (without [$i]) exists.
1023 my $o = "$var\[$i\]";
1024 my $parento = "$var\[$parent\]";
1026 if (defined($opt{$o})) {
1028 $retval = "$retval$o";
1029 } elsif ($repeated && defined($opt{$parento})) {
1030 $o = $opt{$parento};
1031 $retval = "$retval$o";
1032 } elsif (defined($opt{$var})) {
1034 $retval = "$retval$o";
1036 $retval = "$retval\$\{$var\}";
1042 $retval = "$retval$option";
1050 my ($option, $i) = @_;
1054 # Since an option can evaluate to another option,
1055 # keep iterating until we do not evaluate any more
1058 while ($prev ne $option) {
1059 # Check for recursive evaluations.
1060 # 100 deep should be more than enough.
1062 die "Over 100 evaluations accurred with $option\n" .
1063 "Check for recursive variables\n";
1066 $option = __eval_option
($option, $i);
1073 if (defined($opt{"LOG_FILE"})) {
1074 open(OUT
, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
1081 if (defined($opt{"LOG_FILE"})) {
1096 sub wait_for_monitor
;
1101 if (defined($time)) {
1103 # flush out current monitor
1104 # May contain the reboot success line
1108 # try to reboot normally
1109 if (run_command
$reboot) {
1110 if (defined($powercycle_after_reboot)) {
1111 sleep $powercycle_after_reboot;
1112 run_command
"$power_cycle";
1115 # nope? power cycle it.
1116 run_command
"$power_cycle";
1119 if (defined($time)) {
1120 wait_for_monitor
($time, $reboot_success_line);
1125 sub reboot_to_good
{
1128 if (defined($switch_to_good)) {
1129 run_command
$switch_to_good;
1138 return $test_type eq "build" || $no_reboot ||
1139 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
1140 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
1144 doprint
"CRITICAL FAILURE... ", @_, "\n";
1148 if ($reboot_on_error && !do_not_reboot
) {
1150 doprint
"REBOOTING\n";
1153 } elsif ($poweroff_on_error && defined($power_off)) {
1154 doprint
"POWERING OFF\n";
1158 if (defined($opt{"LOG_FILE"})) {
1159 print " See $opt{LOG_FILE} for more info.\n";
1170 my $pid = open($fp, "$console|") or
1171 dodie
"Can't open console $console";
1173 $flags = fcntl($fp, F_GETFL
, 0) or
1174 dodie
"Can't get flags for the socket: $!";
1175 $flags = fcntl($fp, F_SETFL
, $flags | O_NONBLOCK
) or
1176 dodie
"Can't set flags for the socket: $!";
1182 my ($fp, $pid) = @_;
1184 doprint
"kill child process $pid\n";
1192 if ($monitor_cnt++) {
1195 $monitor_fp = \
*MONFD
;
1196 $monitor_pid = open_console
$monitor_fp;
1200 open(MONFD
, "Stop perl from warning about single use of MONFD");
1204 if (--$monitor_cnt) {
1207 close_console
($monitor_fp, $monitor_pid);
1210 sub wait_for_monitor
{
1211 my ($time, $stop) = @_;
1216 doprint
"** Wait for monitor to settle down **\n";
1218 # read the monitor and wait for the system to calm down
1220 $line = wait_for_input
($monitor_fp, $time);
1221 last if (!defined($line));
1223 $full_line .= $line;
1225 if (defined($stop) && $full_line =~ /$stop/) {
1226 doprint
"wait for monitor detected $stop\n";
1230 if ($line =~ /\n/) {
1234 print "** Monitor flushed **\n";
1238 my ($result, $basedir) = @_;
1240 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
1241 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
1243 my $type = $build_type;
1244 if ($type =~ /useconfig/) {
1245 $type = "useconfig";
1248 my $dir = "$machine-$test_type-$type-$result-$date";
1250 $dir = "$basedir/$dir";
1254 die "can't create $dir";
1258 "config" => $output_config,
1259 "buildlog" => $buildlog,
1261 "testlog" => $testlog,
1264 while (my ($name, $source) = each(%files)) {
1266 cp
"$source", "$dir/$name" or
1267 die "failed to copy $source";
1271 doprint
"*** Saved info to $dir ***\n";
1276 if ($die_on_failure) {
1284 # no need to reboot for just building.
1285 if (!do_not_reboot
) {
1286 doprint
"REBOOTING\n";
1287 reboot_to_good
$sleep_time;
1292 if (defined($test_name)) {
1293 $name = " ($test_name)";
1296 doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1297 doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1298 doprint
"KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
1299 doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1300 doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1302 if (defined($store_failures)) {
1303 save_logs
"fail", $store_failures;
1315 $command =~ s/\$SSH_USER/$ssh_user/g;
1316 $command =~ s/\$MACHINE/$machine/g;
1318 doprint
("$command ... ");
1320 $pid = open(CMD
, "$command 2>&1 |") or
1321 (fail
"unable to exec $command" and return 0);
1323 if (defined($opt{"LOG_FILE"})) {
1324 open(LOG
, ">>$opt{LOG_FILE}") or
1325 dodie
"failed to write to log";
1329 if (defined($redirect)) {
1330 open (RD
, ">$redirect") or
1331 dodie
"failed to write to redirect $redirect";
1336 print LOG
if ($dolog);
1337 print RD
if ($dord);
1344 close(LOG
) if ($dolog);
1345 close(RD
) if ($dord);
1348 doprint
"FAILED!\n";
1350 doprint
"SUCCESS\n";
1358 my $cp_exec = $ssh_exec;
1360 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
1361 return run_command
"$cp_exec";
1365 my ($src, $dst, $cp_scp) = @_;
1367 $cp_scp =~ s/\$SRC_FILE/$src/g;
1368 $cp_scp =~ s/\$DST_FILE/$dst/g;
1370 return run_command
"$cp_scp";
1373 sub run_scp_install
{
1374 my ($src, $dst) = @_;
1376 my $cp_scp = $scp_to_target_install;
1378 return run_scp
($src, $dst, $cp_scp);
1382 my ($src, $dst) = @_;
1384 my $cp_scp = $scp_to_target;
1386 return run_scp
($src, $dst, $cp_scp);
1389 sub get_grub_index
{
1391 if ($reboot_type ne "grub") {
1394 return if (defined($grub_number));
1396 doprint
"Find grub menu ... ";
1399 my $ssh_grub = $ssh_exec;
1400 $ssh_grub =~ s
,\
$SSH_COMMAND,cat
/boot/grub
/menu
.lst
,g
;
1402 open(IN
, "$ssh_grub |")
1403 or die "unable to get menu.lst";
1408 if (/^\s*title\s+$grub_menu\s*$/) {
1412 } elsif (/^\s*title\s/) {
1418 die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
1420 doprint
"$grub_number\n";
1425 my ($fp, $time) = @_;
1431 if (!defined($time)) {
1436 vec($rin, fileno($fp), 1) = 1;
1437 $ready = select($rin, undef, undef, $time);
1441 # try to read one char at a time
1442 while (sysread $fp, $ch, 1) {
1444 last if ($ch eq "\n");
1447 if (!length($line)) {
1455 if (defined($switch_to_test)) {
1456 run_command
$switch_to_test;
1459 if ($reboot_type eq "grub") {
1460 run_ssh
"'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
1461 } elsif (defined $reboot_script) {
1462 run_command
"$reboot_script";
1470 doprint
"git rev-list --max-count=1 $commit ... ";
1471 my $sha1 = `git rev-list --max-count=1 $commit`;
1478 dodie
"Failed to get git $commit";
1491 my $bug_ignored = 0;
1492 my $skip_call_trace = 0;
1500 open(DMESG
, "> $dmesg") or
1501 die "unable to write to $dmesg";
1507 my $monitor_start = time;
1509 my $version_found = 0;
1513 if ($bug && defined($stop_after_failure) &&
1514 $stop_after_failure >= 0) {
1515 my $time = $stop_after_failure - (time - $failure_start);
1516 $line = wait_for_input
($monitor_fp, $time);
1517 if (!defined($line)) {
1518 doprint
"bug timed out after $booted_timeout seconds\n";
1519 doprint
"Test forced to stop after $stop_after_failure seconds after failure\n";
1523 $line = wait_for_input
($monitor_fp, $booted_timeout);
1524 if (!defined($line)) {
1525 my $s = $booted_timeout == 1 ?
"" : "s";
1526 doprint
"Successful boot found: break after $booted_timeout second$s\n";
1530 $line = wait_for_input
($monitor_fp);
1531 if (!defined($line)) {
1532 my $s = $timeout == 1 ?
"" : "s";
1533 doprint
"Timed out after $timeout second$s\n";
1541 # we are not guaranteed to get a full line
1542 $full_line .= $line;
1544 if ($full_line =~ /$success_line/) {
1546 $success_start = time;
1549 if ($booted && defined($stop_after_success) &&
1550 $stop_after_success >= 0) {
1552 if ($now - $success_start >= $stop_after_success) {
1553 doprint
"Test forced to stop after $stop_after_success seconds after success\n";
1558 if ($full_line =~ /\[ backtrace testing \]/) {
1559 $skip_call_trace = 1;
1562 if ($full_line =~ /call trace:/i) {
1563 if (!$bug && !$skip_call_trace) {
1564 if ($ignore_errors) {
1568 $failure_start = time;
1573 if ($bug && defined($stop_after_failure) &&
1574 $stop_after_failure >= 0) {
1576 if ($now - $failure_start >= $stop_after_failure) {
1577 doprint
"Test forced to stop after $stop_after_failure seconds after failure\n";
1582 if ($full_line =~ /\[ end of backtrace testing \]/) {
1583 $skip_call_trace = 0;
1586 if ($full_line =~ /Kernel panic -/) {
1587 $failure_start = time;
1591 # Detect triple faults by testing the banner
1592 if ($full_line =~ /\bLinux version (\S+).*\n/) {
1593 if ($1 eq $version) {
1595 } elsif ($version_found && $detect_triplefault) {
1596 # We already booted into the kernel we are testing,
1597 # but now we booted into another kernel?
1598 # Consider this a triple fault.
1599 doprint
"Aleady booted in Linux kernel $version, but now\n";
1600 doprint
"we booted into Linux kernel $1.\n";
1601 doprint
"Assuming that this is a triple fault.\n";
1602 doprint
"To disable this: set DETECT_TRIPLE_FAULT to 0\n";
1607 if ($line =~ /\n/) {
1611 if ($stop_test_after > 0 && !$booted && !$bug) {
1612 if (time - $monitor_start > $stop_test_after) {
1613 doprint
"STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
1622 return 0 if ($in_bisect);
1623 fail
"failed - got a bug report" and return 0;
1627 return 0 if ($in_bisect);
1628 fail
"failed - never got a boot prompt." and return 0;
1632 doprint
"WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
1638 sub eval_kernel_version
{
1641 $option =~ s/\$KERNEL_VERSION/$version/g;
1646 sub do_post_install
{
1648 return if (!defined($post_install));
1650 my $cp_post_install = eval_kernel_version
$post_install;
1651 run_command
"$cp_post_install" or
1652 dodie
"Failed to run post install";
1657 return if ($no_install);
1659 my $cp_target = eval_kernel_version
$target_image;
1661 run_scp_install
"$outputdir/$build_target", "$cp_target" or
1662 dodie
"failed to copy image";
1664 my $install_mods = 0;
1666 # should we process modules?
1668 open(IN
, "$output_config") or dodie
("Can't read config file");
1670 if (/CONFIG_MODULES(=y)?/) {
1671 $install_mods = 1 if (defined($1));
1677 if (!$install_mods) {
1679 doprint
"No modules needed\n";
1683 run_command
"$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or
1684 dodie
"Failed to install modules";
1686 my $modlib = "/lib/modules/$version";
1687 my $modtar = "ktest-mods.tar.bz2";
1689 run_ssh
"rm -rf $modlib" or
1690 dodie
"failed to remove old mods: $modlib";
1692 # would be nice if scp -r did not follow symbolic links
1693 run_command
"cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
1694 dodie
"making tarball";
1696 run_scp_mod
"$tmpdir/$modtar", "/tmp" or
1697 dodie
"failed to copy modules";
1699 unlink "$tmpdir/$modtar";
1701 run_ssh
"'(cd / && tar xjf /tmp/$modtar)'" or
1702 dodie
"failed to tar modules";
1704 run_ssh
"rm -f /tmp/$modtar";
1710 # get the release name
1711 return if ($have_version);
1712 doprint
"$make kernelrelease ... ";
1713 $version = `$make kernelrelease | tail -1`;
1715 doprint
"$version\n";
1719 sub start_monitor_and_boot
{
1720 # Make sure the stable kernel has finished booting
1733 sub check_buildlog
{
1736 my @files = `git show $patch | diffstat -l`;
1738 open(IN
, "git show $patch |") or
1739 dodie
"failed to show $patch";
1741 if (m
,^--- a
/(.*),) {
1743 $files[$#files] = $1;
1748 open(IN
, $buildlog) or dodie
"Can't open $buildlog";
1750 if (/^\s*(.*?):.*(warning|error)/) {
1752 foreach my $file (@files) {
1753 my $fullpath = "$builddir/$file";
1754 if ($file eq $err || $fullpath eq $err) {
1755 fail
"$file built with warnings" and return 0;
1765 sub apply_min_config
{
1766 my $outconfig = "$output_config.new";
1768 # Read the config file and remove anything that
1769 # is in the force_config hash (from minconfig and others)
1770 # then add the force config back.
1772 doprint
"Applying minimum configurations into $output_config.new\n";
1774 open (OUT
, ">$outconfig") or
1775 dodie
"Can't create $outconfig";
1777 if (-f
$output_config) {
1778 open (IN
, $output_config) or
1779 dodie
"Failed to open $output_config";
1781 if (/^(# )?(CONFIG_[^\s=]*)/) {
1782 next if (defined($force_config{$2}));
1788 foreach my $config (keys %force_config) {
1789 print OUT
"$force_config{$config}\n";
1793 run_command
"mv $outconfig $output_config";
1796 sub make_oldconfig
{
1798 my @force_list = keys %force_config;
1800 if ($#force_list >= 0) {
1804 if (!run_command
"$make oldnoconfig") {
1805 # Perhaps oldnoconfig doesn't exist in this version of the kernel
1806 # try a yes '' | oldconfig
1807 doprint
"oldnoconfig failed, trying yes '' | make oldconfig\n";
1808 run_command
"yes '' | $make oldconfig" or
1809 dodie
"failed make config oldconfig";
1813 # read a config file and use this to force new configs.
1814 sub load_force_config
{
1817 open(IN
, $config) or
1818 dodie
"failed to read $config";
1821 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
1822 $force_config{$1} = $_;
1823 } elsif (/^# (CONFIG_\S*) is not set/) {
1824 $force_config{$1} = $_;
1835 # Failed builds should not reboot the target
1836 my $save_no_reboot = $no_reboot;
1839 # Calculate a new version from here.
1842 if (defined($pre_build)) {
1843 my $ret = run_command
$pre_build;
1844 if (!$ret && defined($pre_build_die) &&
1846 dodie
"failed to pre_build\n";
1850 if ($type =~ /^useconfig:(.*)/) {
1851 run_command
"cp $1 $output_config" or
1852 dodie
"could not copy $1 to .config";
1854 $type = "oldconfig";
1857 # old config can ask questions
1858 if ($type eq "oldconfig") {
1859 $type = "oldnoconfig";
1861 # allow for empty configs
1862 run_command
"touch $output_config";
1865 run_command
"mv $output_config $outputdir/config_temp" or
1866 dodie
"moving .config";
1868 run_command
"$make mrproper" or dodie
"make mrproper";
1870 run_command
"mv $outputdir/config_temp $output_config" or
1871 dodie
"moving config_temp";
1874 } elsif (!$noclean) {
1875 unlink "$output_config";
1876 run_command
"$make mrproper" or
1877 dodie
"make mrproper";
1880 # add something to distinguish this build
1881 open(OUT
, "> $outputdir/localversion") or dodie
("Can't make localversion file");
1882 print OUT
"$localversion\n";
1885 if (defined($minconfig)) {
1886 load_force_config
($minconfig);
1889 if ($type ne "oldnoconfig") {
1890 run_command
"$make $type" or
1891 dodie
"failed make config";
1893 # Run old config regardless, to enforce min configurations
1896 $redirect = "$buildlog";
1897 my $build_ret = run_command
"$make $build_options";
1900 if (defined($post_build)) {
1901 # Because a post build may change the kernel version
1904 my $ret = run_command
$post_build;
1905 if (!$ret && defined($post_build_die) &&
1907 dodie
"failed to post_build\n";
1912 # bisect may need this to pass
1914 $no_reboot = $save_no_reboot;
1917 fail
"failed build" and return 0;
1920 $no_reboot = $save_no_reboot;
1926 if (!run_ssh
"halt" or defined($power_off)) {
1927 if (defined($poweroff_after_halt)) {
1928 sleep $poweroff_after_halt;
1929 run_command
"$power_off";
1933 run_command
"$power_off";
1944 if (defined($test_name)) {
1945 $name = " ($test_name)";
1948 doprint
"\n\n*******************************************\n";
1949 doprint
"*******************************************\n";
1950 doprint
"KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
1951 doprint
"*******************************************\n";
1952 doprint
"*******************************************\n";
1954 if (defined($store_successes)) {
1955 save_logs
"success", $store_successes;
1958 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot
) {
1959 doprint
"Reboot and wait $sleep_time seconds\n";
1960 reboot_to_good
$sleep_time;
1966 doprint
"Pass or fail? [p/f]";
1969 if ($ans eq "p" || $ans eq "P") {
1971 } elsif ($ans eq "f" || $ans eq "F") {
1974 print "Please answer 'P' or 'F'\n";
1979 sub child_run_test
{
1982 # child should have no power
1983 $reboot_on_error = 0;
1984 $poweroff_on_error = 0;
1985 $die_on_failure = 1;
1987 $redirect = "$testlog";
1988 run_command
$run_test or $failed = 1;
1996 sub child_finished
{
2009 doprint
"run test $run_test\n";
2013 $SIG{CHLD
} = qw(child_finished);
2017 child_run_test
if (!$child_pid);
2022 $line = wait_for_input
($monitor_fp, 1);
2023 if (defined($line)) {
2025 # we are not guaranteed to get a full line
2026 $full_line .= $line;
2029 if ($full_line =~ /call trace:/i) {
2033 if ($full_line =~ /Kernel panic -/) {
2037 if ($line =~ /\n/) {
2041 } while (!$child_done && !$bug);
2044 my $failure_start = time;
2047 $line = wait_for_input
($monitor_fp, 1);
2048 if (defined($line)) {
2052 if ($now - $failure_start >= $stop_after_failure) {
2055 } while (defined($line));
2057 doprint
"Detected kernel crash!\n";
2058 # kill the child with extreme prejudice
2062 waitpid $child_pid, 0;
2065 if (!$bug && $in_bisect) {
2066 if (defined($bisect_ret_good)) {
2067 if ($child_exit == $bisect_ret_good) {
2071 if (defined($bisect_ret_skip)) {
2072 if ($child_exit == $bisect_ret_skip) {
2076 if (defined($bisect_ret_abort)) {
2077 if ($child_exit == $bisect_ret_abort) {
2078 fail
"test abort" and return -2;
2081 if (defined($bisect_ret_bad)) {
2082 if ($child_exit == $bisect_ret_skip) {
2086 if (defined($bisect_ret_default)) {
2087 if ($bisect_ret_default eq "good") {
2089 } elsif ($bisect_ret_default eq "bad") {
2091 } elsif ($bisect_ret_default eq "skip") {
2093 } elsif ($bisect_ret_default eq "abort") {
2096 fail
"unknown default action: $bisect_ret_default"
2102 if ($bug || $child_exit) {
2103 return 0 if $in_bisect;
2104 fail
"test failed" and return 0;
2109 sub run_git_bisect
{
2112 doprint
"$command ... ";
2114 my $output = `$command 2>&1`;
2121 dodie
"Failed to git bisect";
2124 doprint
"SUCCESS\n";
2125 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
2126 doprint
"$1 [$2]\n";
2127 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
2128 $bisect_bad_commit = $1;
2129 doprint
"Found bad commit... $1\n";
2132 # we already logged it, just print it now.
2140 doprint
"Reboot and sleep $bisect_sleep_time seconds\n";
2141 reboot_to_good
$bisect_sleep_time;
2144 # returns 1 on success, 0 on failure, -1 on skip
2145 sub run_bisect_test
{
2146 my ($type, $buildtype) = @_;
2155 build
$buildtype or $failed = 1;
2157 if ($type ne "build") {
2158 if ($failed && $bisect_skip) {
2162 dodie
"Failed on build" if $failed;
2165 start_monitor_and_boot
or $failed = 1;
2167 if ($type ne "boot") {
2168 if ($failed && $bisect_skip) {
2174 dodie
"Failed on boot" if $failed;
2176 do_run_test
or $failed = 1;
2187 # reboot the box to a kernel we can ssh to
2188 if ($type ne "build") {
2198 my $buildtype = "oldconfig";
2200 # We should have a minconfig to use?
2201 if (defined($minconfig)) {
2202 $buildtype = "useconfig:$minconfig";
2205 my $ret = run_bisect_test
$type, $buildtype;
2207 if ($bisect_manual) {
2208 $ret = answer_bisect
;
2211 # Are we looking for where it worked, not failed?
2212 if ($reverse_bisect && $ret >= 0) {
2218 } elsif ($ret == 0) {
2220 } elsif ($bisect_skip) {
2221 doprint
"HIT A BAD COMMIT ... SKIPPING\n";
2226 sub update_bisect_replay
{
2227 my $tmp_log = "$tmpdir/ktest_bisect_log";
2228 run_command
"git bisect log > $tmp_log" or
2229 die "can't create bisect log";
2238 die "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good));
2239 die "BISECT_BAD[$i] not defined\n" if (!defined($bisect_bad));
2240 die "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type));
2242 my $good = $bisect_good;
2243 my $bad = $bisect_bad;
2244 my $type = $bisect_type;
2245 my $start = $bisect_start;
2246 my $replay = $bisect_replay;
2247 my $start_files = $bisect_files;
2249 if (defined($start_files)) {
2250 $start_files = " -- " . $start_files;
2255 # convert to true sha1's
2256 $good = get_sha1
($good);
2257 $bad = get_sha1
($bad);
2259 if (defined($bisect_reverse) && $bisect_reverse == 1) {
2260 doprint
"Performing a reverse bisect (bad is good, good is bad!)\n";
2261 $reverse_bisect = 1;
2263 $reverse_bisect = 0;
2266 # Can't have a test without having a test to run
2267 if ($type eq "test" && !defined($run_test)) {
2271 # Check if a bisect was running
2272 my $bisect_start_file = "$builddir/.git/BISECT_START";
2274 my $check = $bisect_check;
2275 my $do_check = defined($check) && $check ne "0";
2277 if ( -f
$bisect_start_file ) {
2278 print "Bisect in progress found\n";
2280 print " If you say yes, then no checks of good or bad will be done\n";
2282 if (defined($replay)) {
2283 print "** BISECT_REPLAY is defined in config file **";
2284 print " Ignore config option and perform new git bisect log?\n";
2285 if (read_ync
" (yes, no, or cancel) ") {
2286 $replay = update_bisect_replay
;
2289 } elsif (read_yn
"read git log and continue?") {
2290 $replay = update_bisect_replay
;
2298 my $head = get_sha1
("HEAD");
2300 if ($check ne "good") {
2301 doprint
"TESTING BISECT BAD [$bad]\n";
2302 run_command
"git checkout $bad" or
2303 die "Failed to checkout $bad";
2305 $result = run_bisect
$type;
2307 if ($result ne "bad") {
2308 fail
"Tested BISECT_BAD [$bad] and it succeeded" and return 0;
2312 if ($check ne "bad") {
2313 doprint
"TESTING BISECT GOOD [$good]\n";
2314 run_command
"git checkout $good" or
2315 die "Failed to checkout $good";
2317 $result = run_bisect
$type;
2319 if ($result ne "good") {
2320 fail
"Tested BISECT_GOOD [$good] and it failed" and return 0;
2324 # checkout where we started
2325 run_command
"git checkout $head" or
2326 die "Failed to checkout $head";
2329 run_command
"git bisect start$start_files" or
2330 dodie
"could not start bisect";
2332 run_command
"git bisect good $good" or
2333 dodie
"could not set bisect good to $good";
2335 run_git_bisect
"git bisect bad $bad" or
2336 dodie
"could not set bisect bad to $bad";
2338 if (defined($replay)) {
2339 run_command
"git bisect replay $replay" or
2340 dodie
"failed to run replay";
2343 if (defined($start)) {
2344 run_command
"git checkout $start" or
2345 dodie
"failed to checkout $start";
2350 $result = run_bisect
$type;
2351 $test = run_git_bisect
"git bisect $result";
2354 run_command
"git bisect log" or
2355 dodie
"could not capture git bisect log";
2357 run_command
"git bisect reset" or
2358 dodie
"could not reset git bisect";
2360 doprint
"Bad commit was [$bisect_bad_commit]\n";
2373 sub assign_configs
{
2374 my ($hash, $config) = @_;
2377 or dodie
"Failed to read $config";
2380 if (/^((CONFIG\S*)=.*)/) {
2388 sub process_config_ignore
{
2391 assign_configs \
%config_ignore, $config;
2394 sub read_current_config
{
2395 my ($config_ref) = @_;
2397 %{$config_ref} = ();
2398 undef %{$config_ref};
2400 my @key = keys %{$config_ref};
2402 print "did not delete!\n";
2405 open (IN
, "$output_config");
2408 if (/^(CONFIG\S+)=(.*)/) {
2409 ${$config_ref}{$1} = $2;
2415 sub get_dependencies
{
2418 my $arr = $dependency{$config};
2419 if (!defined($arr)) {
2425 foreach my $dep (@
{$arr}) {
2426 print "ADD DEP $dep\n";
2427 @deps = (@deps, get_dependencies
$dep);
2436 open(OUT
, ">$output_config") or dodie
"Can not write to $output_config";
2438 foreach my $config (@configs) {
2439 print OUT
"$config_set{$config}\n";
2440 my @deps = get_dependencies
$config;
2441 foreach my $dep (@deps) {
2442 print OUT
"$config_set{$dep}\n";
2446 foreach my $config (keys %config_ignore) {
2447 print OUT
"$config_ignore{$config}\n";
2455 sub compare_configs
{
2458 foreach my $item (keys %a) {
2459 if (!defined($b{$item})) {
2460 print "diff $item\n";
2468 print "diff2 $keys[0]\n";
2470 return -1 if ($#keys >= 0);
2475 sub run_config_bisect_test
{
2478 return run_bisect_test
$type, "oldconfig";
2481 sub process_passed
{
2484 doprint
"These configs had no failure: (Enabling them for further compiles)\n";
2485 # Passed! All these configs are part of a good compile.
2486 # Add them to the min options.
2487 foreach my $config (keys %configs) {
2488 if (defined($config_list{$config})) {
2489 doprint
" removing $config\n";
2490 $config_ignore{$config} = $config_list{$config};
2491 delete $config_list{$config};
2494 doprint
"config copied to $outputdir/config_good\n";
2495 run_command
"cp -f $output_config $outputdir/config_good";
2498 sub process_failed
{
2501 doprint
"\n\n***************************************\n";
2502 doprint
"Found bad config: $config\n";
2503 doprint
"***************************************\n\n";
2506 sub run_config_bisect
{
2508 my @start_list = keys %config_list;
2510 if ($#start_list < 0) {
2511 doprint
"No more configs to test!!!\n";
2515 doprint
"***** RUN TEST ***\n";
2516 my $type = $config_bisect_type;
2520 my $count = $#start_list + 1;
2521 doprint
" $count configs to test\n";
2523 my $half = int($#start_list / 2);
2526 my @tophalf = @start_list[0 .. $half];
2528 create_config
@tophalf;
2529 read_current_config \
%current_config;
2531 $count = $#tophalf + 1;
2532 doprint
"Testing $count configs\n";
2534 # make sure we test something
2535 foreach my $config (@tophalf) {
2536 if (defined($current_config{$config})) {
2542 # try the other half
2543 doprint
"Top half produced no set configs, trying bottom half\n";
2544 @tophalf = @start_list[$half + 1 .. $#start_list];
2545 create_config
@tophalf;
2546 read_current_config \
%current_config;
2547 foreach my $config (@tophalf) {
2548 if (defined($current_config{$config})) {
2554 doprint
"Failed: Can't make new config with current configs\n";
2555 foreach my $config (@start_list) {
2556 doprint
" CONFIG: $config\n";
2560 $count = $#tophalf + 1;
2561 doprint
"Testing $count configs\n";
2564 $ret = run_config_bisect_test
$type;
2565 if ($bisect_manual) {
2566 $ret = answer_bisect
;
2569 process_passed
%current_config;
2573 doprint
"This config had a failure.\n";
2574 doprint
"Removing these configs that were not set in this config:\n";
2575 doprint
"config copied to $outputdir/config_bad\n";
2576 run_command
"cp -f $output_config $outputdir/config_bad";
2578 # A config exists in this group that was bad.
2579 foreach my $config (keys %config_list) {
2580 if (!defined($current_config{$config})) {
2581 doprint
" removing $config\n";
2582 delete $config_list{$config};
2586 @start_list = @tophalf;
2588 if ($#start_list == 0) {
2589 process_failed
$start_list[0];
2593 # remove half the configs we are looking at and see if
2595 $half = int($#start_list / 2);
2596 } while ($#start_list > 0);
2598 # we found a single config, try it again unless we are running manually
2600 if ($bisect_manual) {
2601 process_failed
$start_list[0];
2605 my @tophalf = @start_list[0 .. 0];
2607 $ret = run_config_bisect_test
$type;
2609 process_passed
%current_config;
2613 process_failed
$start_list[0];
2620 my $start_config = $config_bisect;
2622 my $tmpconfig = "$tmpdir/use_config";
2624 if (defined($config_bisect_good)) {
2625 process_config_ignore
$config_bisect_good;
2628 # Make the file with the bad config and the min config
2629 if (defined($minconfig)) {
2630 # read the min config for things to ignore
2631 run_command
"cp $minconfig $tmpconfig" or
2632 dodie
"failed to copy $minconfig to $tmpconfig";
2637 if (-f
$tmpconfig) {
2638 load_force_config
($tmpconfig);
2639 process_config_ignore
$tmpconfig;
2642 # now process the start config
2643 run_command
"cp $start_config $output_config" or
2644 dodie
"failed to copy $start_config to $output_config";
2646 # read directly what we want to check
2648 open (IN
, $output_config)
2649 or dodie
"failed to open $output_config";
2652 if (/^((CONFIG\S*)=.*)/) {
2653 $config_check{$2} = $1;
2658 # Now run oldconfig with the minconfig
2661 # check to see what we lost (or gained)
2662 open (IN
, $output_config)
2663 or dodie
"Failed to read $start_config";
2665 my %removed_configs;
2669 if (/^((CONFIG\S*)=.*)/) {
2670 # save off all options
2671 $config_set{$2} = $1;
2672 if (defined($config_check{$2})) {
2673 if (defined($config_ignore{$2})) {
2674 $removed_configs{$2} = $1;
2676 $config_list{$2} = $1;
2678 } elsif (!defined($config_ignore{$2})) {
2679 $added_configs{$2} = $1;
2680 $config_list{$2} = $1;
2686 my @confs = keys %removed_configs;
2688 doprint
"Configs overridden by default configs and removed from check:\n";
2689 foreach my $config (@confs) {
2690 doprint
" $config\n";
2693 @confs = keys %added_configs;
2695 doprint
"Configs appearing in make oldconfig and added:\n";
2696 foreach my $config (@confs) {
2697 doprint
" $config\n";
2704 # Sometimes kconfig does weird things. We must make sure
2705 # that the config we autocreate has everything we need
2706 # to test, otherwise we may miss testing configs, or
2707 # may not be able to create a new config.
2708 # Here we create a config with everything set.
2709 create_config
(keys %config_list);
2710 read_current_config \
%config_test;
2711 foreach my $config (keys %config_list) {
2712 if (!defined($config_test{$config})) {
2715 doprint
"Configs not produced by kconfig (will not be checked):\n";
2717 doprint
" $config\n";
2718 delete $config_list{$config};
2723 $ret = run_config_bisect
;
2726 return $ret if ($ret < 0);
2731 sub patchcheck_reboot
{
2732 doprint
"Reboot and sleep $patchcheck_sleep_time seconds\n";
2733 reboot_to_good
$patchcheck_sleep_time;
2739 die "PATCHCHECK_START[$i] not defined\n"
2740 if (!defined($patchcheck_start));
2741 die "PATCHCHECK_TYPE[$i] not defined\n"
2742 if (!defined($patchcheck_type));
2744 my $start = $patchcheck_start;
2747 if (defined($patchcheck_end)) {
2748 $end = $patchcheck_end;
2751 # Get the true sha1's since we can use things like HEAD~3
2752 $start = get_sha1
($start);
2753 $end = get_sha1
($end);
2755 my $type = $patchcheck_type;
2757 # Can't have a test without having a test to run
2758 if ($type eq "test" && !defined($run_test)) {
2762 open (IN
, "git log --pretty=oneline $end|") or
2763 dodie
"could not get git list";
2769 $list[$#list+1] = $_;
2770 last if (/^$start/);
2774 if ($list[$#list] !~ /^$start/) {
2775 fail
"SHA1 $start not found";
2778 # go backwards in the list
2779 @list = reverse @list;
2781 my $save_clean = $noclean;
2782 my %ignored_warnings;
2784 if (defined($ignore_warnings)) {
2785 foreach my $sha1 (split /\s+/, $ignore_warnings) {
2786 $ignored_warnings{$sha1} = 1;
2791 foreach my $item (@list) {
2793 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
2795 doprint
"\nProcessing commit $item\n\n";
2797 run_command
"git checkout $sha1" or
2798 die "Failed to checkout $sha1";
2800 # only clean on the first and last patch
2801 if ($item eq $list[0] ||
2802 $item eq $list[$#list]) {
2803 $noclean = $save_clean;
2808 if (defined($minconfig)) {
2809 build
"useconfig:$minconfig" or return 0;
2811 # ?? no config to use?
2812 build
"oldconfig" or return 0;
2816 if (!defined($ignored_warnings{$sha1})) {
2817 check_buildlog
$sha1 or return 0;
2820 next if ($type eq "build");
2824 start_monitor_and_boot
or $failed = 1;
2826 if (!$failed && $type ne "boot"){
2827 do_run_test
or $failed = 1;
2830 return 0 if ($failed);
2850 # $config depends on $dep
2851 my ($config, $dep) = @_;
2853 if (defined($depends{$config})) {
2854 $depends{$config} .= " " . $dep;
2856 $depends{$config} = $dep;
2859 # record the number of configs depending on $dep
2860 if (defined $depcount{$dep}) {
2863 $depcount{$dep} = 1;
2867 # taken from streamline_config.pl
2879 if (! -f
$kconfig) {
2880 doprint
"file $kconfig does not exist, skipping\n";
2884 open(KIN
, "$kconfig")
2885 or die "Can't open $kconfig";
2889 # Make sure that lines ending with \ continue
2891 $_ = $line . " " . $_;
2902 # collect any Kconfig sources
2903 if (/^source\s*"(.*)"/) {
2904 $kconfigs[$#kconfigs+1] = $1;
2908 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
2912 for (my $i = 0; $i < $iflevel; $i++) {
2913 add_dep
$config, $ifdeps[$i];
2916 # collect the depends for the config
2917 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
2919 add_dep
$config, $1;
2921 # Get the configs that select this config
2922 } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {
2924 # selected by depends on config
2925 add_dep
$1, $config;
2927 # Check for if statements
2928 } elsif (/^if\s+(.*\S)\s*$/) {
2930 # remove beginning and ending non text
2931 $deps =~ s/^[^a-zA-Z0-9_]*//;
2932 $deps =~ s/[^a-zA-Z0-9_]*$//;
2934 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
2936 $ifdeps[$iflevel++] = join ':', @deps;
2938 } elsif (/^endif/) {
2940 $iflevel-- if ($iflevel);
2943 } elsif (/^\s*help\s*$/) {
2949 # read in any configs that were found.
2950 foreach $kconfig (@kconfigs) {
2951 if (!defined($read_kconfigs{$kconfig})) {
2952 $read_kconfigs{$kconfig} = 1;
2953 read_kconfig
("$builddir/$kconfig");
2959 # find out which arch this is by the kconfig file
2960 open (IN
, $output_config)
2961 or dodie
"Failed to read $output_config";
2964 if (m
,Linux
/(\S
+)\s
+\S
+\s
+Kernel Configuration
,) {
2971 if (!defined($arch)) {
2972 doprint
"Could not find arch from config file\n";
2973 doprint
"no dependencies used\n";
2977 # arch is really the subarch, we need to know
2978 # what directory to look at.
2979 if ($arch eq "i386" || $arch eq "x86_64") {
2981 } elsif ($arch =~ /^tile/) {
2985 my $kconfig = "$builddir/arch/$arch/Kconfig";
2987 if (! -f
$kconfig && $arch =~ /\d$/) {
2989 # some subarchs have numbers, truncate them
2991 $kconfig = "$builddir/arch/$arch/Kconfig";
2992 if (! -f
$kconfig) {
2993 doprint
"No idea what arch dir $orig is for\n";
2994 doprint
"no dependencies used\n";
2999 read_kconfig
($kconfig);
3002 sub read_config_list
{
3006 or dodie
"Failed to read $config";
3009 if (/^((CONFIG\S*)=.*)/) {
3010 if (!defined($config_ignore{$2})) {
3011 $config_list{$2} = $1;
3019 sub read_output_config
{
3022 assign_configs \
%config_ignore, $config;
3025 sub make_new_config
{
3028 open (OUT
, ">$output_config")
3029 or dodie
"Failed to write $output_config";
3031 foreach my $config (@configs) {
3032 print OUT
"$config\n";
3040 $config =~ s/CONFIG_//;
3048 my $kconfig = chomp_config
$dep;
3050 $dep = $depends{"$kconfig"};
3052 # the dep string we have saves the dependencies as they
3053 # were found, including expressions like ! && ||. We
3054 # want to split this out into just an array of configs.
3056 my $valid = "A-Za-z_0-9";
3060 while ($dep =~ /[$valid]/) {
3062 if ($dep =~ /^[^$valid]*([$valid]+)/) {
3063 my $conf = "CONFIG_" . $1;
3065 $configs[$#configs + 1] = $conf;
3067 $dep =~ s/^[^$valid]*[$valid]+//;
3069 die "this should never happen";
3079 my %processed_configs;
3080 my %nochange_config;
3082 sub test_this_config
{
3087 # if we already processed this config, skip it
3088 if (defined($processed_configs{$config})) {
3091 $processed_configs{$config} = 1;
3093 # if this config failed during this round, skip it
3094 if (defined($nochange_config{$config})) {
3098 my $kconfig = chomp_config
$config;
3100 # Test dependencies first
3101 if (defined($depends{"$kconfig"})) {
3102 my @parents = get_depends
$config;
3103 foreach my $parent (@parents) {
3104 # if the parent is in the min config, check it first
3105 next if (!defined($min_configs{$parent}));
3106 $found = test_this_config
($parent);
3107 if (defined($found)) {
3113 # Remove this config from the list of configs
3114 # do a make oldnoconfig and then read the resulting
3115 # .config to make sure it is missing the config that
3117 my %configs = %min_configs;
3118 delete $configs{$config};
3119 make_new_config
((values %configs), (values %keep_configs));
3122 assign_configs \
%configs, $output_config;
3124 return $config if (!defined($configs{$config}));
3126 doprint
"disabling config $config did not change .config\n";
3128 $nochange_config{$config} = 1;
3133 sub make_min_config
{
3136 my $type = $minconfig_type;
3137 if ($type ne "boot" && $type ne "test") {
3138 fail
"Invalid MIN_CONFIG_TYPE '$minconfig_type'\n" .
3139 " make_min_config works only with 'boot' and 'test'\n" and return;
3142 if (!defined($output_minconfig)) {
3143 fail
"OUTPUT_MIN_CONFIG not defined" and return;
3146 # If output_minconfig exists, and the start_minconfig
3147 # came from min_config, than ask if we should use
3149 if (-f
$output_minconfig && !$start_minconfig_defined) {
3150 print "$output_minconfig exists\n";
3151 if (!defined($use_output_minconfig)) {
3152 if (read_yn
" Use it as minconfig?") {
3153 $start_minconfig = $output_minconfig;
3155 } elsif ($use_output_minconfig > 0) {
3156 doprint
"Using $output_minconfig as MIN_CONFIG\n";
3157 $start_minconfig = $output_minconfig;
3159 doprint
"Set to still use MIN_CONFIG as starting point\n";
3163 if (!defined($start_minconfig)) {
3164 fail
"START_MIN_CONFIG or MIN_CONFIG not defined" and return;
3167 my $temp_config = "$tmpdir/temp_config";
3169 # First things first. We build an allnoconfig to find
3170 # out what the defaults are that we can't touch.
3171 # Some are selections, but we really can't handle selections.
3173 my $save_minconfig = $minconfig;
3176 run_command
"$make allnoconfig" or return 0;
3180 process_config_ignore
$output_config;
3182 undef %save_configs;
3185 if (defined($ignore_config)) {
3186 # make sure the file exists
3187 `touch $ignore_config`;
3188 assign_configs \
%save_configs, $ignore_config;
3191 %keep_configs = %save_configs;
3193 doprint
"Load initial configs from $start_minconfig\n";
3195 # Look at the current min configs, and save off all the
3196 # ones that were set via the allnoconfig
3197 assign_configs \
%min_configs, $start_minconfig;
3199 my @config_keys = keys %min_configs;
3201 # All configs need a depcount
3202 foreach my $config (@config_keys) {
3203 my $kconfig = chomp_config
$config;
3204 if (!defined $depcount{$kconfig}) {
3205 $depcount{$kconfig} = 0;
3209 # Remove anything that was set by the make allnoconfig
3210 # we shouldn't need them as they get set for us anyway.
3211 foreach my $config (@config_keys) {
3212 # Remove anything in the ignore_config
3213 if (defined($keep_configs{$config})) {
3214 my $file = $ignore_config;
3215 $file =~ s
,.*/(.*?
)$,$1,;
3216 doprint
"$config set by $file ... ignored\n";
3217 delete $min_configs{$config};
3220 # But make sure the settings are the same. If a min config
3221 # sets a selection, we do not want to get rid of it if
3222 # it is not the same as what we have. Just move it into
3224 if (defined($config_ignore{$config})) {
3225 if ($config_ignore{$config} ne $min_configs{$config}) {
3226 doprint
"$config is in allnoconfig as '$config_ignore{$config}'";
3227 doprint
" but it is '$min_configs{$config}' in minconfig .. keeping\n";
3228 $keep_configs{$config} = $min_configs{$config};
3230 doprint
"$config set by allnoconfig ... ignored\n";
3232 delete $min_configs{$config};
3244 # Now disable each config one by one and do a make oldconfig
3245 # till we find a config that changes our list.
3247 my @test_configs = keys %min_configs;
3249 # Sort keys by who is most dependent on
3250 @test_configs = sort { $depcount{chomp_config
($b)} <=> $depcount{chomp_config
($a)} }
3253 # Put configs that did not modify the config at the end.
3255 for (my $i = 0; $i < $#test_configs; $i++) {
3256 if (!defined($nochange_config{$test_configs[0]})) {
3260 # This config didn't change the .config last time.
3261 # Place it at the end
3262 my $config = shift @test_configs;
3263 push @test_configs, $config;
3266 # if every test config has failed to modify the .config file
3267 # in the past, then reset and start over.
3269 undef %nochange_config;
3272 undef %processed_configs;
3274 foreach my $config (@test_configs) {
3276 $found = test_this_config
$config;
3278 last if (defined($found));
3280 # oh well, try another config
3283 if (!defined($found)) {
3284 # we could have failed due to the nochange_config hash
3285 # reset and try again
3287 undef %nochange_config;
3291 doprint
"No more configs found that we can disable\n";
3299 doprint
"Test with $config disabled\n";
3301 # set in_bisect to keep build and monitor from dieing
3305 build
"oldconfig" or $failed = 1;
3307 start_monitor_and_boot
or $failed = 1;
3309 if ($type eq "test" && !$failed) {
3310 do_run_test
or $failed = 1;
3319 doprint
"$min_configs{$config} is needed to boot the box... keeping\n";
3320 # this config is needed, add it to the ignore list.
3321 $keep_configs{$config} = $min_configs{$config};
3322 $save_configs{$config} = $min_configs{$config};
3323 delete $min_configs{$config};
3325 # update new ignore configs
3326 if (defined($ignore_config)) {
3327 open (OUT
, ">$temp_config")
3328 or die "Can't write to $temp_config";
3329 foreach my $config (keys %save_configs) {
3330 print OUT
"$save_configs{$config}\n";
3333 run_command
"mv $temp_config $ignore_config" or
3334 dodie
"failed to copy update to $ignore_config";
3338 # We booted without this config, remove it from the minconfigs.
3339 doprint
"$config is not needed, disabling\n";
3341 delete $min_configs{$config};
3343 # Also disable anything that is not enabled in this config
3345 assign_configs \
%configs, $output_config;
3346 my @config_keys = keys %min_configs;
3347 foreach my $config (@config_keys) {
3348 if (!defined($configs{$config})) {
3349 doprint
"$config is not set, disabling\n";
3350 delete $min_configs{$config};
3354 # Save off all the current mandidory configs
3355 open (OUT
, ">$temp_config")
3356 or die "Can't write to $temp_config";
3357 foreach my $config (keys %keep_configs) {
3358 print OUT
"$keep_configs{$config}\n";
3360 foreach my $config (keys %min_configs) {
3361 print OUT
"$min_configs{$config}\n";
3365 run_command
"mv $temp_config $output_minconfig" or
3366 dodie
"failed to copy update to $output_minconfig";
3369 doprint
"Reboot and wait $sleep_time seconds\n";
3370 reboot_to_good
$sleep_time;
3377 $#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl config-file\n";
3380 $ktest_config = $ARGV[0];
3381 if (! -f
$ktest_config) {
3382 print "$ktest_config does not exist.\n";
3383 if (!read_yn
"Create it?") {
3388 $ktest_config = "ktest.conf";
3391 if (! -f
$ktest_config) {
3394 open(OUT
, ">$ktest_config") or die "Can not create $ktest_config";
3396 # Generated by ktest.pl
3399 # PWD is a ktest.pl variable that will result in the process working
3400 # directory that ktest.pl is executed in.
3402 # THIS_DIR is automatically assigned the PWD of the path that generated
3403 # the config file. It is best to use this variable when assigning other
3404 # directory paths within this directory. This allows you to easily
3405 # move the test cases to other locations or to other machines.
3407 THIS_DIR
:= $variable{"PWD"}
3409 # Define each test with TEST_START
3410 # The config options below it will override the defaults
3412 TEST_TYPE
= $default{"TEST_TYPE"}
3419 read_config
$ktest_config;
3421 if (defined($opt{"LOG_FILE"})) {
3422 $opt{"LOG_FILE"} = eval_option
($opt{"LOG_FILE"}, -1);
3425 # Append any configs entered in manually to the config file.
3426 my @new_configs = keys %entered_configs;
3427 if ($#new_configs >= 0) {
3428 print "\nAppending entered in configs to $ktest_config\n";
3429 open(OUT
, ">>$ktest_config") or die "Can not append to $ktest_config";
3430 foreach my $config (@new_configs) {
3431 print OUT
"$config = $entered_configs{$config}\n";
3432 $opt{$config} = process_variables
($entered_configs{$config});
3436 if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
3437 unlink $opt{"LOG_FILE"};
3440 doprint
"\n\nSTARTING AUTOMATED TESTS\n\n";
3442 for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
3445 doprint
"DEFAULT OPTIONS:\n";
3447 doprint
"\nTEST $i OPTIONS";
3448 if (defined($repeat_tests{$i})) {
3449 $repeat = $repeat_tests{$i};
3450 doprint
" ITERATE $repeat";
3455 foreach my $option (sort keys %opt) {
3457 if ($option =~ /\[(\d+)\]$/) {
3463 doprint
"$option = $opt{$option}\n";
3467 sub __set_test_option
{
3468 my ($name, $i) = @_;
3470 my $option = "$name\[$i\]";
3472 if (defined($opt{$option})) {
3473 return $opt{$option};
3476 foreach my $test (keys %repeat_tests) {
3478 $i < $test + $repeat_tests{$test}) {
3479 $option = "$name\[$test\]";
3480 if (defined($opt{$option})) {
3481 return $opt{$option};
3486 if (defined($opt{$name})) {
3493 sub set_test_option
{
3494 my ($name, $i) = @_;
3496 my $option = __set_test_option
($name, $i);
3497 return $option if (!defined($option));
3499 return eval_option
($option, $i);
3502 # First we need to do is the builds
3503 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
3505 # Do not reboot on failing test options
3507 $reboot_success = 0;
3513 my $makecmd = set_test_option
("MAKE_CMD", $i);
3515 # Load all the options into their mapped variable names
3516 foreach my $opt (keys %option_map) {
3517 ${$option_map{$opt}} = set_test_option
($opt, $i);
3520 $start_minconfig_defined = 1;
3522 if (!defined($start_minconfig)) {
3523 $start_minconfig_defined = 0;
3524 $start_minconfig = $minconfig;
3527 chdir $builddir || die "can't change directory to $builddir";
3529 foreach my $dir ($tmpdir, $outputdir) {
3532 die "can't create $dir";
3536 $ENV{"SSH_USER"} = $ssh_user;
3537 $ENV{"MACHINE"} = $machine;
3539 $buildlog = "$tmpdir/buildlog-$machine";
3540 $testlog = "$tmpdir/testlog-$machine";
3541 $dmesg = "$tmpdir/dmesg-$machine";
3542 $make = "$makecmd O=$outputdir";
3543 $output_config = "$outputdir/.config";
3546 $target = "$ssh_user\@$machine";
3547 if ($reboot_type eq "grub") {
3548 dodie
"GRUB_MENU not defined" if (!defined($grub_menu));
3552 my $run_type = $build_type;
3553 if ($test_type eq "patchcheck") {
3554 $run_type = $patchcheck_type;
3555 } elsif ($test_type eq "bisect") {
3556 $run_type = $bisect_type;
3557 } elsif ($test_type eq "config_bisect") {
3558 $run_type = $config_bisect_type;
3561 if ($test_type eq "make_min_config") {
3565 # mistake in config file?
3566 if (!defined($run_type)) {
3567 $run_type = "ERROR";
3571 $installme = " no_install" if ($no_install);
3574 doprint
"RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type$installme\n\n";
3580 if (defined($addconfig)) {
3581 my $min = $minconfig;
3582 if (!defined($minconfig)) {
3585 run_command
"cat $addconfig $min > $tmpdir/add_config" or
3586 dodie
"Failed to create temp config";
3587 $minconfig = "$tmpdir/add_config";
3590 if (defined($checkout)) {
3591 run_command
"git checkout $checkout" or
3592 die "failed to checkout $checkout";
3597 # A test may opt to not reboot the box
3598 if ($reboot_on_success) {
3599 $reboot_success = 1;
3602 if ($test_type eq "bisect") {
3605 } elsif ($test_type eq "config_bisect") {
3608 } elsif ($test_type eq "patchcheck") {
3611 } elsif ($test_type eq "make_min_config") {
3616 if ($build_type ne "nobuild") {
3617 build
$build_type or next;
3620 if ($test_type eq "install") {
3627 if ($test_type ne "build") {
3629 start_monitor_and_boot
or $failed = 1;
3631 if (!$failed && $test_type ne "boot" && defined($run_test)) {
3632 do_run_test
or $failed = 1;
3641 if ($opt{"POWEROFF_ON_SUCCESS"}) {
3643 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot
&& $reboot_success) {
3645 } elsif (defined($switch_to_good)) {
3646 # still need to get to the good kernel
3647 run_command
$switch_to_good;
3651 doprint
"\n $successes of $opt{NUM_TESTS} tests were successful\n\n";