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",
75 my $ktest_config = "ktest.conf";
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;
159 my $bisect_sleep_time;
160 my $patchcheck_sleep_time;
167 my $detect_triplefault;
169 my $close_console_signal;
170 my $reboot_success_line;
172 my $stop_after_success;
173 my $stop_after_failure;
192 my $config_bisect_type;
193 my $config_bisect_check;
196 my $patchcheck_start;
197 my $patchcheck_cherry;
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_CHERRY" => \$patchcheck_cherry,
325 "PATCHCHECK_END" => \$patchcheck_end,
328 # Options may be used by other options, record them.
331 # default variables that can be used
332 chomp ($variable{"PWD"} = `pwd`);
334 $config_help{"MACHINE"} = << "EOF"
335 The machine hostname that you will test.
336 For build only tests, it is still needed to differentiate log files.
339 $config_help{"SSH_USER"} = << "EOF"
340 The box is expected to have ssh on normal bootup, provide the user
341 (most likely root, since you need privileged operations)
344 $config_help{"BUILD_DIR"} = << "EOF"
345 The directory that contains the Linux source code (full path).
346 You can use \${PWD} that will be the path where ktest.pl is run, or use
347 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
350 $config_help{"OUTPUT_DIR"} = << "EOF"
351 The directory that the objects will be built (full path).
352 (can not be same as BUILD_DIR)
353 You can use \${PWD} that will be the path where ktest.pl is run, or use
354 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
357 $config_help{"BUILD_TARGET"} = << "EOF"
358 The location of the compiled file to copy to the target.
359 (relative to OUTPUT_DIR)
362 $config_help{"BUILD_OPTIONS"} = << "EOF"
363 Options to add to \"make\" when building.
367 $config_help{"TARGET_IMAGE"} = << "EOF"
368 The place to put your image on the test machine.
371 $config_help{"POWER_CYCLE"} = << "EOF"
372 A script or command to reboot the box.
374 Here is a digital loggers power switch example
375 POWER_CYCLE = wget --no-proxy -O /dev/null -q --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL'
377 Here is an example to reboot a virtual box on the current host
378 with the name "Guest".
379 POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest
382 $config_help{"CONSOLE"} = << "EOF"
383 The script or command that reads the console
385 If you use ttywatch server, something like the following would work.
386 CONSOLE = nc -d localhost 3001
388 For a virtual machine with guest name "Guest".
389 CONSOLE = virsh console Guest
392 $config_help{"LOCALVERSION"} = << "EOF"
393 Required version ending to differentiate the test
394 from other linux builds on the system.
397 $config_help{"REBOOT_TYPE"} = << "EOF"
398 Way to reboot the box to the test kernel.
399 Only valid options so far are "grub", "grub2", "syslinux", and "script".
401 If you specify grub, it will assume grub version 1
402 and will search in /boot/grub/menu.lst for the title \$GRUB_MENU
403 and select that target to reboot to the kernel. If this is not
404 your setup, then specify "script" and have a command or script
405 specified in REBOOT_SCRIPT to boot to the target.
407 The entry in /boot/grub/menu.lst must be entered in manually.
408 The test will not modify that file.
410 If you specify grub2, then you also need to specify both \$GRUB_MENU
413 If you specify syslinux, then you may use SYSLINUX to define the syslinux
414 command (defaults to extlinux), and SYSLINUX_PATH to specify the path to
415 the syslinux install (defaults to /boot/extlinux). But you have to specify
416 SYSLINUX_LABEL to define the label to boot to for the test kernel.
419 $config_help{"GRUB_MENU"} = << "EOF"
420 The grub title name for the test kernel to boot
421 (Only mandatory if REBOOT_TYPE = grub or grub2)
423 Note, ktest.pl will not update the grub menu.lst, you need to
424 manually add an option for the test. ktest.pl will search
425 the grub menu.lst for this option to find what kernel to
428 For example, if in the /boot/grub/menu.lst the test kernel title has:
431 GRUB_MENU = Test Kernel
433 For grub2, a search of \$GRUB_FILE is performed for the lines
434 that begin with "menuentry". It will not detect submenus. The
435 menu must be a non-nested menu. Add the quotes used in the menu
436 to guarantee your selection, as the first menuentry with the content
437 of \$GRUB_MENU that is found will be used.
440 $config_help{"GRUB_FILE"} = << "EOF"
441 If grub2 is used, the full path for the grub.cfg file is placed
442 here. Use something like /boot/grub2/grub.cfg to search.
445 $config_help{"SYSLINUX_LABEL"} = << "EOF"
446 If syslinux is used, the label that boots the target kernel must
447 be specified with SYSLINUX_LABEL.
450 $config_help{"REBOOT_SCRIPT"} = << "EOF"
451 A script to reboot the target into the test kernel
452 (Only mandatory if REBOOT_TYPE = script)
457 if (defined($opt{"LOG_FILE"})) {
458 open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
465 if (defined($opt{"LOG_FILE"})) {
478 my ($cancel, $prompt) = @_;
484 print "$prompt [y/n/C] ";
486 print "$prompt [Y/n] ";
490 if ($ans =~ /^\s*$/) {
497 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
499 last if ($ans =~ /^c$/i);
500 print "Please answer either 'y', 'n' or 'c'.\n";
502 print "Please answer either 'y' or 'n'.\n";
508 if ($ans !~ /^y$/i) {
517 return read_prompt 0, $prompt;
523 return read_prompt 1, $prompt;
526 sub get_mandatory_config {
530 return if (defined($opt{$config}));
532 if (defined($config_help{$config})) {
534 print $config_help{$config};
539 if (defined($default{$config}) && length($default{$config})) {
540 print "\[$default{$config}\] ";
543 $ans =~ s/^\s*(.*\S)\s*$/$1/;
544 if ($ans =~ /^\s*$/) {
545 if ($default{$config}) {
546 $ans = $default{$config};
548 print "Your answer can not be blank\n";
552 $entered_configs{$config} = ${ans};
557 sub get_mandatory_configs {
558 get_mandatory_config("MACHINE");
559 get_mandatory_config("BUILD_DIR");
560 get_mandatory_config("OUTPUT_DIR");
563 get_mandatory_config("BUILD_OPTIONS");
566 # options required for other than just building a kernel
568 get_mandatory_config("POWER_CYCLE");
569 get_mandatory_config("CONSOLE");
572 # options required for install and more
573 if ($buildonly != 1) {
574 get_mandatory_config("SSH_USER");
575 get_mandatory_config("BUILD_TARGET");
576 get_mandatory_config("TARGET_IMAGE");
579 get_mandatory_config("LOCALVERSION");
581 return if ($buildonly);
583 my $rtype = $opt{"REBOOT_TYPE"};
585 if (!defined($rtype)) {
586 if (!defined($opt{"GRUB_MENU"})) {
587 get_mandatory_config("REBOOT_TYPE");
588 $rtype = $entered_configs{"REBOOT_TYPE"};
594 if ($rtype eq "grub") {
595 get_mandatory_config("GRUB_MENU");
598 if ($rtype eq "grub2") {
599 get_mandatory_config("GRUB_MENU");
600 get_mandatory_config("GRUB_FILE");
603 if ($rtype eq "syslinux") {
604 get_mandatory_config("SYSLINUX_LABEL");
608 sub process_variables {
609 my ($value, $remove_undef) = @_;
612 # We want to check for '\', and it is just easier
613 # to check the previous characet of '$' and not need
614 # to worry if '$' is the first character. By adding
615 # a space to $value, we can just check [^\\]\$ and
616 # it will still work.
619 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
623 # append beginning of value to retval
624 $retval = "$retval$begin";
625 if (defined($variable{$var})) {
626 $retval = "$retval$variable{$var}";
627 } elsif (defined($remove_undef) && $remove_undef) {
628 # for if statements, any variable that is not defined,
629 # we simple convert to 0
630 $retval = "${retval}0";
632 # put back the origin piece.
633 $retval = "$retval\$\{$var\}";
634 # This could be an option that is used later, save
635 # it so we don't warn if this option is not one of
637 $used_options{$var} = 1;
641 $retval = "$retval$value";
643 # remove the space added in the beginning
650 my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
652 my $prvalue = process_variables($rvalue);
654 if ($buildonly && $lvalue =~ /^TEST_TYPE(\[.*\])?$/ && $prvalue ne "build") {
655 # Note if a test is something other than build, then we
656 # will need other manditory options.
657 if ($prvalue ne "install") {
658 # for bisect, we need to check BISECT_TYPE
659 if ($prvalue ne "bisect") {
663 # install still limits some manditory options.
668 if ($buildonly && $lvalue =~ /^BISECT_TYPE(\[.*\])?$/ && $prvalue ne "build") {
669 if ($prvalue ne "install") {
672 # install still limits some manditory options.
677 if (defined($opt{$lvalue})) {
678 if (!$override || defined(${$overrides}{$lvalue})) {
681 $extra = "In the same override section!\n";
683 die "$name: $.: Option $lvalue defined more than once!\n$extra";
685 ${$overrides}{$lvalue} = $prvalue;
688 $opt{$lvalue} = $prvalue;
692 my ($lvalue, $rvalue, $name) = @_;
694 my $prvalue = process_variables($rvalue);
697 if (defined($evals{$lvalue})) {
698 $arr = $evals{$lvalue};
701 $evals{$lvalue} = $arr;
704 push @{$arr}, $rvalue;
708 my ($lvalue, $rvalue) = @_;
710 if ($rvalue =~ /^\s*$/) {
711 delete $variable{$lvalue};
713 $rvalue = process_variables($rvalue);
714 $variable{$lvalue} = $rvalue;
718 sub process_compare {
719 my ($lval, $cmp, $rval) = @_;
730 return $lval eq $rval;
731 } elsif ($cmp eq "!=") {
732 return $lval ne $rval;
733 } elsif ($cmp eq "=~") {
734 return $lval =~ m/$rval/;
735 } elsif ($cmp eq "!~") {
736 return $lval !~ m/$rval/;
739 my $statement = "$lval $cmp $rval";
740 my $ret = eval $statement;
742 # $@ stores error of eval
753 return defined($variable{$2}) ||
758 sub process_expression {
759 my ($name, $val) = @_;
763 while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
766 if (process_expression($name, $express)) {
767 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
769 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
777 while ($val =~ s/^(.*?)($OR|$AND)//) {
781 if (process_expression($name, $express)) {
792 if ($val =~ /(.*)(==|\!=|>=|<=|>|<|=~|\!~)(.*)/) {
793 my $ret = process_compare($1, $2, $3);
795 die "$name: $.: Unable to process comparison\n";
800 if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
802 return !value_defined($2);
804 return value_defined($2);
808 if ($val =~ /^\s*0\s*$/) {
810 } elsif ($val =~ /^\s*\d+\s*$/) {
814 die ("$name: $.: Undefined content $val in if statement\n");
818 my ($name, $value) = @_;
820 # Convert variables and replace undefined ones with 0
821 my $val = process_variables($value, 1);
822 my $ret = process_expression $name, $val;
828 my ($config, $current_test_num) = @_;
831 open($in, $config) || die "can't read file $config";
834 $name =~ s,.*/(.*),$1,;
836 my $test_num = $$current_test_num;
839 my $num_tests_set = 0;
852 # ignore blank lines and comments
853 next if (/^\s*$/ || /\s*\#/);
855 if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
865 if ($type eq "TEST_START") {
867 if ($num_tests_set) {
868 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
871 $old_test_num = $test_num;
872 $old_repeat = $repeat;
874 $test_num += $repeat;
881 # If SKIP is anywhere in the line, the command will be skipped
882 if ($rest =~ s/\s+SKIP\b//) {
889 if ($rest =~ s/\sELSE\b//) {
891 die "$name: $.: ELSE found with out matching IF section\n$_";
902 if ($rest =~ s/\sIF\s+(.*)//) {
903 if (process_if($name, $1)) {
915 if ($type eq "TEST_START") {
916 if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
918 $repeat_tests{"$test_num"} = $repeat;
920 } elsif ($rest =~ s/\sOVERRIDE\b//) {
923 # Clear previous overrides
928 if (!$skip && $rest !~ /^\s*$/) {
929 die "$name: $.: Gargbage found after $type\n$_";
932 if ($skip && $type eq "TEST_START") {
933 $test_num = $old_test_num;
934 $repeat = $old_repeat;
937 } elsif (/^\s*ELSE\b(.*)$/) {
939 die "$name: $.: ELSE found with out matching IF section\n$_";
948 if ($rest =~ /\sIF\s+(.*)/) {
949 # May be a ELSE IF section.
950 if (process_if($name, $1)) {
961 if ($rest !~ /^\s*$/) {
962 die "$name: $.: Gargbage found after DEFAULTS\n$_";
965 } elsif (/^\s*INCLUDE\s+(\S+)/) {
970 die "$name: $.: INCLUDE can only be done in default sections\n$_";
973 my $file = process_variables($1);
975 if ($file !~ m,^/,) {
976 # check the path of the config file first
977 if ($config =~ m,(.*)/,) {
985 die "$name: $.: Can't read file $file\n$_";
988 if (__read_config($file, \$test_num)) {
992 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=~\s*(.*?)\s*$/) {
999 if ($default || $lvalue =~ /\[\d+\]$/) {
1000 set_eval($lvalue, $rvalue, $name);
1002 my $val = "$lvalue\[$test_num\]";
1003 set_eval($val, $rvalue, $name);
1006 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
1014 ($lvalue eq "NUM_TESTS" ||
1015 $lvalue eq "LOG_FILE" ||
1016 $lvalue eq "CLEAR_LOG")) {
1017 die "$name: $.: $lvalue must be set in DEFAULTS section\n";
1020 if ($lvalue eq "NUM_TESTS") {
1022 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
1025 die "$name: $.: NUM_TESTS must be set in default section\n";
1030 if ($default || $lvalue =~ /\[\d+\]$/) {
1031 set_value($lvalue, $rvalue, $override, \%overrides, $name);
1033 my $val = "$lvalue\[$test_num\]";
1034 set_value($val, $rvalue, $override, \%overrides, $name);
1037 $repeats{$val} = $repeat;
1040 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
1046 # process config variables.
1047 # Config variables are only active while reading the
1048 # config and can be defined anywhere. They also ignore
1049 # TEST_START and DEFAULTS, but are skipped if they are in
1050 # on of these sections that have SKIP defined.
1051 # The save variable can be
1052 # defined multiple times and the new one simply overrides
1054 set_variable($lvalue, $rvalue);
1057 die "$name: $.: Garbage found in config\n$_";
1062 $test_num += $repeat - 1;
1063 $opt{"NUM_TESTS"} = $test_num;
1068 $$current_test_num = $test_num;
1074 print "What test case would you like to run?\n";
1075 print " (build, install or boot)\n";
1076 print " Other tests are available but require editing the config file\n";
1079 $default{"TEST_TYPE"} = $ans;
1088 $test_case = __read_config $config, \$test_num;
1090 # make sure we have all mandatory configs
1091 get_mandatory_configs;
1093 # was a test specified?
1095 print "No test case specified.\n";
1101 foreach my $default (keys %default) {
1102 if (!defined($opt{$default})) {
1103 $opt{$default} = $default{$default};
1107 if ($opt{"IGNORE_UNUSED"} == 1) {
1113 # check if there are any stragglers (typos?)
1114 foreach my $option (keys %opt) {
1116 # remove per test labels.
1118 if (!exists($option_map{$op}) &&
1119 !exists($default{$op}) &&
1120 !exists($used_options{$op})) {
1127 $s = " is" if (keys %not_used == 1);
1128 print "The following option$s not used; could be a typo:\n";
1129 foreach my $option (keys %not_used) {
1132 print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";
1133 if (!read_yn "Do you want to continue?") {
1140 my ($name, $option, $i) = @_;
1142 # Add space to evaluate the character before $
1143 $option = " $option";
1148 foreach my $test (keys %repeat_tests) {
1150 $i < $test + $repeat_tests{$test}) {
1158 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
1163 # Append beginning of line
1164 $retval = "$retval$start";
1166 # If the iteration option OPT[$i] exists, then use that.
1167 # otherwise see if the default OPT (without [$i]) exists.
1169 my $o = "$var\[$i\]";
1170 my $parento = "$var\[$parent\]";
1172 # If a variable contains itself, use the default var
1173 if (($var eq $name) && defined($opt{$var})) {
1175 $retval = "$retval$o";
1176 } elsif (defined($opt{$o})) {
1178 $retval = "$retval$o";
1179 } elsif ($repeated && defined($opt{$parento})) {
1180 $o = $opt{$parento};
1181 $retval = "$retval$o";
1182 } elsif (defined($opt{$var})) {
1184 $retval = "$retval$o";
1185 } elsif ($var eq "KERNEL_VERSION" && defined($make)) {
1186 # special option KERNEL_VERSION uses kernel version
1188 $retval = "$retval$version";
1190 $retval = "$retval\$\{$var\}";
1196 $retval = "$retval$option";
1204 my ($name, $option, $i) = @_;
1206 my $option_name = "$name\[$i\]";
1209 my $old_option = $option;
1211 if (defined($evals{$option_name})) {
1212 $ev = $evals{$option_name};
1213 } elsif (defined($evals{$name})) {
1214 $ev = $evals{$name};
1219 for my $e (@{$ev}) {
1220 eval "\$option =~ $e";
1223 if ($option ne $old_option) {
1224 doprint("$name changed from '$old_option' to '$option'\n");
1231 my ($name, $option, $i) = @_;
1235 # Since an option can evaluate to another option,
1236 # keep iterating until we do not evaluate any more
1239 while ($prev ne $option) {
1240 # Check for recursive evaluations.
1241 # 100 deep should be more than enough.
1243 die "Over 100 evaluations accurred with $option\n" .
1244 "Check for recursive variables\n";
1247 $option = __eval_option($name, $option, $i);
1250 $option = process_evals($name, $option, $i);
1258 sub wait_for_monitor;
1263 # Make sure everything has been written to disk
1266 if (defined($time)) {
1268 # flush out current monitor
1269 # May contain the reboot success line
1273 # try to reboot normally
1274 if (run_command $reboot) {
1275 if (defined($powercycle_after_reboot)) {
1276 sleep $powercycle_after_reboot;
1277 run_command "$power_cycle";
1280 # nope? power cycle it.
1281 run_command "$power_cycle";
1284 if (defined($time)) {
1286 # We only want to get to the new kernel, don't fail
1287 # if we stumble over a call trace.
1288 my $save_ignore_errors = $ignore_errors;
1291 # Look for the good kernel to boot
1292 if (wait_for_monitor($time, "Linux version")) {
1294 doprint "Reboot did not finish. Forcing power cycle\n";
1295 run_command "$power_cycle";
1298 $ignore_errors = $save_ignore_errors;
1300 # Still need to wait for the reboot to finish
1301 wait_for_monitor($time, $reboot_success_line);
1307 sub reboot_to_good {
1310 if (defined($switch_to_good)) {
1311 run_command $switch_to_good;
1320 return $test_type eq "build" || $no_reboot ||
1321 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
1322 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
1326 doprint "CRITICAL FAILURE... ", @_, "\n";
1330 if ($reboot_on_error && !do_not_reboot) {
1332 doprint "REBOOTING\n";
1335 } elsif ($poweroff_on_error && defined($power_off)) {
1336 doprint "POWERING OFF\n";
1340 if (defined($opt{"LOG_FILE"})) {
1341 print " See $opt{LOG_FILE} for more info.\n";
1352 my $pid = open($fp, "$console|") or
1353 dodie "Can't open console $console";
1355 $flags = fcntl($fp, F_GETFL, 0) or
1356 dodie "Can't get flags for the socket: $!";
1357 $flags = fcntl($fp, F_SETFL, $flags | O_NONBLOCK) or
1358 dodie "Can't set flags for the socket: $!";
1364 my ($fp, $pid) = @_;
1366 doprint "kill child process $pid\n";
1367 kill $close_console_signal, $pid;
1374 if ($monitor_cnt++) {
1377 $monitor_fp = \*MONFD;
1378 $monitor_pid = open_console $monitor_fp;
1382 open(MONFD, "Stop perl from warning about single use of MONFD");
1386 return if (!defined $console);
1387 if (--$monitor_cnt) {
1390 close_console($monitor_fp, $monitor_pid);
1393 sub wait_for_monitor {
1394 my ($time, $stop) = @_;
1398 my $start_time = time;
1399 my $skip_call_trace = 0;
1401 my $bug_ignored = 0;
1404 doprint "** Wait for monitor to settle down **\n";
1406 # read the monitor and wait for the system to calm down
1408 $line = wait_for_input($monitor_fp, $time);
1409 last if (!defined($line));
1411 $full_line .= $line;
1413 if (defined($stop) && $full_line =~ /$stop/) {
1414 doprint "wait for monitor detected $stop\n";
1418 if ($full_line =~ /\[ backtrace testing \]/) {
1419 $skip_call_trace = 1;
1422 if ($full_line =~ /call trace:/i) {
1423 if (!$bug && !$skip_call_trace) {
1424 if ($ignore_errors) {
1432 if ($full_line =~ /\[ end of backtrace testing \]/) {
1433 $skip_call_trace = 0;
1436 if ($full_line =~ /Kernel panic -/) {
1440 if ($line =~ /\n/) {
1444 if ($now - $start_time >= $max_monitor_wait) {
1445 doprint "Exiting monitor flush due to hitting MAX_MONITOR_WAIT\n";
1449 print "** Monitor flushed **\n";
1451 # if stop is defined but wasn't hit, return error
1452 # used by reboot (which wants to see a reboot)
1453 if (defined($stop) && !$booted) {
1460 my ($result, $basedir) = @_;
1462 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
1463 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
1465 my $type = $build_type;
1466 if ($type =~ /useconfig/) {
1467 $type = "useconfig";
1470 my $dir = "$machine-$test_type-$type-$result-$date";
1472 $dir = "$basedir/$dir";
1476 die "can't create $dir";
1480 "config" => $output_config,
1481 "buildlog" => $buildlog,
1483 "testlog" => $testlog,
1486 while (my ($name, $source) = each(%files)) {
1488 cp "$source", "$dir/$name" or
1489 die "failed to copy $source";
1493 doprint "*** Saved info to $dir ***\n";
1498 if (defined($post_test)) {
1499 run_command $post_test;
1502 if ($die_on_failure) {
1510 # no need to reboot for just building.
1511 if (!do_not_reboot) {
1512 doprint "REBOOTING\n";
1513 reboot_to_good $sleep_time;
1518 if (defined($test_name)) {
1519 $name = " ($test_name)";
1522 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1523 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1524 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
1525 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1526 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1528 if (defined($store_failures)) {
1529 save_logs "fail", $store_failures;
1536 my ($command, $redirect) = @_;
1541 $command =~ s/\$SSH_USER/$ssh_user/g;
1542 $command =~ s/\$MACHINE/$machine/g;
1544 doprint("$command ... ");
1546 $pid = open(CMD, "$command 2>&1 |") or
1547 (fail "unable to exec $command" and return 0);
1549 if (defined($opt{"LOG_FILE"})) {
1550 open(LOG, ">>$opt{LOG_FILE}") or
1551 dodie "failed to write to log";
1555 if (defined($redirect)) {
1556 open (RD, ">$redirect") or
1557 dodie "failed to write to redirect $redirect";
1562 print LOG if ($dolog);
1563 print RD if ($dord);
1570 close(LOG) if ($dolog);
1571 close(RD) if ($dord);
1574 doprint "FAILED!\n";
1576 doprint "SUCCESS\n";
1584 my $cp_exec = $ssh_exec;
1586 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
1587 return run_command "$cp_exec";
1591 my ($src, $dst, $cp_scp) = @_;
1593 $cp_scp =~ s/\$SRC_FILE/$src/g;
1594 $cp_scp =~ s/\$DST_FILE/$dst/g;
1596 return run_command "$cp_scp";
1599 sub run_scp_install {
1600 my ($src, $dst) = @_;
1602 my $cp_scp = $scp_to_target_install;
1604 return run_scp($src, $dst, $cp_scp);
1608 my ($src, $dst) = @_;
1610 my $cp_scp = $scp_to_target;
1612 return run_scp($src, $dst, $cp_scp);
1615 sub get_grub2_index {
1617 return if (defined($grub_number) && defined($last_grub_menu) &&
1618 $last_grub_menu eq $grub_menu && defined($last_machine) &&
1619 $last_machine eq $machine);
1621 doprint "Find grub2 menu ... ";
1624 my $ssh_grub = $ssh_exec;
1625 $ssh_grub =~ s,\$SSH_COMMAND,cat $grub_file,g;
1627 open(IN, "$ssh_grub |")
1628 or die "unable to get $grub_file";
1633 if (/^menuentry.*$grub_menu/) {
1637 } elsif (/^menuentry\s/) {
1643 die "Could not find '$grub_menu' in $grub_file on $machine"
1645 doprint "$grub_number\n";
1646 $last_grub_menu = $grub_menu;
1647 $last_machine = $machine;
1650 sub get_grub_index {
1652 if ($reboot_type eq "grub2") {
1657 if ($reboot_type ne "grub") {
1660 return if (defined($grub_number) && defined($last_grub_menu) &&
1661 $last_grub_menu eq $grub_menu && defined($last_machine) &&
1662 $last_machine eq $machine);
1664 doprint "Find grub menu ... ";
1667 my $ssh_grub = $ssh_exec;
1668 $ssh_grub =~ s,\$SSH_COMMAND,cat /boot/grub/menu.lst,g;
1670 open(IN, "$ssh_grub |")
1671 or die "unable to get menu.lst";
1676 if (/^\s*title\s+$grub_menu\s*$/) {
1680 } elsif (/^\s*title\s/) {
1686 die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
1688 doprint "$grub_number\n";
1689 $last_grub_menu = $grub_menu;
1690 $last_machine = $machine;
1695 my ($fp, $time) = @_;
1701 if (!defined($time)) {
1706 vec($rin, fileno($fp), 1) = 1;
1707 ($ready, $time) = select($rin, undef, undef, $time);
1711 # try to read one char at a time
1712 while (sysread $fp, $ch, 1) {
1714 last if ($ch eq "\n");
1717 if (!length($line)) {
1725 if (defined($switch_to_test)) {
1726 run_command $switch_to_test;
1729 if ($reboot_type eq "grub") {
1730 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
1731 } elsif ($reboot_type eq "grub2") {
1732 run_ssh "$grub_reboot $grub_number";
1733 } elsif ($reboot_type eq "syslinux") {
1734 run_ssh "$syslinux --once \\\"$syslinux_label\\\" $syslinux_path";
1735 } elsif (defined $reboot_script) {
1736 run_command "$reboot_script";
1744 doprint "git rev-list --max-count=1 $commit ... ";
1745 my $sha1 = `git rev-list --max-count=1 $commit`;
1752 dodie "Failed to get git $commit";
1765 my $bug_ignored = 0;
1766 my $skip_call_trace = 0;
1774 open(DMESG, "> $dmesg") or
1775 die "unable to write to $dmesg";
1781 my $monitor_start = time;
1783 my $version_found = 0;
1787 if ($bug && defined($stop_after_failure) &&
1788 $stop_after_failure >= 0) {
1789 my $time = $stop_after_failure - (time - $failure_start);
1790 $line = wait_for_input($monitor_fp, $time);
1791 if (!defined($line)) {
1792 doprint "bug timed out after $booted_timeout seconds\n";
1793 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1797 $line = wait_for_input($monitor_fp, $booted_timeout);
1798 if (!defined($line)) {
1799 my $s = $booted_timeout == 1 ? "" : "s";
1800 doprint "Successful boot found: break after $booted_timeout second$s\n";
1804 $line = wait_for_input($monitor_fp);
1805 if (!defined($line)) {
1806 my $s = $timeout == 1 ? "" : "s";
1807 doprint "Timed out after $timeout second$s\n";
1815 # we are not guaranteed to get a full line
1816 $full_line .= $line;
1818 if ($full_line =~ /$success_line/) {
1820 $success_start = time;
1823 if ($booted && defined($stop_after_success) &&
1824 $stop_after_success >= 0) {
1826 if ($now - $success_start >= $stop_after_success) {
1827 doprint "Test forced to stop after $stop_after_success seconds after success\n";
1832 if ($full_line =~ /\[ backtrace testing \]/) {
1833 $skip_call_trace = 1;
1836 if ($full_line =~ /call trace:/i) {
1837 if (!$bug && !$skip_call_trace) {
1838 if ($ignore_errors) {
1842 $failure_start = time;
1847 if ($bug && defined($stop_after_failure) &&
1848 $stop_after_failure >= 0) {
1850 if ($now - $failure_start >= $stop_after_failure) {
1851 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1856 if ($full_line =~ /\[ end of backtrace testing \]/) {
1857 $skip_call_trace = 0;
1860 if ($full_line =~ /Kernel panic -/) {
1861 $failure_start = time;
1865 # Detect triple faults by testing the banner
1866 if ($full_line =~ /\bLinux version (\S+).*\n/) {
1867 if ($1 eq $version) {
1869 } elsif ($version_found && $detect_triplefault) {
1870 # We already booted into the kernel we are testing,
1871 # but now we booted into another kernel?
1872 # Consider this a triple fault.
1873 doprint "Already booted in Linux kernel $version, but now\n";
1874 doprint "we booted into Linux kernel $1.\n";
1875 doprint "Assuming that this is a triple fault.\n";
1876 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
1881 if ($line =~ /\n/) {
1885 if ($stop_test_after > 0 && !$booted && !$bug) {
1886 if (time - $monitor_start > $stop_test_after) {
1887 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
1896 return 0 if ($in_bisect);
1897 fail "failed - got a bug report" and return 0;
1901 return 0 if ($in_bisect);
1902 fail "failed - never got a boot prompt." and return 0;
1906 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
1912 sub eval_kernel_version {
1915 $option =~ s/\$KERNEL_VERSION/$version/g;
1920 sub do_post_install {
1922 return if (!defined($post_install));
1924 my $cp_post_install = eval_kernel_version $post_install;
1925 run_command "$cp_post_install" or
1926 dodie "Failed to run post install";
1929 # Sometimes the reboot fails, and will hang. We try to ssh to the box
1930 # and if we fail, we force another reboot, that should powercycle it.
1932 if (!run_ssh "echo testing connection") {
1939 return if ($no_install);
1941 if (defined($pre_install)) {
1942 my $cp_pre_install = eval_kernel_version $pre_install;
1943 run_command "$cp_pre_install" or
1944 dodie "Failed to run pre install";
1947 my $cp_target = eval_kernel_version $target_image;
1951 run_scp_install "$outputdir/$build_target", "$cp_target" or
1952 dodie "failed to copy image";
1954 my $install_mods = 0;
1956 # should we process modules?
1958 open(IN, "$output_config") or dodie("Can't read config file");
1960 if (/CONFIG_MODULES(=y)?/) {
1969 if (!$install_mods) {
1971 doprint "No modules needed\n";
1975 run_command "$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or
1976 dodie "Failed to install modules";
1978 my $modlib = "/lib/modules/$version";
1979 my $modtar = "ktest-mods.tar.bz2";
1981 run_ssh "rm -rf $modlib" or
1982 dodie "failed to remove old mods: $modlib";
1984 # would be nice if scp -r did not follow symbolic links
1985 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
1986 dodie "making tarball";
1988 run_scp_mod "$tmpdir/$modtar", "/tmp" or
1989 dodie "failed to copy modules";
1991 unlink "$tmpdir/$modtar";
1993 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
1994 dodie "failed to tar modules";
1996 run_ssh "rm -f /tmp/$modtar";
2002 # get the release name
2003 return if ($have_version);
2004 doprint "$make kernelrelease ... ";
2005 $version = `$make -s kernelrelease | tail -1`;
2007 doprint "$version\n";
2011 sub start_monitor_and_boot {
2012 # Make sure the stable kernel has finished booting
2014 # Install bisects, don't need console
2015 if (defined $console) {
2025 start_monitor if (defined $console);
2029 my $check_build_re = ".*:.*(warning|error|Error):.*";
2030 my $utf8_quote = "\\x{e2}\\x{80}(\\x{98}|\\x{99})";
2032 sub process_warning_line {
2037 # for distcc heterogeneous systems, some compilers
2038 # do things differently causing warning lines
2039 # to be slightly different. This makes an attempt
2040 # to fixe those issues.
2042 # chop off the index into the line
2043 # using distcc, some compilers give different indexes
2044 # depending on white space
2045 $line =~ s/^(\s*\S+:\d+:)\d+/$1/;
2047 # Some compilers use UTF-8 extended for quotes and some don't.
2048 $line =~ s/$utf8_quote/'/g;
2053 # Read buildlog and check against warnings file for any
2058 sub check_buildlog {
2059 return 1 if (!defined $warnings_file);
2063 # Failed builds should not reboot the target
2064 my $save_no_reboot = $no_reboot;
2067 if (-f $warnings_file) {
2068 open(IN, $warnings_file) or
2069 dodie "Error opening $warnings_file";
2072 if (/$check_build_re/) {
2073 my $warning = process_warning_line $_;
2075 $warnings_list{$warning} = 1;
2081 # If warnings file didn't exist, and WARNINGS_FILE exist,
2082 # then we fail on any warning!
2084 open(IN, $buildlog) or dodie "Can't open $buildlog";
2086 if (/$check_build_re/) {
2087 my $warning = process_warning_line $_;
2089 if (!defined $warnings_list{$warning}) {
2090 fail "New warning found (not in $warnings_file)\n$_\n";
2091 $no_reboot = $save_no_reboot;
2096 $no_reboot = $save_no_reboot;
2100 sub check_patch_buildlog {
2103 my @files = `git show $patch | diffstat -l`;
2105 foreach my $file (@files) {
2109 open(IN, "git show $patch |") or
2110 dodie "failed to show $patch";
2112 if (m,^--- a/(.*),) {
2114 $files[$#files] = $1;
2119 open(IN, $buildlog) or dodie "Can't open $buildlog";
2121 if (/^\s*(.*?):.*(warning|error)/) {
2123 foreach my $file (@files) {
2124 my $fullpath = "$builddir/$file";
2125 if ($file eq $err || $fullpath eq $err) {
2126 fail "$file built with warnings" and return 0;
2136 sub apply_min_config {
2137 my $outconfig = "$output_config.new";
2139 # Read the config file and remove anything that
2140 # is in the force_config hash (from minconfig and others)
2141 # then add the force config back.
2143 doprint "Applying minimum configurations into $output_config.new\n";
2145 open (OUT, ">$outconfig") or
2146 dodie "Can't create $outconfig";
2148 if (-f $output_config) {
2149 open (IN, $output_config) or
2150 dodie "Failed to open $output_config";
2152 if (/^(# )?(CONFIG_[^\s=]*)/) {
2153 next if (defined($force_config{$2}));
2159 foreach my $config (keys %force_config) {
2160 print OUT "$force_config{$config}\n";
2164 run_command "mv $outconfig $output_config";
2167 sub make_oldconfig {
2169 my @force_list = keys %force_config;
2171 if ($#force_list >= 0) {
2175 if (!run_command "$make olddefconfig") {
2176 # Perhaps olddefconfig doesn't exist in this version of the kernel
2178 doprint "olddefconfig failed, trying make oldnoconfig\n";
2179 if (!run_command "$make oldnoconfig") {
2180 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
2181 # try a yes '' | oldconfig
2182 run_command "yes '' | $make oldconfig" or
2183 dodie "failed make config oldconfig";
2188 # read a config file and use this to force new configs.
2189 sub load_force_config {
2192 doprint "Loading force configs from $config\n";
2193 open(IN, $config) or
2194 dodie "failed to read $config";
2197 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
2198 $force_config{$1} = $_;
2199 } elsif (/^# (CONFIG_\S*) is not set/) {
2200 $force_config{$1} = $_;
2211 # Failed builds should not reboot the target
2212 my $save_no_reboot = $no_reboot;
2215 # Calculate a new version from here.
2218 if (defined($pre_build)) {
2219 my $ret = run_command $pre_build;
2220 if (!$ret && defined($pre_build_die) &&
2222 dodie "failed to pre_build\n";
2226 if ($type =~ /^useconfig:(.*)/) {
2227 run_command "cp $1 $output_config" or
2228 dodie "could not copy $1 to .config";
2230 $type = "oldconfig";
2233 # old config can ask questions
2234 if ($type eq "oldconfig") {
2235 $type = "olddefconfig";
2237 # allow for empty configs
2238 run_command "touch $output_config";
2241 run_command "mv $output_config $outputdir/config_temp" or
2242 dodie "moving .config";
2244 run_command "$make mrproper" or dodie "make mrproper";
2246 run_command "mv $outputdir/config_temp $output_config" or
2247 dodie "moving config_temp";
2250 } elsif (!$noclean) {
2251 unlink "$output_config";
2252 run_command "$make mrproper" or
2253 dodie "make mrproper";
2256 # add something to distinguish this build
2257 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
2258 print OUT "$localversion\n";
2261 if (defined($minconfig)) {
2262 load_force_config($minconfig);
2265 if ($type ne "olddefconfig") {
2266 run_command "$make $type" or
2267 dodie "failed make config";
2269 # Run old config regardless, to enforce min configurations
2272 my $build_ret = run_command "$make $build_options", $buildlog;
2274 if (defined($post_build)) {
2275 # Because a post build may change the kernel version
2278 my $ret = run_command $post_build;
2279 if (!$ret && defined($post_build_die) &&
2281 dodie "failed to post_build\n";
2286 # bisect may need this to pass
2288 $no_reboot = $save_no_reboot;
2291 fail "failed build" and return 0;
2294 $no_reboot = $save_no_reboot;
2300 if (!run_ssh "halt" or defined($power_off)) {
2301 if (defined($poweroff_after_halt)) {
2302 sleep $poweroff_after_halt;
2303 run_command "$power_off";
2307 run_command "$power_off";
2314 if (defined($post_test)) {
2315 run_command $post_test;
2322 if (defined($test_name)) {
2323 $name = " ($test_name)";
2326 doprint "\n\n*******************************************\n";
2327 doprint "*******************************************\n";
2328 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
2329 doprint "*******************************************\n";
2330 doprint "*******************************************\n";
2332 if (defined($store_successes)) {
2333 save_logs "success", $store_successes;
2336 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
2337 doprint "Reboot and wait $sleep_time seconds\n";
2338 reboot_to_good $sleep_time;
2344 doprint "Pass, fail, or skip? [p/f/s]";
2347 if ($ans eq "p" || $ans eq "P") {
2349 } elsif ($ans eq "f" || $ans eq "F") {
2351 } elsif ($ans eq "s" || $ans eq "S") {
2354 print "Please answer 'p', 'f', or 's'\n";
2359 sub child_run_test {
2362 # child should have no power
2363 $reboot_on_error = 0;
2364 $poweroff_on_error = 0;
2365 $die_on_failure = 1;
2367 run_command $run_test, $testlog or $failed = 1;
2374 sub child_finished {
2384 my $bug_ignored = 0;
2388 doprint "run test $run_test\n";
2392 $SIG{CHLD} = qw(child_finished);
2396 child_run_test if (!$child_pid);
2401 $line = wait_for_input($monitor_fp, 1);
2402 if (defined($line)) {
2404 # we are not guaranteed to get a full line
2405 $full_line .= $line;
2408 if ($full_line =~ /call trace:/i) {
2409 if ($ignore_errors) {
2416 if ($full_line =~ /Kernel panic -/) {
2420 if ($line =~ /\n/) {
2424 } while (!$child_done && !$bug);
2426 if (!$bug && $bug_ignored) {
2427 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2431 my $failure_start = time;
2434 $line = wait_for_input($monitor_fp, 1);
2435 if (defined($line)) {
2439 if ($now - $failure_start >= $stop_after_failure) {
2442 } while (defined($line));
2444 doprint "Detected kernel crash!\n";
2445 # kill the child with extreme prejudice
2449 waitpid $child_pid, 0;
2452 if (!$bug && $in_bisect) {
2453 if (defined($bisect_ret_good)) {
2454 if ($child_exit == $bisect_ret_good) {
2458 if (defined($bisect_ret_skip)) {
2459 if ($child_exit == $bisect_ret_skip) {
2463 if (defined($bisect_ret_abort)) {
2464 if ($child_exit == $bisect_ret_abort) {
2465 fail "test abort" and return -2;
2468 if (defined($bisect_ret_bad)) {
2469 if ($child_exit == $bisect_ret_skip) {
2473 if (defined($bisect_ret_default)) {
2474 if ($bisect_ret_default eq "good") {
2476 } elsif ($bisect_ret_default eq "bad") {
2478 } elsif ($bisect_ret_default eq "skip") {
2480 } elsif ($bisect_ret_default eq "abort") {
2483 fail "unknown default action: $bisect_ret_default"
2489 if ($bug || $child_exit) {
2490 return 0 if $in_bisect;
2491 fail "test failed" and return 0;
2496 sub run_git_bisect {
2499 doprint "$command ... ";
2501 my $output = `$command 2>&1`;
2508 dodie "Failed to git bisect";
2511 doprint "SUCCESS\n";
2512 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
2513 doprint "$1 [$2]\n";
2514 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
2515 $bisect_bad_commit = $1;
2516 doprint "Found bad commit... $1\n";
2519 # we already logged it, just print it now.
2527 doprint "Reboot and sleep $bisect_sleep_time seconds\n";
2528 reboot_to_good $bisect_sleep_time;
2531 # returns 1 on success, 0 on failure, -1 on skip
2532 sub run_bisect_test {
2533 my ($type, $buildtype) = @_;
2542 build $buildtype or $failed = 1;
2544 if ($type ne "build") {
2545 if ($failed && $bisect_skip) {
2549 dodie "Failed on build" if $failed;
2552 start_monitor_and_boot or $failed = 1;
2554 if ($type ne "boot") {
2555 if ($failed && $bisect_skip) {
2561 dodie "Failed on boot" if $failed;
2563 do_run_test or $failed = 1;
2574 # reboot the box to a kernel we can ssh to
2575 if ($type ne "build") {
2585 my $buildtype = "oldconfig";
2587 # We should have a minconfig to use?
2588 if (defined($minconfig)) {
2589 $buildtype = "useconfig:$minconfig";
2592 # If the user sets bisect_tries to less than 1, then no tries
2596 # Still let the user manually decide that though.
2597 if ($bisect_tries < 1 && $bisect_manual) {
2598 $ret = answer_bisect;
2601 for (my $i = 0; $i < $bisect_tries; $i++) {
2602 if ($bisect_tries > 1) {
2604 doprint("Running bisect trial $t of $bisect_tries:\n");
2606 $ret = run_bisect_test $type, $buildtype;
2608 if ($bisect_manual) {
2609 $ret = answer_bisect;
2615 # Are we looking for where it worked, not failed?
2616 if ($reverse_bisect && $ret >= 0) {
2622 } elsif ($ret == 0) {
2624 } elsif ($bisect_skip) {
2625 doprint "HIT A BAD COMMIT ... SKIPPING\n";
2630 sub update_bisect_replay {
2631 my $tmp_log = "$tmpdir/ktest_bisect_log";
2632 run_command "git bisect log > $tmp_log" or
2633 die "can't create bisect log";
2642 die "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good));
2643 die "BISECT_BAD[$i] not defined\n" if (!defined($bisect_bad));
2644 die "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type));
2646 my $good = $bisect_good;
2647 my $bad = $bisect_bad;
2648 my $type = $bisect_type;
2649 my $start = $bisect_start;
2650 my $replay = $bisect_replay;
2651 my $start_files = $bisect_files;
2653 if (defined($start_files)) {
2654 $start_files = " -- " . $start_files;
2659 # convert to true sha1's
2660 $good = get_sha1($good);
2661 $bad = get_sha1($bad);
2663 if (defined($bisect_reverse) && $bisect_reverse == 1) {
2664 doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
2665 $reverse_bisect = 1;
2667 $reverse_bisect = 0;
2670 # Can't have a test without having a test to run
2671 if ($type eq "test" && !defined($run_test)) {
2675 # Check if a bisect was running
2676 my $bisect_start_file = "$builddir/.git/BISECT_START";
2678 my $check = $bisect_check;
2679 my $do_check = defined($check) && $check ne "0";
2681 if ( -f $bisect_start_file ) {
2682 print "Bisect in progress found\n";
2684 print " If you say yes, then no checks of good or bad will be done\n";
2686 if (defined($replay)) {
2687 print "** BISECT_REPLAY is defined in config file **";
2688 print " Ignore config option and perform new git bisect log?\n";
2689 if (read_ync " (yes, no, or cancel) ") {
2690 $replay = update_bisect_replay;
2693 } elsif (read_yn "read git log and continue?") {
2694 $replay = update_bisect_replay;
2702 my $head = get_sha1("HEAD");
2704 if ($check ne "good") {
2705 doprint "TESTING BISECT BAD [$bad]\n";
2706 run_command "git checkout $bad" or
2707 die "Failed to checkout $bad";
2709 $result = run_bisect $type;
2711 if ($result ne "bad") {
2712 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
2716 if ($check ne "bad") {
2717 doprint "TESTING BISECT GOOD [$good]\n";
2718 run_command "git checkout $good" or
2719 die "Failed to checkout $good";
2721 $result = run_bisect $type;
2723 if ($result ne "good") {
2724 fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
2728 # checkout where we started
2729 run_command "git checkout $head" or
2730 die "Failed to checkout $head";
2733 run_command "git bisect start$start_files" or
2734 dodie "could not start bisect";
2736 if (defined($replay)) {
2737 run_command "git bisect replay $replay" or
2738 dodie "failed to run replay";
2741 run_command "git bisect good $good" or
2742 dodie "could not set bisect good to $good";
2744 run_git_bisect "git bisect bad $bad" or
2745 dodie "could not set bisect bad to $bad";
2749 if (defined($start)) {
2750 run_command "git checkout $start" or
2751 dodie "failed to checkout $start";
2756 $result = run_bisect $type;
2757 $test = run_git_bisect "git bisect $result";
2760 run_command "git bisect log" or
2761 dodie "could not capture git bisect log";
2763 run_command "git bisect reset" or
2764 dodie "could not reset git bisect";
2766 doprint "Bad commit was [$bisect_bad_commit]\n";
2771 # config_ignore holds the configs that were set (or unset) for
2772 # a good config and we will ignore these configs for the rest
2773 # of a config bisect. These configs stay as they were.
2776 # config_set holds what all configs were set as.
2779 # config_off holds the set of configs that the bad config had disabled.
2780 # We need to record them and set them in the .config when running
2781 # olddefconfig, because olddefconfig keeps the defaults.
2784 # config_off_tmp holds a set of configs to turn off for now
2787 # config_list is the set of configs that are being tested
2793 sub assign_configs {
2794 my ($hash, $config) = @_;
2796 doprint "Reading configs from $config\n";
2799 or dodie "Failed to read $config";
2803 if (/^((CONFIG\S*)=.*)/) {
2805 } elsif (/^(# (CONFIG\S*) is not set)/) {
2813 sub process_config_ignore {
2816 assign_configs \%config_ignore, $config;
2819 sub get_dependencies {
2822 my $arr = $dependency{$config};
2823 if (!defined($arr)) {
2829 foreach my $dep (@{$arr}) {
2830 print "ADD DEP $dep\n";
2831 @deps = (@deps, get_dependencies $dep);
2838 my ($pc, $file) = @_;
2840 my %configs = %{$pc};
2842 doprint "Saving configs into $file\n";
2844 open(OUT, ">$file") or dodie "Can not write to $file";
2846 foreach my $config (keys %configs) {
2847 print OUT "$configs{$config}\n";
2853 my ($name, $pc) = @_;
2855 doprint "Creating old config from $name configs\n";
2857 save_config $pc, $output_config;
2862 # compare two config hashes, and return configs with different vals.
2863 # It returns B's config values, but you can use A to see what A was.
2864 sub diff_config_vals {
2867 # crappy Perl way to pass in hashes.
2873 foreach my $item (keys %a) {
2874 if (defined($b{$item}) && $b{$item} ne $a{$item}) {
2875 $ret{$item} = $b{$item};
2882 # compare two config hashes and return the configs in B but not A
2888 # crappy Perl way to pass in hashes.
2892 foreach my $item (keys %b) {
2893 if (!defined($a{$item})) {
2894 $ret{$item} = $b{$item};
2901 # return if two configs are equal or not
2902 # 0 is equal +1 b has something a does not
2903 # +1 if a and b have a different item.
2904 # -1 if a has something b does not
2905 sub compare_configs {
2910 # crappy Perl way to pass in hashes.
2914 foreach my $item (keys %b) {
2915 if (!defined($a{$item})) {
2918 if ($a{$item} ne $b{$item}) {
2923 foreach my $item (keys %a) {
2924 if (!defined($b{$item})) {
2932 sub run_config_bisect_test {
2935 my $ret = run_bisect_test $type, "oldconfig";
2937 if ($bisect_manual) {
2938 $ret = answer_bisect;
2944 sub process_failed {
2947 doprint "\n\n***************************************\n";
2948 doprint "Found bad config: $config\n";
2949 doprint "***************************************\n\n";
2952 # used for config bisecting
2956 sub process_new_config {
2957 my ($tc, $nc, $gc, $bc) = @_;
2959 my %tmp_config = %{$tc};
2960 my %good_configs = %{$gc};
2961 my %bad_configs = %{$bc};
2968 create_config "tmp_configs", \%tmp_config;
2969 assign_configs \%new_configs, $output_config;
2971 $ret = compare_configs \%new_configs, \%bad_configs;
2973 doprint "New config equals bad config, try next test\n";
2978 $ret = compare_configs \%new_configs, \%good_configs;
2980 doprint "New config equals good config, try next test\n";
2985 %{$nc} = %new_configs;
2990 sub run_config_bisect {
2991 my ($pgood, $pbad) = @_;
2993 my $type = $config_bisect_type;
2995 my %good_configs = %{$pgood};
2996 my %bad_configs = %{$pbad};
2998 my %diff_configs = diff_config_vals \%good_configs, \%bad_configs;
2999 my %b_configs = diff_configs \%good_configs, \%bad_configs;
3000 my %g_configs = diff_configs \%bad_configs, \%good_configs;
3002 my @diff_arr = keys %diff_configs;
3003 my $len_diff = $#diff_arr + 1;
3005 my @b_arr = keys %b_configs;
3006 my $len_b = $#b_arr + 1;
3008 my @g_arr = keys %g_configs;
3009 my $len_g = $#g_arr + 1;
3015 # First, lets get it down to a single subset.
3016 # Is the problem with a difference in values?
3017 # Is the problem with a missing config?
3018 # Is the problem with a config that breaks things?
3020 # Enable all of one set and see if we get a new bad
3023 # first set the good config to the bad values.
3025 doprint "d=$len_diff g=$len_g b=$len_b\n";
3027 # first lets enable things in bad config that are enabled in good config
3029 if ($len_diff > 0) {
3030 if ($len_b > 0 || $len_g > 0) {
3031 my %tmp_config = %bad_configs;
3033 doprint "Set tmp config to be bad config with good config values\n";
3034 foreach my $item (@diff_arr) {
3035 $tmp_config{$item} = $good_configs{$item};
3038 $runtest = process_new_config \%tmp_config, \%new_configs,
3039 \%good_configs, \%bad_configs;
3043 if (!$runtest && $len_diff > 0) {
3045 if ($len_diff == 1) {
3046 process_failed $diff_arr[0];
3049 my %tmp_config = %bad_configs;
3051 my $half = int($#diff_arr / 2);
3052 my @tophalf = @diff_arr[0 .. $half];
3054 doprint "Settings bisect with top half:\n";
3055 doprint "Set tmp config to be bad config with some good config values\n";
3056 foreach my $item (@tophalf) {
3057 $tmp_config{$item} = $good_configs{$item};
3060 $runtest = process_new_config \%tmp_config, \%new_configs,
3061 \%good_configs, \%bad_configs;
3064 my %tmp_config = %bad_configs;
3066 doprint "Try bottom half\n";
3068 my @bottomhalf = @diff_arr[$half+1 .. $#diff_arr];
3070 foreach my $item (@bottomhalf) {
3071 $tmp_config{$item} = $good_configs{$item};
3074 $runtest = process_new_config \%tmp_config, \%new_configs,
3075 \%good_configs, \%bad_configs;
3080 $ret = run_config_bisect_test $type;
3082 doprint "NEW GOOD CONFIG\n";
3083 %good_configs = %new_configs;
3084 run_command "mv $good_config ${good_config}.last";
3085 save_config \%good_configs, $good_config;
3086 %{$pgood} = %good_configs;
3088 doprint "NEW BAD CONFIG\n";
3089 %bad_configs = %new_configs;
3090 run_command "mv $bad_config ${bad_config}.last";
3091 save_config \%bad_configs, $bad_config;
3092 %{$pbad} = %bad_configs;
3097 fail "Hmm, need to do a mix match?\n";
3104 my $type = $config_bisect_type;
3107 $bad_config = $config_bisect;
3109 if (defined($config_bisect_good)) {
3110 $good_config = $config_bisect_good;
3111 } elsif (defined($minconfig)) {
3112 $good_config = $minconfig;
3114 doprint "No config specified, checking if defconfig works";
3115 $ret = run_bisect_test $type, "defconfig";
3117 fail "Have no good config to compare with, please set CONFIG_BISECT_GOOD";
3120 $good_config = $output_config;
3123 # we don't want min configs to cause issues here.
3124 doprint "Disabling 'MIN_CONFIG' for this test\n";
3131 doprint "Run good configs through make oldconfig\n";
3132 assign_configs \%tmp_configs, $good_config;
3133 create_config "$good_config", \%tmp_configs;
3134 assign_configs \%good_configs, $output_config;
3136 doprint "Run bad configs through make oldconfig\n";
3137 assign_configs \%tmp_configs, $bad_config;
3138 create_config "$bad_config", \%tmp_configs;
3139 assign_configs \%bad_configs, $output_config;
3141 $good_config = "$tmpdir/good_config";
3142 $bad_config = "$tmpdir/bad_config";
3144 save_config \%good_configs, $good_config;
3145 save_config \%bad_configs, $bad_config;
3148 if (defined($config_bisect_check) && $config_bisect_check ne "0") {
3149 if ($config_bisect_check ne "good") {
3150 doprint "Testing bad config\n";
3152 $ret = run_bisect_test $type, "useconfig:$bad_config";
3154 fail "Bad config succeeded when expected to fail!";
3158 if ($config_bisect_check ne "bad") {
3159 doprint "Testing good config\n";
3161 $ret = run_bisect_test $type, "useconfig:$good_config";
3163 fail "Good config failed when expected to succeed!";
3170 $ret = run_config_bisect \%good_configs, \%bad_configs;
3173 return $ret if ($ret < 0);
3178 sub patchcheck_reboot {
3179 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
3180 reboot_to_good $patchcheck_sleep_time;
3186 die "PATCHCHECK_START[$i] not defined\n"
3187 if (!defined($patchcheck_start));
3188 die "PATCHCHECK_TYPE[$i] not defined\n"
3189 if (!defined($patchcheck_type));
3191 my $start = $patchcheck_start;
3193 my $cherry = $patchcheck_cherry;
3194 if (!defined($cherry)) {
3199 if (defined($patchcheck_end)) {
3200 $end = $patchcheck_end;
3202 die "PATCHCHECK_END must be defined with PATCHCHECK_CHERRY\n";
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)) {
3217 open (IN, "git cherry -v $start $end|") or
3218 dodie "could not get git list";
3220 open (IN, "git log --pretty=oneline $end|") or
3221 dodie "could not get git list";
3228 # git cherry adds a '+' we want to remove
3230 $list[$#list+1] = $_;
3231 last if (/^$start/);
3236 if ($list[$#list] !~ /^$start/) {
3237 fail "SHA1 $start not found";
3240 # go backwards in the list
3241 @list = reverse @list;
3244 doprint("Going to test the following commits:\n");
3245 foreach my $l (@list) {
3249 my $save_clean = $noclean;
3250 my %ignored_warnings;
3252 if (defined($ignore_warnings)) {
3253 foreach my $sha1 (split /\s+/, $ignore_warnings) {
3254 $ignored_warnings{$sha1} = 1;
3259 foreach my $item (@list) {
3261 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
3263 doprint "\nProcessing commit $item\n\n";
3265 run_command "git checkout $sha1" or
3266 die "Failed to checkout $sha1";
3268 # only clean on the first and last patch
3269 if ($item eq $list[0] ||
3270 $item eq $list[$#list]) {
3271 $noclean = $save_clean;
3276 if (defined($minconfig)) {
3277 build "useconfig:$minconfig" or return 0;
3279 # ?? no config to use?
3280 build "oldconfig" or return 0;
3283 # No need to do per patch checking if warnings file exists
3284 if (!defined($warnings_file) && !defined($ignored_warnings{$sha1})) {
3285 check_patch_buildlog $sha1 or return 0;
3288 check_buildlog or return 0;
3290 next if ($type eq "build");
3294 start_monitor_and_boot or $failed = 1;
3296 if (!$failed && $type ne "boot"){
3297 do_run_test or $failed = 1;
3300 return 0 if ($failed);
3320 # $config depends on $dep
3321 my ($config, $dep) = @_;
3323 if (defined($depends{$config})) {
3324 $depends{$config} .= " " . $dep;
3326 $depends{$config} = $dep;
3329 # record the number of configs depending on $dep
3330 if (defined $depcount{$dep}) {
3333 $depcount{$dep} = 1;
3337 # taken from streamline_config.pl
3349 if (! -f $kconfig) {
3350 doprint "file $kconfig does not exist, skipping\n";
3354 open(KIN, "$kconfig")
3355 or die "Can't open $kconfig";
3359 # Make sure that lines ending with \ continue
3361 $_ = $line . " " . $_;
3372 # collect any Kconfig sources
3373 if (/^source\s*"(.*)"/) {
3374 $kconfigs[$#kconfigs+1] = $1;
3378 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
3382 for (my $i = 0; $i < $iflevel; $i++) {
3383 add_dep $config, $ifdeps[$i];
3386 # collect the depends for the config
3387 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
3389 add_dep $config, $1;
3391 # Get the configs that select this config
3392 } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {
3394 # selected by depends on config
3395 add_dep $1, $config;
3397 # Check for if statements
3398 } elsif (/^if\s+(.*\S)\s*$/) {
3400 # remove beginning and ending non text
3401 $deps =~ s/^[^a-zA-Z0-9_]*//;
3402 $deps =~ s/[^a-zA-Z0-9_]*$//;
3404 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
3406 $ifdeps[$iflevel++] = join ':', @deps;
3408 } elsif (/^endif/) {
3410 $iflevel-- if ($iflevel);
3413 } elsif (/^\s*help\s*$/) {
3419 # read in any configs that were found.
3420 foreach $kconfig (@kconfigs) {
3421 if (!defined($read_kconfigs{$kconfig})) {
3422 $read_kconfigs{$kconfig} = 1;
3423 read_kconfig("$builddir/$kconfig");
3429 # find out which arch this is by the kconfig file
3430 open (IN, $output_config)
3431 or dodie "Failed to read $output_config";
3434 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
3441 if (!defined($arch)) {
3442 doprint "Could not find arch from config file\n";
3443 doprint "no dependencies used\n";
3447 # arch is really the subarch, we need to know
3448 # what directory to look at.
3449 if ($arch eq "i386" || $arch eq "x86_64") {
3451 } elsif ($arch =~ /^tile/) {
3455 my $kconfig = "$builddir/arch/$arch/Kconfig";
3457 if (! -f $kconfig && $arch =~ /\d$/) {
3459 # some subarchs have numbers, truncate them
3461 $kconfig = "$builddir/arch/$arch/Kconfig";
3462 if (! -f $kconfig) {
3463 doprint "No idea what arch dir $orig is for\n";
3464 doprint "no dependencies used\n";
3469 read_kconfig($kconfig);
3472 sub make_new_config {
3475 open (OUT, ">$output_config")
3476 or dodie "Failed to write $output_config";
3478 foreach my $config (@configs) {
3479 print OUT "$config\n";
3487 $config =~ s/CONFIG_//;
3495 my $kconfig = chomp_config $dep;
3497 $dep = $depends{"$kconfig"};
3499 # the dep string we have saves the dependencies as they
3500 # were found, including expressions like ! && ||. We
3501 # want to split this out into just an array of configs.
3503 my $valid = "A-Za-z_0-9";
3507 while ($dep =~ /[$valid]/) {
3509 if ($dep =~ /^[^$valid]*([$valid]+)/) {
3510 my $conf = "CONFIG_" . $1;
3512 $configs[$#configs + 1] = $conf;
3514 $dep =~ s/^[^$valid]*[$valid]+//;
3516 die "this should never happen";
3526 my %processed_configs;
3527 my %nochange_config;
3529 sub test_this_config {
3534 # if we already processed this config, skip it
3535 if (defined($processed_configs{$config})) {
3538 $processed_configs{$config} = 1;
3540 # if this config failed during this round, skip it
3541 if (defined($nochange_config{$config})) {
3545 my $kconfig = chomp_config $config;
3547 # Test dependencies first
3548 if (defined($depends{"$kconfig"})) {
3549 my @parents = get_depends $config;
3550 foreach my $parent (@parents) {
3551 # if the parent is in the min config, check it first
3552 next if (!defined($min_configs{$parent}));
3553 $found = test_this_config($parent);
3554 if (defined($found)) {
3560 # Remove this config from the list of configs
3561 # do a make olddefconfig and then read the resulting
3562 # .config to make sure it is missing the config that
3564 my %configs = %min_configs;
3565 delete $configs{$config};
3566 make_new_config ((values %configs), (values %keep_configs));
3569 assign_configs \%configs, $output_config;
3571 if (!defined($configs{$config}) || $configs{$config} =~ /^#/) {
3575 doprint "disabling config $config did not change .config\n";
3577 $nochange_config{$config} = 1;
3582 sub make_min_config {
3585 my $type = $minconfig_type;
3586 if ($type ne "boot" && $type ne "test") {
3587 fail "Invalid MIN_CONFIG_TYPE '$minconfig_type'\n" .
3588 " make_min_config works only with 'boot' and 'test'\n" and return;
3591 if (!defined($output_minconfig)) {
3592 fail "OUTPUT_MIN_CONFIG not defined" and return;
3595 # If output_minconfig exists, and the start_minconfig
3596 # came from min_config, than ask if we should use
3598 if (-f $output_minconfig && !$start_minconfig_defined) {
3599 print "$output_minconfig exists\n";
3600 if (!defined($use_output_minconfig)) {
3601 if (read_yn " Use it as minconfig?") {
3602 $start_minconfig = $output_minconfig;
3604 } elsif ($use_output_minconfig > 0) {
3605 doprint "Using $output_minconfig as MIN_CONFIG\n";
3606 $start_minconfig = $output_minconfig;
3608 doprint "Set to still use MIN_CONFIG as starting point\n";
3612 if (!defined($start_minconfig)) {
3613 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
3616 my $temp_config = "$tmpdir/temp_config";
3618 # First things first. We build an allnoconfig to find
3619 # out what the defaults are that we can't touch.
3620 # Some are selections, but we really can't handle selections.
3622 my $save_minconfig = $minconfig;
3625 run_command "$make allnoconfig" or return 0;
3629 process_config_ignore $output_config;
3631 undef %save_configs;
3634 if (defined($ignore_config)) {
3635 # make sure the file exists
3636 `touch $ignore_config`;
3637 assign_configs \%save_configs, $ignore_config;
3640 %keep_configs = %save_configs;
3642 doprint "Load initial configs from $start_minconfig\n";
3644 # Look at the current min configs, and save off all the
3645 # ones that were set via the allnoconfig
3646 assign_configs \%min_configs, $start_minconfig;
3648 my @config_keys = keys %min_configs;
3650 # All configs need a depcount
3651 foreach my $config (@config_keys) {
3652 my $kconfig = chomp_config $config;
3653 if (!defined $depcount{$kconfig}) {
3654 $depcount{$kconfig} = 0;
3658 # Remove anything that was set by the make allnoconfig
3659 # we shouldn't need them as they get set for us anyway.
3660 foreach my $config (@config_keys) {
3661 # Remove anything in the ignore_config
3662 if (defined($keep_configs{$config})) {
3663 my $file = $ignore_config;
3664 $file =~ s,.*/(.*?)$,$1,;
3665 doprint "$config set by $file ... ignored\n";
3666 delete $min_configs{$config};
3669 # But make sure the settings are the same. If a min config
3670 # sets a selection, we do not want to get rid of it if
3671 # it is not the same as what we have. Just move it into
3673 if (defined($config_ignore{$config})) {
3674 if ($config_ignore{$config} ne $min_configs{$config}) {
3675 doprint "$config is in allnoconfig as '$config_ignore{$config}'";
3676 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
3677 $keep_configs{$config} = $min_configs{$config};
3679 doprint "$config set by allnoconfig ... ignored\n";
3681 delete $min_configs{$config};
3693 # Now disable each config one by one and do a make oldconfig
3694 # till we find a config that changes our list.
3696 my @test_configs = keys %min_configs;
3698 # Sort keys by who is most dependent on
3699 @test_configs = sort { $depcount{chomp_config($b)} <=> $depcount{chomp_config($a)} }
3702 # Put configs that did not modify the config at the end.
3704 for (my $i = 0; $i < $#test_configs; $i++) {
3705 if (!defined($nochange_config{$test_configs[0]})) {
3709 # This config didn't change the .config last time.
3710 # Place it at the end
3711 my $config = shift @test_configs;
3712 push @test_configs, $config;
3715 # if every test config has failed to modify the .config file
3716 # in the past, then reset and start over.
3718 undef %nochange_config;
3721 undef %processed_configs;
3723 foreach my $config (@test_configs) {
3725 $found = test_this_config $config;
3727 last if (defined($found));
3729 # oh well, try another config
3732 if (!defined($found)) {
3733 # we could have failed due to the nochange_config hash
3734 # reset and try again
3736 undef %nochange_config;
3740 doprint "No more configs found that we can disable\n";
3748 doprint "Test with $config disabled\n";
3750 # set in_bisect to keep build and monitor from dieing
3754 build "oldconfig" or $failed = 1;
3756 start_monitor_and_boot or $failed = 1;
3758 if ($type eq "test" && !$failed) {
3759 do_run_test or $failed = 1;
3768 doprint "$min_configs{$config} is needed to boot the box... keeping\n";
3769 # this config is needed, add it to the ignore list.
3770 $keep_configs{$config} = $min_configs{$config};
3771 $save_configs{$config} = $min_configs{$config};
3772 delete $min_configs{$config};
3774 # update new ignore configs
3775 if (defined($ignore_config)) {
3776 open (OUT, ">$temp_config")
3777 or die "Can't write to $temp_config";
3778 foreach my $config (keys %save_configs) {
3779 print OUT "$save_configs{$config}\n";
3782 run_command "mv $temp_config $ignore_config" or
3783 dodie "failed to copy update to $ignore_config";
3787 # We booted without this config, remove it from the minconfigs.
3788 doprint "$config is not needed, disabling\n";
3790 delete $min_configs{$config};
3792 # Also disable anything that is not enabled in this config
3794 assign_configs \%configs, $output_config;
3795 my @config_keys = keys %min_configs;
3796 foreach my $config (@config_keys) {
3797 if (!defined($configs{$config})) {
3798 doprint "$config is not set, disabling\n";
3799 delete $min_configs{$config};
3803 # Save off all the current mandidory configs
3804 open (OUT, ">$temp_config")
3805 or die "Can't write to $temp_config";
3806 foreach my $config (keys %keep_configs) {
3807 print OUT "$keep_configs{$config}\n";
3809 foreach my $config (keys %min_configs) {
3810 print OUT "$min_configs{$config}\n";
3814 run_command "mv $temp_config $output_minconfig" or
3815 dodie "failed to copy update to $output_minconfig";
3818 doprint "Reboot and wait $sleep_time seconds\n";
3819 reboot_to_good $sleep_time;
3826 sub make_warnings_file {
3829 if (!defined($warnings_file)) {
3830 dodie "Must define WARNINGS_FILE for make_warnings_file test";
3833 if ($build_type eq "nobuild") {
3834 dodie "BUILD_TYPE can not be 'nobuild' for make_warnings_file test";
3837 build $build_type or dodie "Failed to build";
3839 open(OUT, ">$warnings_file") or dodie "Can't create $warnings_file";
3841 open(IN, $buildlog) or dodie "Can't open $buildlog";
3844 # Some compilers use UTF-8 extended for quotes
3845 # for distcc heterogeneous systems, this causes issues
3848 if (/$check_build_re/) {
3859 $#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl [config-file]\n";
3862 $ktest_config = $ARGV[0];
3863 if (! -f $ktest_config) {
3864 print "$ktest_config does not exist.\n";
3865 if (!read_yn "Create it?") {
3871 if (! -f $ktest_config) {
3874 open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
3876 # Generated by ktest.pl
3879 # PWD is a ktest.pl variable that will result in the process working
3880 # directory that ktest.pl is executed in.
3882 # THIS_DIR is automatically assigned the PWD of the path that generated
3883 # the config file. It is best to use this variable when assigning other
3884 # directory paths within this directory. This allows you to easily
3885 # move the test cases to other locations or to other machines.
3887 THIS_DIR := $variable{"PWD"}
3889 # Define each test with TEST_START
3890 # The config options below it will override the defaults
3892 TEST_TYPE = $default{"TEST_TYPE"}
3899 read_config $ktest_config;
3901 if (defined($opt{"LOG_FILE"})) {
3902 $opt{"LOG_FILE"} = eval_option("LOG_FILE", $opt{"LOG_FILE"}, -1);
3905 # Append any configs entered in manually to the config file.
3906 my @new_configs = keys %entered_configs;
3907 if ($#new_configs >= 0) {
3908 print "\nAppending entered in configs to $ktest_config\n";
3909 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
3910 foreach my $config (@new_configs) {
3911 print OUT "$config = $entered_configs{$config}\n";
3912 $opt{$config} = process_variables($entered_configs{$config});
3916 if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
3917 unlink $opt{"LOG_FILE"};
3920 doprint "\n\nSTARTING AUTOMATED TESTS\n\n";
3922 for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
3925 doprint "DEFAULT OPTIONS:\n";
3927 doprint "\nTEST $i OPTIONS";
3928 if (defined($repeat_tests{$i})) {
3929 $repeat = $repeat_tests{$i};
3930 doprint " ITERATE $repeat";
3935 foreach my $option (sort keys %opt) {
3937 if ($option =~ /\[(\d+)\]$/) {
3943 doprint "$option = $opt{$option}\n";
3947 sub option_defined {
3950 if (defined($opt{$option}) && $opt{$option} !~ /^\s*$/) {
3957 sub __set_test_option {
3958 my ($name, $i) = @_;
3960 my $option = "$name\[$i\]";
3962 if (option_defined($option)) {
3963 return $opt{$option};
3966 foreach my $test (keys %repeat_tests) {
3968 $i < $test + $repeat_tests{$test}) {
3969 $option = "$name\[$test\]";
3970 if (option_defined($option)) {
3971 return $opt{$option};
3976 if (option_defined($name)) {
3983 sub set_test_option {
3984 my ($name, $i) = @_;
3986 my $option = __set_test_option($name, $i);
3987 return $option if (!defined($option));
3989 return eval_option($name, $option, $i);
3992 # First we need to do is the builds
3993 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
3995 # Do not reboot on failing test options
3997 $reboot_success = 0;
4003 undef %force_config;
4005 my $makecmd = set_test_option("MAKE_CMD", $i);
4007 $outputdir = set_test_option("OUTPUT_DIR", $i);
4008 $builddir = set_test_option("BUILD_DIR", $i);
4010 chdir $builddir || die "can't change directory to $builddir";
4012 if (!-d $outputdir) {
4013 mkpath($outputdir) or
4014 die "can't create $outputdir";
4017 $make = "$makecmd O=$outputdir";
4019 # Load all the options into their mapped variable names
4020 foreach my $opt (keys %option_map) {
4021 ${$option_map{$opt}} = set_test_option($opt, $i);
4024 $start_minconfig_defined = 1;
4026 # The first test may override the PRE_KTEST option
4027 if (defined($pre_ktest) && $i == 1) {
4029 run_command $pre_ktest;
4032 # Any test can override the POST_KTEST option
4033 # The last test takes precedence.
4034 if (defined($post_ktest)) {
4035 $final_post_ktest = $post_ktest;
4038 if (!defined($start_minconfig)) {
4039 $start_minconfig_defined = 0;
4040 $start_minconfig = $minconfig;
4045 die "can't create $tmpdir";
4048 $ENV{"SSH_USER"} = $ssh_user;
4049 $ENV{"MACHINE"} = $machine;
4051 $buildlog = "$tmpdir/buildlog-$machine";
4052 $testlog = "$tmpdir/testlog-$machine";
4053 $dmesg = "$tmpdir/dmesg-$machine";
4054 $output_config = "$outputdir/.config";
4057 $target = "$ssh_user\@$machine";
4058 if ($reboot_type eq "grub") {
4059 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
4060 } elsif ($reboot_type eq "grub2") {
4061 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
4062 dodie "GRUB_FILE not defined" if (!defined($grub_file));
4063 } elsif ($reboot_type eq "syslinux") {
4064 dodie "SYSLINUX_LABEL not defined" if (!defined($syslinux_label));
4068 my $run_type = $build_type;
4069 if ($test_type eq "patchcheck") {
4070 $run_type = $patchcheck_type;
4071 } elsif ($test_type eq "bisect") {
4072 $run_type = $bisect_type;
4073 } elsif ($test_type eq "config_bisect") {
4074 $run_type = $config_bisect_type;
4075 } elsif ($test_type eq "make_min_config") {
4077 } elsif ($test_type eq "make_warnings_file") {
4081 # mistake in config file?
4082 if (!defined($run_type)) {
4083 $run_type = "ERROR";
4087 $installme = " no_install" if ($no_install);
4091 if (defined($test_name)) {
4092 $name = " ($test_name)";
4096 doprint "RUNNING TEST $i of $opt{NUM_TESTS}$name with option $test_type $run_type$installme\n\n";
4098 if (defined($pre_test)) {
4099 run_command $pre_test;
4106 if (defined($addconfig)) {
4107 my $min = $minconfig;
4108 if (!defined($minconfig)) {
4111 run_command "cat $addconfig $min > $tmpdir/add_config" or
4112 dodie "Failed to create temp config";
4113 $minconfig = "$tmpdir/add_config";
4116 if (defined($checkout)) {
4117 run_command "git checkout $checkout" or
4118 die "failed to checkout $checkout";
4123 # A test may opt to not reboot the box
4124 if ($reboot_on_success) {
4125 $reboot_success = 1;
4128 if ($test_type eq "bisect") {
4131 } elsif ($test_type eq "config_bisect") {
4134 } elsif ($test_type eq "patchcheck") {
4137 } elsif ($test_type eq "make_min_config") {
4140 } elsif ($test_type eq "make_warnings_file") {
4142 make_warnings_file $i;
4146 if ($build_type ne "nobuild") {
4147 build $build_type or next;
4148 check_buildlog or next;
4151 if ($test_type eq "install") {
4158 if ($test_type ne "build") {
4160 start_monitor_and_boot or $failed = 1;
4162 if (!$failed && $test_type ne "boot" && defined($run_test)) {
4163 do_run_test or $failed = 1;
4172 if (defined($final_post_ktest)) {
4173 run_command $final_post_ktest;
4176 if ($opt{"POWEROFF_ON_SUCCESS"}) {
4178 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot && $reboot_success) {
4180 } elsif (defined($switch_to_good)) {
4181 # still need to get to the good kernel
4182 run_command $switch_to_good;
4186 doprint "\n $successes of $opt{NUM_TESTS} tests were successful\n\n";