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,
55 "MAX_MONITOR_WAIT" => 1800,
57 # required, and we will ask users if they don't have them but we keep the default
58 # value something that is common.
59 "REBOOT_TYPE" => "grub",
60 "LOCALVERSION" => "-test",
62 "BUILD_TARGET" => "arch/x86/boot/bzImage",
63 "TARGET_IMAGE" => "/boot/vmlinuz-test",
97 my $poweroff_on_error;
98 my $reboot_on_success;
100 my $powercycle_after_reboot;
101 my $poweroff_after_halt;
102 my $max_monitor_wait;
105 my $scp_to_target_install;
117 my $start_minconfig_defined;
118 my $output_minconfig;
120 my $use_output_minconfig;
125 my $bisect_bad_commit = "";
129 my $config_bisect_good;
133 my $bisect_ret_abort;
134 my $bisect_ret_default;
135 my $in_patchcheck = 0;
145 my $bisect_sleep_time;
146 my $patchcheck_sleep_time;
153 my $detect_triplefault;
155 my $reboot_success_line;
157 my $stop_after_success;
158 my $stop_after_failure;
177 my $config_bisect_type;
178 my $config_bisect_check;
181 my $patchcheck_start;
184 # set when a test is something other that just building or install
185 # which would require more options.
188 # set when creating a new config
195 # force_config is the list of configs that we force enabled (or disabled)
196 # in a .config file. The MIN_CONFIG and ADD_CONFIG configs.
199 # do not force reboots on config problems
203 my $reboot_success = 0;
206 "MACHINE" => \$machine,
207 "SSH_USER" => \$ssh_user,
208 "TMP_DIR" => \$tmpdir,
209 "OUTPUT_DIR" => \$outputdir,
210 "BUILD_DIR" => \$builddir,
211 "TEST_TYPE" => \$test_type,
212 "PRE_KTEST" => \$pre_ktest,
213 "POST_KTEST" => \$post_ktest,
214 "PRE_TEST" => \$pre_test,
215 "POST_TEST" => \$post_test,
216 "BUILD_TYPE" => \$build_type,
217 "BUILD_OPTIONS" => \$build_options,
218 "PRE_BUILD" => \$pre_build,
219 "POST_BUILD" => \$post_build,
220 "PRE_BUILD_DIE" => \$pre_build_die,
221 "POST_BUILD_DIE" => \$post_build_die,
222 "POWER_CYCLE" => \$power_cycle,
223 "REBOOT" => \$reboot,
224 "BUILD_NOCLEAN" => \$noclean,
225 "MIN_CONFIG" => \$minconfig,
226 "OUTPUT_MIN_CONFIG" => \$output_minconfig,
227 "START_MIN_CONFIG" => \$start_minconfig,
228 "MIN_CONFIG_TYPE" => \$minconfig_type,
229 "USE_OUTPUT_MIN_CONFIG" => \$use_output_minconfig,
230 "IGNORE_CONFIG" => \$ignore_config,
231 "TEST" => \$run_test,
232 "ADD_CONFIG" => \$addconfig,
233 "REBOOT_TYPE" => \$reboot_type,
234 "GRUB_MENU" => \$grub_menu,
235 "PRE_INSTALL" => \$pre_install,
236 "POST_INSTALL" => \$post_install,
237 "NO_INSTALL" => \$no_install,
238 "REBOOT_SCRIPT" => \$reboot_script,
239 "REBOOT_ON_ERROR" => \$reboot_on_error,
240 "SWITCH_TO_GOOD" => \$switch_to_good,
241 "SWITCH_TO_TEST" => \$switch_to_test,
242 "POWEROFF_ON_ERROR" => \$poweroff_on_error,
243 "REBOOT_ON_SUCCESS" => \$reboot_on_success,
244 "DIE_ON_FAILURE" => \$die_on_failure,
245 "POWER_OFF" => \$power_off,
246 "POWERCYCLE_AFTER_REBOOT" => \$powercycle_after_reboot,
247 "POWEROFF_AFTER_HALT" => \$poweroff_after_halt,
248 "MAX_MONITOR_WAIT" => \$max_monitor_wait,
249 "SLEEP_TIME" => \$sleep_time,
250 "BISECT_SLEEP_TIME" => \$bisect_sleep_time,
251 "PATCHCHECK_SLEEP_TIME" => \$patchcheck_sleep_time,
252 "IGNORE_WARNINGS" => \$ignore_warnings,
253 "IGNORE_ERRORS" => \$ignore_errors,
254 "BISECT_MANUAL" => \$bisect_manual,
255 "BISECT_SKIP" => \$bisect_skip,
256 "CONFIG_BISECT_GOOD" => \$config_bisect_good,
257 "BISECT_RET_GOOD" => \$bisect_ret_good,
258 "BISECT_RET_BAD" => \$bisect_ret_bad,
259 "BISECT_RET_SKIP" => \$bisect_ret_skip,
260 "BISECT_RET_ABORT" => \$bisect_ret_abort,
261 "BISECT_RET_DEFAULT" => \$bisect_ret_default,
262 "STORE_FAILURES" => \$store_failures,
263 "STORE_SUCCESSES" => \$store_successes,
264 "TEST_NAME" => \$test_name,
265 "TIMEOUT" => \$timeout,
266 "BOOTED_TIMEOUT" => \$booted_timeout,
267 "CONSOLE" => \$console,
268 "DETECT_TRIPLE_FAULT" => \$detect_triplefault,
269 "SUCCESS_LINE" => \$success_line,
270 "REBOOT_SUCCESS_LINE" => \$reboot_success_line,
271 "STOP_AFTER_SUCCESS" => \$stop_after_success,
272 "STOP_AFTER_FAILURE" => \$stop_after_failure,
273 "STOP_TEST_AFTER" => \$stop_test_after,
274 "BUILD_TARGET" => \$build_target,
275 "SSH_EXEC" => \$ssh_exec,
276 "SCP_TO_TARGET" => \$scp_to_target,
277 "SCP_TO_TARGET_INSTALL" => \$scp_to_target_install,
278 "CHECKOUT" => \$checkout,
279 "TARGET_IMAGE" => \$target_image,
280 "LOCALVERSION" => \$localversion,
282 "BISECT_GOOD" => \$bisect_good,
283 "BISECT_BAD" => \$bisect_bad,
284 "BISECT_TYPE" => \$bisect_type,
285 "BISECT_START" => \$bisect_start,
286 "BISECT_REPLAY" => \$bisect_replay,
287 "BISECT_FILES" => \$bisect_files,
288 "BISECT_REVERSE" => \$bisect_reverse,
289 "BISECT_CHECK" => \$bisect_check,
291 "CONFIG_BISECT" => \$config_bisect,
292 "CONFIG_BISECT_TYPE" => \$config_bisect_type,
293 "CONFIG_BISECT_CHECK" => \$config_bisect_check,
295 "PATCHCHECK_TYPE" => \$patchcheck_type,
296 "PATCHCHECK_START" => \$patchcheck_start,
297 "PATCHCHECK_END" => \$patchcheck_end,
300 # Options may be used by other options, record them.
303 # default variables that can be used
304 chomp ($variable{"PWD"} = `pwd`);
306 $config_help{"MACHINE"} = << "EOF"
307 The machine hostname that you will test.
308 For build only tests, it is still needed to differentiate log files.
311 $config_help{"SSH_USER"} = << "EOF"
312 The box is expected to have ssh on normal bootup, provide the user
313 (most likely root, since you need privileged operations)
316 $config_help{"BUILD_DIR"} = << "EOF"
317 The directory that contains the Linux source code (full path).
318 You can use \${PWD} that will be the path where ktest.pl is run, or use
319 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
322 $config_help{"OUTPUT_DIR"} = << "EOF"
323 The directory that the objects will be built (full path).
324 (can not be same as BUILD_DIR)
325 You can use \${PWD} that will be the path where ktest.pl is run, or use
326 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
329 $config_help{"BUILD_TARGET"} = << "EOF"
330 The location of the compiled file to copy to the target.
331 (relative to OUTPUT_DIR)
334 $config_help{"BUILD_OPTIONS"} = << "EOF"
335 Options to add to \"make\" when building.
339 $config_help{"TARGET_IMAGE"} = << "EOF"
340 The place to put your image on the test machine.
343 $config_help{"POWER_CYCLE"} = << "EOF"
344 A script or command to reboot the box.
346 Here is a digital loggers power switch example
347 POWER_CYCLE = wget --no-proxy -O /dev/null -q --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL'
349 Here is an example to reboot a virtual box on the current host
350 with the name "Guest".
351 POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest
354 $config_help{"CONSOLE"} = << "EOF"
355 The script or command that reads the console
357 If you use ttywatch server, something like the following would work.
358 CONSOLE = nc -d localhost 3001
360 For a virtual machine with guest name "Guest".
361 CONSOLE = virsh console Guest
364 $config_help{"LOCALVERSION"} = << "EOF"
365 Required version ending to differentiate the test
366 from other linux builds on the system.
369 $config_help{"REBOOT_TYPE"} = << "EOF"
370 Way to reboot the box to the test kernel.
371 Only valid options so far are "grub" and "script".
373 If you specify grub, it will assume grub version 1
374 and will search in /boot/grub/menu.lst for the title \$GRUB_MENU
375 and select that target to reboot to the kernel. If this is not
376 your setup, then specify "script" and have a command or script
377 specified in REBOOT_SCRIPT to boot to the target.
379 The entry in /boot/grub/menu.lst must be entered in manually.
380 The test will not modify that file.
383 $config_help{"GRUB_MENU"} = << "EOF"
384 The grub title name for the test kernel to boot
385 (Only mandatory if REBOOT_TYPE = grub)
387 Note, ktest.pl will not update the grub menu.lst, you need to
388 manually add an option for the test. ktest.pl will search
389 the grub menu.lst for this option to find what kernel to
392 For example, if in the /boot/grub/menu.lst the test kernel title has:
395 GRUB_MENU = Test Kernel
398 $config_help{"REBOOT_SCRIPT"} = << "EOF"
399 A script to reboot the target into the test kernel
400 (Only mandatory if REBOOT_TYPE = script)
405 my ($cancel, $prompt) = @_;
411 print "$prompt [y/n/C] ";
413 print "$prompt [Y/n] ";
417 if ($ans =~ /^\s*$/) {
424 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
426 last if ($ans =~ /^c$/i);
427 print "Please answer either 'y', 'n' or 'c'.\n";
429 print "Please answer either 'y' or 'n'.\n";
435 if ($ans !~ /^y$/i) {
444 return read_prompt 0, $prompt;
450 return read_prompt 1, $prompt;
453 sub get_ktest_config {
457 return if (defined($opt{$config}));
459 if (defined($config_help{$config})) {
461 print $config_help{$config};
466 if (defined($default{$config}) && length($default{$config})) {
467 print "\[$default{$config}\] ";
470 $ans =~ s/^\s*(.*\S)\s*$/$1/;
471 if ($ans =~ /^\s*$/) {
472 if ($default{$config}) {
473 $ans = $default{$config};
475 print "Your answer can not be blank\n";
479 $entered_configs{$config} = ${ans};
484 sub get_ktest_configs {
485 get_ktest_config("MACHINE");
486 get_ktest_config("BUILD_DIR");
487 get_ktest_config("OUTPUT_DIR");
490 get_ktest_config("BUILD_OPTIONS");
493 # options required for other than just building a kernel
495 get_ktest_config("POWER_CYCLE");
496 get_ktest_config("CONSOLE");
499 # options required for install and more
500 if ($buildonly != 1) {
501 get_ktest_config("SSH_USER");
502 get_ktest_config("BUILD_TARGET");
503 get_ktest_config("TARGET_IMAGE");
506 get_ktest_config("LOCALVERSION");
508 return if ($buildonly);
510 my $rtype = $opt{"REBOOT_TYPE"};
512 if (!defined($rtype)) {
513 if (!defined($opt{"GRUB_MENU"})) {
514 get_ktest_config("REBOOT_TYPE");
515 $rtype = $entered_configs{"REBOOT_TYPE"};
521 if ($rtype eq "grub") {
522 get_ktest_config("GRUB_MENU");
526 sub process_variables {
527 my ($value, $remove_undef) = @_;
530 # We want to check for '\', and it is just easier
531 # to check the previous characet of '$' and not need
532 # to worry if '$' is the first character. By adding
533 # a space to $value, we can just check [^\\]\$ and
534 # it will still work.
537 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
541 # append beginning of value to retval
542 $retval = "$retval$begin";
543 if (defined($variable{$var})) {
544 $retval = "$retval$variable{$var}";
545 } elsif (defined($remove_undef) && $remove_undef) {
546 # for if statements, any variable that is not defined,
547 # we simple convert to 0
548 $retval = "${retval}0";
550 # put back the origin piece.
551 $retval = "$retval\$\{$var\}";
552 # This could be an option that is used later, save
553 # it so we don't warn if this option is not one of
555 $used_options{$var} = 1;
559 $retval = "$retval$value";
561 # remove the space added in the beginning
568 my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
570 my $prvalue = process_variables($rvalue);
572 if ($buildonly && $lvalue =~ /^TEST_TYPE(\[.*\])?$/ && $prvalue ne "build") {
573 # Note if a test is something other than build, then we
574 # will need other manditory options.
575 if ($prvalue ne "install") {
578 # install still limits some manditory options.
583 if (defined($opt{$lvalue})) {
584 if (!$override || defined(${$overrides}{$lvalue})) {
587 $extra = "In the same override section!\n";
589 die "$name: $.: Option $lvalue defined more than once!\n$extra";
591 ${$overrides}{$lvalue} = $prvalue;
593 if ($rvalue =~ /^\s*$/) {
594 delete $opt{$lvalue};
596 $opt{$lvalue} = $prvalue;
601 my ($lvalue, $rvalue) = @_;
603 if ($rvalue =~ /^\s*$/) {
604 delete $variable{$lvalue};
606 $rvalue = process_variables($rvalue);
607 $variable{$lvalue} = $rvalue;
611 sub process_compare {
612 my ($lval, $cmp, $rval) = @_;
623 return $lval eq $rval;
624 } elsif ($cmp eq "!=") {
625 return $lval ne $rval;
626 } elsif ($cmp eq "=~") {
627 return $lval =~ m/$rval/;
628 } elsif ($cmp eq "!~") {
629 return $lval !~ m/$rval/;
632 my $statement = "$lval $cmp $rval";
633 my $ret = eval $statement;
635 # $@ stores error of eval
646 return defined($variable{$2}) ||
651 sub process_expression {
652 my ($name, $val) = @_;
656 while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
659 if (process_expression($name, $express)) {
660 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
662 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
670 while ($val =~ s/^(.*?)($OR|$AND)//) {
674 if (process_expression($name, $express)) {
685 if ($val =~ /(.*)(==|\!=|>=|<=|>|<|=~|\!~)(.*)/) {
686 my $ret = process_compare($1, $2, $3);
688 die "$name: $.: Unable to process comparison\n";
693 if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
695 return !value_defined($2);
697 return value_defined($2);
701 if ($val =~ /^\s*0\s*$/) {
703 } elsif ($val =~ /^\s*\d+\s*$/) {
707 die ("$name: $.: Undefined content $val in if statement\n");
711 my ($name, $value) = @_;
713 # Convert variables and replace undefined ones with 0
714 my $val = process_variables($value, 1);
715 my $ret = process_expression $name, $val;
721 my ($config, $current_test_num) = @_;
724 open($in, $config) || die "can't read file $config";
727 $name =~ s,.*/(.*),$1,;
729 my $test_num = $$current_test_num;
732 my $num_tests_set = 0;
745 # ignore blank lines and comments
746 next if (/^\s*$/ || /\s*\#/);
748 if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
758 if ($type eq "TEST_START") {
760 if ($num_tests_set) {
761 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
764 $old_test_num = $test_num;
765 $old_repeat = $repeat;
767 $test_num += $repeat;
774 # If SKIP is anywhere in the line, the command will be skipped
775 if ($rest =~ s/\s+SKIP\b//) {
782 if ($rest =~ s/\sELSE\b//) {
784 die "$name: $.: ELSE found with out matching IF section\n$_";
795 if ($rest =~ s/\sIF\s+(.*)//) {
796 if (process_if($name, $1)) {
808 if ($type eq "TEST_START") {
809 if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
811 $repeat_tests{"$test_num"} = $repeat;
813 } elsif ($rest =~ s/\sOVERRIDE\b//) {
816 # Clear previous overrides
821 if (!$skip && $rest !~ /^\s*$/) {
822 die "$name: $.: Gargbage found after $type\n$_";
825 if ($skip && $type eq "TEST_START") {
826 $test_num = $old_test_num;
827 $repeat = $old_repeat;
830 } elsif (/^\s*ELSE\b(.*)$/) {
832 die "$name: $.: ELSE found with out matching IF section\n$_";
841 if ($rest =~ /\sIF\s+(.*)/) {
842 # May be a ELSE IF section.
843 if (!process_if($name, $1)) {
852 if ($rest !~ /^\s*$/) {
853 die "$name: $.: Gargbage found after DEFAULTS\n$_";
856 } elsif (/^\s*INCLUDE\s+(\S+)/) {
861 die "$name: $.: INCLUDE can only be done in default sections\n$_";
864 my $file = process_variables($1);
866 if ($file !~ m,^/,) {
867 # check the path of the config file first
868 if ($config =~ m,(.*)/,) {
876 die "$name: $.: Can't read file $file\n$_";
879 if (__read_config($file, \$test_num)) {
883 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
891 ($lvalue eq "NUM_TESTS" ||
892 $lvalue eq "LOG_FILE" ||
893 $lvalue eq "CLEAR_LOG")) {
894 die "$name: $.: $lvalue must be set in DEFAULTS section\n";
897 if ($lvalue eq "NUM_TESTS") {
899 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
902 die "$name: $.: NUM_TESTS must be set in default section\n";
907 if ($default || $lvalue =~ /\[\d+\]$/) {
908 set_value($lvalue, $rvalue, $override, \%overrides, $name);
910 my $val = "$lvalue\[$test_num\]";
911 set_value($val, $rvalue, $override, \%overrides, $name);
914 $repeats{$val} = $repeat;
917 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
923 # process config variables.
924 # Config variables are only active while reading the
925 # config and can be defined anywhere. They also ignore
926 # TEST_START and DEFAULTS, but are skipped if they are in
927 # on of these sections that have SKIP defined.
928 # The save variable can be
929 # defined multiple times and the new one simply overrides
931 set_variable($lvalue, $rvalue);
934 die "$name: $.: Garbage found in config\n$_";
939 $test_num += $repeat - 1;
940 $opt{"NUM_TESTS"} = $test_num;
945 $$current_test_num = $test_num;
951 print "What test case would you like to run?\n";
952 print " (build, install or boot)\n";
953 print " Other tests are available but require editing the config file\n";
956 $default{"TEST_TYPE"} = $ans;
965 $test_case = __read_config $config, \$test_num;
967 # make sure we have all mandatory configs
970 # was a test specified?
972 print "No test case specified.\n";
978 foreach my $default (keys %default) {
979 if (!defined($opt{$default})) {
980 $opt{$default} = $default{$default};
984 if ($opt{"IGNORE_UNUSED"} == 1) {
990 # check if there are any stragglers (typos?)
991 foreach my $option (keys %opt) {
993 # remove per test labels.
995 if (!exists($option_map{$op}) &&
996 !exists($default{$op}) &&
997 !exists($used_options{$op})) {
1004 $s = " is" if (keys %not_used == 1);
1005 print "The following option$s not used; could be a typo:\n";
1006 foreach my $option (keys %not_used) {
1009 print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";
1010 if (!read_yn "Do you want to continue?") {
1017 my ($option, $i) = @_;
1019 # Add space to evaluate the character before $
1020 $option = " $option";
1025 foreach my $test (keys %repeat_tests) {
1027 $i < $test + $repeat_tests{$test}) {
1035 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
1040 # Append beginning of line
1041 $retval = "$retval$start";
1043 # If the iteration option OPT[$i] exists, then use that.
1044 # otherwise see if the default OPT (without [$i]) exists.
1046 my $o = "$var\[$i\]";
1047 my $parento = "$var\[$parent\]";
1049 if (defined($opt{$o})) {
1051 $retval = "$retval$o";
1052 } elsif ($repeated && defined($opt{$parento})) {
1053 $o = $opt{$parento};
1054 $retval = "$retval$o";
1055 } elsif (defined($opt{$var})) {
1057 $retval = "$retval$o";
1059 $retval = "$retval\$\{$var\}";
1065 $retval = "$retval$option";
1073 my ($option, $i) = @_;
1077 # Since an option can evaluate to another option,
1078 # keep iterating until we do not evaluate any more
1081 while ($prev ne $option) {
1082 # Check for recursive evaluations.
1083 # 100 deep should be more than enough.
1085 die "Over 100 evaluations accurred with $option\n" .
1086 "Check for recursive variables\n";
1089 $option = __eval_option($option, $i);
1096 if (defined($opt{"LOG_FILE"})) {
1097 open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
1104 if (defined($opt{"LOG_FILE"})) {
1119 sub wait_for_monitor;
1124 if (defined($time)) {
1126 # flush out current monitor
1127 # May contain the reboot success line
1131 # try to reboot normally
1132 if (run_command $reboot) {
1133 if (defined($powercycle_after_reboot)) {
1134 sleep $powercycle_after_reboot;
1135 run_command "$power_cycle";
1138 # nope? power cycle it.
1139 run_command "$power_cycle";
1142 if (defined($time)) {
1143 if (wait_for_monitor($time, $reboot_success_line)) {
1145 doprint "Reboot did not finish. Forcing power cycle\n";
1146 run_command "$power_cycle";
1152 sub reboot_to_good {
1155 if (defined($switch_to_good)) {
1156 run_command $switch_to_good;
1165 return $test_type eq "build" || $no_reboot ||
1166 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
1167 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
1171 doprint "CRITICAL FAILURE... ", @_, "\n";
1175 if ($reboot_on_error && !do_not_reboot) {
1177 doprint "REBOOTING\n";
1180 } elsif ($poweroff_on_error && defined($power_off)) {
1181 doprint "POWERING OFF\n";
1185 if (defined($opt{"LOG_FILE"})) {
1186 print " See $opt{LOG_FILE} for more info.\n";
1197 my $pid = open($fp, "$console|") or
1198 dodie "Can't open console $console";
1200 $flags = fcntl($fp, F_GETFL, 0) or
1201 dodie "Can't get flags for the socket: $!";
1202 $flags = fcntl($fp, F_SETFL, $flags | O_NONBLOCK) or
1203 dodie "Can't set flags for the socket: $!";
1209 my ($fp, $pid) = @_;
1211 doprint "kill child process $pid\n";
1219 if ($monitor_cnt++) {
1222 $monitor_fp = \*MONFD;
1223 $monitor_pid = open_console $monitor_fp;
1227 open(MONFD, "Stop perl from warning about single use of MONFD");
1231 if (--$monitor_cnt) {
1234 close_console($monitor_fp, $monitor_pid);
1237 sub wait_for_monitor {
1238 my ($time, $stop) = @_;
1242 my $start_time = time;
1243 my $skip_call_trace = 0;
1245 my $bug_ignored = 0;
1248 doprint "** Wait for monitor to settle down **\n";
1250 # read the monitor and wait for the system to calm down
1252 $line = wait_for_input($monitor_fp, $time);
1253 last if (!defined($line));
1255 $full_line .= $line;
1257 if (defined($stop) && $full_line =~ /$stop/) {
1258 doprint "wait for monitor detected $stop\n";
1262 if ($full_line =~ /\[ backtrace testing \]/) {
1263 $skip_call_trace = 1;
1266 if ($full_line =~ /call trace:/i) {
1267 if (!$bug && !$skip_call_trace) {
1268 if ($ignore_errors) {
1276 if ($full_line =~ /\[ end of backtrace testing \]/) {
1277 $skip_call_trace = 0;
1280 if ($full_line =~ /Kernel panic -/) {
1284 if ($line =~ /\n/) {
1288 if ($now - $start_time >= $max_monitor_wait) {
1289 doprint "Exiting monitor flush due to hitting MAX_MONITOR_WAIT\n";
1293 print "** Monitor flushed **\n";
1298 my ($result, $basedir) = @_;
1300 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
1301 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
1303 my $type = $build_type;
1304 if ($type =~ /useconfig/) {
1305 $type = "useconfig";
1308 my $dir = "$machine-$test_type-$type-$result-$date";
1310 $dir = "$basedir/$dir";
1314 die "can't create $dir";
1318 "config" => $output_config,
1319 "buildlog" => $buildlog,
1321 "testlog" => $testlog,
1324 while (my ($name, $source) = each(%files)) {
1326 cp "$source", "$dir/$name" or
1327 die "failed to copy $source";
1331 doprint "*** Saved info to $dir ***\n";
1336 if (defined($post_test)) {
1337 run_command $post_test;
1340 if ($die_on_failure) {
1348 # no need to reboot for just building.
1349 if (!do_not_reboot) {
1350 doprint "REBOOTING\n";
1351 reboot_to_good $sleep_time;
1356 if (defined($test_name)) {
1357 $name = " ($test_name)";
1360 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1361 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1362 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
1363 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1364 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1366 if (defined($store_failures)) {
1367 save_logs "fail", $store_failures;
1379 $command =~ s/\$SSH_USER/$ssh_user/g;
1380 $command =~ s/\$MACHINE/$machine/g;
1382 doprint("$command ... ");
1384 $pid = open(CMD, "$command 2>&1 |") or
1385 (fail "unable to exec $command" and return 0);
1387 if (defined($opt{"LOG_FILE"})) {
1388 open(LOG, ">>$opt{LOG_FILE}") or
1389 dodie "failed to write to log";
1393 if (defined($redirect)) {
1394 open (RD, ">$redirect") or
1395 dodie "failed to write to redirect $redirect";
1400 print LOG if ($dolog);
1401 print RD if ($dord);
1408 close(LOG) if ($dolog);
1409 close(RD) if ($dord);
1412 doprint "FAILED!\n";
1414 doprint "SUCCESS\n";
1422 my $cp_exec = $ssh_exec;
1424 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
1425 return run_command "$cp_exec";
1429 my ($src, $dst, $cp_scp) = @_;
1431 $cp_scp =~ s/\$SRC_FILE/$src/g;
1432 $cp_scp =~ s/\$DST_FILE/$dst/g;
1434 return run_command "$cp_scp";
1437 sub run_scp_install {
1438 my ($src, $dst) = @_;
1440 my $cp_scp = $scp_to_target_install;
1442 return run_scp($src, $dst, $cp_scp);
1446 my ($src, $dst) = @_;
1448 my $cp_scp = $scp_to_target;
1450 return run_scp($src, $dst, $cp_scp);
1453 sub get_grub_index {
1455 if ($reboot_type ne "grub") {
1458 return if (defined($grub_number));
1460 doprint "Find grub menu ... ";
1463 my $ssh_grub = $ssh_exec;
1464 $ssh_grub =~ s,\$SSH_COMMAND,cat /boot/grub/menu.lst,g;
1466 open(IN, "$ssh_grub |")
1467 or die "unable to get menu.lst";
1472 if (/^\s*title\s+$grub_menu\s*$/) {
1476 } elsif (/^\s*title\s/) {
1482 die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
1484 doprint "$grub_number\n";
1489 my ($fp, $time) = @_;
1495 if (!defined($time)) {
1500 vec($rin, fileno($fp), 1) = 1;
1501 $ready = select($rin, undef, undef, $time);
1505 # try to read one char at a time
1506 while (sysread $fp, $ch, 1) {
1508 last if ($ch eq "\n");
1511 if (!length($line)) {
1519 if (defined($switch_to_test)) {
1520 run_command $switch_to_test;
1523 if ($reboot_type eq "grub") {
1524 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
1525 } elsif (defined $reboot_script) {
1526 run_command "$reboot_script";
1534 doprint "git rev-list --max-count=1 $commit ... ";
1535 my $sha1 = `git rev-list --max-count=1 $commit`;
1542 dodie "Failed to get git $commit";
1555 my $bug_ignored = 0;
1556 my $skip_call_trace = 0;
1564 open(DMESG, "> $dmesg") or
1565 die "unable to write to $dmesg";
1571 my $monitor_start = time;
1573 my $version_found = 0;
1577 if ($bug && defined($stop_after_failure) &&
1578 $stop_after_failure >= 0) {
1579 my $time = $stop_after_failure - (time - $failure_start);
1580 $line = wait_for_input($monitor_fp, $time);
1581 if (!defined($line)) {
1582 doprint "bug timed out after $booted_timeout seconds\n";
1583 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1587 $line = wait_for_input($monitor_fp, $booted_timeout);
1588 if (!defined($line)) {
1589 my $s = $booted_timeout == 1 ? "" : "s";
1590 doprint "Successful boot found: break after $booted_timeout second$s\n";
1594 $line = wait_for_input($monitor_fp);
1595 if (!defined($line)) {
1596 my $s = $timeout == 1 ? "" : "s";
1597 doprint "Timed out after $timeout second$s\n";
1605 # we are not guaranteed to get a full line
1606 $full_line .= $line;
1608 if ($full_line =~ /$success_line/) {
1610 $success_start = time;
1613 if ($booted && defined($stop_after_success) &&
1614 $stop_after_success >= 0) {
1616 if ($now - $success_start >= $stop_after_success) {
1617 doprint "Test forced to stop after $stop_after_success seconds after success\n";
1622 if ($full_line =~ /\[ backtrace testing \]/) {
1623 $skip_call_trace = 1;
1626 if ($full_line =~ /call trace:/i) {
1627 if (!$bug && !$skip_call_trace) {
1628 if ($ignore_errors) {
1632 $failure_start = time;
1637 if ($bug && defined($stop_after_failure) &&
1638 $stop_after_failure >= 0) {
1640 if ($now - $failure_start >= $stop_after_failure) {
1641 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1646 if ($full_line =~ /\[ end of backtrace testing \]/) {
1647 $skip_call_trace = 0;
1650 if ($full_line =~ /Kernel panic -/) {
1651 $failure_start = time;
1655 # Detect triple faults by testing the banner
1656 if ($full_line =~ /\bLinux version (\S+).*\n/) {
1657 if ($1 eq $version) {
1659 } elsif ($version_found && $detect_triplefault) {
1660 # We already booted into the kernel we are testing,
1661 # but now we booted into another kernel?
1662 # Consider this a triple fault.
1663 doprint "Aleady booted in Linux kernel $version, but now\n";
1664 doprint "we booted into Linux kernel $1.\n";
1665 doprint "Assuming that this is a triple fault.\n";
1666 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
1671 if ($line =~ /\n/) {
1675 if ($stop_test_after > 0 && !$booted && !$bug) {
1676 if (time - $monitor_start > $stop_test_after) {
1677 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
1686 return 0 if ($in_bisect);
1687 fail "failed - got a bug report" and return 0;
1691 return 0 if ($in_bisect);
1692 fail "failed - never got a boot prompt." and return 0;
1696 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
1702 sub eval_kernel_version {
1705 $option =~ s/\$KERNEL_VERSION/$version/g;
1710 sub do_post_install {
1712 return if (!defined($post_install));
1714 my $cp_post_install = eval_kernel_version $post_install;
1715 run_command "$cp_post_install" or
1716 dodie "Failed to run post install";
1721 return if ($no_install);
1723 if (defined($pre_install)) {
1724 my $cp_pre_install = eval_kernel_version $pre_install;
1725 run_command "$cp_pre_install" or
1726 dodie "Failed to run pre install";
1729 my $cp_target = eval_kernel_version $target_image;
1731 run_scp_install "$outputdir/$build_target", "$cp_target" or
1732 dodie "failed to copy image";
1734 my $install_mods = 0;
1736 # should we process modules?
1738 open(IN, "$output_config") or dodie("Can't read config file");
1740 if (/CONFIG_MODULES(=y)?/) {
1741 $install_mods = 1 if (defined($1));
1747 if (!$install_mods) {
1749 doprint "No modules needed\n";
1753 run_command "$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or
1754 dodie "Failed to install modules";
1756 my $modlib = "/lib/modules/$version";
1757 my $modtar = "ktest-mods.tar.bz2";
1759 run_ssh "rm -rf $modlib" or
1760 dodie "failed to remove old mods: $modlib";
1762 # would be nice if scp -r did not follow symbolic links
1763 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
1764 dodie "making tarball";
1766 run_scp_mod "$tmpdir/$modtar", "/tmp" or
1767 dodie "failed to copy modules";
1769 unlink "$tmpdir/$modtar";
1771 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
1772 dodie "failed to tar modules";
1774 run_ssh "rm -f /tmp/$modtar";
1780 # get the release name
1781 return if ($have_version);
1782 doprint "$make kernelrelease ... ";
1783 $version = `$make kernelrelease | tail -1`;
1785 doprint "$version\n";
1789 sub start_monitor_and_boot {
1790 # Make sure the stable kernel has finished booting
1803 sub check_buildlog {
1806 my @files = `git show $patch | diffstat -l`;
1808 open(IN, "git show $patch |") or
1809 dodie "failed to show $patch";
1811 if (m,^--- a/(.*),) {
1813 $files[$#files] = $1;
1818 open(IN, $buildlog) or dodie "Can't open $buildlog";
1820 if (/^\s*(.*?):.*(warning|error)/) {
1822 foreach my $file (@files) {
1823 my $fullpath = "$builddir/$file";
1824 if ($file eq $err || $fullpath eq $err) {
1825 fail "$file built with warnings" and return 0;
1835 sub apply_min_config {
1836 my $outconfig = "$output_config.new";
1838 # Read the config file and remove anything that
1839 # is in the force_config hash (from minconfig and others)
1840 # then add the force config back.
1842 doprint "Applying minimum configurations into $output_config.new\n";
1844 open (OUT, ">$outconfig") or
1845 dodie "Can't create $outconfig";
1847 if (-f $output_config) {
1848 open (IN, $output_config) or
1849 dodie "Failed to open $output_config";
1851 if (/^(# )?(CONFIG_[^\s=]*)/) {
1852 next if (defined($force_config{$2}));
1858 foreach my $config (keys %force_config) {
1859 print OUT "$force_config{$config}\n";
1863 run_command "mv $outconfig $output_config";
1866 sub make_oldconfig {
1868 my @force_list = keys %force_config;
1870 if ($#force_list >= 0) {
1874 if (!run_command "$make oldnoconfig") {
1875 # Perhaps oldnoconfig doesn't exist in this version of the kernel
1876 # try a yes '' | oldconfig
1877 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
1878 run_command "yes '' | $make oldconfig" or
1879 dodie "failed make config oldconfig";
1883 # read a config file and use this to force new configs.
1884 sub load_force_config {
1887 doprint "Loading force configs from $config\n";
1888 open(IN, $config) or
1889 dodie "failed to read $config";
1892 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
1893 $force_config{$1} = $_;
1894 } elsif (/^# (CONFIG_\S*) is not set/) {
1895 $force_config{$1} = $_;
1906 # Failed builds should not reboot the target
1907 my $save_no_reboot = $no_reboot;
1910 # Calculate a new version from here.
1913 if (defined($pre_build)) {
1914 my $ret = run_command $pre_build;
1915 if (!$ret && defined($pre_build_die) &&
1917 dodie "failed to pre_build\n";
1921 if ($type =~ /^useconfig:(.*)/) {
1922 run_command "cp $1 $output_config" or
1923 dodie "could not copy $1 to .config";
1925 $type = "oldconfig";
1928 # old config can ask questions
1929 if ($type eq "oldconfig") {
1930 $type = "oldnoconfig";
1932 # allow for empty configs
1933 run_command "touch $output_config";
1936 run_command "mv $output_config $outputdir/config_temp" or
1937 dodie "moving .config";
1939 run_command "$make mrproper" or dodie "make mrproper";
1941 run_command "mv $outputdir/config_temp $output_config" or
1942 dodie "moving config_temp";
1945 } elsif (!$noclean) {
1946 unlink "$output_config";
1947 run_command "$make mrproper" or
1948 dodie "make mrproper";
1951 # add something to distinguish this build
1952 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
1953 print OUT "$localversion\n";
1956 if (defined($minconfig)) {
1957 load_force_config($minconfig);
1960 if ($type ne "oldnoconfig") {
1961 run_command "$make $type" or
1962 dodie "failed make config";
1964 # Run old config regardless, to enforce min configurations
1967 $redirect = "$buildlog";
1968 my $build_ret = run_command "$make $build_options";
1971 if (defined($post_build)) {
1972 # Because a post build may change the kernel version
1975 my $ret = run_command $post_build;
1976 if (!$ret && defined($post_build_die) &&
1978 dodie "failed to post_build\n";
1983 # bisect may need this to pass
1985 $no_reboot = $save_no_reboot;
1988 fail "failed build" and return 0;
1991 $no_reboot = $save_no_reboot;
1997 if (!run_ssh "halt" or defined($power_off)) {
1998 if (defined($poweroff_after_halt)) {
1999 sleep $poweroff_after_halt;
2000 run_command "$power_off";
2004 run_command "$power_off";
2011 if (defined($post_test)) {
2012 run_command $post_test;
2019 if (defined($test_name)) {
2020 $name = " ($test_name)";
2023 doprint "\n\n*******************************************\n";
2024 doprint "*******************************************\n";
2025 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
2026 doprint "*******************************************\n";
2027 doprint "*******************************************\n";
2029 if (defined($store_successes)) {
2030 save_logs "success", $store_successes;
2033 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
2034 doprint "Reboot and wait $sleep_time seconds\n";
2035 reboot_to_good $sleep_time;
2041 doprint "Pass or fail? [p/f]";
2044 if ($ans eq "p" || $ans eq "P") {
2046 } elsif ($ans eq "f" || $ans eq "F") {
2049 print "Please answer 'P' or 'F'\n";
2054 sub child_run_test {
2057 # child should have no power
2058 $reboot_on_error = 0;
2059 $poweroff_on_error = 0;
2060 $die_on_failure = 1;
2062 $redirect = "$testlog";
2063 run_command $run_test or $failed = 1;
2071 sub child_finished {
2081 my $bug_ignored = 0;
2085 doprint "run test $run_test\n";
2089 $SIG{CHLD} = qw(child_finished);
2093 child_run_test if (!$child_pid);
2098 $line = wait_for_input($monitor_fp, 1);
2099 if (defined($line)) {
2101 # we are not guaranteed to get a full line
2102 $full_line .= $line;
2105 if ($full_line =~ /call trace:/i) {
2106 if ($ignore_errors) {
2113 if ($full_line =~ /Kernel panic -/) {
2117 if ($line =~ /\n/) {
2121 } while (!$child_done && !$bug);
2123 if (!$bug && $bug_ignored) {
2124 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2128 my $failure_start = time;
2131 $line = wait_for_input($monitor_fp, 1);
2132 if (defined($line)) {
2136 if ($now - $failure_start >= $stop_after_failure) {
2139 } while (defined($line));
2141 doprint "Detected kernel crash!\n";
2142 # kill the child with extreme prejudice
2146 waitpid $child_pid, 0;
2149 if (!$bug && $in_bisect) {
2150 if (defined($bisect_ret_good)) {
2151 if ($child_exit == $bisect_ret_good) {
2155 if (defined($bisect_ret_skip)) {
2156 if ($child_exit == $bisect_ret_skip) {
2160 if (defined($bisect_ret_abort)) {
2161 if ($child_exit == $bisect_ret_abort) {
2162 fail "test abort" and return -2;
2165 if (defined($bisect_ret_bad)) {
2166 if ($child_exit == $bisect_ret_skip) {
2170 if (defined($bisect_ret_default)) {
2171 if ($bisect_ret_default eq "good") {
2173 } elsif ($bisect_ret_default eq "bad") {
2175 } elsif ($bisect_ret_default eq "skip") {
2177 } elsif ($bisect_ret_default eq "abort") {
2180 fail "unknown default action: $bisect_ret_default"
2186 if ($bug || $child_exit) {
2187 return 0 if $in_bisect;
2188 fail "test failed" and return 0;
2193 sub run_git_bisect {
2196 doprint "$command ... ";
2198 my $output = `$command 2>&1`;
2205 dodie "Failed to git bisect";
2208 doprint "SUCCESS\n";
2209 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
2210 doprint "$1 [$2]\n";
2211 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
2212 $bisect_bad_commit = $1;
2213 doprint "Found bad commit... $1\n";
2216 # we already logged it, just print it now.
2224 doprint "Reboot and sleep $bisect_sleep_time seconds\n";
2225 reboot_to_good $bisect_sleep_time;
2228 # returns 1 on success, 0 on failure, -1 on skip
2229 sub run_bisect_test {
2230 my ($type, $buildtype) = @_;
2239 build $buildtype or $failed = 1;
2241 if ($type ne "build") {
2242 if ($failed && $bisect_skip) {
2246 dodie "Failed on build" if $failed;
2249 start_monitor_and_boot or $failed = 1;
2251 if ($type ne "boot") {
2252 if ($failed && $bisect_skip) {
2258 dodie "Failed on boot" if $failed;
2260 do_run_test or $failed = 1;
2271 # reboot the box to a kernel we can ssh to
2272 if ($type ne "build") {
2282 my $buildtype = "oldconfig";
2284 # We should have a minconfig to use?
2285 if (defined($minconfig)) {
2286 $buildtype = "useconfig:$minconfig";
2289 my $ret = run_bisect_test $type, $buildtype;
2291 if ($bisect_manual) {
2292 $ret = answer_bisect;
2295 # Are we looking for where it worked, not failed?
2296 if ($reverse_bisect && $ret >= 0) {
2302 } elsif ($ret == 0) {
2304 } elsif ($bisect_skip) {
2305 doprint "HIT A BAD COMMIT ... SKIPPING\n";
2310 sub update_bisect_replay {
2311 my $tmp_log = "$tmpdir/ktest_bisect_log";
2312 run_command "git bisect log > $tmp_log" or
2313 die "can't create bisect log";
2322 die "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good));
2323 die "BISECT_BAD[$i] not defined\n" if (!defined($bisect_bad));
2324 die "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type));
2326 my $good = $bisect_good;
2327 my $bad = $bisect_bad;
2328 my $type = $bisect_type;
2329 my $start = $bisect_start;
2330 my $replay = $bisect_replay;
2331 my $start_files = $bisect_files;
2333 if (defined($start_files)) {
2334 $start_files = " -- " . $start_files;
2339 # convert to true sha1's
2340 $good = get_sha1($good);
2341 $bad = get_sha1($bad);
2343 if (defined($bisect_reverse) && $bisect_reverse == 1) {
2344 doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
2345 $reverse_bisect = 1;
2347 $reverse_bisect = 0;
2350 # Can't have a test without having a test to run
2351 if ($type eq "test" && !defined($run_test)) {
2355 # Check if a bisect was running
2356 my $bisect_start_file = "$builddir/.git/BISECT_START";
2358 my $check = $bisect_check;
2359 my $do_check = defined($check) && $check ne "0";
2361 if ( -f $bisect_start_file ) {
2362 print "Bisect in progress found\n";
2364 print " If you say yes, then no checks of good or bad will be done\n";
2366 if (defined($replay)) {
2367 print "** BISECT_REPLAY is defined in config file **";
2368 print " Ignore config option and perform new git bisect log?\n";
2369 if (read_ync " (yes, no, or cancel) ") {
2370 $replay = update_bisect_replay;
2373 } elsif (read_yn "read git log and continue?") {
2374 $replay = update_bisect_replay;
2382 my $head = get_sha1("HEAD");
2384 if ($check ne "good") {
2385 doprint "TESTING BISECT BAD [$bad]\n";
2386 run_command "git checkout $bad" or
2387 die "Failed to checkout $bad";
2389 $result = run_bisect $type;
2391 if ($result ne "bad") {
2392 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
2396 if ($check ne "bad") {
2397 doprint "TESTING BISECT GOOD [$good]\n";
2398 run_command "git checkout $good" or
2399 die "Failed to checkout $good";
2401 $result = run_bisect $type;
2403 if ($result ne "good") {
2404 fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
2408 # checkout where we started
2409 run_command "git checkout $head" or
2410 die "Failed to checkout $head";
2413 run_command "git bisect start$start_files" or
2414 dodie "could not start bisect";
2416 run_command "git bisect good $good" or
2417 dodie "could not set bisect good to $good";
2419 run_git_bisect "git bisect bad $bad" or
2420 dodie "could not set bisect bad to $bad";
2422 if (defined($replay)) {
2423 run_command "git bisect replay $replay" or
2424 dodie "failed to run replay";
2427 if (defined($start)) {
2428 run_command "git checkout $start" or
2429 dodie "failed to checkout $start";
2434 $result = run_bisect $type;
2435 $test = run_git_bisect "git bisect $result";
2438 run_command "git bisect log" or
2439 dodie "could not capture git bisect log";
2441 run_command "git bisect reset" or
2442 dodie "could not reset git bisect";
2444 doprint "Bad commit was [$bisect_bad_commit]\n";
2449 # config_ignore holds the configs that were set (or unset) for
2450 # a good config and we will ignore these configs for the rest
2451 # of a config bisect. These configs stay as they were.
2454 # config_set holds what all configs were set as.
2457 # config_off holds the set of configs that the bad config had disabled.
2458 # We need to record them and set them in the .config when running
2459 # oldnoconfig, because oldnoconfig does not turn off new symbols, but
2460 # instead just keeps the defaults.
2463 # config_off_tmp holds a set of configs to turn off for now
2466 # config_list is the set of configs that are being tested
2472 sub assign_configs {
2473 my ($hash, $config) = @_;
2476 or dodie "Failed to read $config";
2479 if (/^((CONFIG\S*)=.*)/) {
2487 sub process_config_ignore {
2490 assign_configs \%config_ignore, $config;
2493 sub read_current_config {
2494 my ($config_ref) = @_;
2496 %{$config_ref} = ();
2497 undef %{$config_ref};
2499 my @key = keys %{$config_ref};
2501 print "did not delete!\n";
2504 open (IN, "$output_config");
2507 if (/^(CONFIG\S+)=(.*)/) {
2508 ${$config_ref}{$1} = $2;
2514 sub get_dependencies {
2517 my $arr = $dependency{$config};
2518 if (!defined($arr)) {
2524 foreach my $dep (@{$arr}) {
2525 print "ADD DEP $dep\n";
2526 @deps = (@deps, get_dependencies $dep);
2535 open(OUT, ">$output_config") or dodie "Can not write to $output_config";
2537 foreach my $config (@configs) {
2538 print OUT "$config_set{$config}\n";
2539 my @deps = get_dependencies $config;
2540 foreach my $dep (@deps) {
2541 print OUT "$config_set{$dep}\n";
2545 # turn off configs to keep off
2546 foreach my $config (keys %config_off) {
2547 print OUT "# $config is not set\n";
2550 # turn off configs that should be off for now
2551 foreach my $config (@config_off_tmp) {
2552 print OUT "# $config is not set\n";
2555 foreach my $config (keys %config_ignore) {
2556 print OUT "$config_ignore{$config}\n";
2563 sub compare_configs {
2566 foreach my $item (keys %a) {
2567 if (!defined($b{$item})) {
2568 print "diff $item\n";
2576 print "diff2 $keys[0]\n";
2578 return -1 if ($#keys >= 0);
2583 sub run_config_bisect_test {
2586 return run_bisect_test $type, "oldconfig";
2589 sub process_passed {
2592 doprint "These configs had no failure: (Enabling them for further compiles)\n";
2593 # Passed! All these configs are part of a good compile.
2594 # Add them to the min options.
2595 foreach my $config (keys %configs) {
2596 if (defined($config_list{$config})) {
2597 doprint " removing $config\n";
2598 $config_ignore{$config} = $config_list{$config};
2599 delete $config_list{$config};
2602 doprint "config copied to $outputdir/config_good\n";
2603 run_command "cp -f $output_config $outputdir/config_good";
2606 sub process_failed {
2609 doprint "\n\n***************************************\n";
2610 doprint "Found bad config: $config\n";
2611 doprint "***************************************\n\n";
2614 sub run_config_bisect {
2616 my @start_list = keys %config_list;
2618 if ($#start_list < 0) {
2619 doprint "No more configs to test!!!\n";
2623 doprint "***** RUN TEST ***\n";
2624 my $type = $config_bisect_type;
2628 my $count = $#start_list + 1;
2629 doprint " $count configs to test\n";
2631 my $half = int($#start_list / 2);
2634 my @tophalf = @start_list[0 .. $half];
2636 # keep the bottom half off
2637 if ($half < $#start_list) {
2638 @config_off_tmp = @start_list[$half + 1 .. $#start_list];
2640 @config_off_tmp = ();
2643 create_config @tophalf;
2644 read_current_config \%current_config;
2646 $count = $#tophalf + 1;
2647 doprint "Testing $count configs\n";
2649 # make sure we test something
2650 foreach my $config (@tophalf) {
2651 if (defined($current_config{$config})) {
2657 # try the other half
2658 doprint "Top half produced no set configs, trying bottom half\n";
2660 # keep the top half off
2661 @config_off_tmp = @tophalf;
2662 @tophalf = @start_list[$half + 1 .. $#start_list];
2664 create_config @tophalf;
2665 read_current_config \%current_config;
2666 foreach my $config (@tophalf) {
2667 if (defined($current_config{$config})) {
2673 doprint "Failed: Can't make new config with current configs\n";
2674 foreach my $config (@start_list) {
2675 doprint " CONFIG: $config\n";
2679 $count = $#tophalf + 1;
2680 doprint "Testing $count configs\n";
2683 $ret = run_config_bisect_test $type;
2684 if ($bisect_manual) {
2685 $ret = answer_bisect;
2688 process_passed %current_config;
2692 doprint "This config had a failure.\n";
2693 doprint "Removing these configs that were not set in this config:\n";
2694 doprint "config copied to $outputdir/config_bad\n";
2695 run_command "cp -f $output_config $outputdir/config_bad";
2697 # A config exists in this group that was bad.
2698 foreach my $config (keys %config_list) {
2699 if (!defined($current_config{$config})) {
2700 doprint " removing $config\n";
2701 delete $config_list{$config};
2705 @start_list = @tophalf;
2707 if ($#start_list == 0) {
2708 process_failed $start_list[0];
2712 # remove half the configs we are looking at and see if
2714 $half = int($#start_list / 2);
2715 } while ($#start_list > 0);
2717 # we found a single config, try it again unless we are running manually
2719 if ($bisect_manual) {
2720 process_failed $start_list[0];
2724 my @tophalf = @start_list[0 .. 0];
2726 $ret = run_config_bisect_test $type;
2728 process_passed %current_config;
2732 process_failed $start_list[0];
2739 my $start_config = $config_bisect;
2741 my $tmpconfig = "$tmpdir/use_config";
2743 if (defined($config_bisect_good)) {
2744 process_config_ignore $config_bisect_good;
2747 # Make the file with the bad config and the min config
2748 if (defined($minconfig)) {
2749 # read the min config for things to ignore
2750 run_command "cp $minconfig $tmpconfig" or
2751 dodie "failed to copy $minconfig to $tmpconfig";
2756 if (-f $tmpconfig) {
2757 load_force_config($tmpconfig);
2758 process_config_ignore $tmpconfig;
2761 # now process the start config
2762 run_command "cp $start_config $output_config" or
2763 dodie "failed to copy $start_config to $output_config";
2765 # read directly what we want to check
2767 open (IN, $output_config)
2768 or dodie "failed to open $output_config";
2771 if (/^((CONFIG\S*)=.*)/) {
2772 $config_check{$2} = $1;
2777 # Now run oldconfig with the minconfig
2780 # check to see what we lost (or gained)
2781 open (IN, $output_config)
2782 or dodie "Failed to read $start_config";
2784 my %removed_configs;
2788 if (/^((CONFIG\S*)=.*)/) {
2789 # save off all options
2790 $config_set{$2} = $1;
2791 if (defined($config_check{$2})) {
2792 if (defined($config_ignore{$2})) {
2793 $removed_configs{$2} = $1;
2795 $config_list{$2} = $1;
2797 } elsif (!defined($config_ignore{$2})) {
2798 $added_configs{$2} = $1;
2799 $config_list{$2} = $1;
2801 } elsif (/^# ((CONFIG\S*).*)/) {
2802 # Keep these configs disabled
2803 $config_set{$2} = $1;
2804 $config_off{$2} = $1;
2809 my @confs = keys %removed_configs;
2811 doprint "Configs overridden by default configs and removed from check:\n";
2812 foreach my $config (@confs) {
2813 doprint " $config\n";
2816 @confs = keys %added_configs;
2818 doprint "Configs appearing in make oldconfig and added:\n";
2819 foreach my $config (@confs) {
2820 doprint " $config\n";
2827 @config_off_tmp = ();
2829 # Sometimes kconfig does weird things. We must make sure
2830 # that the config we autocreate has everything we need
2831 # to test, otherwise we may miss testing configs, or
2832 # may not be able to create a new config.
2833 # Here we create a config with everything set.
2834 create_config (keys %config_list);
2835 read_current_config \%config_test;
2836 foreach my $config (keys %config_list) {
2837 if (!defined($config_test{$config})) {
2840 doprint "Configs not produced by kconfig (will not be checked):\n";
2842 doprint " $config\n";
2843 delete $config_list{$config};
2848 if (defined($config_bisect_check) && $config_bisect_check) {
2849 doprint " Checking to make sure bad config with min config fails\n";
2850 create_config keys %config_list;
2851 $ret = run_config_bisect_test $config_bisect_type;
2853 doprint " FAILED! Bad config with min config boots fine\n";
2856 doprint " Bad config with min config fails as expected\n";
2860 $ret = run_config_bisect;
2863 return $ret if ($ret < 0);
2868 sub patchcheck_reboot {
2869 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
2870 reboot_to_good $patchcheck_sleep_time;
2876 die "PATCHCHECK_START[$i] not defined\n"
2877 if (!defined($patchcheck_start));
2878 die "PATCHCHECK_TYPE[$i] not defined\n"
2879 if (!defined($patchcheck_type));
2881 my $start = $patchcheck_start;
2884 if (defined($patchcheck_end)) {
2885 $end = $patchcheck_end;
2888 # Get the true sha1's since we can use things like HEAD~3
2889 $start = get_sha1($start);
2890 $end = get_sha1($end);
2892 my $type = $patchcheck_type;
2894 # Can't have a test without having a test to run
2895 if ($type eq "test" && !defined($run_test)) {
2899 open (IN, "git log --pretty=oneline $end|") or
2900 dodie "could not get git list";
2906 $list[$#list+1] = $_;
2907 last if (/^$start/);
2911 if ($list[$#list] !~ /^$start/) {
2912 fail "SHA1 $start not found";
2915 # go backwards in the list
2916 @list = reverse @list;
2918 my $save_clean = $noclean;
2919 my %ignored_warnings;
2921 if (defined($ignore_warnings)) {
2922 foreach my $sha1 (split /\s+/, $ignore_warnings) {
2923 $ignored_warnings{$sha1} = 1;
2928 foreach my $item (@list) {
2930 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
2932 doprint "\nProcessing commit $item\n\n";
2934 run_command "git checkout $sha1" or
2935 die "Failed to checkout $sha1";
2937 # only clean on the first and last patch
2938 if ($item eq $list[0] ||
2939 $item eq $list[$#list]) {
2940 $noclean = $save_clean;
2945 if (defined($minconfig)) {
2946 build "useconfig:$minconfig" or return 0;
2948 # ?? no config to use?
2949 build "oldconfig" or return 0;
2953 if (!defined($ignored_warnings{$sha1})) {
2954 check_buildlog $sha1 or return 0;
2957 next if ($type eq "build");
2961 start_monitor_and_boot or $failed = 1;
2963 if (!$failed && $type ne "boot"){
2964 do_run_test or $failed = 1;
2967 return 0 if ($failed);
2987 # $config depends on $dep
2988 my ($config, $dep) = @_;
2990 if (defined($depends{$config})) {
2991 $depends{$config} .= " " . $dep;
2993 $depends{$config} = $dep;
2996 # record the number of configs depending on $dep
2997 if (defined $depcount{$dep}) {
3000 $depcount{$dep} = 1;
3004 # taken from streamline_config.pl
3016 if (! -f $kconfig) {
3017 doprint "file $kconfig does not exist, skipping\n";
3021 open(KIN, "$kconfig")
3022 or die "Can't open $kconfig";
3026 # Make sure that lines ending with \ continue
3028 $_ = $line . " " . $_;
3039 # collect any Kconfig sources
3040 if (/^source\s*"(.*)"/) {
3041 $kconfigs[$#kconfigs+1] = $1;
3045 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
3049 for (my $i = 0; $i < $iflevel; $i++) {
3050 add_dep $config, $ifdeps[$i];
3053 # collect the depends for the config
3054 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
3056 add_dep $config, $1;
3058 # Get the configs that select this config
3059 } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {
3061 # selected by depends on config
3062 add_dep $1, $config;
3064 # Check for if statements
3065 } elsif (/^if\s+(.*\S)\s*$/) {
3067 # remove beginning and ending non text
3068 $deps =~ s/^[^a-zA-Z0-9_]*//;
3069 $deps =~ s/[^a-zA-Z0-9_]*$//;
3071 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
3073 $ifdeps[$iflevel++] = join ':', @deps;
3075 } elsif (/^endif/) {
3077 $iflevel-- if ($iflevel);
3080 } elsif (/^\s*help\s*$/) {
3086 # read in any configs that were found.
3087 foreach $kconfig (@kconfigs) {
3088 if (!defined($read_kconfigs{$kconfig})) {
3089 $read_kconfigs{$kconfig} = 1;
3090 read_kconfig("$builddir/$kconfig");
3096 # find out which arch this is by the kconfig file
3097 open (IN, $output_config)
3098 or dodie "Failed to read $output_config";
3101 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
3108 if (!defined($arch)) {
3109 doprint "Could not find arch from config file\n";
3110 doprint "no dependencies used\n";
3114 # arch is really the subarch, we need to know
3115 # what directory to look at.
3116 if ($arch eq "i386" || $arch eq "x86_64") {
3118 } elsif ($arch =~ /^tile/) {
3122 my $kconfig = "$builddir/arch/$arch/Kconfig";
3124 if (! -f $kconfig && $arch =~ /\d$/) {
3126 # some subarchs have numbers, truncate them
3128 $kconfig = "$builddir/arch/$arch/Kconfig";
3129 if (! -f $kconfig) {
3130 doprint "No idea what arch dir $orig is for\n";
3131 doprint "no dependencies used\n";
3136 read_kconfig($kconfig);
3139 sub read_config_list {
3143 or dodie "Failed to read $config";
3146 if (/^((CONFIG\S*)=.*)/) {
3147 if (!defined($config_ignore{$2})) {
3148 $config_list{$2} = $1;
3156 sub read_output_config {
3159 assign_configs \%config_ignore, $config;
3162 sub make_new_config {
3165 open (OUT, ">$output_config")
3166 or dodie "Failed to write $output_config";
3168 foreach my $config (@configs) {
3169 print OUT "$config\n";
3177 $config =~ s/CONFIG_//;
3185 my $kconfig = chomp_config $dep;
3187 $dep = $depends{"$kconfig"};
3189 # the dep string we have saves the dependencies as they
3190 # were found, including expressions like ! && ||. We
3191 # want to split this out into just an array of configs.
3193 my $valid = "A-Za-z_0-9";
3197 while ($dep =~ /[$valid]/) {
3199 if ($dep =~ /^[^$valid]*([$valid]+)/) {
3200 my $conf = "CONFIG_" . $1;
3202 $configs[$#configs + 1] = $conf;
3204 $dep =~ s/^[^$valid]*[$valid]+//;
3206 die "this should never happen";
3216 my %processed_configs;
3217 my %nochange_config;
3219 sub test_this_config {
3224 # if we already processed this config, skip it
3225 if (defined($processed_configs{$config})) {
3228 $processed_configs{$config} = 1;
3230 # if this config failed during this round, skip it
3231 if (defined($nochange_config{$config})) {
3235 my $kconfig = chomp_config $config;
3237 # Test dependencies first
3238 if (defined($depends{"$kconfig"})) {
3239 my @parents = get_depends $config;
3240 foreach my $parent (@parents) {
3241 # if the parent is in the min config, check it first
3242 next if (!defined($min_configs{$parent}));
3243 $found = test_this_config($parent);
3244 if (defined($found)) {
3250 # Remove this config from the list of configs
3251 # do a make oldnoconfig and then read the resulting
3252 # .config to make sure it is missing the config that
3254 my %configs = %min_configs;
3255 delete $configs{$config};
3256 make_new_config ((values %configs), (values %keep_configs));
3259 assign_configs \%configs, $output_config;
3261 return $config if (!defined($configs{$config}));
3263 doprint "disabling config $config did not change .config\n";
3265 $nochange_config{$config} = 1;
3270 sub make_min_config {
3273 my $type = $minconfig_type;
3274 if ($type ne "boot" && $type ne "test") {
3275 fail "Invalid MIN_CONFIG_TYPE '$minconfig_type'\n" .
3276 " make_min_config works only with 'boot' and 'test'\n" and return;
3279 if (!defined($output_minconfig)) {
3280 fail "OUTPUT_MIN_CONFIG not defined" and return;
3283 # If output_minconfig exists, and the start_minconfig
3284 # came from min_config, than ask if we should use
3286 if (-f $output_minconfig && !$start_minconfig_defined) {
3287 print "$output_minconfig exists\n";
3288 if (!defined($use_output_minconfig)) {
3289 if (read_yn " Use it as minconfig?") {
3290 $start_minconfig = $output_minconfig;
3292 } elsif ($use_output_minconfig > 0) {
3293 doprint "Using $output_minconfig as MIN_CONFIG\n";
3294 $start_minconfig = $output_minconfig;
3296 doprint "Set to still use MIN_CONFIG as starting point\n";
3300 if (!defined($start_minconfig)) {
3301 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
3304 my $temp_config = "$tmpdir/temp_config";
3306 # First things first. We build an allnoconfig to find
3307 # out what the defaults are that we can't touch.
3308 # Some are selections, but we really can't handle selections.
3310 my $save_minconfig = $minconfig;
3313 run_command "$make allnoconfig" or return 0;
3317 process_config_ignore $output_config;
3319 undef %save_configs;
3322 if (defined($ignore_config)) {
3323 # make sure the file exists
3324 `touch $ignore_config`;
3325 assign_configs \%save_configs, $ignore_config;
3328 %keep_configs = %save_configs;
3330 doprint "Load initial configs from $start_minconfig\n";
3332 # Look at the current min configs, and save off all the
3333 # ones that were set via the allnoconfig
3334 assign_configs \%min_configs, $start_minconfig;
3336 my @config_keys = keys %min_configs;
3338 # All configs need a depcount
3339 foreach my $config (@config_keys) {
3340 my $kconfig = chomp_config $config;
3341 if (!defined $depcount{$kconfig}) {
3342 $depcount{$kconfig} = 0;
3346 # Remove anything that was set by the make allnoconfig
3347 # we shouldn't need them as they get set for us anyway.
3348 foreach my $config (@config_keys) {
3349 # Remove anything in the ignore_config
3350 if (defined($keep_configs{$config})) {
3351 my $file = $ignore_config;
3352 $file =~ s,.*/(.*?)$,$1,;
3353 doprint "$config set by $file ... ignored\n";
3354 delete $min_configs{$config};
3357 # But make sure the settings are the same. If a min config
3358 # sets a selection, we do not want to get rid of it if
3359 # it is not the same as what we have. Just move it into
3361 if (defined($config_ignore{$config})) {
3362 if ($config_ignore{$config} ne $min_configs{$config}) {
3363 doprint "$config is in allnoconfig as '$config_ignore{$config}'";
3364 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
3365 $keep_configs{$config} = $min_configs{$config};
3367 doprint "$config set by allnoconfig ... ignored\n";
3369 delete $min_configs{$config};
3381 # Now disable each config one by one and do a make oldconfig
3382 # till we find a config that changes our list.
3384 my @test_configs = keys %min_configs;
3386 # Sort keys by who is most dependent on
3387 @test_configs = sort { $depcount{chomp_config($b)} <=> $depcount{chomp_config($a)} }
3390 # Put configs that did not modify the config at the end.
3392 for (my $i = 0; $i < $#test_configs; $i++) {
3393 if (!defined($nochange_config{$test_configs[0]})) {
3397 # This config didn't change the .config last time.
3398 # Place it at the end
3399 my $config = shift @test_configs;
3400 push @test_configs, $config;
3403 # if every test config has failed to modify the .config file
3404 # in the past, then reset and start over.
3406 undef %nochange_config;
3409 undef %processed_configs;
3411 foreach my $config (@test_configs) {
3413 $found = test_this_config $config;
3415 last if (defined($found));
3417 # oh well, try another config
3420 if (!defined($found)) {
3421 # we could have failed due to the nochange_config hash
3422 # reset and try again
3424 undef %nochange_config;
3428 doprint "No more configs found that we can disable\n";
3436 doprint "Test with $config disabled\n";
3438 # set in_bisect to keep build and monitor from dieing
3442 build "oldconfig" or $failed = 1;
3444 start_monitor_and_boot or $failed = 1;
3446 if ($type eq "test" && !$failed) {
3447 do_run_test or $failed = 1;
3456 doprint "$min_configs{$config} is needed to boot the box... keeping\n";
3457 # this config is needed, add it to the ignore list.
3458 $keep_configs{$config} = $min_configs{$config};
3459 $save_configs{$config} = $min_configs{$config};
3460 delete $min_configs{$config};
3462 # update new ignore configs
3463 if (defined($ignore_config)) {
3464 open (OUT, ">$temp_config")
3465 or die "Can't write to $temp_config";
3466 foreach my $config (keys %save_configs) {
3467 print OUT "$save_configs{$config}\n";
3470 run_command "mv $temp_config $ignore_config" or
3471 dodie "failed to copy update to $ignore_config";
3475 # We booted without this config, remove it from the minconfigs.
3476 doprint "$config is not needed, disabling\n";
3478 delete $min_configs{$config};
3480 # Also disable anything that is not enabled in this config
3482 assign_configs \%configs, $output_config;
3483 my @config_keys = keys %min_configs;
3484 foreach my $config (@config_keys) {
3485 if (!defined($configs{$config})) {
3486 doprint "$config is not set, disabling\n";
3487 delete $min_configs{$config};
3491 # Save off all the current mandidory configs
3492 open (OUT, ">$temp_config")
3493 or die "Can't write to $temp_config";
3494 foreach my $config (keys %keep_configs) {
3495 print OUT "$keep_configs{$config}\n";
3497 foreach my $config (keys %min_configs) {
3498 print OUT "$min_configs{$config}\n";
3502 run_command "mv $temp_config $output_minconfig" or
3503 dodie "failed to copy update to $output_minconfig";
3506 doprint "Reboot and wait $sleep_time seconds\n";
3507 reboot_to_good $sleep_time;
3514 $#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl config-file\n";
3517 $ktest_config = $ARGV[0];
3518 if (! -f $ktest_config) {
3519 print "$ktest_config does not exist.\n";
3520 if (!read_yn "Create it?") {
3525 $ktest_config = "ktest.conf";
3528 if (! -f $ktest_config) {
3531 open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
3533 # Generated by ktest.pl
3536 # PWD is a ktest.pl variable that will result in the process working
3537 # directory that ktest.pl is executed in.
3539 # THIS_DIR is automatically assigned the PWD of the path that generated
3540 # the config file. It is best to use this variable when assigning other
3541 # directory paths within this directory. This allows you to easily
3542 # move the test cases to other locations or to other machines.
3544 THIS_DIR := $variable{"PWD"}
3546 # Define each test with TEST_START
3547 # The config options below it will override the defaults
3549 TEST_TYPE = $default{"TEST_TYPE"}
3556 read_config $ktest_config;
3558 if (defined($opt{"LOG_FILE"})) {
3559 $opt{"LOG_FILE"} = eval_option($opt{"LOG_FILE"}, -1);
3562 # Append any configs entered in manually to the config file.
3563 my @new_configs = keys %entered_configs;
3564 if ($#new_configs >= 0) {
3565 print "\nAppending entered in configs to $ktest_config\n";
3566 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
3567 foreach my $config (@new_configs) {
3568 print OUT "$config = $entered_configs{$config}\n";
3569 $opt{$config} = process_variables($entered_configs{$config});
3573 if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
3574 unlink $opt{"LOG_FILE"};
3577 doprint "\n\nSTARTING AUTOMATED TESTS\n\n";
3579 for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
3582 doprint "DEFAULT OPTIONS:\n";
3584 doprint "\nTEST $i OPTIONS";
3585 if (defined($repeat_tests{$i})) {
3586 $repeat = $repeat_tests{$i};
3587 doprint " ITERATE $repeat";
3592 foreach my $option (sort keys %opt) {
3594 if ($option =~ /\[(\d+)\]$/) {
3600 doprint "$option = $opt{$option}\n";
3604 sub __set_test_option {
3605 my ($name, $i) = @_;
3607 my $option = "$name\[$i\]";
3609 if (defined($opt{$option})) {
3610 return $opt{$option};
3613 foreach my $test (keys %repeat_tests) {
3615 $i < $test + $repeat_tests{$test}) {
3616 $option = "$name\[$test\]";
3617 if (defined($opt{$option})) {
3618 return $opt{$option};
3623 if (defined($opt{$name})) {
3630 sub set_test_option {
3631 my ($name, $i) = @_;
3633 my $option = __set_test_option($name, $i);
3634 return $option if (!defined($option));
3636 return eval_option($option, $i);
3639 # First we need to do is the builds
3640 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
3642 # Do not reboot on failing test options
3644 $reboot_success = 0;
3650 undef %force_config;
3652 my $makecmd = set_test_option("MAKE_CMD", $i);
3654 # Load all the options into their mapped variable names
3655 foreach my $opt (keys %option_map) {
3656 ${$option_map{$opt}} = set_test_option($opt, $i);
3659 $start_minconfig_defined = 1;
3661 # The first test may override the PRE_KTEST option
3662 if (defined($pre_ktest) && $i == 1) {
3664 run_command $pre_ktest;
3667 # Any test can override the POST_KTEST option
3668 # The last test takes precedence.
3669 if (defined($post_ktest)) {
3670 $final_post_ktest = $post_ktest;
3673 if (!defined($start_minconfig)) {
3674 $start_minconfig_defined = 0;
3675 $start_minconfig = $minconfig;
3678 chdir $builddir || die "can't change directory to $builddir";
3680 foreach my $dir ($tmpdir, $outputdir) {
3683 die "can't create $dir";
3687 $ENV{"SSH_USER"} = $ssh_user;
3688 $ENV{"MACHINE"} = $machine;
3690 $buildlog = "$tmpdir/buildlog-$machine";
3691 $testlog = "$tmpdir/testlog-$machine";
3692 $dmesg = "$tmpdir/dmesg-$machine";
3693 $make = "$makecmd O=$outputdir";
3694 $output_config = "$outputdir/.config";
3697 $target = "$ssh_user\@$machine";
3698 if ($reboot_type eq "grub") {
3699 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
3703 my $run_type = $build_type;
3704 if ($test_type eq "patchcheck") {
3705 $run_type = $patchcheck_type;
3706 } elsif ($test_type eq "bisect") {
3707 $run_type = $bisect_type;
3708 } elsif ($test_type eq "config_bisect") {
3709 $run_type = $config_bisect_type;
3712 if ($test_type eq "make_min_config") {
3716 # mistake in config file?
3717 if (!defined($run_type)) {
3718 $run_type = "ERROR";
3722 $installme = " no_install" if ($no_install);
3725 doprint "RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type$installme\n\n";
3727 if (defined($pre_test)) {
3728 run_command $pre_test;
3735 if (defined($addconfig)) {
3736 my $min = $minconfig;
3737 if (!defined($minconfig)) {
3740 run_command "cat $addconfig $min > $tmpdir/add_config" or
3741 dodie "Failed to create temp config";
3742 $minconfig = "$tmpdir/add_config";
3745 if (defined($checkout)) {
3746 run_command "git checkout $checkout" or
3747 die "failed to checkout $checkout";
3752 # A test may opt to not reboot the box
3753 if ($reboot_on_success) {
3754 $reboot_success = 1;
3757 if ($test_type eq "bisect") {
3760 } elsif ($test_type eq "config_bisect") {
3763 } elsif ($test_type eq "patchcheck") {
3766 } elsif ($test_type eq "make_min_config") {
3771 if ($build_type ne "nobuild") {
3772 build $build_type or next;
3775 if ($test_type eq "install") {
3782 if ($test_type ne "build") {
3784 start_monitor_and_boot or $failed = 1;
3786 if (!$failed && $test_type ne "boot" && defined($run_test)) {
3787 do_run_test or $failed = 1;
3796 if (defined($final_post_ktest)) {
3797 run_command $final_post_ktest;
3800 if ($opt{"POWEROFF_ON_SUCCESS"}) {
3802 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot && $reboot_success) {
3804 } elsif (defined($switch_to_good)) {
3805 # still need to get to the good kernel
3806 run_command $switch_to_good;
3810 doprint "\n $successes of $opt{NUM_TESTS} tests were successful\n\n";