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);
26 "TEST_TYPE" => "build",
27 "BUILD_TYPE" => "randconfig",
29 "CLOSE_CONSOLE_SIGNAL" => "INT",
31 "TMP_DIR" => "/tmp/ktest/\${MACHINE}",
32 "SLEEP_TIME" => 60, # sleep time between tests
34 "REBOOT_ON_ERROR" => 0,
35 "POWEROFF_ON_ERROR" => 0,
36 "REBOOT_ON_SUCCESS" => 1,
37 "POWEROFF_ON_SUCCESS" => 0,
38 "BUILD_OPTIONS" => "",
39 "BISECT_SLEEP_TIME" => 60, # sleep time between bisects
40 "PATCHCHECK_SLEEP_TIME" => 60, # sleep time between patch checks
45 "MIN_CONFIG_TYPE" => "boot",
46 "SUCCESS_LINE" => "login:",
47 "DETECT_TRIPLE_FAULT" => 1,
49 "BOOTED_TIMEOUT" => 1,
50 "DIE_ON_FAILURE" => 1,
51 "SSH_EXEC" => "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND",
52 "SCP_TO_TARGET" => "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE",
53 "SCP_TO_TARGET_INSTALL" => "\${SCP_TO_TARGET}",
54 "REBOOT" => "ssh \$SSH_USER\@\$MACHINE reboot",
55 "STOP_AFTER_SUCCESS" => 10,
56 "STOP_AFTER_FAILURE" => 60,
57 "STOP_TEST_AFTER" => 600,
58 "MAX_MONITOR_WAIT" => 1800,
59 "GRUB_REBOOT" => "grub2-reboot",
60 "SYSLINUX" => "extlinux",
61 "SYSLINUX_PATH" => "/boot/extlinux",
63 # required, and we will ask users if they don't have them but we keep the default
64 # value something that is common.
65 "REBOOT_TYPE" => "grub",
66 "LOCALVERSION" => "-test",
68 "BUILD_TARGET" => "arch/x86/boot/bzImage",
69 "TARGET_IMAGE" => "/boot/vmlinuz-test",
104 my $poweroff_on_error;
105 my $reboot_on_success;
107 my $powercycle_after_reboot;
108 my $poweroff_after_halt;
109 my $max_monitor_wait;
112 my $scp_to_target_install;
130 my $start_minconfig_defined;
131 my $output_minconfig;
133 my $use_output_minconfig;
139 my $bisect_bad_commit = "";
144 my $config_bisect_good;
148 my $bisect_ret_abort;
149 my $bisect_ret_default;
150 my $in_patchcheck = 0;
160 my $bisect_sleep_time;
161 my $patchcheck_sleep_time;
168 my $detect_triplefault;
170 my $close_console_signal;
171 my $reboot_success_line;
173 my $stop_after_success;
174 my $stop_after_failure;
193 my $config_bisect_type;
194 my $config_bisect_check;
197 my $patchcheck_start;
200 # set when a test is something other that just building or install
201 # which would require more options.
204 # tell build not to worry about warnings, even when WARNINGS_FILE is set
207 # set when creating a new config
214 # force_config is the list of configs that we force enabled (or disabled)
215 # in a .config file. The MIN_CONFIG and ADD_CONFIG configs.
218 # do not force reboots on config problems
222 my $reboot_success = 0;
225 "MACHINE" => \$machine,
226 "SSH_USER" => \$ssh_user,
227 "TMP_DIR" => \$tmpdir,
228 "OUTPUT_DIR" => \$outputdir,
229 "BUILD_DIR" => \$builddir,
230 "TEST_TYPE" => \$test_type,
231 "PRE_KTEST" => \$pre_ktest,
232 "POST_KTEST" => \$post_ktest,
233 "PRE_TEST" => \$pre_test,
234 "POST_TEST" => \$post_test,
235 "BUILD_TYPE" => \$build_type,
236 "BUILD_OPTIONS" => \$build_options,
237 "PRE_BUILD" => \$pre_build,
238 "POST_BUILD" => \$post_build,
239 "PRE_BUILD_DIE" => \$pre_build_die,
240 "POST_BUILD_DIE" => \$post_build_die,
241 "POWER_CYCLE" => \$power_cycle,
242 "REBOOT" => \$reboot,
243 "BUILD_NOCLEAN" => \$noclean,
244 "MIN_CONFIG" => \$minconfig,
245 "OUTPUT_MIN_CONFIG" => \$output_minconfig,
246 "START_MIN_CONFIG" => \$start_minconfig,
247 "MIN_CONFIG_TYPE" => \$minconfig_type,
248 "USE_OUTPUT_MIN_CONFIG" => \$use_output_minconfig,
249 "WARNINGS_FILE" => \$warnings_file,
250 "IGNORE_CONFIG" => \$ignore_config,
251 "TEST" => \$run_test,
252 "ADD_CONFIG" => \$addconfig,
253 "REBOOT_TYPE" => \$reboot_type,
254 "GRUB_MENU" => \$grub_menu,
255 "GRUB_FILE" => \$grub_file,
256 "GRUB_REBOOT" => \$grub_reboot,
257 "SYSLINUX" => \$syslinux,
258 "SYSLINUX_PATH" => \$syslinux_path,
259 "SYSLINUX_LABEL" => \$syslinux_label,
260 "PRE_INSTALL" => \$pre_install,
261 "POST_INSTALL" => \$post_install,
262 "NO_INSTALL" => \$no_install,
263 "REBOOT_SCRIPT" => \$reboot_script,
264 "REBOOT_ON_ERROR" => \$reboot_on_error,
265 "SWITCH_TO_GOOD" => \$switch_to_good,
266 "SWITCH_TO_TEST" => \$switch_to_test,
267 "POWEROFF_ON_ERROR" => \$poweroff_on_error,
268 "REBOOT_ON_SUCCESS" => \$reboot_on_success,
269 "DIE_ON_FAILURE" => \$die_on_failure,
270 "POWER_OFF" => \$power_off,
271 "POWERCYCLE_AFTER_REBOOT" => \$powercycle_after_reboot,
272 "POWEROFF_AFTER_HALT" => \$poweroff_after_halt,
273 "MAX_MONITOR_WAIT" => \$max_monitor_wait,
274 "SLEEP_TIME" => \$sleep_time,
275 "BISECT_SLEEP_TIME" => \$bisect_sleep_time,
276 "PATCHCHECK_SLEEP_TIME" => \$patchcheck_sleep_time,
277 "IGNORE_WARNINGS" => \$ignore_warnings,
278 "IGNORE_ERRORS" => \$ignore_errors,
279 "BISECT_MANUAL" => \$bisect_manual,
280 "BISECT_SKIP" => \$bisect_skip,
281 "BISECT_TRIES" => \$bisect_tries,
282 "CONFIG_BISECT_GOOD" => \$config_bisect_good,
283 "BISECT_RET_GOOD" => \$bisect_ret_good,
284 "BISECT_RET_BAD" => \$bisect_ret_bad,
285 "BISECT_RET_SKIP" => \$bisect_ret_skip,
286 "BISECT_RET_ABORT" => \$bisect_ret_abort,
287 "BISECT_RET_DEFAULT" => \$bisect_ret_default,
288 "STORE_FAILURES" => \$store_failures,
289 "STORE_SUCCESSES" => \$store_successes,
290 "TEST_NAME" => \$test_name,
291 "TIMEOUT" => \$timeout,
292 "BOOTED_TIMEOUT" => \$booted_timeout,
293 "CONSOLE" => \$console,
294 "CLOSE_CONSOLE_SIGNAL" => \$close_console_signal,
295 "DETECT_TRIPLE_FAULT" => \$detect_triplefault,
296 "SUCCESS_LINE" => \$success_line,
297 "REBOOT_SUCCESS_LINE" => \$reboot_success_line,
298 "STOP_AFTER_SUCCESS" => \$stop_after_success,
299 "STOP_AFTER_FAILURE" => \$stop_after_failure,
300 "STOP_TEST_AFTER" => \$stop_test_after,
301 "BUILD_TARGET" => \$build_target,
302 "SSH_EXEC" => \$ssh_exec,
303 "SCP_TO_TARGET" => \$scp_to_target,
304 "SCP_TO_TARGET_INSTALL" => \$scp_to_target_install,
305 "CHECKOUT" => \$checkout,
306 "TARGET_IMAGE" => \$target_image,
307 "LOCALVERSION" => \$localversion,
309 "BISECT_GOOD" => \$bisect_good,
310 "BISECT_BAD" => \$bisect_bad,
311 "BISECT_TYPE" => \$bisect_type,
312 "BISECT_START" => \$bisect_start,
313 "BISECT_REPLAY" => \$bisect_replay,
314 "BISECT_FILES" => \$bisect_files,
315 "BISECT_REVERSE" => \$bisect_reverse,
316 "BISECT_CHECK" => \$bisect_check,
318 "CONFIG_BISECT" => \$config_bisect,
319 "CONFIG_BISECT_TYPE" => \$config_bisect_type,
320 "CONFIG_BISECT_CHECK" => \$config_bisect_check,
322 "PATCHCHECK_TYPE" => \$patchcheck_type,
323 "PATCHCHECK_START" => \$patchcheck_start,
324 "PATCHCHECK_END" => \$patchcheck_end,
327 # Options may be used by other options, record them.
330 # default variables that can be used
331 chomp ($variable{"PWD"} = `pwd`);
333 $config_help{"MACHINE"} = << "EOF"
334 The machine hostname that you will test.
335 For build only tests, it is still needed to differentiate log files.
338 $config_help{"SSH_USER"} = << "EOF"
339 The box is expected to have ssh on normal bootup, provide the user
340 (most likely root, since you need privileged operations)
343 $config_help{"BUILD_DIR"} = << "EOF"
344 The directory that contains the Linux source code (full path).
345 You can use \${PWD} that will be the path where ktest.pl is run, or use
346 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
349 $config_help{"OUTPUT_DIR"} = << "EOF"
350 The directory that the objects will be built (full path).
351 (can not be same as BUILD_DIR)
352 You can use \${PWD} that will be the path where ktest.pl is run, or use
353 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
356 $config_help{"BUILD_TARGET"} = << "EOF"
357 The location of the compiled file to copy to the target.
358 (relative to OUTPUT_DIR)
361 $config_help{"BUILD_OPTIONS"} = << "EOF"
362 Options to add to \"make\" when building.
366 $config_help{"TARGET_IMAGE"} = << "EOF"
367 The place to put your image on the test machine.
370 $config_help{"POWER_CYCLE"} = << "EOF"
371 A script or command to reboot the box.
373 Here is a digital loggers power switch example
374 POWER_CYCLE = wget --no-proxy -O /dev/null -q --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL'
376 Here is an example to reboot a virtual box on the current host
377 with the name "Guest".
378 POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest
381 $config_help{"CONSOLE"} = << "EOF"
382 The script or command that reads the console
384 If you use ttywatch server, something like the following would work.
385 CONSOLE = nc -d localhost 3001
387 For a virtual machine with guest name "Guest".
388 CONSOLE = virsh console Guest
391 $config_help{"LOCALVERSION"} = << "EOF"
392 Required version ending to differentiate the test
393 from other linux builds on the system.
396 $config_help{"REBOOT_TYPE"} = << "EOF"
397 Way to reboot the box to the test kernel.
398 Only valid options so far are "grub", "grub2", "syslinux", and "script".
400 If you specify grub, it will assume grub version 1
401 and will search in /boot/grub/menu.lst for the title \$GRUB_MENU
402 and select that target to reboot to the kernel. If this is not
403 your setup, then specify "script" and have a command or script
404 specified in REBOOT_SCRIPT to boot to the target.
406 The entry in /boot/grub/menu.lst must be entered in manually.
407 The test will not modify that file.
409 If you specify grub2, then you also need to specify both \$GRUB_MENU
412 If you specify syslinux, then you may use SYSLINUX to define the syslinux
413 command (defaults to extlinux), and SYSLINUX_PATH to specify the path to
414 the syslinux install (defaults to /boot/extlinux). But you have to specify
415 SYSLINUX_LABEL to define the label to boot to for the test kernel.
418 $config_help{"GRUB_MENU"} = << "EOF"
419 The grub title name for the test kernel to boot
420 (Only mandatory if REBOOT_TYPE = grub or grub2)
422 Note, ktest.pl will not update the grub menu.lst, you need to
423 manually add an option for the test. ktest.pl will search
424 the grub menu.lst for this option to find what kernel to
427 For example, if in the /boot/grub/menu.lst the test kernel title has:
430 GRUB_MENU = Test Kernel
432 For grub2, a search of \$GRUB_FILE is performed for the lines
433 that begin with "menuentry". It will not detect submenus. The
434 menu must be a non-nested menu. Add the quotes used in the menu
435 to guarantee your selection, as the first menuentry with the content
436 of \$GRUB_MENU that is found will be used.
439 $config_help{"GRUB_FILE"} = << "EOF"
440 If grub2 is used, the full path for the grub.cfg file is placed
441 here. Use something like /boot/grub2/grub.cfg to search.
444 $config_help{"SYSLINUX_LABEL"} = << "EOF"
445 If syslinux is used, the label that boots the target kernel must
446 be specified with SYSLINUX_LABEL.
449 $config_help{"REBOOT_SCRIPT"} = << "EOF"
450 A script to reboot the target into the test kernel
451 (Only mandatory if REBOOT_TYPE = script)
456 if (defined($opt{"LOG_FILE"})) {
457 open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
464 if (defined($opt{"LOG_FILE"})) {
477 my ($cancel, $prompt) = @_;
483 print "$prompt [y/n/C] ";
485 print "$prompt [Y/n] ";
489 if ($ans =~ /^\s*$/) {
496 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
498 last if ($ans =~ /^c$/i);
499 print "Please answer either 'y', 'n' or 'c'.\n";
501 print "Please answer either 'y' or 'n'.\n";
507 if ($ans !~ /^y$/i) {
516 return read_prompt 0, $prompt;
522 return read_prompt 1, $prompt;
525 sub get_ktest_config {
529 return if (defined($opt{$config}));
531 if (defined($config_help{$config})) {
533 print $config_help{$config};
538 if (defined($default{$config}) && length($default{$config})) {
539 print "\[$default{$config}\] ";
542 $ans =~ s/^\s*(.*\S)\s*$/$1/;
543 if ($ans =~ /^\s*$/) {
544 if ($default{$config}) {
545 $ans = $default{$config};
547 print "Your answer can not be blank\n";
551 $entered_configs{$config} = ${ans};
556 sub get_ktest_configs {
557 get_ktest_config("MACHINE");
558 get_ktest_config("BUILD_DIR");
559 get_ktest_config("OUTPUT_DIR");
562 get_ktest_config("BUILD_OPTIONS");
565 # options required for other than just building a kernel
567 get_ktest_config("POWER_CYCLE");
568 get_ktest_config("CONSOLE");
571 # options required for install and more
572 if ($buildonly != 1) {
573 get_ktest_config("SSH_USER");
574 get_ktest_config("BUILD_TARGET");
575 get_ktest_config("TARGET_IMAGE");
578 get_ktest_config("LOCALVERSION");
580 return if ($buildonly);
582 my $rtype = $opt{"REBOOT_TYPE"};
584 if (!defined($rtype)) {
585 if (!defined($opt{"GRUB_MENU"})) {
586 get_ktest_config("REBOOT_TYPE");
587 $rtype = $entered_configs{"REBOOT_TYPE"};
593 if ($rtype eq "grub") {
594 get_ktest_config("GRUB_MENU");
597 if ($rtype eq "grub2") {
598 get_ktest_config("GRUB_MENU");
599 get_ktest_config("GRUB_FILE");
602 if ($rtype eq "syslinux") {
603 get_ktest_config("SYSLINUX_LABEL");
607 sub process_variables {
608 my ($value, $remove_undef) = @_;
611 # We want to check for '\', and it is just easier
612 # to check the previous characet of '$' and not need
613 # to worry if '$' is the first character. By adding
614 # a space to $value, we can just check [^\\]\$ and
615 # it will still work.
618 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
622 # append beginning of value to retval
623 $retval = "$retval$begin";
624 if (defined($variable{$var})) {
625 $retval = "$retval$variable{$var}";
626 } elsif (defined($remove_undef) && $remove_undef) {
627 # for if statements, any variable that is not defined,
628 # we simple convert to 0
629 $retval = "${retval}0";
631 # put back the origin piece.
632 $retval = "$retval\$\{$var\}";
633 # This could be an option that is used later, save
634 # it so we don't warn if this option is not one of
636 $used_options{$var} = 1;
640 $retval = "$retval$value";
642 # remove the space added in the beginning
649 my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
651 my $prvalue = process_variables($rvalue);
653 if ($buildonly && $lvalue =~ /^TEST_TYPE(\[.*\])?$/ && $prvalue ne "build") {
654 # Note if a test is something other than build, then we
655 # will need other manditory options.
656 if ($prvalue ne "install") {
657 # for bisect, we need to check BISECT_TYPE
658 if ($prvalue ne "bisect") {
662 # install still limits some manditory options.
667 if ($buildonly && $lvalue =~ /^BISECT_TYPE(\[.*\])?$/ && $prvalue ne "build") {
668 if ($prvalue ne "install") {
671 # install still limits some manditory options.
676 if (defined($opt{$lvalue})) {
677 if (!$override || defined(${$overrides}{$lvalue})) {
680 $extra = "In the same override section!\n";
682 die "$name: $.: Option $lvalue defined more than once!\n$extra";
684 ${$overrides}{$lvalue} = $prvalue;
686 if ($rvalue =~ /^\s*$/) {
687 delete $opt{$lvalue};
689 $opt{$lvalue} = $prvalue;
694 my ($lvalue, $rvalue, $name) = @_;
696 my $prvalue = process_variables($rvalue);
699 if (defined($evals{$lvalue})) {
700 $arr = $evals{$lvalue};
703 $evals{$lvalue} = $arr;
706 push @{$arr}, $rvalue;
710 my ($lvalue, $rvalue) = @_;
712 if ($rvalue =~ /^\s*$/) {
713 delete $variable{$lvalue};
715 $rvalue = process_variables($rvalue);
716 $variable{$lvalue} = $rvalue;
720 sub process_compare {
721 my ($lval, $cmp, $rval) = @_;
732 return $lval eq $rval;
733 } elsif ($cmp eq "!=") {
734 return $lval ne $rval;
735 } elsif ($cmp eq "=~") {
736 return $lval =~ m/$rval/;
737 } elsif ($cmp eq "!~") {
738 return $lval !~ m/$rval/;
741 my $statement = "$lval $cmp $rval";
742 my $ret = eval $statement;
744 # $@ stores error of eval
755 return defined($variable{$2}) ||
760 sub process_expression {
761 my ($name, $val) = @_;
765 while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
768 if (process_expression($name, $express)) {
769 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
771 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
779 while ($val =~ s/^(.*?)($OR|$AND)//) {
783 if (process_expression($name, $express)) {
794 if ($val =~ /(.*)(==|\!=|>=|<=|>|<|=~|\!~)(.*)/) {
795 my $ret = process_compare($1, $2, $3);
797 die "$name: $.: Unable to process comparison\n";
802 if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
804 return !value_defined($2);
806 return value_defined($2);
810 if ($val =~ /^\s*0\s*$/) {
812 } elsif ($val =~ /^\s*\d+\s*$/) {
816 die ("$name: $.: Undefined content $val in if statement\n");
820 my ($name, $value) = @_;
822 # Convert variables and replace undefined ones with 0
823 my $val = process_variables($value, 1);
824 my $ret = process_expression $name, $val;
830 my ($config, $current_test_num) = @_;
833 open($in, $config) || die "can't read file $config";
836 $name =~ s,.*/(.*),$1,;
838 my $test_num = $$current_test_num;
841 my $num_tests_set = 0;
854 # ignore blank lines and comments
855 next if (/^\s*$/ || /\s*\#/);
857 if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
867 if ($type eq "TEST_START") {
869 if ($num_tests_set) {
870 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
873 $old_test_num = $test_num;
874 $old_repeat = $repeat;
876 $test_num += $repeat;
883 # If SKIP is anywhere in the line, the command will be skipped
884 if ($rest =~ s/\s+SKIP\b//) {
891 if ($rest =~ s/\sELSE\b//) {
893 die "$name: $.: ELSE found with out matching IF section\n$_";
904 if ($rest =~ s/\sIF\s+(.*)//) {
905 if (process_if($name, $1)) {
917 if ($type eq "TEST_START") {
918 if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
920 $repeat_tests{"$test_num"} = $repeat;
922 } elsif ($rest =~ s/\sOVERRIDE\b//) {
925 # Clear previous overrides
930 if (!$skip && $rest !~ /^\s*$/) {
931 die "$name: $.: Gargbage found after $type\n$_";
934 if ($skip && $type eq "TEST_START") {
935 $test_num = $old_test_num;
936 $repeat = $old_repeat;
939 } elsif (/^\s*ELSE\b(.*)$/) {
941 die "$name: $.: ELSE found with out matching IF section\n$_";
950 if ($rest =~ /\sIF\s+(.*)/) {
951 # May be a ELSE IF section.
952 if (process_if($name, $1)) {
963 if ($rest !~ /^\s*$/) {
964 die "$name: $.: Gargbage found after DEFAULTS\n$_";
967 } elsif (/^\s*INCLUDE\s+(\S+)/) {
972 die "$name: $.: INCLUDE can only be done in default sections\n$_";
975 my $file = process_variables($1);
977 if ($file !~ m,^/,) {
978 # check the path of the config file first
979 if ($config =~ m,(.*)/,) {
987 die "$name: $.: Can't read file $file\n$_";
990 if (__read_config($file, \$test_num)) {
994 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=~\s*(.*?)\s*$/) {
1001 if ($default || $lvalue =~ /\[\d+\]$/) {
1002 set_eval($lvalue, $rvalue, $name);
1004 my $val = "$lvalue\[$test_num\]";
1005 set_eval($val, $rvalue, $name);
1008 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
1016 ($lvalue eq "NUM_TESTS" ||
1017 $lvalue eq "LOG_FILE" ||
1018 $lvalue eq "CLEAR_LOG")) {
1019 die "$name: $.: $lvalue must be set in DEFAULTS section\n";
1022 if ($lvalue eq "NUM_TESTS") {
1024 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
1027 die "$name: $.: NUM_TESTS must be set in default section\n";
1032 if ($default || $lvalue =~ /\[\d+\]$/) {
1033 set_value($lvalue, $rvalue, $override, \%overrides, $name);
1035 my $val = "$lvalue\[$test_num\]";
1036 set_value($val, $rvalue, $override, \%overrides, $name);
1039 $repeats{$val} = $repeat;
1042 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
1048 # process config variables.
1049 # Config variables are only active while reading the
1050 # config and can be defined anywhere. They also ignore
1051 # TEST_START and DEFAULTS, but are skipped if they are in
1052 # on of these sections that have SKIP defined.
1053 # The save variable can be
1054 # defined multiple times and the new one simply overrides
1056 set_variable($lvalue, $rvalue);
1059 die "$name: $.: Garbage found in config\n$_";
1064 $test_num += $repeat - 1;
1065 $opt{"NUM_TESTS"} = $test_num;
1070 $$current_test_num = $test_num;
1076 print "What test case would you like to run?\n";
1077 print " (build, install or boot)\n";
1078 print " Other tests are available but require editing the config file\n";
1081 $default{"TEST_TYPE"} = $ans;
1090 $test_case = __read_config $config, \$test_num;
1092 # make sure we have all mandatory configs
1095 # was a test specified?
1097 print "No test case specified.\n";
1103 foreach my $default (keys %default) {
1104 if (!defined($opt{$default})) {
1105 $opt{$default} = $default{$default};
1109 if ($opt{"IGNORE_UNUSED"} == 1) {
1115 # check if there are any stragglers (typos?)
1116 foreach my $option (keys %opt) {
1118 # remove per test labels.
1120 if (!exists($option_map{$op}) &&
1121 !exists($default{$op}) &&
1122 !exists($used_options{$op})) {
1129 $s = " is" if (keys %not_used == 1);
1130 print "The following option$s not used; could be a typo:\n";
1131 foreach my $option (keys %not_used) {
1134 print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";
1135 if (!read_yn "Do you want to continue?") {
1142 my ($name, $option, $i) = @_;
1144 # Add space to evaluate the character before $
1145 $option = " $option";
1150 foreach my $test (keys %repeat_tests) {
1152 $i < $test + $repeat_tests{$test}) {
1160 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
1165 # Append beginning of line
1166 $retval = "$retval$start";
1168 # If the iteration option OPT[$i] exists, then use that.
1169 # otherwise see if the default OPT (without [$i]) exists.
1171 my $o = "$var\[$i\]";
1172 my $parento = "$var\[$parent\]";
1174 # If a variable contains itself, use the default var
1175 if (($var eq $name) && defined($opt{$var})) {
1177 $retval = "$retval$o";
1178 } elsif (defined($opt{$o})) {
1180 $retval = "$retval$o";
1181 } elsif ($repeated && defined($opt{$parento})) {
1182 $o = $opt{$parento};
1183 $retval = "$retval$o";
1184 } elsif (defined($opt{$var})) {
1186 $retval = "$retval$o";
1187 } elsif ($var eq "KERNEL_VERSION" && defined($make)) {
1188 # special option KERNEL_VERSION uses kernel version
1190 $retval = "$retval$version";
1192 $retval = "$retval\$\{$var\}";
1198 $retval = "$retval$option";
1206 my ($name, $option, $i) = @_;
1208 my $option_name = "$name\[$i\]";
1211 my $old_option = $option;
1213 if (defined($evals{$option_name})) {
1214 $ev = $evals{$option_name};
1215 } elsif (defined($evals{$name})) {
1216 $ev = $evals{$name};
1221 for my $e (@{$ev}) {
1222 eval "\$option =~ $e";
1225 if ($option ne $old_option) {
1226 doprint("$name changed from '$old_option' to '$option'\n");
1233 my ($name, $option, $i) = @_;
1237 # Since an option can evaluate to another option,
1238 # keep iterating until we do not evaluate any more
1241 while ($prev ne $option) {
1242 # Check for recursive evaluations.
1243 # 100 deep should be more than enough.
1245 die "Over 100 evaluations accurred with $option\n" .
1246 "Check for recursive variables\n";
1249 $option = __eval_option($name, $option, $i);
1252 $option = process_evals($name, $option, $i);
1260 sub wait_for_monitor;
1265 # Make sure everything has been written to disk
1268 if (defined($time)) {
1270 # flush out current monitor
1271 # May contain the reboot success line
1275 # try to reboot normally
1276 if (run_command $reboot) {
1277 if (defined($powercycle_after_reboot)) {
1278 sleep $powercycle_after_reboot;
1279 run_command "$power_cycle";
1282 # nope? power cycle it.
1283 run_command "$power_cycle";
1286 if (defined($time)) {
1288 # We only want to get to the new kernel, don't fail
1289 # if we stumble over a call trace.
1290 my $save_ignore_errors = $ignore_errors;
1293 # Look for the good kernel to boot
1294 if (wait_for_monitor($time, "Linux version")) {
1296 doprint "Reboot did not finish. Forcing power cycle\n";
1297 run_command "$power_cycle";
1300 $ignore_errors = $save_ignore_errors;
1302 # Still need to wait for the reboot to finish
1303 wait_for_monitor($time, $reboot_success_line);
1309 sub reboot_to_good {
1312 if (defined($switch_to_good)) {
1313 run_command $switch_to_good;
1322 return $test_type eq "build" || $no_reboot ||
1323 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
1324 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
1328 doprint "CRITICAL FAILURE... ", @_, "\n";
1332 if ($reboot_on_error && !do_not_reboot) {
1334 doprint "REBOOTING\n";
1337 } elsif ($poweroff_on_error && defined($power_off)) {
1338 doprint "POWERING OFF\n";
1342 if (defined($opt{"LOG_FILE"})) {
1343 print " See $opt{LOG_FILE} for more info.\n";
1354 my $pid = open($fp, "$console|") or
1355 dodie "Can't open console $console";
1357 $flags = fcntl($fp, F_GETFL, 0) or
1358 dodie "Can't get flags for the socket: $!";
1359 $flags = fcntl($fp, F_SETFL, $flags | O_NONBLOCK) or
1360 dodie "Can't set flags for the socket: $!";
1366 my ($fp, $pid) = @_;
1368 doprint "kill child process $pid\n";
1369 kill $close_console_signal, $pid;
1376 if ($monitor_cnt++) {
1379 $monitor_fp = \*MONFD;
1380 $monitor_pid = open_console $monitor_fp;
1384 open(MONFD, "Stop perl from warning about single use of MONFD");
1388 return if (!defined $console);
1389 if (--$monitor_cnt) {
1392 close_console($monitor_fp, $monitor_pid);
1395 sub wait_for_monitor {
1396 my ($time, $stop) = @_;
1400 my $start_time = time;
1401 my $skip_call_trace = 0;
1403 my $bug_ignored = 0;
1406 doprint "** Wait for monitor to settle down **\n";
1408 # read the monitor and wait for the system to calm down
1410 $line = wait_for_input($monitor_fp, $time);
1411 last if (!defined($line));
1413 $full_line .= $line;
1415 if (defined($stop) && $full_line =~ /$stop/) {
1416 doprint "wait for monitor detected $stop\n";
1420 if ($full_line =~ /\[ backtrace testing \]/) {
1421 $skip_call_trace = 1;
1424 if ($full_line =~ /call trace:/i) {
1425 if (!$bug && !$skip_call_trace) {
1426 if ($ignore_errors) {
1434 if ($full_line =~ /\[ end of backtrace testing \]/) {
1435 $skip_call_trace = 0;
1438 if ($full_line =~ /Kernel panic -/) {
1442 if ($line =~ /\n/) {
1446 if ($now - $start_time >= $max_monitor_wait) {
1447 doprint "Exiting monitor flush due to hitting MAX_MONITOR_WAIT\n";
1451 print "** Monitor flushed **\n";
1456 my ($result, $basedir) = @_;
1458 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
1459 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
1461 my $type = $build_type;
1462 if ($type =~ /useconfig/) {
1463 $type = "useconfig";
1466 my $dir = "$machine-$test_type-$type-$result-$date";
1468 $dir = "$basedir/$dir";
1472 die "can't create $dir";
1476 "config" => $output_config,
1477 "buildlog" => $buildlog,
1479 "testlog" => $testlog,
1482 while (my ($name, $source) = each(%files)) {
1484 cp "$source", "$dir/$name" or
1485 die "failed to copy $source";
1489 doprint "*** Saved info to $dir ***\n";
1494 if (defined($post_test)) {
1495 run_command $post_test;
1498 if ($die_on_failure) {
1506 # no need to reboot for just building.
1507 if (!do_not_reboot) {
1508 doprint "REBOOTING\n";
1509 reboot_to_good $sleep_time;
1514 if (defined($test_name)) {
1515 $name = " ($test_name)";
1518 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1519 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1520 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
1521 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1522 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1524 if (defined($store_failures)) {
1525 save_logs "fail", $store_failures;
1537 $command =~ s/\$SSH_USER/$ssh_user/g;
1538 $command =~ s/\$MACHINE/$machine/g;
1540 doprint("$command ... ");
1542 $pid = open(CMD, "$command 2>&1 |") or
1543 (fail "unable to exec $command" and return 0);
1545 if (defined($opt{"LOG_FILE"})) {
1546 open(LOG, ">>$opt{LOG_FILE}") or
1547 dodie "failed to write to log";
1551 if (defined($redirect)) {
1552 open (RD, ">$redirect") or
1553 dodie "failed to write to redirect $redirect";
1558 print LOG if ($dolog);
1559 print RD if ($dord);
1566 close(LOG) if ($dolog);
1567 close(RD) if ($dord);
1570 doprint "FAILED!\n";
1572 doprint "SUCCESS\n";
1580 my $cp_exec = $ssh_exec;
1582 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
1583 return run_command "$cp_exec";
1587 my ($src, $dst, $cp_scp) = @_;
1589 $cp_scp =~ s/\$SRC_FILE/$src/g;
1590 $cp_scp =~ s/\$DST_FILE/$dst/g;
1592 return run_command "$cp_scp";
1595 sub run_scp_install {
1596 my ($src, $dst) = @_;
1598 my $cp_scp = $scp_to_target_install;
1600 return run_scp($src, $dst, $cp_scp);
1604 my ($src, $dst) = @_;
1606 my $cp_scp = $scp_to_target;
1608 return run_scp($src, $dst, $cp_scp);
1611 sub get_grub2_index {
1613 return if (defined($grub_number) && defined($last_grub_menu) &&
1614 $last_grub_menu eq $grub_menu && defined($last_machine) &&
1615 $last_machine eq $machine);
1617 doprint "Find grub2 menu ... ";
1620 my $ssh_grub = $ssh_exec;
1621 $ssh_grub =~ s,\$SSH_COMMAND,cat $grub_file,g;
1623 open(IN, "$ssh_grub |")
1624 or die "unable to get $grub_file";
1629 if (/^menuentry.*$grub_menu/) {
1633 } elsif (/^menuentry\s/) {
1639 die "Could not find '$grub_menu' in $grub_file on $machine"
1641 doprint "$grub_number\n";
1642 $last_grub_menu = $grub_menu;
1643 $last_machine = $machine;
1646 sub get_grub_index {
1648 if ($reboot_type eq "grub2") {
1653 if ($reboot_type ne "grub") {
1656 return if (defined($grub_number) && defined($last_grub_menu) &&
1657 $last_grub_menu eq $grub_menu && defined($last_machine) &&
1658 $last_machine eq $machine);
1660 doprint "Find grub menu ... ";
1663 my $ssh_grub = $ssh_exec;
1664 $ssh_grub =~ s,\$SSH_COMMAND,cat /boot/grub/menu.lst,g;
1666 open(IN, "$ssh_grub |")
1667 or die "unable to get menu.lst";
1672 if (/^\s*title\s+$grub_menu\s*$/) {
1676 } elsif (/^\s*title\s/) {
1682 die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
1684 doprint "$grub_number\n";
1685 $last_grub_menu = $grub_menu;
1686 $last_machine = $machine;
1691 my ($fp, $time) = @_;
1697 if (!defined($time)) {
1702 vec($rin, fileno($fp), 1) = 1;
1703 ($ready, $time) = select($rin, undef, undef, $time);
1707 # try to read one char at a time
1708 while (sysread $fp, $ch, 1) {
1710 last if ($ch eq "\n");
1713 if (!length($line)) {
1721 if (defined($switch_to_test)) {
1722 run_command $switch_to_test;
1725 if ($reboot_type eq "grub") {
1726 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
1727 } elsif ($reboot_type eq "grub2") {
1728 run_ssh "$grub_reboot $grub_number";
1729 } elsif ($reboot_type eq "syslinux") {
1730 run_ssh "$syslinux --once \\\"$syslinux_label\\\" $syslinux_path";
1731 } elsif (defined $reboot_script) {
1732 run_command "$reboot_script";
1740 doprint "git rev-list --max-count=1 $commit ... ";
1741 my $sha1 = `git rev-list --max-count=1 $commit`;
1748 dodie "Failed to get git $commit";
1761 my $bug_ignored = 0;
1762 my $skip_call_trace = 0;
1770 open(DMESG, "> $dmesg") or
1771 die "unable to write to $dmesg";
1777 my $monitor_start = time;
1779 my $version_found = 0;
1783 if ($bug && defined($stop_after_failure) &&
1784 $stop_after_failure >= 0) {
1785 my $time = $stop_after_failure - (time - $failure_start);
1786 $line = wait_for_input($monitor_fp, $time);
1787 if (!defined($line)) {
1788 doprint "bug timed out after $booted_timeout seconds\n";
1789 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1793 $line = wait_for_input($monitor_fp, $booted_timeout);
1794 if (!defined($line)) {
1795 my $s = $booted_timeout == 1 ? "" : "s";
1796 doprint "Successful boot found: break after $booted_timeout second$s\n";
1800 $line = wait_for_input($monitor_fp);
1801 if (!defined($line)) {
1802 my $s = $timeout == 1 ? "" : "s";
1803 doprint "Timed out after $timeout second$s\n";
1811 # we are not guaranteed to get a full line
1812 $full_line .= $line;
1814 if ($full_line =~ /$success_line/) {
1816 $success_start = time;
1819 if ($booted && defined($stop_after_success) &&
1820 $stop_after_success >= 0) {
1822 if ($now - $success_start >= $stop_after_success) {
1823 doprint "Test forced to stop after $stop_after_success seconds after success\n";
1828 if ($full_line =~ /\[ backtrace testing \]/) {
1829 $skip_call_trace = 1;
1832 if ($full_line =~ /call trace:/i) {
1833 if (!$bug && !$skip_call_trace) {
1834 if ($ignore_errors) {
1838 $failure_start = time;
1843 if ($bug && defined($stop_after_failure) &&
1844 $stop_after_failure >= 0) {
1846 if ($now - $failure_start >= $stop_after_failure) {
1847 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1852 if ($full_line =~ /\[ end of backtrace testing \]/) {
1853 $skip_call_trace = 0;
1856 if ($full_line =~ /Kernel panic -/) {
1857 $failure_start = time;
1861 # Detect triple faults by testing the banner
1862 if ($full_line =~ /\bLinux version (\S+).*\n/) {
1863 if ($1 eq $version) {
1865 } elsif ($version_found && $detect_triplefault) {
1866 # We already booted into the kernel we are testing,
1867 # but now we booted into another kernel?
1868 # Consider this a triple fault.
1869 doprint "Already booted in Linux kernel $version, but now\n";
1870 doprint "we booted into Linux kernel $1.\n";
1871 doprint "Assuming that this is a triple fault.\n";
1872 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
1877 if ($line =~ /\n/) {
1881 if ($stop_test_after > 0 && !$booted && !$bug) {
1882 if (time - $monitor_start > $stop_test_after) {
1883 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
1892 return 0 if ($in_bisect);
1893 fail "failed - got a bug report" and return 0;
1897 return 0 if ($in_bisect);
1898 fail "failed - never got a boot prompt." and return 0;
1902 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
1908 sub eval_kernel_version {
1911 $option =~ s/\$KERNEL_VERSION/$version/g;
1916 sub do_post_install {
1918 return if (!defined($post_install));
1920 my $cp_post_install = eval_kernel_version $post_install;
1921 run_command "$cp_post_install" or
1922 dodie "Failed to run post install";
1925 # Sometimes the reboot fails, and will hang. We try to ssh to the box
1926 # and if we fail, we force another reboot, that should powercycle it.
1928 if (!run_ssh "echo testing connection") {
1935 return if ($no_install);
1937 if (defined($pre_install)) {
1938 my $cp_pre_install = eval_kernel_version $pre_install;
1939 run_command "$cp_pre_install" or
1940 dodie "Failed to run pre install";
1943 my $cp_target = eval_kernel_version $target_image;
1947 run_scp_install "$outputdir/$build_target", "$cp_target" or
1948 dodie "failed to copy image";
1950 my $install_mods = 0;
1952 # should we process modules?
1954 open(IN, "$output_config") or dodie("Can't read config file");
1956 if (/CONFIG_MODULES(=y)?/) {
1965 if (!$install_mods) {
1967 doprint "No modules needed\n";
1971 run_command "$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or
1972 dodie "Failed to install modules";
1974 my $modlib = "/lib/modules/$version";
1975 my $modtar = "ktest-mods.tar.bz2";
1977 run_ssh "rm -rf $modlib" or
1978 dodie "failed to remove old mods: $modlib";
1980 # would be nice if scp -r did not follow symbolic links
1981 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
1982 dodie "making tarball";
1984 run_scp_mod "$tmpdir/$modtar", "/tmp" or
1985 dodie "failed to copy modules";
1987 unlink "$tmpdir/$modtar";
1989 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
1990 dodie "failed to tar modules";
1992 run_ssh "rm -f /tmp/$modtar";
1998 # get the release name
1999 return if ($have_version);
2000 doprint "$make kernelrelease ... ";
2001 $version = `$make kernelrelease | tail -1`;
2003 doprint "$version\n";
2007 sub start_monitor_and_boot {
2008 # Make sure the stable kernel has finished booting
2010 # Install bisects, don't need console
2011 if (defined $console) {
2021 start_monitor if (defined $console);
2025 my $check_build_re = ".*:.*(warning|error|Error):.*";
2026 my $utf8_quote = "\\x{e2}\\x{80}(\\x{98}|\\x{99})";
2028 sub process_warning_line {
2033 # for distcc heterogeneous systems, some compilers
2034 # do things differently causing warning lines
2035 # to be slightly different. This makes an attempt
2036 # to fixe those issues.
2038 # chop off the index into the line
2039 # using distcc, some compilers give different indexes
2040 # depending on white space
2041 $line =~ s/^(\s*\S+:\d+:)\d+/$1/;
2043 # Some compilers use UTF-8 extended for quotes and some don't.
2044 $line =~ s/$utf8_quote/'/g;
2049 # Read buildlog and check against warnings file for any
2054 sub check_buildlog {
2055 return 1 if (!defined $warnings_file);
2059 # Failed builds should not reboot the target
2060 my $save_no_reboot = $no_reboot;
2063 if (-f $warnings_file) {
2064 open(IN, $warnings_file) or
2065 dodie "Error opening $warnings_file";
2068 if (/$check_build_re/) {
2069 my $warning = process_warning_line $_;
2071 $warnings_list{$warning} = 1;
2077 # If warnings file didn't exist, and WARNINGS_FILE exist,
2078 # then we fail on any warning!
2080 open(IN, $buildlog) or dodie "Can't open $buildlog";
2082 if (/$check_build_re/) {
2083 my $warning = process_warning_line $_;
2085 if (!defined $warnings_list{$warning}) {
2086 fail "New warning found (not in $warnings_file)\n$_\n";
2087 $no_reboot = $save_no_reboot;
2092 $no_reboot = $save_no_reboot;
2096 sub check_patch_buildlog {
2099 my @files = `git show $patch | diffstat -l`;
2101 foreach my $file (@files) {
2105 open(IN, "git show $patch |") or
2106 dodie "failed to show $patch";
2108 if (m,^--- a/(.*),) {
2110 $files[$#files] = $1;
2115 open(IN, $buildlog) or dodie "Can't open $buildlog";
2117 if (/^\s*(.*?):.*(warning|error)/) {
2119 foreach my $file (@files) {
2120 my $fullpath = "$builddir/$file";
2121 if ($file eq $err || $fullpath eq $err) {
2122 fail "$file built with warnings" and return 0;
2132 sub apply_min_config {
2133 my $outconfig = "$output_config.new";
2135 # Read the config file and remove anything that
2136 # is in the force_config hash (from minconfig and others)
2137 # then add the force config back.
2139 doprint "Applying minimum configurations into $output_config.new\n";
2141 open (OUT, ">$outconfig") or
2142 dodie "Can't create $outconfig";
2144 if (-f $output_config) {
2145 open (IN, $output_config) or
2146 dodie "Failed to open $output_config";
2148 if (/^(# )?(CONFIG_[^\s=]*)/) {
2149 next if (defined($force_config{$2}));
2155 foreach my $config (keys %force_config) {
2156 print OUT "$force_config{$config}\n";
2160 run_command "mv $outconfig $output_config";
2163 sub make_oldconfig {
2165 my @force_list = keys %force_config;
2167 if ($#force_list >= 0) {
2171 if (!run_command "$make olddefconfig") {
2172 # Perhaps olddefconfig doesn't exist in this version of the kernel
2174 doprint "olddefconfig failed, trying make oldnoconfig\n";
2175 if (!run_command "$make oldnoconfig") {
2176 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
2177 # try a yes '' | oldconfig
2178 run_command "yes '' | $make oldconfig" or
2179 dodie "failed make config oldconfig";
2184 # read a config file and use this to force new configs.
2185 sub load_force_config {
2188 doprint "Loading force configs from $config\n";
2189 open(IN, $config) or
2190 dodie "failed to read $config";
2193 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
2194 $force_config{$1} = $_;
2195 } elsif (/^# (CONFIG_\S*) is not set/) {
2196 $force_config{$1} = $_;
2207 # Failed builds should not reboot the target
2208 my $save_no_reboot = $no_reboot;
2211 # Calculate a new version from here.
2214 if (defined($pre_build)) {
2215 my $ret = run_command $pre_build;
2216 if (!$ret && defined($pre_build_die) &&
2218 dodie "failed to pre_build\n";
2222 if ($type =~ /^useconfig:(.*)/) {
2223 run_command "cp $1 $output_config" or
2224 dodie "could not copy $1 to .config";
2226 $type = "oldconfig";
2229 # old config can ask questions
2230 if ($type eq "oldconfig") {
2231 $type = "olddefconfig";
2233 # allow for empty configs
2234 run_command "touch $output_config";
2237 run_command "mv $output_config $outputdir/config_temp" or
2238 dodie "moving .config";
2240 run_command "$make mrproper" or dodie "make mrproper";
2242 run_command "mv $outputdir/config_temp $output_config" or
2243 dodie "moving config_temp";
2246 } elsif (!$noclean) {
2247 unlink "$output_config";
2248 run_command "$make mrproper" or
2249 dodie "make mrproper";
2252 # add something to distinguish this build
2253 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
2254 print OUT "$localversion\n";
2257 if (defined($minconfig)) {
2258 load_force_config($minconfig);
2261 if ($type ne "olddefconfig") {
2262 run_command "$make $type" or
2263 dodie "failed make config";
2265 # Run old config regardless, to enforce min configurations
2268 $redirect = "$buildlog";
2269 my $build_ret = run_command "$make $build_options";
2272 if (defined($post_build)) {
2273 # Because a post build may change the kernel version
2276 my $ret = run_command $post_build;
2277 if (!$ret && defined($post_build_die) &&
2279 dodie "failed to post_build\n";
2284 # bisect may need this to pass
2286 $no_reboot = $save_no_reboot;
2289 fail "failed build" and return 0;
2292 $no_reboot = $save_no_reboot;
2298 if (!run_ssh "halt" or defined($power_off)) {
2299 if (defined($poweroff_after_halt)) {
2300 sleep $poweroff_after_halt;
2301 run_command "$power_off";
2305 run_command "$power_off";
2312 if (defined($post_test)) {
2313 run_command $post_test;
2320 if (defined($test_name)) {
2321 $name = " ($test_name)";
2324 doprint "\n\n*******************************************\n";
2325 doprint "*******************************************\n";
2326 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
2327 doprint "*******************************************\n";
2328 doprint "*******************************************\n";
2330 if (defined($store_successes)) {
2331 save_logs "success", $store_successes;
2334 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
2335 doprint "Reboot and wait $sleep_time seconds\n";
2336 reboot_to_good $sleep_time;
2342 doprint "Pass or fail? [p/f]";
2345 if ($ans eq "p" || $ans eq "P") {
2347 } elsif ($ans eq "f" || $ans eq "F") {
2350 print "Please answer 'P' or 'F'\n";
2355 sub child_run_test {
2358 # child should have no power
2359 $reboot_on_error = 0;
2360 $poweroff_on_error = 0;
2361 $die_on_failure = 1;
2363 $redirect = "$testlog";
2364 run_command $run_test or $failed = 1;
2372 sub child_finished {
2382 my $bug_ignored = 0;
2386 doprint "run test $run_test\n";
2390 $SIG{CHLD} = qw(child_finished);
2394 child_run_test if (!$child_pid);
2399 $line = wait_for_input($monitor_fp, 1);
2400 if (defined($line)) {
2402 # we are not guaranteed to get a full line
2403 $full_line .= $line;
2406 if ($full_line =~ /call trace:/i) {
2407 if ($ignore_errors) {
2414 if ($full_line =~ /Kernel panic -/) {
2418 if ($line =~ /\n/) {
2422 } while (!$child_done && !$bug);
2424 if (!$bug && $bug_ignored) {
2425 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2429 my $failure_start = time;
2432 $line = wait_for_input($monitor_fp, 1);
2433 if (defined($line)) {
2437 if ($now - $failure_start >= $stop_after_failure) {
2440 } while (defined($line));
2442 doprint "Detected kernel crash!\n";
2443 # kill the child with extreme prejudice
2447 waitpid $child_pid, 0;
2450 if (!$bug && $in_bisect) {
2451 if (defined($bisect_ret_good)) {
2452 if ($child_exit == $bisect_ret_good) {
2456 if (defined($bisect_ret_skip)) {
2457 if ($child_exit == $bisect_ret_skip) {
2461 if (defined($bisect_ret_abort)) {
2462 if ($child_exit == $bisect_ret_abort) {
2463 fail "test abort" and return -2;
2466 if (defined($bisect_ret_bad)) {
2467 if ($child_exit == $bisect_ret_skip) {
2471 if (defined($bisect_ret_default)) {
2472 if ($bisect_ret_default eq "good") {
2474 } elsif ($bisect_ret_default eq "bad") {
2476 } elsif ($bisect_ret_default eq "skip") {
2478 } elsif ($bisect_ret_default eq "abort") {
2481 fail "unknown default action: $bisect_ret_default"
2487 if ($bug || $child_exit) {
2488 return 0 if $in_bisect;
2489 fail "test failed" and return 0;
2494 sub run_git_bisect {
2497 doprint "$command ... ";
2499 my $output = `$command 2>&1`;
2506 dodie "Failed to git bisect";
2509 doprint "SUCCESS\n";
2510 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
2511 doprint "$1 [$2]\n";
2512 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
2513 $bisect_bad_commit = $1;
2514 doprint "Found bad commit... $1\n";
2517 # we already logged it, just print it now.
2525 doprint "Reboot and sleep $bisect_sleep_time seconds\n";
2526 reboot_to_good $bisect_sleep_time;
2529 # returns 1 on success, 0 on failure, -1 on skip
2530 sub run_bisect_test {
2531 my ($type, $buildtype) = @_;
2540 build $buildtype or $failed = 1;
2542 if ($type ne "build") {
2543 if ($failed && $bisect_skip) {
2547 dodie "Failed on build" if $failed;
2550 start_monitor_and_boot or $failed = 1;
2552 if ($type ne "boot") {
2553 if ($failed && $bisect_skip) {
2559 dodie "Failed on boot" if $failed;
2561 do_run_test or $failed = 1;
2572 # reboot the box to a kernel we can ssh to
2573 if ($type ne "build") {
2583 my $buildtype = "oldconfig";
2585 # We should have a minconfig to use?
2586 if (defined($minconfig)) {
2587 $buildtype = "useconfig:$minconfig";
2590 # If the user sets bisect_tries to less than 1, then no tries
2594 # Still let the user manually decide that though.
2595 if ($bisect_tries < 1 && $bisect_manual) {
2596 $ret = answer_bisect;
2599 for (my $i = 0; $i < $bisect_tries; $i++) {
2600 if ($bisect_tries > 1) {
2602 doprint("Running bisect trial $t of $bisect_tries:\n");
2604 $ret = run_bisect_test $type, $buildtype;
2606 if ($bisect_manual) {
2607 $ret = answer_bisect;
2613 # Are we looking for where it worked, not failed?
2614 if ($reverse_bisect && $ret >= 0) {
2620 } elsif ($ret == 0) {
2622 } elsif ($bisect_skip) {
2623 doprint "HIT A BAD COMMIT ... SKIPPING\n";
2628 sub update_bisect_replay {
2629 my $tmp_log = "$tmpdir/ktest_bisect_log";
2630 run_command "git bisect log > $tmp_log" or
2631 die "can't create bisect log";
2640 die "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good));
2641 die "BISECT_BAD[$i] not defined\n" if (!defined($bisect_bad));
2642 die "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type));
2644 my $good = $bisect_good;
2645 my $bad = $bisect_bad;
2646 my $type = $bisect_type;
2647 my $start = $bisect_start;
2648 my $replay = $bisect_replay;
2649 my $start_files = $bisect_files;
2651 if (defined($start_files)) {
2652 $start_files = " -- " . $start_files;
2657 # convert to true sha1's
2658 $good = get_sha1($good);
2659 $bad = get_sha1($bad);
2661 if (defined($bisect_reverse) && $bisect_reverse == 1) {
2662 doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
2663 $reverse_bisect = 1;
2665 $reverse_bisect = 0;
2668 # Can't have a test without having a test to run
2669 if ($type eq "test" && !defined($run_test)) {
2673 # Check if a bisect was running
2674 my $bisect_start_file = "$builddir/.git/BISECT_START";
2676 my $check = $bisect_check;
2677 my $do_check = defined($check) && $check ne "0";
2679 if ( -f $bisect_start_file ) {
2680 print "Bisect in progress found\n";
2682 print " If you say yes, then no checks of good or bad will be done\n";
2684 if (defined($replay)) {
2685 print "** BISECT_REPLAY is defined in config file **";
2686 print " Ignore config option and perform new git bisect log?\n";
2687 if (read_ync " (yes, no, or cancel) ") {
2688 $replay = update_bisect_replay;
2691 } elsif (read_yn "read git log and continue?") {
2692 $replay = update_bisect_replay;
2700 my $head = get_sha1("HEAD");
2702 if ($check ne "good") {
2703 doprint "TESTING BISECT BAD [$bad]\n";
2704 run_command "git checkout $bad" or
2705 die "Failed to checkout $bad";
2707 $result = run_bisect $type;
2709 if ($result ne "bad") {
2710 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
2714 if ($check ne "bad") {
2715 doprint "TESTING BISECT GOOD [$good]\n";
2716 run_command "git checkout $good" or
2717 die "Failed to checkout $good";
2719 $result = run_bisect $type;
2721 if ($result ne "good") {
2722 fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
2726 # checkout where we started
2727 run_command "git checkout $head" or
2728 die "Failed to checkout $head";
2731 run_command "git bisect start$start_files" or
2732 dodie "could not start bisect";
2734 run_command "git bisect good $good" or
2735 dodie "could not set bisect good to $good";
2737 run_git_bisect "git bisect bad $bad" or
2738 dodie "could not set bisect bad to $bad";
2740 if (defined($replay)) {
2741 run_command "git bisect replay $replay" or
2742 dodie "failed to run replay";
2745 if (defined($start)) {
2746 run_command "git checkout $start" or
2747 dodie "failed to checkout $start";
2752 $result = run_bisect $type;
2753 $test = run_git_bisect "git bisect $result";
2756 run_command "git bisect log" or
2757 dodie "could not capture git bisect log";
2759 run_command "git bisect reset" or
2760 dodie "could not reset git bisect";
2762 doprint "Bad commit was [$bisect_bad_commit]\n";
2767 # config_ignore holds the configs that were set (or unset) for
2768 # a good config and we will ignore these configs for the rest
2769 # of a config bisect. These configs stay as they were.
2772 # config_set holds what all configs were set as.
2775 # config_off holds the set of configs that the bad config had disabled.
2776 # We need to record them and set them in the .config when running
2777 # olddefconfig, because olddefconfig keeps the defaults.
2780 # config_off_tmp holds a set of configs to turn off for now
2783 # config_list is the set of configs that are being tested
2789 sub assign_configs {
2790 my ($hash, $config) = @_;
2793 or dodie "Failed to read $config";
2796 if (/^((CONFIG\S*)=.*)/) {
2804 sub process_config_ignore {
2807 assign_configs \%config_ignore, $config;
2810 sub read_current_config {
2811 my ($config_ref) = @_;
2813 %{$config_ref} = ();
2814 undef %{$config_ref};
2816 my @key = keys %{$config_ref};
2818 print "did not delete!\n";
2821 open (IN, "$output_config");
2824 if (/^(CONFIG\S+)=(.*)/) {
2825 ${$config_ref}{$1} = $2;
2831 sub get_dependencies {
2834 my $arr = $dependency{$config};
2835 if (!defined($arr)) {
2841 foreach my $dep (@{$arr}) {
2842 print "ADD DEP $dep\n";
2843 @deps = (@deps, get_dependencies $dep);
2852 open(OUT, ">$output_config") or dodie "Can not write to $output_config";
2854 foreach my $config (@configs) {
2855 print OUT "$config_set{$config}\n";
2856 my @deps = get_dependencies $config;
2857 foreach my $dep (@deps) {
2858 print OUT "$config_set{$dep}\n";
2862 # turn off configs to keep off
2863 foreach my $config (keys %config_off) {
2864 print OUT "# $config is not set\n";
2867 # turn off configs that should be off for now
2868 foreach my $config (@config_off_tmp) {
2869 print OUT "# $config is not set\n";
2872 foreach my $config (keys %config_ignore) {
2873 print OUT "$config_ignore{$config}\n";
2880 sub compare_configs {
2883 foreach my $item (keys %a) {
2884 if (!defined($b{$item})) {
2885 print "diff $item\n";
2893 print "diff2 $keys[0]\n";
2895 return -1 if ($#keys >= 0);
2900 sub run_config_bisect_test {
2903 return run_bisect_test $type, "oldconfig";
2906 sub process_passed {
2909 doprint "These configs had no failure: (Enabling them for further compiles)\n";
2910 # Passed! All these configs are part of a good compile.
2911 # Add them to the min options.
2912 foreach my $config (keys %configs) {
2913 if (defined($config_list{$config})) {
2914 doprint " removing $config\n";
2915 $config_ignore{$config} = $config_list{$config};
2916 delete $config_list{$config};
2919 doprint "config copied to $outputdir/config_good\n";
2920 run_command "cp -f $output_config $outputdir/config_good";
2923 sub process_failed {
2926 doprint "\n\n***************************************\n";
2927 doprint "Found bad config: $config\n";
2928 doprint "***************************************\n\n";
2931 sub run_config_bisect {
2933 my @start_list = keys %config_list;
2935 if ($#start_list < 0) {
2936 doprint "No more configs to test!!!\n";
2940 doprint "***** RUN TEST ***\n";
2941 my $type = $config_bisect_type;
2945 my $count = $#start_list + 1;
2946 doprint " $count configs to test\n";
2948 my $half = int($#start_list / 2);
2951 my @tophalf = @start_list[0 .. $half];
2953 # keep the bottom half off
2954 if ($half < $#start_list) {
2955 @config_off_tmp = @start_list[$half + 1 .. $#start_list];
2957 @config_off_tmp = ();
2960 create_config @tophalf;
2961 read_current_config \%current_config;
2963 $count = $#tophalf + 1;
2964 doprint "Testing $count configs\n";
2966 # make sure we test something
2967 foreach my $config (@tophalf) {
2968 if (defined($current_config{$config})) {
2974 # try the other half
2975 doprint "Top half produced no set configs, trying bottom half\n";
2977 # keep the top half off
2978 @config_off_tmp = @tophalf;
2979 @tophalf = @start_list[$half + 1 .. $#start_list];
2981 create_config @tophalf;
2982 read_current_config \%current_config;
2983 foreach my $config (@tophalf) {
2984 if (defined($current_config{$config})) {
2990 doprint "Failed: Can't make new config with current configs\n";
2991 foreach my $config (@start_list) {
2992 doprint " CONFIG: $config\n";
2996 $count = $#tophalf + 1;
2997 doprint "Testing $count configs\n";
3000 $ret = run_config_bisect_test $type;
3001 if ($bisect_manual) {
3002 $ret = answer_bisect;
3005 process_passed %current_config;
3009 doprint "This config had a failure.\n";
3010 doprint "Removing these configs that were not set in this config:\n";
3011 doprint "config copied to $outputdir/config_bad\n";
3012 run_command "cp -f $output_config $outputdir/config_bad";
3014 # A config exists in this group that was bad.
3015 foreach my $config (keys %config_list) {
3016 if (!defined($current_config{$config})) {
3017 doprint " removing $config\n";
3018 delete $config_list{$config};
3022 @start_list = @tophalf;
3024 if ($#start_list == 0) {
3025 process_failed $start_list[0];
3029 # remove half the configs we are looking at and see if
3031 $half = int($#start_list / 2);
3032 } while ($#start_list > 0);
3034 # we found a single config, try it again unless we are running manually
3036 if ($bisect_manual) {
3037 process_failed $start_list[0];
3041 my @tophalf = @start_list[0 .. 0];
3043 $ret = run_config_bisect_test $type;
3045 process_passed %current_config;
3049 process_failed $start_list[0];
3056 my $start_config = $config_bisect;
3058 my $tmpconfig = "$tmpdir/use_config";
3060 if (defined($config_bisect_good)) {
3061 process_config_ignore $config_bisect_good;
3064 # Make the file with the bad config and the min config
3065 if (defined($minconfig)) {
3066 # read the min config for things to ignore
3067 run_command "cp $minconfig $tmpconfig" or
3068 dodie "failed to copy $minconfig to $tmpconfig";
3073 if (-f $tmpconfig) {
3074 load_force_config($tmpconfig);
3075 process_config_ignore $tmpconfig;
3078 # now process the start config
3079 run_command "cp $start_config $output_config" or
3080 dodie "failed to copy $start_config to $output_config";
3082 # read directly what we want to check
3084 open (IN, $output_config)
3085 or dodie "failed to open $output_config";
3088 if (/^((CONFIG\S*)=.*)/) {
3089 $config_check{$2} = $1;
3094 # Now run oldconfig with the minconfig
3097 # check to see what we lost (or gained)
3098 open (IN, $output_config)
3099 or dodie "Failed to read $start_config";
3101 my %removed_configs;
3105 if (/^((CONFIG\S*)=.*)/) {
3106 # save off all options
3107 $config_set{$2} = $1;
3108 if (defined($config_check{$2})) {
3109 if (defined($config_ignore{$2})) {
3110 $removed_configs{$2} = $1;
3112 $config_list{$2} = $1;
3114 } elsif (!defined($config_ignore{$2})) {
3115 $added_configs{$2} = $1;
3116 $config_list{$2} = $1;
3118 } elsif (/^# ((CONFIG\S*).*)/) {
3119 # Keep these configs disabled
3120 $config_set{$2} = $1;
3121 $config_off{$2} = $1;
3126 my @confs = keys %removed_configs;
3128 doprint "Configs overridden by default configs and removed from check:\n";
3129 foreach my $config (@confs) {
3130 doprint " $config\n";
3133 @confs = keys %added_configs;
3135 doprint "Configs appearing in make oldconfig and added:\n";
3136 foreach my $config (@confs) {
3137 doprint " $config\n";
3144 @config_off_tmp = ();
3146 # Sometimes kconfig does weird things. We must make sure
3147 # that the config we autocreate has everything we need
3148 # to test, otherwise we may miss testing configs, or
3149 # may not be able to create a new config.
3150 # Here we create a config with everything set.
3151 create_config (keys %config_list);
3152 read_current_config \%config_test;
3153 foreach my $config (keys %config_list) {
3154 if (!defined($config_test{$config})) {
3157 doprint "Configs not produced by kconfig (will not be checked):\n";
3159 doprint " $config\n";
3160 delete $config_list{$config};
3165 if (defined($config_bisect_check) && $config_bisect_check) {
3166 doprint " Checking to make sure bad config with min config fails\n";
3167 create_config keys %config_list;
3168 $ret = run_config_bisect_test $config_bisect_type;
3170 doprint " FAILED! Bad config with min config boots fine\n";
3173 doprint " Bad config with min config fails as expected\n";
3177 $ret = run_config_bisect;
3180 return $ret if ($ret < 0);
3185 sub patchcheck_reboot {
3186 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
3187 reboot_to_good $patchcheck_sleep_time;
3193 die "PATCHCHECK_START[$i] not defined\n"
3194 if (!defined($patchcheck_start));
3195 die "PATCHCHECK_TYPE[$i] not defined\n"
3196 if (!defined($patchcheck_type));
3198 my $start = $patchcheck_start;
3201 if (defined($patchcheck_end)) {
3202 $end = $patchcheck_end;
3205 # Get the true sha1's since we can use things like HEAD~3
3206 $start = get_sha1($start);
3207 $end = get_sha1($end);
3209 my $type = $patchcheck_type;
3211 # Can't have a test without having a test to run
3212 if ($type eq "test" && !defined($run_test)) {
3216 open (IN, "git log --pretty=oneline $end|") or
3217 dodie "could not get git list";
3223 $list[$#list+1] = $_;
3224 last if (/^$start/);
3228 if ($list[$#list] !~ /^$start/) {
3229 fail "SHA1 $start not found";
3232 # go backwards in the list
3233 @list = reverse @list;
3235 my $save_clean = $noclean;
3236 my %ignored_warnings;
3238 if (defined($ignore_warnings)) {
3239 foreach my $sha1 (split /\s+/, $ignore_warnings) {
3240 $ignored_warnings{$sha1} = 1;
3245 foreach my $item (@list) {
3247 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
3249 doprint "\nProcessing commit $item\n\n";
3251 run_command "git checkout $sha1" or
3252 die "Failed to checkout $sha1";
3254 # only clean on the first and last patch
3255 if ($item eq $list[0] ||
3256 $item eq $list[$#list]) {
3257 $noclean = $save_clean;
3262 if (defined($minconfig)) {
3263 build "useconfig:$minconfig" or return 0;
3265 # ?? no config to use?
3266 build "oldconfig" or return 0;
3269 # No need to do per patch checking if warnings file exists
3270 if (!defined($warnings_file) && !defined($ignored_warnings{$sha1})) {
3271 check_patch_buildlog $sha1 or return 0;
3274 check_buildlog or return 0;
3276 next if ($type eq "build");
3280 start_monitor_and_boot or $failed = 1;
3282 if (!$failed && $type ne "boot"){
3283 do_run_test or $failed = 1;
3286 return 0 if ($failed);
3306 # $config depends on $dep
3307 my ($config, $dep) = @_;
3309 if (defined($depends{$config})) {
3310 $depends{$config} .= " " . $dep;
3312 $depends{$config} = $dep;
3315 # record the number of configs depending on $dep
3316 if (defined $depcount{$dep}) {
3319 $depcount{$dep} = 1;
3323 # taken from streamline_config.pl
3335 if (! -f $kconfig) {
3336 doprint "file $kconfig does not exist, skipping\n";
3340 open(KIN, "$kconfig")
3341 or die "Can't open $kconfig";
3345 # Make sure that lines ending with \ continue
3347 $_ = $line . " " . $_;
3358 # collect any Kconfig sources
3359 if (/^source\s*"(.*)"/) {
3360 $kconfigs[$#kconfigs+1] = $1;
3364 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
3368 for (my $i = 0; $i < $iflevel; $i++) {
3369 add_dep $config, $ifdeps[$i];
3372 # collect the depends for the config
3373 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
3375 add_dep $config, $1;
3377 # Get the configs that select this config
3378 } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {
3380 # selected by depends on config
3381 add_dep $1, $config;
3383 # Check for if statements
3384 } elsif (/^if\s+(.*\S)\s*$/) {
3386 # remove beginning and ending non text
3387 $deps =~ s/^[^a-zA-Z0-9_]*//;
3388 $deps =~ s/[^a-zA-Z0-9_]*$//;
3390 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
3392 $ifdeps[$iflevel++] = join ':', @deps;
3394 } elsif (/^endif/) {
3396 $iflevel-- if ($iflevel);
3399 } elsif (/^\s*help\s*$/) {
3405 # read in any configs that were found.
3406 foreach $kconfig (@kconfigs) {
3407 if (!defined($read_kconfigs{$kconfig})) {
3408 $read_kconfigs{$kconfig} = 1;
3409 read_kconfig("$builddir/$kconfig");
3415 # find out which arch this is by the kconfig file
3416 open (IN, $output_config)
3417 or dodie "Failed to read $output_config";
3420 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
3427 if (!defined($arch)) {
3428 doprint "Could not find arch from config file\n";
3429 doprint "no dependencies used\n";
3433 # arch is really the subarch, we need to know
3434 # what directory to look at.
3435 if ($arch eq "i386" || $arch eq "x86_64") {
3437 } elsif ($arch =~ /^tile/) {
3441 my $kconfig = "$builddir/arch/$arch/Kconfig";
3443 if (! -f $kconfig && $arch =~ /\d$/) {
3445 # some subarchs have numbers, truncate them
3447 $kconfig = "$builddir/arch/$arch/Kconfig";
3448 if (! -f $kconfig) {
3449 doprint "No idea what arch dir $orig is for\n";
3450 doprint "no dependencies used\n";
3455 read_kconfig($kconfig);
3458 sub read_config_list {
3462 or dodie "Failed to read $config";
3465 if (/^((CONFIG\S*)=.*)/) {
3466 if (!defined($config_ignore{$2})) {
3467 $config_list{$2} = $1;
3475 sub read_output_config {
3478 assign_configs \%config_ignore, $config;
3481 sub make_new_config {
3484 open (OUT, ">$output_config")
3485 or dodie "Failed to write $output_config";
3487 foreach my $config (@configs) {
3488 print OUT "$config\n";
3496 $config =~ s/CONFIG_//;
3504 my $kconfig = chomp_config $dep;
3506 $dep = $depends{"$kconfig"};
3508 # the dep string we have saves the dependencies as they
3509 # were found, including expressions like ! && ||. We
3510 # want to split this out into just an array of configs.
3512 my $valid = "A-Za-z_0-9";
3516 while ($dep =~ /[$valid]/) {
3518 if ($dep =~ /^[^$valid]*([$valid]+)/) {
3519 my $conf = "CONFIG_" . $1;
3521 $configs[$#configs + 1] = $conf;
3523 $dep =~ s/^[^$valid]*[$valid]+//;
3525 die "this should never happen";
3535 my %processed_configs;
3536 my %nochange_config;
3538 sub test_this_config {
3543 # if we already processed this config, skip it
3544 if (defined($processed_configs{$config})) {
3547 $processed_configs{$config} = 1;
3549 # if this config failed during this round, skip it
3550 if (defined($nochange_config{$config})) {
3554 my $kconfig = chomp_config $config;
3556 # Test dependencies first
3557 if (defined($depends{"$kconfig"})) {
3558 my @parents = get_depends $config;
3559 foreach my $parent (@parents) {
3560 # if the parent is in the min config, check it first
3561 next if (!defined($min_configs{$parent}));
3562 $found = test_this_config($parent);
3563 if (defined($found)) {
3569 # Remove this config from the list of configs
3570 # do a make olddefconfig and then read the resulting
3571 # .config to make sure it is missing the config that
3573 my %configs = %min_configs;
3574 delete $configs{$config};
3575 make_new_config ((values %configs), (values %keep_configs));
3578 assign_configs \%configs, $output_config;
3580 return $config if (!defined($configs{$config}));
3582 doprint "disabling config $config did not change .config\n";
3584 $nochange_config{$config} = 1;
3589 sub make_min_config {
3592 my $type = $minconfig_type;
3593 if ($type ne "boot" && $type ne "test") {
3594 fail "Invalid MIN_CONFIG_TYPE '$minconfig_type'\n" .
3595 " make_min_config works only with 'boot' and 'test'\n" and return;
3598 if (!defined($output_minconfig)) {
3599 fail "OUTPUT_MIN_CONFIG not defined" and return;
3602 # If output_minconfig exists, and the start_minconfig
3603 # came from min_config, than ask if we should use
3605 if (-f $output_minconfig && !$start_minconfig_defined) {
3606 print "$output_minconfig exists\n";
3607 if (!defined($use_output_minconfig)) {
3608 if (read_yn " Use it as minconfig?") {
3609 $start_minconfig = $output_minconfig;
3611 } elsif ($use_output_minconfig > 0) {
3612 doprint "Using $output_minconfig as MIN_CONFIG\n";
3613 $start_minconfig = $output_minconfig;
3615 doprint "Set to still use MIN_CONFIG as starting point\n";
3619 if (!defined($start_minconfig)) {
3620 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
3623 my $temp_config = "$tmpdir/temp_config";
3625 # First things first. We build an allnoconfig to find
3626 # out what the defaults are that we can't touch.
3627 # Some are selections, but we really can't handle selections.
3629 my $save_minconfig = $minconfig;
3632 run_command "$make allnoconfig" or return 0;
3636 process_config_ignore $output_config;
3638 undef %save_configs;
3641 if (defined($ignore_config)) {
3642 # make sure the file exists
3643 `touch $ignore_config`;
3644 assign_configs \%save_configs, $ignore_config;
3647 %keep_configs = %save_configs;
3649 doprint "Load initial configs from $start_minconfig\n";
3651 # Look at the current min configs, and save off all the
3652 # ones that were set via the allnoconfig
3653 assign_configs \%min_configs, $start_minconfig;
3655 my @config_keys = keys %min_configs;
3657 # All configs need a depcount
3658 foreach my $config (@config_keys) {
3659 my $kconfig = chomp_config $config;
3660 if (!defined $depcount{$kconfig}) {
3661 $depcount{$kconfig} = 0;
3665 # Remove anything that was set by the make allnoconfig
3666 # we shouldn't need them as they get set for us anyway.
3667 foreach my $config (@config_keys) {
3668 # Remove anything in the ignore_config
3669 if (defined($keep_configs{$config})) {
3670 my $file = $ignore_config;
3671 $file =~ s,.*/(.*?)$,$1,;
3672 doprint "$config set by $file ... ignored\n";
3673 delete $min_configs{$config};
3676 # But make sure the settings are the same. If a min config
3677 # sets a selection, we do not want to get rid of it if
3678 # it is not the same as what we have. Just move it into
3680 if (defined($config_ignore{$config})) {
3681 if ($config_ignore{$config} ne $min_configs{$config}) {
3682 doprint "$config is in allnoconfig as '$config_ignore{$config}'";
3683 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
3684 $keep_configs{$config} = $min_configs{$config};
3686 doprint "$config set by allnoconfig ... ignored\n";
3688 delete $min_configs{$config};
3700 # Now disable each config one by one and do a make oldconfig
3701 # till we find a config that changes our list.
3703 my @test_configs = keys %min_configs;
3705 # Sort keys by who is most dependent on
3706 @test_configs = sort { $depcount{chomp_config($b)} <=> $depcount{chomp_config($a)} }
3709 # Put configs that did not modify the config at the end.
3711 for (my $i = 0; $i < $#test_configs; $i++) {
3712 if (!defined($nochange_config{$test_configs[0]})) {
3716 # This config didn't change the .config last time.
3717 # Place it at the end
3718 my $config = shift @test_configs;
3719 push @test_configs, $config;
3722 # if every test config has failed to modify the .config file
3723 # in the past, then reset and start over.
3725 undef %nochange_config;
3728 undef %processed_configs;
3730 foreach my $config (@test_configs) {
3732 $found = test_this_config $config;
3734 last if (defined($found));
3736 # oh well, try another config
3739 if (!defined($found)) {
3740 # we could have failed due to the nochange_config hash
3741 # reset and try again
3743 undef %nochange_config;
3747 doprint "No more configs found that we can disable\n";
3755 doprint "Test with $config disabled\n";
3757 # set in_bisect to keep build and monitor from dieing
3761 build "oldconfig" or $failed = 1;
3763 start_monitor_and_boot or $failed = 1;
3765 if ($type eq "test" && !$failed) {
3766 do_run_test or $failed = 1;
3775 doprint "$min_configs{$config} is needed to boot the box... keeping\n";
3776 # this config is needed, add it to the ignore list.
3777 $keep_configs{$config} = $min_configs{$config};
3778 $save_configs{$config} = $min_configs{$config};
3779 delete $min_configs{$config};
3781 # update new ignore configs
3782 if (defined($ignore_config)) {
3783 open (OUT, ">$temp_config")
3784 or die "Can't write to $temp_config";
3785 foreach my $config (keys %save_configs) {
3786 print OUT "$save_configs{$config}\n";
3789 run_command "mv $temp_config $ignore_config" or
3790 dodie "failed to copy update to $ignore_config";
3794 # We booted without this config, remove it from the minconfigs.
3795 doprint "$config is not needed, disabling\n";
3797 delete $min_configs{$config};
3799 # Also disable anything that is not enabled in this config
3801 assign_configs \%configs, $output_config;
3802 my @config_keys = keys %min_configs;
3803 foreach my $config (@config_keys) {
3804 if (!defined($configs{$config})) {
3805 doprint "$config is not set, disabling\n";
3806 delete $min_configs{$config};
3810 # Save off all the current mandidory configs
3811 open (OUT, ">$temp_config")
3812 or die "Can't write to $temp_config";
3813 foreach my $config (keys %keep_configs) {
3814 print OUT "$keep_configs{$config}\n";
3816 foreach my $config (keys %min_configs) {
3817 print OUT "$min_configs{$config}\n";
3821 run_command "mv $temp_config $output_minconfig" or
3822 dodie "failed to copy update to $output_minconfig";
3825 doprint "Reboot and wait $sleep_time seconds\n";
3826 reboot_to_good $sleep_time;
3833 sub make_warnings_file {
3836 if (!defined($warnings_file)) {
3837 dodie "Must define WARNINGS_FILE for make_warnings_file test";
3840 if ($build_type eq "nobuild") {
3841 dodie "BUILD_TYPE can not be 'nobuild' for make_warnings_file test";
3844 build $build_type or dodie "Failed to build";
3846 open(OUT, ">$warnings_file") or dodie "Can't create $warnings_file";
3848 open(IN, $buildlog) or dodie "Can't open $buildlog";
3851 # Some compilers use UTF-8 extended for quotes
3852 # for distcc heterogeneous systems, this causes issues
3855 if (/$check_build_re/) {
3866 $#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl config-file\n";
3869 $ktest_config = $ARGV[0];
3870 if (! -f $ktest_config) {
3871 print "$ktest_config does not exist.\n";
3872 if (!read_yn "Create it?") {
3877 $ktest_config = "ktest.conf";
3880 if (! -f $ktest_config) {
3883 open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
3885 # Generated by ktest.pl
3888 # PWD is a ktest.pl variable that will result in the process working
3889 # directory that ktest.pl is executed in.
3891 # THIS_DIR is automatically assigned the PWD of the path that generated
3892 # the config file. It is best to use this variable when assigning other
3893 # directory paths within this directory. This allows you to easily
3894 # move the test cases to other locations or to other machines.
3896 THIS_DIR := $variable{"PWD"}
3898 # Define each test with TEST_START
3899 # The config options below it will override the defaults
3901 TEST_TYPE = $default{"TEST_TYPE"}
3908 read_config $ktest_config;
3910 if (defined($opt{"LOG_FILE"})) {
3911 $opt{"LOG_FILE"} = eval_option("LOG_FILE", $opt{"LOG_FILE"}, -1);
3914 # Append any configs entered in manually to the config file.
3915 my @new_configs = keys %entered_configs;
3916 if ($#new_configs >= 0) {
3917 print "\nAppending entered in configs to $ktest_config\n";
3918 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
3919 foreach my $config (@new_configs) {
3920 print OUT "$config = $entered_configs{$config}\n";
3921 $opt{$config} = process_variables($entered_configs{$config});
3925 if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
3926 unlink $opt{"LOG_FILE"};
3929 doprint "\n\nSTARTING AUTOMATED TESTS\n\n";
3931 for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
3934 doprint "DEFAULT OPTIONS:\n";
3936 doprint "\nTEST $i OPTIONS";
3937 if (defined($repeat_tests{$i})) {
3938 $repeat = $repeat_tests{$i};
3939 doprint " ITERATE $repeat";
3944 foreach my $option (sort keys %opt) {
3946 if ($option =~ /\[(\d+)\]$/) {
3952 doprint "$option = $opt{$option}\n";
3956 sub __set_test_option {
3957 my ($name, $i) = @_;
3959 my $option = "$name\[$i\]";
3961 if (defined($opt{$option})) {
3962 return $opt{$option};
3965 foreach my $test (keys %repeat_tests) {
3967 $i < $test + $repeat_tests{$test}) {
3968 $option = "$name\[$test\]";
3969 if (defined($opt{$option})) {
3970 return $opt{$option};
3975 if (defined($opt{$name})) {
3982 sub set_test_option {
3983 my ($name, $i) = @_;
3985 my $option = __set_test_option($name, $i);
3986 return $option if (!defined($option));
3988 return eval_option($name, $option, $i);
3991 # First we need to do is the builds
3992 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
3994 # Do not reboot on failing test options
3996 $reboot_success = 0;
4002 undef %force_config;
4004 my $makecmd = set_test_option("MAKE_CMD", $i);
4006 $outputdir = set_test_option("OUTPUT_DIR", $i);
4007 $builddir = set_test_option("BUILD_DIR", $i);
4009 chdir $builddir || die "can't change directory to $builddir";
4011 if (!-d $outputdir) {
4012 mkpath($outputdir) or
4013 die "can't create $outputdir";
4016 $make = "$makecmd O=$outputdir";
4018 # Load all the options into their mapped variable names
4019 foreach my $opt (keys %option_map) {
4020 ${$option_map{$opt}} = set_test_option($opt, $i);
4023 $start_minconfig_defined = 1;
4025 # The first test may override the PRE_KTEST option
4026 if (defined($pre_ktest) && $i == 1) {
4028 run_command $pre_ktest;
4031 # Any test can override the POST_KTEST option
4032 # The last test takes precedence.
4033 if (defined($post_ktest)) {
4034 $final_post_ktest = $post_ktest;
4037 if (!defined($start_minconfig)) {
4038 $start_minconfig_defined = 0;
4039 $start_minconfig = $minconfig;
4044 die "can't create $tmpdir";
4047 $ENV{"SSH_USER"} = $ssh_user;
4048 $ENV{"MACHINE"} = $machine;
4050 $buildlog = "$tmpdir/buildlog-$machine";
4051 $testlog = "$tmpdir/testlog-$machine";
4052 $dmesg = "$tmpdir/dmesg-$machine";
4053 $output_config = "$outputdir/.config";
4056 $target = "$ssh_user\@$machine";
4057 if ($reboot_type eq "grub") {
4058 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
4059 } elsif ($reboot_type eq "grub2") {
4060 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
4061 dodie "GRUB_FILE not defined" if (!defined($grub_file));
4062 } elsif ($reboot_type eq "syslinux") {
4063 dodie "SYSLINUX_LABEL not defined" if (!defined($syslinux_label));
4067 my $run_type = $build_type;
4068 if ($test_type eq "patchcheck") {
4069 $run_type = $patchcheck_type;
4070 } elsif ($test_type eq "bisect") {
4071 $run_type = $bisect_type;
4072 } elsif ($test_type eq "config_bisect") {
4073 $run_type = $config_bisect_type;
4074 } elsif ($test_type eq "make_min_config") {
4076 } elsif ($test_type eq "make_warnings_file") {
4080 # mistake in config file?
4081 if (!defined($run_type)) {
4082 $run_type = "ERROR";
4086 $installme = " no_install" if ($no_install);
4089 doprint "RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type$installme\n\n";
4091 if (defined($pre_test)) {
4092 run_command $pre_test;
4099 if (defined($addconfig)) {
4100 my $min = $minconfig;
4101 if (!defined($minconfig)) {
4104 run_command "cat $addconfig $min > $tmpdir/add_config" or
4105 dodie "Failed to create temp config";
4106 $minconfig = "$tmpdir/add_config";
4109 if (defined($checkout)) {
4110 run_command "git checkout $checkout" or
4111 die "failed to checkout $checkout";
4116 # A test may opt to not reboot the box
4117 if ($reboot_on_success) {
4118 $reboot_success = 1;
4121 if ($test_type eq "bisect") {
4124 } elsif ($test_type eq "config_bisect") {
4127 } elsif ($test_type eq "patchcheck") {
4130 } elsif ($test_type eq "make_min_config") {
4133 } elsif ($test_type eq "make_warnings_file") {
4135 make_warnings_file $i;
4139 if ($build_type ne "nobuild") {
4140 build $build_type or next;
4141 check_buildlog or next;
4144 if ($test_type eq "install") {
4151 if ($test_type ne "build") {
4153 start_monitor_and_boot or $failed = 1;
4155 if (!$failed && $test_type ne "boot" && defined($run_test)) {
4156 do_run_test or $failed = 1;
4165 if (defined($final_post_ktest)) {
4166 run_command $final_post_ktest;
4169 if ($opt{"POWEROFF_ON_SUCCESS"}) {
4171 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot && $reboot_success) {
4173 } elsif (defined($switch_to_good)) {
4174 # still need to get to the good kernel
4175 run_command $switch_to_good;
4179 doprint "\n $successes of $opt{NUM_TESTS} tests were successful\n\n";