2 # SPDX-License-Identifier: GPL-2.0-only
4 # Copyright 2010 - Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
9 use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
10 use File::Path qw(mkpath);
11 use File::Copy qw(cp);
26 "MAILER" => "sendmail", # default mailer
27 "EMAIL_ON_ERROR" => 1,
28 "EMAIL_WHEN_FINISHED" => 1,
29 "EMAIL_WHEN_CANCELED" => 0,
30 "EMAIL_WHEN_STARTED" => 0,
32 "TEST_TYPE" => "build",
33 "BUILD_TYPE" => "randconfig",
35 "CLOSE_CONSOLE_SIGNAL" => "INT",
37 "TMP_DIR" => "/tmp/ktest/\${MACHINE}",
38 "SLEEP_TIME" => 60, # sleep time between tests
40 "REBOOT_ON_ERROR" => 0,
41 "POWEROFF_ON_ERROR" => 0,
42 "REBOOT_ON_SUCCESS" => 1,
43 "POWEROFF_ON_SUCCESS" => 0,
44 "BUILD_OPTIONS" => "",
45 "BISECT_SLEEP_TIME" => 60, # sleep time between bisects
46 "PATCHCHECK_SLEEP_TIME" => 60, # sleep time between patch checks
51 "MIN_CONFIG_TYPE" => "boot",
52 "SUCCESS_LINE" => "login:",
53 "DETECT_TRIPLE_FAULT" => 1,
55 "BOOTED_TIMEOUT" => 1,
56 "DIE_ON_FAILURE" => 1,
57 "SSH_EXEC" => "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND",
58 "SCP_TO_TARGET" => "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE",
59 "SCP_TO_TARGET_INSTALL" => "\${SCP_TO_TARGET}",
60 "REBOOT" => "ssh \$SSH_USER\@\$MACHINE reboot",
61 "REBOOT_RETURN_CODE" => 255,
62 "STOP_AFTER_SUCCESS" => 10,
63 "STOP_AFTER_FAILURE" => 60,
64 "STOP_TEST_AFTER" => 600,
65 "MAX_MONITOR_WAIT" => 1800,
66 "GRUB_REBOOT" => "grub2-reboot",
67 "GRUB_BLS_GET" => "grubby --info=ALL",
68 "SYSLINUX" => "extlinux",
69 "SYSLINUX_PATH" => "/boot/extlinux",
70 "CONNECT_TIMEOUT" => 25,
72 # required, and we will ask users if they don't have them but we keep the default
73 # value something that is common.
74 "REBOOT_TYPE" => "grub",
75 "LOCALVERSION" => "-test",
77 "BUILD_TARGET" => "arch/x86/boot/bzImage",
78 "TARGET_IMAGE" => "/boot/vmlinuz-test",
84 my $ktest_config = "ktest.conf";
110 my $reboot_return_code;
114 my $poweroff_on_error;
115 my $reboot_on_success;
117 my $powercycle_after_reboot;
118 my $poweroff_after_halt;
119 my $max_monitor_wait;
122 my $scp_to_target_install;
141 my $start_minconfig_defined;
142 my $output_minconfig;
144 my $use_output_minconfig;
150 my $bisect_bad_commit = "";
155 my $config_bisect_good;
159 my $bisect_ret_abort;
160 my $bisect_ret_default;
161 my $in_patchcheck = 0;
170 my $bisect_sleep_time;
171 my $patchcheck_sleep_time;
178 my $config_bisect_exec;
180 my $detect_triplefault;
182 my $close_console_signal;
183 my $reboot_success_line;
185 my $stop_after_success;
186 my $stop_after_failure;
195 my $run_command_status = 0;
207 my $config_bisect_type;
208 my $config_bisect_check;
211 my $patchcheck_start;
212 my $patchcheck_cherry;
221 my $dirname = $FindBin::Bin;
228 my $email_when_finished;
229 my $email_when_started;
230 my $email_when_canceled;
232 my $script_start_time = localtime();
234 # set when a test is something other that just building or install
235 # which would require more options.
238 # tell build not to worry about warnings, even when WARNINGS_FILE is set
241 # set when creating a new config
248 # force_config is the list of configs that we force enabled (or disabled)
249 # in a .config file. The MIN_CONFIG and ADD_CONFIG configs.
252 # do not force reboots on config problems
256 my $reboot_success = 0;
259 "MAILTO" => \$mailto,
260 "MAILER" => \$mailer,
261 "MAIL_PATH" => \$mail_path,
262 "MAIL_COMMAND" => \$mail_command,
263 "EMAIL_ON_ERROR" => \$email_on_error,
264 "EMAIL_WHEN_FINISHED" => \$email_when_finished,
265 "EMAIL_WHEN_STARTED" => \$email_when_started,
266 "EMAIL_WHEN_CANCELED" => \$email_when_canceled,
267 "MACHINE" => \$machine,
268 "SSH_USER" => \$ssh_user,
269 "TMP_DIR" => \$tmpdir,
270 "OUTPUT_DIR" => \$outputdir,
271 "BUILD_DIR" => \$builddir,
272 "TEST_TYPE" => \$test_type,
273 "PRE_KTEST" => \$pre_ktest,
274 "POST_KTEST" => \$post_ktest,
275 "PRE_TEST" => \$pre_test,
276 "POST_TEST" => \$post_test,
277 "BUILD_TYPE" => \$build_type,
278 "BUILD_OPTIONS" => \$build_options,
279 "PRE_BUILD" => \$pre_build,
280 "POST_BUILD" => \$post_build,
281 "PRE_BUILD_DIE" => \$pre_build_die,
282 "POST_BUILD_DIE" => \$post_build_die,
283 "POWER_CYCLE" => \$power_cycle,
284 "REBOOT" => \$reboot,
285 "REBOOT_RETURN_CODE" => \$reboot_return_code,
286 "BUILD_NOCLEAN" => \$noclean,
287 "MIN_CONFIG" => \$minconfig,
288 "OUTPUT_MIN_CONFIG" => \$output_minconfig,
289 "START_MIN_CONFIG" => \$start_minconfig,
290 "MIN_CONFIG_TYPE" => \$minconfig_type,
291 "USE_OUTPUT_MIN_CONFIG" => \$use_output_minconfig,
292 "WARNINGS_FILE" => \$warnings_file,
293 "IGNORE_CONFIG" => \$ignore_config,
294 "TEST" => \$run_test,
295 "ADD_CONFIG" => \$addconfig,
296 "REBOOT_TYPE" => \$reboot_type,
297 "GRUB_MENU" => \$grub_menu,
298 "GRUB_FILE" => \$grub_file,
299 "GRUB_REBOOT" => \$grub_reboot,
300 "GRUB_BLS_GET" => \$grub_bls_get,
301 "SYSLINUX" => \$syslinux,
302 "SYSLINUX_PATH" => \$syslinux_path,
303 "SYSLINUX_LABEL" => \$syslinux_label,
304 "PRE_INSTALL" => \$pre_install,
305 "POST_INSTALL" => \$post_install,
306 "NO_INSTALL" => \$no_install,
307 "REBOOT_SCRIPT" => \$reboot_script,
308 "REBOOT_ON_ERROR" => \$reboot_on_error,
309 "SWITCH_TO_GOOD" => \$switch_to_good,
310 "SWITCH_TO_TEST" => \$switch_to_test,
311 "POWEROFF_ON_ERROR" => \$poweroff_on_error,
312 "REBOOT_ON_SUCCESS" => \$reboot_on_success,
313 "DIE_ON_FAILURE" => \$die_on_failure,
314 "POWER_OFF" => \$power_off,
315 "POWERCYCLE_AFTER_REBOOT" => \$powercycle_after_reboot,
316 "POWEROFF_AFTER_HALT" => \$poweroff_after_halt,
317 "MAX_MONITOR_WAIT" => \$max_monitor_wait,
318 "SLEEP_TIME" => \$sleep_time,
319 "BISECT_SLEEP_TIME" => \$bisect_sleep_time,
320 "PATCHCHECK_SLEEP_TIME" => \$patchcheck_sleep_time,
321 "IGNORE_WARNINGS" => \$ignore_warnings,
322 "IGNORE_ERRORS" => \$ignore_errors,
323 "BISECT_MANUAL" => \$bisect_manual,
324 "BISECT_SKIP" => \$bisect_skip,
325 "BISECT_TRIES" => \$bisect_tries,
326 "CONFIG_BISECT_GOOD" => \$config_bisect_good,
327 "BISECT_RET_GOOD" => \$bisect_ret_good,
328 "BISECT_RET_BAD" => \$bisect_ret_bad,
329 "BISECT_RET_SKIP" => \$bisect_ret_skip,
330 "BISECT_RET_ABORT" => \$bisect_ret_abort,
331 "BISECT_RET_DEFAULT" => \$bisect_ret_default,
332 "STORE_FAILURES" => \$store_failures,
333 "STORE_SUCCESSES" => \$store_successes,
334 "TEST_NAME" => \$test_name,
335 "TIMEOUT" => \$timeout,
336 "CONNECT_TIMEOUT" => \$connect_timeout,
337 "CONFIG_BISECT_EXEC" => \$config_bisect_exec,
338 "BOOTED_TIMEOUT" => \$booted_timeout,
339 "CONSOLE" => \$console,
340 "CLOSE_CONSOLE_SIGNAL" => \$close_console_signal,
341 "DETECT_TRIPLE_FAULT" => \$detect_triplefault,
342 "SUCCESS_LINE" => \$success_line,
343 "REBOOT_SUCCESS_LINE" => \$reboot_success_line,
344 "STOP_AFTER_SUCCESS" => \$stop_after_success,
345 "STOP_AFTER_FAILURE" => \$stop_after_failure,
346 "STOP_TEST_AFTER" => \$stop_test_after,
347 "BUILD_TARGET" => \$build_target,
348 "SSH_EXEC" => \$ssh_exec,
349 "SCP_TO_TARGET" => \$scp_to_target,
350 "SCP_TO_TARGET_INSTALL" => \$scp_to_target_install,
351 "CHECKOUT" => \$checkout,
352 "TARGET_IMAGE" => \$target_image,
353 "LOCALVERSION" => \$localversion,
355 "BISECT_GOOD" => \$bisect_good,
356 "BISECT_BAD" => \$bisect_bad,
357 "BISECT_TYPE" => \$bisect_type,
358 "BISECT_START" => \$bisect_start,
359 "BISECT_REPLAY" => \$bisect_replay,
360 "BISECT_FILES" => \$bisect_files,
361 "BISECT_REVERSE" => \$bisect_reverse,
362 "BISECT_CHECK" => \$bisect_check,
364 "CONFIG_BISECT" => \$config_bisect,
365 "CONFIG_BISECT_TYPE" => \$config_bisect_type,
366 "CONFIG_BISECT_CHECK" => \$config_bisect_check,
368 "PATCHCHECK_TYPE" => \$patchcheck_type,
369 "PATCHCHECK_START" => \$patchcheck_start,
370 "PATCHCHECK_CHERRY" => \$patchcheck_cherry,
371 "PATCHCHECK_END" => \$patchcheck_end,
374 # Options may be used by other options, record them.
377 # default variables that can be used
378 chomp ($variable{"PWD"} = `pwd`);
379 $pwd = $variable{"PWD"};
381 $config_help{"MACHINE"} = << "EOF"
382 The machine hostname that you will test.
383 For build only tests, it is still needed to differentiate log files.
386 $config_help{"SSH_USER"} = << "EOF"
387 The box is expected to have ssh on normal bootup, provide the user
388 (most likely root, since you need privileged operations)
391 $config_help{"BUILD_DIR"} = << "EOF"
392 The directory that contains the Linux source code (full path).
393 You can use \${PWD} that will be the path where ktest.pl is run, or use
394 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
397 $config_help{"OUTPUT_DIR"} = << "EOF"
398 The directory that the objects will be built (full path).
399 (can not be same as BUILD_DIR)
400 You can use \${PWD} that will be the path where ktest.pl is run, or use
401 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
404 $config_help{"BUILD_TARGET"} = << "EOF"
405 The location of the compiled file to copy to the target.
406 (relative to OUTPUT_DIR)
409 $config_help{"BUILD_OPTIONS"} = << "EOF"
410 Options to add to \"make\" when building.
414 $config_help{"TARGET_IMAGE"} = << "EOF"
415 The place to put your image on the test machine.
418 $config_help{"POWER_CYCLE"} = << "EOF"
419 A script or command to reboot the box.
421 Here is a digital loggers power switch example
422 POWER_CYCLE = wget --no-proxy -O /dev/null -q --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL'
424 Here is an example to reboot a virtual box on the current host
425 with the name "Guest".
426 POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest
429 $config_help{"CONSOLE"} = << "EOF"
430 The script or command that reads the console
432 If you use ttywatch server, something like the following would work.
433 CONSOLE = nc -d localhost 3001
435 For a virtual machine with guest name "Guest".
436 CONSOLE = virsh console Guest
439 $config_help{"LOCALVERSION"} = << "EOF"
440 Required version ending to differentiate the test
441 from other linux builds on the system.
444 $config_help{"REBOOT_TYPE"} = << "EOF"
445 Way to reboot the box to the test kernel.
446 Only valid options so far are "grub", "grub2", "grub2bls", "syslinux", and "script".
448 If you specify grub, it will assume grub version 1
449 and will search in /boot/grub/menu.lst for the title \$GRUB_MENU
450 and select that target to reboot to the kernel. If this is not
451 your setup, then specify "script" and have a command or script
452 specified in REBOOT_SCRIPT to boot to the target.
454 The entry in /boot/grub/menu.lst must be entered in manually.
455 The test will not modify that file.
457 If you specify grub2, then you also need to specify both \$GRUB_MENU
460 If you specify grub2bls, then you also need to specify \$GRUB_MENU.
462 If you specify syslinux, then you may use SYSLINUX to define the syslinux
463 command (defaults to extlinux), and SYSLINUX_PATH to specify the path to
464 the syslinux install (defaults to /boot/extlinux). But you have to specify
465 SYSLINUX_LABEL to define the label to boot to for the test kernel.
468 $config_help{"GRUB_MENU"} = << "EOF"
469 The grub title name for the test kernel to boot
470 (Only mandatory if REBOOT_TYPE = grub or grub2)
472 Note, ktest.pl will not update the grub menu.lst, you need to
473 manually add an option for the test. ktest.pl will search
474 the grub menu.lst for this option to find what kernel to
477 For example, if in the /boot/grub/menu.lst the test kernel title has:
480 GRUB_MENU = Test Kernel
482 For grub2, a search of \$GRUB_FILE is performed for the lines
483 that begin with "menuentry". It will not detect submenus. The
484 menu must be a non-nested menu. Add the quotes used in the menu
485 to guarantee your selection, as the first menuentry with the content
486 of \$GRUB_MENU that is found will be used.
488 For grub2bls, \$GRUB_MENU is searched on the result of \$GRUB_BLS_GET
489 command for the lines that begin with "title".
492 $config_help{"GRUB_FILE"} = << "EOF"
493 If grub2 is used, the full path for the grub.cfg file is placed
494 here. Use something like /boot/grub2/grub.cfg to search.
497 $config_help{"SYSLINUX_LABEL"} = << "EOF"
498 If syslinux is used, the label that boots the target kernel must
499 be specified with SYSLINUX_LABEL.
502 $config_help{"REBOOT_SCRIPT"} = << "EOF"
503 A script to reboot the target into the test kernel
504 (Only mandatory if REBOOT_TYPE = script)
509 if (defined($opt{"LOG_FILE"})) {
510 open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
517 if (defined($opt{"LOG_FILE"})) {
530 my ($cancel, $prompt) = @_;
536 print "$prompt [y/n/C] ";
538 print "$prompt [Y/n] ";
542 if ($ans =~ /^\s*$/) {
549 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
551 last if ($ans =~ /^c$/i);
552 print "Please answer either 'y', 'n' or 'c'.\n";
554 print "Please answer either 'y' or 'n'.\n";
560 if ($ans !~ /^y$/i) {
569 return read_prompt 0, $prompt;
575 return read_prompt 1, $prompt;
578 sub get_mandatory_config {
582 return if (defined($opt{$config}));
584 if (defined($config_help{$config})) {
586 print $config_help{$config};
591 if (defined($default{$config}) && length($default{$config})) {
592 print "\[$default{$config}\] ";
595 $ans =~ s/^\s*(.*\S)\s*$/$1/;
596 if ($ans =~ /^\s*$/) {
597 if ($default{$config}) {
598 $ans = $default{$config};
600 print "Your answer can not be blank\n";
604 $entered_configs{$config} = ${ans};
616 $hours = int($time / 3600);
617 $time -= $hours * 3600;
620 $minutes = int($time / 60);
621 $time -= $minutes * 60;
625 doprint "$hours hour";
626 doprint "s" if ($hours > 1);
631 doprint "$minutes minute";
632 doprint "s" if ($minutes > 1);
636 doprint "$time second";
637 doprint "s" if ($time != 1);
643 doprint "Build time: ";
644 show_time($build_time);
648 doprint "Install time: ";
649 show_time($install_time);
653 doprint "Reboot time: ";
654 show_time($reboot_time);
658 doprint "Test time: ";
659 show_time($test_time);
662 # reset for iterations like bisect
669 sub get_mandatory_configs {
670 get_mandatory_config("MACHINE");
671 get_mandatory_config("BUILD_DIR");
672 get_mandatory_config("OUTPUT_DIR");
675 get_mandatory_config("BUILD_OPTIONS");
678 # options required for other than just building a kernel
680 get_mandatory_config("POWER_CYCLE");
681 get_mandatory_config("CONSOLE");
684 # options required for install and more
685 if ($buildonly != 1) {
686 get_mandatory_config("SSH_USER");
687 get_mandatory_config("BUILD_TARGET");
688 get_mandatory_config("TARGET_IMAGE");
691 get_mandatory_config("LOCALVERSION");
693 return if ($buildonly);
695 my $rtype = $opt{"REBOOT_TYPE"};
697 if (!defined($rtype)) {
698 if (!defined($opt{"GRUB_MENU"})) {
699 get_mandatory_config("REBOOT_TYPE");
700 $rtype = $entered_configs{"REBOOT_TYPE"};
706 if (($rtype eq "grub") or ($rtype eq "grub2bls")) {
707 get_mandatory_config("GRUB_MENU");
710 if ($rtype eq "grub2") {
711 get_mandatory_config("GRUB_MENU");
712 get_mandatory_config("GRUB_FILE");
715 if ($rtype eq "syslinux") {
716 get_mandatory_config("SYSLINUX_LABEL");
720 sub process_variables {
721 my ($value, $remove_undef) = @_;
724 # We want to check for '\', and it is just easier
725 # to check the previous characet of '$' and not need
726 # to worry if '$' is the first character. By adding
727 # a space to $value, we can just check [^\\]\$ and
728 # it will still work.
731 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
735 # append beginning of value to retval
736 $retval = "$retval$begin";
737 if (defined($variable{$var})) {
738 $retval = "$retval$variable{$var}";
739 } elsif (defined($remove_undef) && $remove_undef) {
740 # for if statements, any variable that is not defined,
741 # we simple convert to 0
742 $retval = "${retval}0";
744 # put back the origin piece.
745 $retval = "$retval\$\{$var\}";
746 # This could be an option that is used later, save
747 # it so we don't warn if this option is not one of
749 $used_options{$var} = 1;
753 $retval = "$retval$value";
755 # remove the space added in the beginning
762 my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
764 my $prvalue = process_variables($rvalue);
766 if ($lvalue =~ /^(TEST|BISECT|CONFIG_BISECT)_TYPE(\[.*\])?$/ &&
767 $prvalue !~ /^(config_|)bisect$/ &&
768 $prvalue !~ /^build$/ &&
771 # Note if a test is something other than build, then we
772 # will need other mandatory options.
773 if ($prvalue ne "install") {
776 # install still limits some mandatory options.
781 if (defined($opt{$lvalue})) {
782 if (!$override || defined(${$overrides}{$lvalue})) {
785 $extra = "In the same override section!\n";
787 die "$name: $.: Option $lvalue defined more than once!\n$extra";
789 ${$overrides}{$lvalue} = $prvalue;
792 $opt{$lvalue} = $prvalue;
796 my ($lvalue, $rvalue, $name) = @_;
798 my $prvalue = process_variables($rvalue);
801 if (defined($evals{$lvalue})) {
802 $arr = $evals{$lvalue};
805 $evals{$lvalue} = $arr;
808 push @{$arr}, $rvalue;
812 my ($lvalue, $rvalue) = @_;
814 if ($rvalue =~ /^\s*$/) {
815 delete $variable{$lvalue};
817 $rvalue = process_variables($rvalue);
818 $variable{$lvalue} = $rvalue;
822 sub process_compare {
823 my ($lval, $cmp, $rval) = @_;
834 return $lval eq $rval;
835 } elsif ($cmp eq "!=") {
836 return $lval ne $rval;
837 } elsif ($cmp eq "=~") {
838 return $lval =~ m/$rval/;
839 } elsif ($cmp eq "!~") {
840 return $lval !~ m/$rval/;
843 my $statement = "$lval $cmp $rval";
844 my $ret = eval $statement;
846 # $@ stores error of eval
857 return defined($variable{$2}) ||
862 sub process_expression {
863 my ($name, $val) = @_;
867 while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
870 if (process_expression($name, $express)) {
871 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
873 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
881 while ($val =~ s/^(.*?)($OR|$AND)//) {
885 if (process_expression($name, $express)) {
896 if ($val =~ /(.*)(==|\!=|>=|<=|>|<|=~|\!~)(.*)/) {
897 my $ret = process_compare($1, $2, $3);
899 die "$name: $.: Unable to process comparison\n";
904 if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
906 return !value_defined($2);
908 return value_defined($2);
912 if ($val =~ /^\s*0\s*$/) {
914 } elsif ($val =~ /^\s*\d+\s*$/) {
918 die ("$name: $.: Undefined content $val in if statement\n");
922 my ($name, $value) = @_;
924 # Convert variables and replace undefined ones with 0
925 my $val = process_variables($value, 1);
926 my $ret = process_expression $name, $val;
932 my ($config, $current_test_num) = @_;
935 open($in, $config) || die "can't read file $config";
938 $name =~ s,.*/(.*),$1,;
940 my $test_num = $$current_test_num;
943 my $num_tests_set = 0;
956 # ignore blank lines and comments
957 next if (/^\s*$/ || /\s*\#/);
959 if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
969 if ($type eq "TEST_START") {
971 if ($num_tests_set) {
972 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
975 $old_test_num = $test_num;
976 $old_repeat = $repeat;
978 $test_num += $repeat;
985 # If SKIP is anywhere in the line, the command will be skipped
986 if ($rest =~ s/\s+SKIP\b//) {
993 if ($rest =~ s/\sELSE\b//) {
995 die "$name: $.: ELSE found with out matching IF section\n$_";
1006 if ($rest =~ s/\sIF\s+(.*)//) {
1007 if (process_if($name, $1)) {
1019 if ($type eq "TEST_START") {
1020 if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
1022 $repeat_tests{"$test_num"} = $repeat;
1024 } elsif ($rest =~ s/\sOVERRIDE\b//) {
1027 # Clear previous overrides
1032 if (!$skip && $rest !~ /^\s*$/) {
1033 die "$name: $.: Gargbage found after $type\n$_";
1036 if ($skip && $type eq "TEST_START") {
1037 $test_num = $old_test_num;
1038 $repeat = $old_repeat;
1041 } elsif (/^\s*ELSE\b(.*)$/) {
1043 die "$name: $.: ELSE found with out matching IF section\n$_";
1052 if ($rest =~ /\sIF\s+(.*)/) {
1053 # May be a ELSE IF section.
1054 if (process_if($name, $1)) {
1065 if ($rest !~ /^\s*$/) {
1066 die "$name: $.: Gargbage found after DEFAULTS\n$_";
1069 } elsif (/^\s*INCLUDE\s+(\S+)/) {
1074 die "$name: $.: INCLUDE can only be done in default sections\n$_";
1077 my $file = process_variables($1);
1079 if ($file !~ m,^/,) {
1080 # check the path of the config file first
1081 if ($config =~ m,(.*)/,) {
1082 if (-f "$1/$file") {
1089 die "$name: $.: Can't read file $file\n$_";
1092 if (__read_config($file, \$test_num)) {
1096 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=~\s*(.*?)\s*$/) {
1103 if ($default || $lvalue =~ /\[\d+\]$/) {
1104 set_eval($lvalue, $rvalue, $name);
1106 my $val = "$lvalue\[$test_num\]";
1107 set_eval($val, $rvalue, $name);
1110 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
1118 ($lvalue eq "NUM_TESTS" ||
1119 $lvalue eq "LOG_FILE" ||
1120 $lvalue eq "CLEAR_LOG")) {
1121 die "$name: $.: $lvalue must be set in DEFAULTS section\n";
1124 if ($lvalue eq "NUM_TESTS") {
1126 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
1129 die "$name: $.: NUM_TESTS must be set in default section\n";
1134 if ($default || $lvalue =~ /\[\d+\]$/) {
1135 set_value($lvalue, $rvalue, $override, \%overrides, $name);
1137 my $val = "$lvalue\[$test_num\]";
1138 set_value($val, $rvalue, $override, \%overrides, $name);
1141 $repeats{$val} = $repeat;
1144 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
1150 # process config variables.
1151 # Config variables are only active while reading the
1152 # config and can be defined anywhere. They also ignore
1153 # TEST_START and DEFAULTS, but are skipped if they are in
1154 # on of these sections that have SKIP defined.
1155 # The save variable can be
1156 # defined multiple times and the new one simply overrides
1158 set_variable($lvalue, $rvalue);
1161 die "$name: $.: Garbage found in config\n$_";
1166 $test_num += $repeat - 1;
1167 $opt{"NUM_TESTS"} = $test_num;
1172 $$current_test_num = $test_num;
1178 print "What test case would you like to run?\n";
1179 print " (build, install or boot)\n";
1180 print " Other tests are available but require editing ktest.conf\n";
1181 print " (see tools/testing/ktest/sample.conf)\n";
1184 $default{"TEST_TYPE"} = $ans;
1193 $test_case = __read_config $config, \$test_num;
1195 # make sure we have all mandatory configs
1196 get_mandatory_configs;
1198 # was a test specified?
1200 print "No test case specified.\n";
1206 foreach my $default (keys %default) {
1207 if (!defined($opt{$default})) {
1208 $opt{$default} = $default{$default};
1212 if ($opt{"IGNORE_UNUSED"} == 1) {
1218 # check if there are any stragglers (typos?)
1219 foreach my $option (keys %opt) {
1221 # remove per test labels.
1223 if (!exists($option_map{$op}) &&
1224 !exists($default{$op}) &&
1225 !exists($used_options{$op})) {
1232 $s = " is" if (keys %not_used == 1);
1233 print "The following option$s not used; could be a typo:\n";
1234 foreach my $option (keys %not_used) {
1237 print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";
1238 if (!read_yn "Do you want to continue?") {
1245 my ($name, $option, $i) = @_;
1247 # Add space to evaluate the character before $
1248 $option = " $option";
1253 foreach my $test (keys %repeat_tests) {
1255 $i < $test + $repeat_tests{$test}) {
1263 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
1268 # Append beginning of line
1269 $retval = "$retval$start";
1271 # If the iteration option OPT[$i] exists, then use that.
1272 # otherwise see if the default OPT (without [$i]) exists.
1274 my $o = "$var\[$i\]";
1275 my $parento = "$var\[$parent\]";
1277 # If a variable contains itself, use the default var
1278 if (($var eq $name) && defined($opt{$var})) {
1280 $retval = "$retval$o";
1281 } elsif (defined($opt{$o})) {
1283 $retval = "$retval$o";
1284 } elsif ($repeated && defined($opt{$parento})) {
1285 $o = $opt{$parento};
1286 $retval = "$retval$o";
1287 } elsif (defined($opt{$var})) {
1289 $retval = "$retval$o";
1290 } elsif ($var eq "KERNEL_VERSION" && defined($make)) {
1291 # special option KERNEL_VERSION uses kernel version
1293 $retval = "$retval$version";
1295 $retval = "$retval\$\{$var\}";
1301 $retval = "$retval$option";
1309 my ($name, $option, $i) = @_;
1311 my $option_name = "$name\[$i\]";
1314 my $old_option = $option;
1316 if (defined($evals{$option_name})) {
1317 $ev = $evals{$option_name};
1318 } elsif (defined($evals{$name})) {
1319 $ev = $evals{$name};
1324 for my $e (@{$ev}) {
1325 eval "\$option =~ $e";
1328 if ($option ne $old_option) {
1329 doprint("$name changed from '$old_option' to '$option'\n");
1336 my ($name, $option, $i) = @_;
1340 # Since an option can evaluate to another option,
1341 # keep iterating until we do not evaluate any more
1344 while ($prev ne $option) {
1345 # Check for recursive evaluations.
1346 # 100 deep should be more than enough.
1348 die "Over 100 evaluations accurred with $option\n" .
1349 "Check for recursive variables\n";
1352 $option = __eval_option($name, $option, $i);
1355 $option = process_evals($name, $option, $i);
1363 sub wait_for_monitor;
1369 # test if the machine can be connected to within a few seconds
1370 my $stat = run_ssh("echo check machine status", $connect_timeout);
1372 doprint("power cycle\n");
1377 run_command "$power_cycle";
1380 # flush out current monitor
1381 # May contain the reboot success line
1385 # Make sure everything has been written to disk
1386 run_ssh("sync", 10);
1388 if (defined($time)) {
1390 # flush out current monitor
1391 # May contain the reboot success line
1395 # try to reboot normally
1396 if (run_command $reboot) {
1397 if (defined($powercycle_after_reboot)) {
1398 sleep $powercycle_after_reboot;
1399 run_command "$power_cycle";
1402 # nope? power cycle it.
1403 run_command "$power_cycle";
1407 if (defined($time)) {
1409 # We only want to get to the new kernel, don't fail
1410 # if we stumble over a call trace.
1411 my $save_ignore_errors = $ignore_errors;
1414 # Look for the good kernel to boot
1415 if (wait_for_monitor($time, "Linux version")) {
1417 doprint "Reboot did not finish. Forcing power cycle\n";
1418 run_command "$power_cycle";
1421 $ignore_errors = $save_ignore_errors;
1423 # Still need to wait for the reboot to finish
1424 wait_for_monitor($time, $reboot_success_line);
1430 sub reboot_to_good {
1433 if (defined($switch_to_good)) {
1434 run_command $switch_to_good;
1443 return $test_type eq "build" || $no_reboot ||
1444 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
1445 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build") ||
1446 ($test_type eq "config_bisect" && $opt{"CONFIG_BISECT_TYPE[$i]"} eq "build");
1451 sub get_test_name() {
1454 if (defined($test_name)) {
1455 $name = "$test_name:$test_type";
1465 return if ($in_die);
1470 doprint "CRITICAL FAILURE... [TEST $i] ", @_, "\n";
1472 if ($reboot_on_error && !do_not_reboot) {
1474 doprint "REBOOTING\n";
1477 } elsif ($poweroff_on_error && defined($power_off)) {
1478 doprint "POWERING OFF\n";
1482 if (defined($opt{"LOG_FILE"})) {
1483 print " See $opt{LOG_FILE} for more info.\n";
1486 if ($email_on_error) {
1487 my $name = get_test_name;
1488 send_email("KTEST: critical failure for test $i [$name]",
1489 "Your test started at $script_start_time has failed with:\n@_\n");
1493 # restore terminal settings
1494 system("stty $stty_orig");
1497 if (defined($post_test)) {
1498 run_command $post_test;
1505 my ($ptm, $pts) = @_;
1507 my $TIOCSPTLCK = 0x40045431;
1508 my $TIOCGPTN = 0x80045430;
1510 sysopen($ptm, "/dev/ptmx", O_RDWR | O_NONBLOCK) or
1511 dodie "Cant open /dev/ptmx";
1514 $tmp = pack("i", 0);
1515 ioctl($ptm, $TIOCSPTLCK, $tmp) or
1516 dodie "ioctl TIOCSPTLCK for /dev/ptmx failed";
1519 ioctl($ptm, $TIOCGPTN, $tmp) or
1520 dodie "ioctl TIOCGPTN for /dev/ptmx failed";
1521 $tmp = unpack("i", $tmp);
1523 sysopen($pts, "/dev/pts/$tmp", O_RDWR | O_NONBLOCK) or
1524 dodie "Can't open /dev/pts/$tmp";
1528 my ($ptm, $pts) = @_;
1536 open(\*STDIN, '<&', $pts);
1537 open(\*STDOUT, '>&', $pts);
1538 open(\*STDERR, '>&', $pts);
1543 dodie "Can't open console $console";
1551 # save terminal settings
1552 $stty_orig = `stty -g`;
1554 # place terminal in cbreak mode so that stdin can be read one character at
1555 # a time without having to wait for a newline
1556 system("stty -icanon -echo -icrnl");
1558 create_pty($ptm, $pts);
1564 exec_console($ptm, $pts)
1572 open(PTSFD, "Stop perl from warning about single use of PTSFD");
1576 my ($fp, $pid) = @_;
1578 doprint "kill child process $pid\n";
1579 kill $close_console_signal, $pid;
1581 doprint "wait for child process $pid to exit\n";
1587 # restore terminal settings
1588 system("stty $stty_orig");
1592 if ($monitor_cnt++) {
1595 $monitor_fp = \*MONFD;
1596 $monitor_pid = open_console $monitor_fp;
1600 open(MONFD, "Stop perl from warning about single use of MONFD");
1604 return if (!defined $console);
1605 if (--$monitor_cnt) {
1608 close_console($monitor_fp, $monitor_pid);
1611 sub wait_for_monitor {
1612 my ($time, $stop) = @_;
1616 my $start_time = time;
1617 my $skip_call_trace = 0;
1619 my $bug_ignored = 0;
1622 doprint "** Wait for monitor to settle down **\n";
1624 # read the monitor and wait for the system to calm down
1626 $line = wait_for_input($monitor_fp, $time);
1627 last if (!defined($line));
1629 $full_line .= $line;
1631 if (defined($stop) && $full_line =~ /$stop/) {
1632 doprint "wait for monitor detected $stop\n";
1636 if ($full_line =~ /\[ backtrace testing \]/) {
1637 $skip_call_trace = 1;
1640 if ($full_line =~ /call trace:/i) {
1641 if (!$bug && !$skip_call_trace) {
1642 if ($ignore_errors) {
1650 if ($full_line =~ /\[ end of backtrace testing \]/) {
1651 $skip_call_trace = 0;
1654 if ($full_line =~ /Kernel panic -/) {
1658 if ($line =~ /\n/) {
1662 if ($now - $start_time >= $max_monitor_wait) {
1663 doprint "Exiting monitor flush due to hitting MAX_MONITOR_WAIT\n";
1667 print "** Monitor flushed **\n";
1669 # if stop is defined but wasn't hit, return error
1670 # used by reboot (which wants to see a reboot)
1671 if (defined($stop) && !$booted) {
1678 my ($result, $basedir) = @_;
1680 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
1681 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
1683 my $type = $build_type;
1684 if ($type =~ /useconfig/) {
1685 $type = "useconfig";
1688 my $dir = "$machine-$test_type-$type-$result-$date";
1690 $dir = "$basedir/$dir";
1694 dodie "can't create $dir";
1698 "config" => $output_config,
1699 "buildlog" => $buildlog,
1701 "testlog" => $testlog,
1704 while (my ($name, $source) = each(%files)) {
1706 cp "$source", "$dir/$name" or
1707 dodie "failed to copy $source";
1711 doprint "*** Saved info to $dir ***\n";
1716 if ($die_on_failure) {
1724 # no need to reboot for just building.
1725 if (!do_not_reboot) {
1726 doprint "REBOOTING\n";
1727 reboot_to_good $sleep_time;
1732 if (defined($test_name)) {
1733 $name = " ($test_name)";
1738 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1739 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1740 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
1741 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1742 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1744 if (defined($store_failures)) {
1745 save_logs "fail", $store_failures;
1748 if (defined($post_test)) {
1749 run_command $post_test;
1756 my ($command, $redirect, $timeout) = @_;
1763 my $command_orig = $command;
1765 $command =~ s/\$SSH_USER/$ssh_user/g;
1766 $command =~ s/\$MACHINE/$machine/g;
1768 doprint("$command ... ");
1771 $pid = open(CMD, "$command 2>&1 |") or
1772 (fail "unable to exec $command" and return 0);
1774 if (defined($opt{"LOG_FILE"})) {
1775 open(LOG, ">>$opt{LOG_FILE}") or
1776 dodie "failed to write to log";
1780 if (defined($redirect)) {
1781 if ($redirect eq 1) {
1783 # Have the output of the command on its own line
1786 open (RD, ">$redirect") or
1787 dodie "failed to write to redirect $redirect";
1792 my $hit_timeout = 0;
1796 if (defined($timeout)) {
1797 doprint "timeout = $timeout\n";
1799 my $line = wait_for_input($fp, $timeout);
1800 if (!defined($line)) {
1802 if (defined($timeout) && (($now - $start_time) >= $timeout)) {
1803 doprint "Hit timeout of $timeout, killing process\n";
1809 print LOG $line if ($dolog);
1810 print RD $line if ($dord);
1811 print $line if ($dostdout);
1815 # shift 8 for real exit status
1816 $run_command_status = $? >> 8;
1818 if ($command_orig eq $default{REBOOT} &&
1819 $run_command_status == $reboot_return_code) {
1820 $run_command_status = 0;
1824 close(LOG) if ($dolog);
1825 close(RD) if ($dord);
1828 my $delta = $end_time - $start_time;
1831 doprint "[1 second] ";
1833 doprint "[$delta seconds] ";
1837 $run_command_status = 1;
1840 if ($run_command_status) {
1841 doprint "FAILED!\n";
1843 doprint "SUCCESS\n";
1846 return !$run_command_status;
1850 my ($cmd, $timeout) = @_;
1851 my $cp_exec = $ssh_exec;
1853 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
1854 return run_command "$cp_exec", undef , $timeout;
1858 my ($src, $dst, $cp_scp) = @_;
1860 $cp_scp =~ s/\$SRC_FILE/$src/g;
1861 $cp_scp =~ s/\$DST_FILE/$dst/g;
1863 return run_command "$cp_scp";
1866 sub run_scp_install {
1867 my ($src, $dst) = @_;
1869 my $cp_scp = $scp_to_target_install;
1871 return run_scp($src, $dst, $cp_scp);
1875 my ($src, $dst) = @_;
1877 my $cp_scp = $scp_to_target;
1879 return run_scp($src, $dst, $cp_scp);
1882 sub _get_grub_index {
1884 my ($command, $target, $skip) = @_;
1886 return if (defined($grub_number) && defined($last_grub_menu) &&
1887 $last_grub_menu eq $grub_menu && defined($last_machine) &&
1888 $last_machine eq $machine);
1890 doprint "Find $reboot_type menu ... ";
1893 my $ssh_grub = $ssh_exec;
1894 $ssh_grub =~ s,\$SSH_COMMAND,$command,g;
1896 open(IN, "$ssh_grub |")
1897 or dodie "unable to execute $command";
1912 dodie "Could not find '$grub_menu' through $command on $machine"
1914 doprint "$grub_number\n";
1915 $last_grub_menu = $grub_menu;
1916 $last_machine = $machine;
1919 sub get_grub_index {
1926 if ($reboot_type !~ /^grub/) {
1930 $grub_menu_qt = quotemeta($grub_menu);
1932 if ($reboot_type eq "grub") {
1933 $command = "cat /boot/grub/menu.lst";
1934 $target = '^\s*title\s+' . $grub_menu_qt . '\s*$';
1935 $skip = '^\s*title\s';
1936 } elsif ($reboot_type eq "grub2") {
1937 $command = "cat $grub_file";
1938 $target = '^menuentry.*' . $grub_menu_qt;
1939 $skip = '^menuentry\s|^submenu\s';
1940 } elsif ($reboot_type eq "grub2bls") {
1941 $command = $grub_bls_get;
1942 $target = '^title=.*' . $grub_menu_qt;
1948 _get_grub_index($command, $target, $skip);
1953 my ($fp, $time) = @_;
1962 if (!defined($time)) {
1967 vec($rin, fileno($fp), 1) = 1;
1968 vec($rin, fileno(\*STDIN), 1) = 1;
1973 $nr = select($rout=$rin, undef, undef, $time);
1977 # copy data from stdin to the console
1978 if (vec($rout, fileno(\*STDIN), 1) == 1) {
1979 $nr = sysread(\*STDIN, $buf, 1000);
1980 syswrite($fp, $buf, $nr) if ($nr > 0);
1983 # The timeout is based on time waiting for the fp data
1984 if (vec($rout, fileno($fp), 1) != 1) {
1985 last if (defined($time) && (time - $start_time > $time));
1991 # try to read one char at a time
1992 while (sysread $fp, $ch, 1) {
1994 last if ($ch eq "\n");
1997 last if (!length($line));
2005 if (defined($switch_to_test)) {
2006 run_command $switch_to_test;
2009 if ($reboot_type eq "grub") {
2010 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
2011 } elsif (($reboot_type eq "grub2") or ($reboot_type eq "grub2bls")) {
2012 run_ssh "$grub_reboot $grub_number";
2013 } elsif ($reboot_type eq "syslinux") {
2014 run_ssh "$syslinux --once \\\"$syslinux_label\\\" $syslinux_path";
2015 } elsif (defined $reboot_script) {
2016 run_command "$reboot_script";
2024 doprint "git rev-list --max-count=1 $commit ... ";
2025 my $sha1 = `git rev-list --max-count=1 $commit`;
2032 dodie "Failed to get git $commit";
2045 my $bug_ignored = 0;
2046 my $skip_call_trace = 0;
2049 my $start_time = time;
2056 open(DMESG, "> $dmesg") or
2057 dodie "unable to write to $dmesg";
2063 my $monitor_start = time;
2065 my $version_found = 0;
2069 if ($bug && defined($stop_after_failure) &&
2070 $stop_after_failure >= 0) {
2071 my $time = $stop_after_failure - (time - $failure_start);
2072 $line = wait_for_input($monitor_fp, $time);
2073 if (!defined($line)) {
2074 doprint "bug timed out after $booted_timeout seconds\n";
2075 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
2079 $line = wait_for_input($monitor_fp, $booted_timeout);
2080 if (!defined($line)) {
2081 my $s = $booted_timeout == 1 ? "" : "s";
2082 doprint "Successful boot found: break after $booted_timeout second$s\n";
2086 $line = wait_for_input($monitor_fp);
2087 if (!defined($line)) {
2088 my $s = $timeout == 1 ? "" : "s";
2089 doprint "Timed out after $timeout second$s\n";
2097 # we are not guaranteed to get a full line
2098 $full_line .= $line;
2100 if ($full_line =~ /$success_line/) {
2102 $success_start = time;
2105 if ($booted && defined($stop_after_success) &&
2106 $stop_after_success >= 0) {
2108 if ($now - $success_start >= $stop_after_success) {
2109 doprint "Test forced to stop after $stop_after_success seconds after success\n";
2114 if ($full_line =~ /\[ backtrace testing \]/) {
2115 $skip_call_trace = 1;
2118 if ($full_line =~ /call trace:/i) {
2119 if (!$bug && !$skip_call_trace) {
2120 if ($ignore_errors) {
2124 $failure_start = time;
2129 if ($bug && defined($stop_after_failure) &&
2130 $stop_after_failure >= 0) {
2132 if ($now - $failure_start >= $stop_after_failure) {
2133 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
2138 if ($full_line =~ /\[ end of backtrace testing \]/) {
2139 $skip_call_trace = 0;
2142 if ($full_line =~ /Kernel panic -/) {
2143 $failure_start = time;
2147 # Detect triple faults by testing the banner
2148 if ($full_line =~ /\bLinux version (\S+).*\n/) {
2149 if ($1 eq $version) {
2151 } elsif ($version_found && $detect_triplefault) {
2152 # We already booted into the kernel we are testing,
2153 # but now we booted into another kernel?
2154 # Consider this a triple fault.
2155 doprint "Already booted in Linux kernel $version, but now\n";
2156 doprint "we booted into Linux kernel $1.\n";
2157 doprint "Assuming that this is a triple fault.\n";
2158 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
2163 if ($line =~ /\n/) {
2167 if ($stop_test_after > 0 && !$booted && !$bug) {
2168 if (time - $monitor_start > $stop_test_after) {
2169 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
2175 my $end_time = time;
2176 $reboot_time = $end_time - $start_time;
2181 return 0 if ($in_bisect);
2182 fail "failed - got a bug report" and return 0;
2186 return 0 if ($in_bisect);
2187 fail "failed - never got a boot prompt." and return 0;
2191 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2197 sub eval_kernel_version {
2200 $option =~ s/\$KERNEL_VERSION/$version/g;
2205 sub do_post_install {
2207 return if (!defined($post_install));
2209 my $cp_post_install = eval_kernel_version $post_install;
2210 run_command "$cp_post_install" or
2211 dodie "Failed to run post install";
2214 # Sometimes the reboot fails, and will hang. We try to ssh to the box
2215 # and if we fail, we force another reboot, that should powercycle it.
2217 if (!run_ssh "echo testing connection") {
2224 return if ($no_install);
2226 my $start_time = time;
2228 if (defined($pre_install)) {
2229 my $cp_pre_install = eval_kernel_version $pre_install;
2230 run_command "$cp_pre_install" or
2231 dodie "Failed to run pre install";
2234 my $cp_target = eval_kernel_version $target_image;
2238 run_scp_install "$outputdir/$build_target", "$cp_target" or
2239 dodie "failed to copy image";
2241 my $install_mods = 0;
2243 # should we process modules?
2245 open(IN, "$output_config") or dodie("Can't read config file");
2247 if (/CONFIG_MODULES(=y)?/) {
2256 if (!$install_mods) {
2258 doprint "No modules needed\n";
2259 my $end_time = time;
2260 $install_time = $end_time - $start_time;
2264 run_command "$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or
2265 dodie "Failed to install modules";
2267 my $modlib = "/lib/modules/$version";
2268 my $modtar = "ktest-mods.tar.bz2";
2270 run_ssh "rm -rf $modlib" or
2271 dodie "failed to remove old mods: $modlib";
2273 # would be nice if scp -r did not follow symbolic links
2274 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
2275 dodie "making tarball";
2277 run_scp_mod "$tmpdir/$modtar", "/tmp" or
2278 dodie "failed to copy modules";
2280 unlink "$tmpdir/$modtar";
2282 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
2283 dodie "failed to tar modules";
2285 run_ssh "rm -f /tmp/$modtar";
2289 my $end_time = time;
2290 $install_time = $end_time - $start_time;
2294 # get the release name
2295 return if ($have_version);
2296 doprint "$make kernelrelease ... ";
2297 $version = `$make -s kernelrelease | tail -1`;
2299 doprint "$version\n";
2303 sub start_monitor_and_install {
2304 # Make sure the stable kernel has finished booting
2306 # Install bisects, don't need console
2307 if (defined $console) {
2317 start_monitor if (defined $console);
2321 my $check_build_re = ".*:.*(warning|error|Error):.*";
2322 my $utf8_quote = "\\x{e2}\\x{80}(\\x{98}|\\x{99})";
2324 sub process_warning_line {
2329 # for distcc heterogeneous systems, some compilers
2330 # do things differently causing warning lines
2331 # to be slightly different. This makes an attempt
2332 # to fixe those issues.
2334 # chop off the index into the line
2335 # using distcc, some compilers give different indexes
2336 # depending on white space
2337 $line =~ s/^(\s*\S+:\d+:)\d+/$1/;
2339 # Some compilers use UTF-8 extended for quotes and some don't.
2340 $line =~ s/$utf8_quote/'/g;
2345 # Read buildlog and check against warnings file for any
2350 sub check_buildlog {
2351 return 1 if (!defined $warnings_file);
2355 # Failed builds should not reboot the target
2356 my $save_no_reboot = $no_reboot;
2359 if (-f $warnings_file) {
2360 open(IN, $warnings_file) or
2361 dodie "Error opening $warnings_file";
2364 if (/$check_build_re/) {
2365 my $warning = process_warning_line $_;
2367 $warnings_list{$warning} = 1;
2373 # If warnings file didn't exist, and WARNINGS_FILE exist,
2374 # then we fail on any warning!
2376 open(IN, $buildlog) or dodie "Can't open $buildlog";
2378 if (/$check_build_re/) {
2379 my $warning = process_warning_line $_;
2381 if (!defined $warnings_list{$warning}) {
2382 fail "New warning found (not in $warnings_file)\n$_\n";
2383 $no_reboot = $save_no_reboot;
2388 $no_reboot = $save_no_reboot;
2392 sub check_patch_buildlog {
2395 my @files = `git show $patch | diffstat -l`;
2397 foreach my $file (@files) {
2401 open(IN, "git show $patch |") or
2402 dodie "failed to show $patch";
2404 if (m,^--- a/(.*),) {
2406 $files[$#files] = $1;
2411 open(IN, $buildlog) or dodie "Can't open $buildlog";
2413 if (/^\s*(.*?):.*(warning|error)/) {
2415 foreach my $file (@files) {
2416 my $fullpath = "$builddir/$file";
2417 if ($file eq $err || $fullpath eq $err) {
2418 fail "$file built with warnings" and return 0;
2428 sub apply_min_config {
2429 my $outconfig = "$output_config.new";
2431 # Read the config file and remove anything that
2432 # is in the force_config hash (from minconfig and others)
2433 # then add the force config back.
2435 doprint "Applying minimum configurations into $output_config.new\n";
2437 open (OUT, ">$outconfig") or
2438 dodie "Can't create $outconfig";
2440 if (-f $output_config) {
2441 open (IN, $output_config) or
2442 dodie "Failed to open $output_config";
2444 if (/^(# )?(CONFIG_[^\s=]*)/) {
2445 next if (defined($force_config{$2}));
2451 foreach my $config (keys %force_config) {
2452 print OUT "$force_config{$config}\n";
2456 run_command "mv $outconfig $output_config";
2459 sub make_oldconfig {
2461 my @force_list = keys %force_config;
2463 if ($#force_list >= 0) {
2467 if (!run_command "$make olddefconfig") {
2468 # Perhaps olddefconfig doesn't exist in this version of the kernel
2470 doprint "olddefconfig failed, trying make oldnoconfig\n";
2471 if (!run_command "$make oldnoconfig") {
2472 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
2473 # try a yes '' | oldconfig
2474 run_command "yes '' | $make oldconfig" or
2475 dodie "failed make config oldconfig";
2480 # read a config file and use this to force new configs.
2481 sub load_force_config {
2484 doprint "Loading force configs from $config\n";
2485 open(IN, $config) or
2486 dodie "failed to read $config";
2489 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
2490 $force_config{$1} = $_;
2491 } elsif (/^# (CONFIG_\S*) is not set/) {
2492 $force_config{$1} = $_;
2503 my $start_time = time;
2505 # Failed builds should not reboot the target
2506 my $save_no_reboot = $no_reboot;
2509 # Calculate a new version from here.
2512 if (defined($pre_build)) {
2513 my $ret = run_command $pre_build;
2514 if (!$ret && defined($pre_build_die) &&
2516 dodie "failed to pre_build\n";
2520 if ($type =~ /^useconfig:(.*)/) {
2521 run_command "cp $1 $output_config" or
2522 dodie "could not copy $1 to .config";
2524 $type = "oldconfig";
2527 # old config can ask questions
2528 if ($type eq "oldconfig") {
2529 $type = "olddefconfig";
2531 # allow for empty configs
2532 run_command "touch $output_config";
2535 run_command "mv $output_config $outputdir/config_temp" or
2536 dodie "moving .config";
2538 run_command "$make mrproper" or dodie "make mrproper";
2540 run_command "mv $outputdir/config_temp $output_config" or
2541 dodie "moving config_temp";
2544 } elsif (!$noclean) {
2545 unlink "$output_config";
2546 run_command "$make mrproper" or
2547 dodie "make mrproper";
2550 # add something to distinguish this build
2551 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
2552 print OUT "$localversion\n";
2555 if (defined($minconfig)) {
2556 load_force_config($minconfig);
2559 if ($type ne "olddefconfig") {
2560 run_command "$make $type" or
2561 dodie "failed make config";
2563 # Run old config regardless, to enforce min configurations
2566 my $build_ret = run_command "$make $build_options", $buildlog;
2568 if (defined($post_build)) {
2569 # Because a post build may change the kernel version
2572 my $ret = run_command $post_build;
2573 if (!$ret && defined($post_build_die) &&
2575 dodie "failed to post_build\n";
2580 # bisect may need this to pass
2582 $no_reboot = $save_no_reboot;
2585 fail "failed build" and return 0;
2588 $no_reboot = $save_no_reboot;
2590 my $end_time = time;
2591 $build_time = $end_time - $start_time;
2597 if (!run_ssh "halt" or defined($power_off)) {
2598 if (defined($poweroff_after_halt)) {
2599 sleep $poweroff_after_halt;
2600 run_command "$power_off";
2604 run_command "$power_off";
2615 if (defined($test_name)) {
2616 $name = " ($test_name)";
2621 doprint "\n\n*******************************************\n";
2622 doprint "*******************************************\n";
2623 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
2624 doprint "*******************************************\n";
2625 doprint "*******************************************\n";
2627 if (defined($store_successes)) {
2628 save_logs "success", $store_successes;
2631 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
2632 doprint "Reboot and wait $sleep_time seconds\n";
2633 reboot_to_good $sleep_time;
2636 if (defined($post_test)) {
2637 run_command $post_test;
2643 doprint "Pass, fail, or skip? [p/f/s]";
2646 if ($ans eq "p" || $ans eq "P") {
2648 } elsif ($ans eq "f" || $ans eq "F") {
2650 } elsif ($ans eq "s" || $ans eq "S") {
2653 print "Please answer 'p', 'f', or 's'\n";
2658 sub child_run_test {
2660 # child should have no power
2661 $reboot_on_error = 0;
2662 $poweroff_on_error = 0;
2663 $die_on_failure = 1;
2665 run_command $run_test, $testlog;
2667 exit $run_command_status;
2672 sub child_finished {
2682 my $bug_ignored = 0;
2684 my $start_time = time;
2688 doprint "run test $run_test\n";
2692 $SIG{CHLD} = qw(child_finished);
2696 child_run_test if (!$child_pid);
2701 $line = wait_for_input($monitor_fp, 1);
2702 if (defined($line)) {
2704 # we are not guaranteed to get a full line
2705 $full_line .= $line;
2708 if ($full_line =~ /call trace:/i) {
2709 if ($ignore_errors) {
2716 if ($full_line =~ /Kernel panic -/) {
2720 if ($line =~ /\n/) {
2724 } while (!$child_done && !$bug);
2726 if (!$bug && $bug_ignored) {
2727 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2731 my $failure_start = time;
2734 $line = wait_for_input($monitor_fp, 1);
2735 if (defined($line)) {
2739 if ($now - $failure_start >= $stop_after_failure) {
2742 } while (defined($line));
2744 doprint "Detected kernel crash!\n";
2745 # kill the child with extreme prejudice
2749 waitpid $child_pid, 0;
2750 $child_exit = $? >> 8;
2752 my $end_time = time;
2753 $test_time = $end_time - $start_time;
2755 if (!$bug && $in_bisect) {
2756 if (defined($bisect_ret_good)) {
2757 if ($child_exit == $bisect_ret_good) {
2761 if (defined($bisect_ret_skip)) {
2762 if ($child_exit == $bisect_ret_skip) {
2766 if (defined($bisect_ret_abort)) {
2767 if ($child_exit == $bisect_ret_abort) {
2768 fail "test abort" and return -2;
2771 if (defined($bisect_ret_bad)) {
2772 if ($child_exit == $bisect_ret_skip) {
2776 if (defined($bisect_ret_default)) {
2777 if ($bisect_ret_default eq "good") {
2779 } elsif ($bisect_ret_default eq "bad") {
2781 } elsif ($bisect_ret_default eq "skip") {
2783 } elsif ($bisect_ret_default eq "abort") {
2786 fail "unknown default action: $bisect_ret_default"
2792 if ($bug || $child_exit) {
2793 return 0 if $in_bisect;
2794 fail "test failed" and return 0;
2799 sub run_git_bisect {
2802 doprint "$command ... ";
2804 my $output = `$command 2>&1`;
2811 dodie "Failed to git bisect";
2814 doprint "SUCCESS\n";
2815 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
2816 doprint "$1 [$2]\n";
2817 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
2818 $bisect_bad_commit = $1;
2819 doprint "Found bad commit... $1\n";
2822 # we already logged it, just print it now.
2830 doprint "Reboot and sleep $bisect_sleep_time seconds\n";
2831 reboot_to_good $bisect_sleep_time;
2834 # returns 1 on success, 0 on failure, -1 on skip
2835 sub run_bisect_test {
2836 my ($type, $buildtype) = @_;
2845 build $buildtype or $failed = 1;
2847 if ($type ne "build") {
2848 if ($failed && $bisect_skip) {
2852 dodie "Failed on build" if $failed;
2855 start_monitor_and_install or $failed = 1;
2857 if ($type ne "boot") {
2858 if ($failed && $bisect_skip) {
2864 dodie "Failed on boot" if $failed;
2866 do_run_test or $failed = 1;
2877 # reboot the box to a kernel we can ssh to
2878 if ($type ne "build") {
2888 my $buildtype = "oldconfig";
2890 # We should have a minconfig to use?
2891 if (defined($minconfig)) {
2892 $buildtype = "useconfig:$minconfig";
2895 # If the user sets bisect_tries to less than 1, then no tries
2899 # Still let the user manually decide that though.
2900 if ($bisect_tries < 1 && $bisect_manual) {
2901 $ret = answer_bisect;
2904 for (my $i = 0; $i < $bisect_tries; $i++) {
2905 if ($bisect_tries > 1) {
2907 doprint("Running bisect trial $t of $bisect_tries:\n");
2909 $ret = run_bisect_test $type, $buildtype;
2911 if ($bisect_manual) {
2912 $ret = answer_bisect;
2918 # Are we looking for where it worked, not failed?
2919 if ($reverse_bisect && $ret >= 0) {
2925 } elsif ($ret == 0) {
2927 } elsif ($bisect_skip) {
2928 doprint "HIT A BAD COMMIT ... SKIPPING\n";
2933 sub update_bisect_replay {
2934 my $tmp_log = "$tmpdir/ktest_bisect_log";
2935 run_command "git bisect log > $tmp_log" or
2936 dodie "can't create bisect log";
2945 dodie "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good));
2946 dodie "BISECT_BAD[$i] not defined\n" if (!defined($bisect_bad));
2947 dodie "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type));
2949 my $good = $bisect_good;
2950 my $bad = $bisect_bad;
2951 my $type = $bisect_type;
2952 my $start = $bisect_start;
2953 my $replay = $bisect_replay;
2954 my $start_files = $bisect_files;
2956 if (defined($start_files)) {
2957 $start_files = " -- " . $start_files;
2962 # convert to true sha1's
2963 $good = get_sha1($good);
2964 $bad = get_sha1($bad);
2966 if (defined($bisect_reverse) && $bisect_reverse == 1) {
2967 doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
2968 $reverse_bisect = 1;
2970 $reverse_bisect = 0;
2973 # Can't have a test without having a test to run
2974 if ($type eq "test" && !defined($run_test)) {
2978 # Check if a bisect was running
2979 my $bisect_start_file = "$builddir/.git/BISECT_START";
2981 my $check = $bisect_check;
2982 my $do_check = defined($check) && $check ne "0";
2984 if ( -f $bisect_start_file ) {
2985 print "Bisect in progress found\n";
2987 print " If you say yes, then no checks of good or bad will be done\n";
2989 if (defined($replay)) {
2990 print "** BISECT_REPLAY is defined in config file **";
2991 print " Ignore config option and perform new git bisect log?\n";
2992 if (read_ync " (yes, no, or cancel) ") {
2993 $replay = update_bisect_replay;
2996 } elsif (read_yn "read git log and continue?") {
2997 $replay = update_bisect_replay;
3005 my $head = get_sha1("HEAD");
3007 if ($check ne "good") {
3008 doprint "TESTING BISECT BAD [$bad]\n";
3009 run_command "git checkout $bad" or
3010 dodie "Failed to checkout $bad";
3012 $result = run_bisect $type;
3014 if ($result ne "bad") {
3015 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
3019 if ($check ne "bad") {
3020 doprint "TESTING BISECT GOOD [$good]\n";
3021 run_command "git checkout $good" or
3022 dodie "Failed to checkout $good";
3024 $result = run_bisect $type;
3026 if ($result ne "good") {
3027 fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
3031 # checkout where we started
3032 run_command "git checkout $head" or
3033 dodie "Failed to checkout $head";
3036 run_command "git bisect start$start_files" or
3037 dodie "could not start bisect";
3039 if (defined($replay)) {
3040 run_command "git bisect replay $replay" or
3041 dodie "failed to run replay";
3044 run_command "git bisect good $good" or
3045 dodie "could not set bisect good to $good";
3047 run_git_bisect "git bisect bad $bad" or
3048 dodie "could not set bisect bad to $bad";
3052 if (defined($start)) {
3053 run_command "git checkout $start" or
3054 dodie "failed to checkout $start";
3059 $result = run_bisect $type;
3060 $test = run_git_bisect "git bisect $result";
3064 run_command "git bisect log" or
3065 dodie "could not capture git bisect log";
3067 run_command "git bisect reset" or
3068 dodie "could not reset git bisect";
3070 doprint "Bad commit was [$bisect_bad_commit]\n";
3075 # config_ignore holds the configs that were set (or unset) for
3076 # a good config and we will ignore these configs for the rest
3077 # of a config bisect. These configs stay as they were.
3080 # config_set holds what all configs were set as.
3083 # config_off holds the set of configs that the bad config had disabled.
3084 # We need to record them and set them in the .config when running
3085 # olddefconfig, because olddefconfig keeps the defaults.
3088 # config_off_tmp holds a set of configs to turn off for now
3091 # config_list is the set of configs that are being tested
3097 sub assign_configs {
3098 my ($hash, $config) = @_;
3100 doprint "Reading configs from $config\n";
3103 or dodie "Failed to read $config";
3107 if (/^((CONFIG\S*)=.*)/) {
3109 } elsif (/^(# (CONFIG\S*) is not set)/) {
3117 sub process_config_ignore {
3120 assign_configs \%config_ignore, $config;
3123 sub get_dependencies {
3126 my $arr = $dependency{$config};
3127 if (!defined($arr)) {
3133 foreach my $dep (@{$arr}) {
3134 print "ADD DEP $dep\n";
3135 @deps = (@deps, get_dependencies $dep);
3142 my ($pc, $file) = @_;
3144 my %configs = %{$pc};
3146 doprint "Saving configs into $file\n";
3148 open(OUT, ">$file") or dodie "Can not write to $file";
3150 foreach my $config (keys %configs) {
3151 print OUT "$configs{$config}\n";
3157 my ($name, $pc) = @_;
3159 doprint "Creating old config from $name configs\n";
3161 save_config $pc, $output_config;
3166 sub run_config_bisect_test {
3169 my $ret = run_bisect_test $type, "oldconfig";
3171 if ($bisect_manual) {
3172 $ret = answer_bisect;
3178 sub config_bisect_end {
3179 my ($good, $bad) = @_;
3180 my $diffexec = "diff -u";
3182 if (-f "$builddir/scripts/diffconfig") {
3183 $diffexec = "$builddir/scripts/diffconfig";
3185 doprint "\n\n***************************************\n";
3186 doprint "No more config bisecting possible.\n";
3187 run_command "$diffexec $good $bad", 1;
3188 doprint "***************************************\n\n";
3191 sub run_config_bisect {
3192 my ($good, $bad, $last_result) = @_;
3197 if (!length($last_result)) {
3200 run_command "$config_bisect_exec $reset -b $outputdir $good $bad $last_result", 1;
3202 # config-bisect returns:
3203 # 0 if there is more to bisect
3204 # 1 for finding a good config
3205 # 2 if it can not find any more configs
3207 if ($run_command_status) {
3208 return $run_command_status;
3211 $ret = run_config_bisect_test $config_bisect_type;
3213 doprint "NEW GOOD CONFIG\n";
3214 # Return 3 for good config
3217 doprint "NEW BAD CONFIG\n";
3218 # Return 4 for bad config
3229 my $type = $config_bisect_type;
3232 $bad_config = $config_bisect;
3234 if (defined($config_bisect_good)) {
3235 $good_config = $config_bisect_good;
3236 } elsif (defined($minconfig)) {
3237 $good_config = $minconfig;
3239 doprint "No config specified, checking if defconfig works";
3240 $ret = run_bisect_test $type, "defconfig";
3242 fail "Have no good config to compare with, please set CONFIG_BISECT_GOOD";
3245 $good_config = $output_config;
3248 if (!defined($config_bisect_exec)) {
3249 # First check the location that ktest.pl ran
3250 my @locations = ( "$pwd/config-bisect.pl",
3251 "$dirname/config-bisect.pl",
3252 "$builddir/tools/testing/ktest/config-bisect.pl",
3254 foreach my $loc (@locations) {
3255 doprint "loc = $loc\n";
3256 $config_bisect_exec = $loc;
3257 last if (defined($config_bisect_exec && -x $config_bisect_exec));
3259 if (!defined($config_bisect_exec)) {
3260 fail "Could not find an executable config-bisect.pl\n",
3261 " Set CONFIG_BISECT_EXEC to point to config-bisect.pl";
3266 # we don't want min configs to cause issues here.
3267 doprint "Disabling 'MIN_CONFIG' for this test\n";
3274 if (-f "$tmpdir/good_config.tmp" || -f "$tmpdir/bad_config.tmp") {
3275 if (read_yn "Interrupted config-bisect. Continue (n - will start new)?") {
3276 if (-f "$tmpdir/good_config.tmp") {
3277 $good_config = "$tmpdir/good_config.tmp";
3279 $good_config = "$tmpdir/good_config";
3281 if (-f "$tmpdir/bad_config.tmp") {
3282 $bad_config = "$tmpdir/bad_config.tmp";
3284 $bad_config = "$tmpdir/bad_config";
3288 doprint "Run good configs through make oldconfig\n";
3289 assign_configs \%tmp_configs, $good_config;
3290 create_config "$good_config", \%tmp_configs;
3291 $good_config = "$tmpdir/good_config";
3292 system("cp $output_config $good_config") == 0 or dodie "cp good config";
3294 doprint "Run bad configs through make oldconfig\n";
3295 assign_configs \%tmp_configs, $bad_config;
3296 create_config "$bad_config", \%tmp_configs;
3297 $bad_config = "$tmpdir/bad_config";
3298 system("cp $output_config $bad_config") == 0 or dodie "cp bad config";
3300 if (defined($config_bisect_check) && $config_bisect_check ne "0") {
3301 if ($config_bisect_check ne "good") {
3302 doprint "Testing bad config\n";
3304 $ret = run_bisect_test $type, "useconfig:$bad_config";
3306 fail "Bad config succeeded when expected to fail!";
3310 if ($config_bisect_check ne "bad") {
3311 doprint "Testing good config\n";
3313 $ret = run_bisect_test $type, "useconfig:$good_config";
3315 fail "Good config failed when expected to succeed!";
3324 $ret = run_config_bisect $good_config, $bad_config, $last_run;
3327 } elsif ($ret == 4) {
3331 } while ($ret == 3 || $ret == 4);
3334 config_bisect_end "$good_config.tmp", "$bad_config.tmp";
3337 return $ret if ($ret < 0);
3342 sub patchcheck_reboot {
3343 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
3344 reboot_to_good $patchcheck_sleep_time;
3350 dodie "PATCHCHECK_START[$i] not defined\n"
3351 if (!defined($patchcheck_start));
3352 dodie "PATCHCHECK_TYPE[$i] not defined\n"
3353 if (!defined($patchcheck_type));
3355 my $start = $patchcheck_start;
3357 my $cherry = $patchcheck_cherry;
3358 if (!defined($cherry)) {
3363 if (defined($patchcheck_end)) {
3364 $end = $patchcheck_end;
3366 dodie "PATCHCHECK_END must be defined with PATCHCHECK_CHERRY\n";
3369 # Get the true sha1's since we can use things like HEAD~3
3370 $start = get_sha1($start);
3371 $end = get_sha1($end);
3373 my $type = $patchcheck_type;
3375 # Can't have a test without having a test to run
3376 if ($type eq "test" && !defined($run_test)) {
3381 open (IN, "git cherry -v $start $end|") or
3382 dodie "could not get git list";
3384 open (IN, "git log --pretty=oneline $end|") or
3385 dodie "could not get git list";
3392 # git cherry adds a '+' we want to remove
3394 $list[$#list+1] = $_;
3395 last if (/^$start/);
3400 if ($list[$#list] !~ /^$start/) {
3401 fail "SHA1 $start not found";
3404 # go backwards in the list
3405 @list = reverse @list;
3408 doprint("Going to test the following commits:\n");
3409 foreach my $l (@list) {
3413 my $save_clean = $noclean;
3414 my %ignored_warnings;
3416 if (defined($ignore_warnings)) {
3417 foreach my $sha1 (split /\s+/, $ignore_warnings) {
3418 $ignored_warnings{$sha1} = 1;
3423 foreach my $item (@list) {
3425 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
3427 doprint "\nProcessing commit \"$item\"\n\n";
3429 run_command "git checkout $sha1" or
3430 dodie "Failed to checkout $sha1";
3432 # only clean on the first and last patch
3433 if ($item eq $list[0] ||
3434 $item eq $list[$#list]) {
3435 $noclean = $save_clean;
3440 if (defined($minconfig)) {
3441 build "useconfig:$minconfig" or return 0;
3443 # ?? no config to use?
3444 build "oldconfig" or return 0;
3447 # No need to do per patch checking if warnings file exists
3448 if (!defined($warnings_file) && !defined($ignored_warnings{$sha1})) {
3449 check_patch_buildlog $sha1 or return 0;
3452 check_buildlog or return 0;
3454 next if ($type eq "build");
3458 start_monitor_and_install or $failed = 1;
3460 if (!$failed && $type ne "boot"){
3461 do_run_test or $failed = 1;
3486 # $config depends on $dep
3487 my ($config, $dep) = @_;
3489 if (defined($depends{$config})) {
3490 $depends{$config} .= " " . $dep;
3492 $depends{$config} = $dep;
3495 # record the number of configs depending on $dep
3496 if (defined $depcount{$dep}) {
3499 $depcount{$dep} = 1;
3503 # taken from streamline_config.pl
3515 if (! -f $kconfig) {
3516 doprint "file $kconfig does not exist, skipping\n";
3520 open(KIN, "$kconfig")
3521 or dodie "Can't open $kconfig";
3525 # Make sure that lines ending with \ continue
3527 $_ = $line . " " . $_;
3538 # collect any Kconfig sources
3539 if (/^source\s*"(.*)"/) {
3540 $kconfigs[$#kconfigs+1] = $1;
3544 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
3548 for (my $i = 0; $i < $iflevel; $i++) {
3549 add_dep $config, $ifdeps[$i];
3552 # collect the depends for the config
3553 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
3555 add_dep $config, $1;
3557 # Get the configs that select this config
3558 } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {
3560 # selected by depends on config
3561 add_dep $1, $config;
3563 # Check for if statements
3564 } elsif (/^if\s+(.*\S)\s*$/) {
3566 # remove beginning and ending non text
3567 $deps =~ s/^[^a-zA-Z0-9_]*//;
3568 $deps =~ s/[^a-zA-Z0-9_]*$//;
3570 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
3572 $ifdeps[$iflevel++] = join ':', @deps;
3574 } elsif (/^endif/) {
3576 $iflevel-- if ($iflevel);
3579 } elsif (/^\s*help\s*$/) {
3585 # read in any configs that were found.
3586 foreach $kconfig (@kconfigs) {
3587 if (!defined($read_kconfigs{$kconfig})) {
3588 $read_kconfigs{$kconfig} = 1;
3589 read_kconfig("$builddir/$kconfig");
3595 # find out which arch this is by the kconfig file
3596 open (IN, $output_config)
3597 or dodie "Failed to read $output_config";
3600 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
3607 if (!defined($arch)) {
3608 doprint "Could not find arch from config file\n";
3609 doprint "no dependencies used\n";
3613 # arch is really the subarch, we need to know
3614 # what directory to look at.
3615 if ($arch eq "i386" || $arch eq "x86_64") {
3619 my $kconfig = "$builddir/arch/$arch/Kconfig";
3621 if (! -f $kconfig && $arch =~ /\d$/) {
3623 # some subarchs have numbers, truncate them
3625 $kconfig = "$builddir/arch/$arch/Kconfig";
3626 if (! -f $kconfig) {
3627 doprint "No idea what arch dir $orig is for\n";
3628 doprint "no dependencies used\n";
3633 read_kconfig($kconfig);
3636 sub make_new_config {
3639 open (OUT, ">$output_config")
3640 or dodie "Failed to write $output_config";
3642 foreach my $config (@configs) {
3643 print OUT "$config\n";
3651 $config =~ s/CONFIG_//;
3659 my $kconfig = chomp_config $dep;
3661 $dep = $depends{"$kconfig"};
3663 # the dep string we have saves the dependencies as they
3664 # were found, including expressions like ! && ||. We
3665 # want to split this out into just an array of configs.
3667 my $valid = "A-Za-z_0-9";
3671 while ($dep =~ /[$valid]/) {
3673 if ($dep =~ /^[^$valid]*([$valid]+)/) {
3674 my $conf = "CONFIG_" . $1;
3676 $configs[$#configs + 1] = $conf;
3678 $dep =~ s/^[^$valid]*[$valid]+//;
3680 dodie "this should never happen";
3690 my %processed_configs;
3691 my %nochange_config;
3693 sub test_this_config {
3698 # if we already processed this config, skip it
3699 if (defined($processed_configs{$config})) {
3702 $processed_configs{$config} = 1;
3704 # if this config failed during this round, skip it
3705 if (defined($nochange_config{$config})) {
3709 my $kconfig = chomp_config $config;
3711 # Test dependencies first
3712 if (defined($depends{"$kconfig"})) {
3713 my @parents = get_depends $config;
3714 foreach my $parent (@parents) {
3715 # if the parent is in the min config, check it first
3716 next if (!defined($min_configs{$parent}));
3717 $found = test_this_config($parent);
3718 if (defined($found)) {
3724 # Remove this config from the list of configs
3725 # do a make olddefconfig and then read the resulting
3726 # .config to make sure it is missing the config that
3728 my %configs = %min_configs;
3729 delete $configs{$config};
3730 make_new_config ((values %configs), (values %keep_configs));
3733 assign_configs \%configs, $output_config;
3735 if (!defined($configs{$config}) || $configs{$config} =~ /^#/) {
3739 doprint "disabling config $config did not change .config\n";
3741 $nochange_config{$config} = 1;
3746 sub make_min_config {
3749 my $type = $minconfig_type;
3750 if ($type ne "boot" && $type ne "test") {
3751 fail "Invalid MIN_CONFIG_TYPE '$minconfig_type'\n" .
3752 " make_min_config works only with 'boot' and 'test'\n" and return;
3755 if (!defined($output_minconfig)) {
3756 fail "OUTPUT_MIN_CONFIG not defined" and return;
3759 # If output_minconfig exists, and the start_minconfig
3760 # came from min_config, than ask if we should use
3762 if (-f $output_minconfig && !$start_minconfig_defined) {
3763 print "$output_minconfig exists\n";
3764 if (!defined($use_output_minconfig)) {
3765 if (read_yn " Use it as minconfig?") {
3766 $start_minconfig = $output_minconfig;
3768 } elsif ($use_output_minconfig > 0) {
3769 doprint "Using $output_minconfig as MIN_CONFIG\n";
3770 $start_minconfig = $output_minconfig;
3772 doprint "Set to still use MIN_CONFIG as starting point\n";
3776 if (!defined($start_minconfig)) {
3777 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
3780 my $temp_config = "$tmpdir/temp_config";
3782 # First things first. We build an allnoconfig to find
3783 # out what the defaults are that we can't touch.
3784 # Some are selections, but we really can't handle selections.
3786 my $save_minconfig = $minconfig;
3789 run_command "$make allnoconfig" or return 0;
3793 process_config_ignore $output_config;
3795 undef %save_configs;
3798 if (defined($ignore_config)) {
3799 # make sure the file exists
3800 `touch $ignore_config`;
3801 assign_configs \%save_configs, $ignore_config;
3804 %keep_configs = %save_configs;
3806 doprint "Load initial configs from $start_minconfig\n";
3808 # Look at the current min configs, and save off all the
3809 # ones that were set via the allnoconfig
3810 assign_configs \%min_configs, $start_minconfig;
3812 my @config_keys = keys %min_configs;
3814 # All configs need a depcount
3815 foreach my $config (@config_keys) {
3816 my $kconfig = chomp_config $config;
3817 if (!defined $depcount{$kconfig}) {
3818 $depcount{$kconfig} = 0;
3822 # Remove anything that was set by the make allnoconfig
3823 # we shouldn't need them as they get set for us anyway.
3824 foreach my $config (@config_keys) {
3825 # Remove anything in the ignore_config
3826 if (defined($keep_configs{$config})) {
3827 my $file = $ignore_config;
3828 $file =~ s,.*/(.*?)$,$1,;
3829 doprint "$config set by $file ... ignored\n";
3830 delete $min_configs{$config};
3833 # But make sure the settings are the same. If a min config
3834 # sets a selection, we do not want to get rid of it if
3835 # it is not the same as what we have. Just move it into
3837 if (defined($config_ignore{$config})) {
3838 if ($config_ignore{$config} ne $min_configs{$config}) {
3839 doprint "$config is in allnoconfig as '$config_ignore{$config}'";
3840 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
3841 $keep_configs{$config} = $min_configs{$config};
3843 doprint "$config set by allnoconfig ... ignored\n";
3845 delete $min_configs{$config};
3857 # Now disable each config one by one and do a make oldconfig
3858 # till we find a config that changes our list.
3860 my @test_configs = keys %min_configs;
3862 # Sort keys by who is most dependent on
3863 @test_configs = sort { $depcount{chomp_config($b)} <=> $depcount{chomp_config($a)} }
3866 # Put configs that did not modify the config at the end.
3868 for (my $i = 0; $i < $#test_configs; $i++) {
3869 if (!defined($nochange_config{$test_configs[0]})) {
3873 # This config didn't change the .config last time.
3874 # Place it at the end
3875 my $config = shift @test_configs;
3876 push @test_configs, $config;
3879 # if every test config has failed to modify the .config file
3880 # in the past, then reset and start over.
3882 undef %nochange_config;
3885 undef %processed_configs;
3887 foreach my $config (@test_configs) {
3889 $found = test_this_config $config;
3891 last if (defined($found));
3893 # oh well, try another config
3896 if (!defined($found)) {
3897 # we could have failed due to the nochange_config hash
3898 # reset and try again
3900 undef %nochange_config;
3904 doprint "No more configs found that we can disable\n";
3912 doprint "Test with $config disabled\n";
3914 # set in_bisect to keep build and monitor from dieing
3918 build "oldconfig" or $failed = 1;
3920 start_monitor_and_install or $failed = 1;
3922 if ($type eq "test" && !$failed) {
3923 do_run_test or $failed = 1;
3932 doprint "$min_configs{$config} is needed to boot the box... keeping\n";
3933 # this config is needed, add it to the ignore list.
3934 $keep_configs{$config} = $min_configs{$config};
3935 $save_configs{$config} = $min_configs{$config};
3936 delete $min_configs{$config};
3938 # update new ignore configs
3939 if (defined($ignore_config)) {
3940 open (OUT, ">$temp_config")
3941 or dodie "Can't write to $temp_config";
3942 foreach my $config (keys %save_configs) {
3943 print OUT "$save_configs{$config}\n";
3946 run_command "mv $temp_config $ignore_config" or
3947 dodie "failed to copy update to $ignore_config";
3951 # We booted without this config, remove it from the minconfigs.
3952 doprint "$config is not needed, disabling\n";
3954 delete $min_configs{$config};
3956 # Also disable anything that is not enabled in this config
3958 assign_configs \%configs, $output_config;
3959 my @config_keys = keys %min_configs;
3960 foreach my $config (@config_keys) {
3961 if (!defined($configs{$config})) {
3962 doprint "$config is not set, disabling\n";
3963 delete $min_configs{$config};
3967 # Save off all the current mandatory configs
3968 open (OUT, ">$temp_config")
3969 or dodie "Can't write to $temp_config";
3970 foreach my $config (keys %keep_configs) {
3971 print OUT "$keep_configs{$config}\n";
3973 foreach my $config (keys %min_configs) {
3974 print OUT "$min_configs{$config}\n";
3978 run_command "mv $temp_config $output_minconfig" or
3979 dodie "failed to copy update to $output_minconfig";
3982 doprint "Reboot and wait $sleep_time seconds\n";
3983 reboot_to_good $sleep_time;
3990 sub make_warnings_file {
3993 if (!defined($warnings_file)) {
3994 dodie "Must define WARNINGS_FILE for make_warnings_file test";
3997 if ($build_type eq "nobuild") {
3998 dodie "BUILD_TYPE can not be 'nobuild' for make_warnings_file test";
4001 build $build_type or dodie "Failed to build";
4003 open(OUT, ">$warnings_file") or dodie "Can't create $warnings_file";
4005 open(IN, $buildlog) or dodie "Can't open $buildlog";
4008 # Some compilers use UTF-8 extended for quotes
4009 # for distcc heterogeneous systems, this causes issues
4012 if (/$check_build_re/) {
4023 $#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl [config-file]\n";
4026 $ktest_config = $ARGV[0];
4027 if (! -f $ktest_config) {
4028 print "$ktest_config does not exist.\n";
4029 if (!read_yn "Create it?") {
4035 if (! -f $ktest_config) {
4038 open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
4040 # Generated by ktest.pl
4043 # PWD is a ktest.pl variable that will result in the process working
4044 # directory that ktest.pl is executed in.
4046 # THIS_DIR is automatically assigned the PWD of the path that generated
4047 # the config file. It is best to use this variable when assigning other
4048 # directory paths within this directory. This allows you to easily
4049 # move the test cases to other locations or to other machines.
4051 THIS_DIR := $variable{"PWD"}
4053 # Define each test with TEST_START
4054 # The config options below it will override the defaults
4056 TEST_TYPE = $default{"TEST_TYPE"}
4063 read_config $ktest_config;
4065 if (defined($opt{"LOG_FILE"})) {
4066 $opt{"LOG_FILE"} = eval_option("LOG_FILE", $opt{"LOG_FILE"}, -1);
4069 # Append any configs entered in manually to the config file.
4070 my @new_configs = keys %entered_configs;
4071 if ($#new_configs >= 0) {
4072 print "\nAppending entered in configs to $ktest_config\n";
4073 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
4074 foreach my $config (@new_configs) {
4075 print OUT "$config = $entered_configs{$config}\n";
4076 $opt{$config} = process_variables($entered_configs{$config});
4080 if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
4081 unlink $opt{"LOG_FILE"};
4084 doprint "\n\nSTARTING AUTOMATED TESTS\n\n";
4086 for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
4089 doprint "DEFAULT OPTIONS:\n";
4091 doprint "\nTEST $i OPTIONS";
4092 if (defined($repeat_tests{$i})) {
4093 $repeat = $repeat_tests{$i};
4094 doprint " ITERATE $repeat";
4099 foreach my $option (sort keys %opt) {
4101 if ($option =~ /\[(\d+)\]$/) {
4107 doprint "$option = $opt{$option}\n";
4111 sub option_defined {
4114 if (defined($opt{$option}) && $opt{$option} !~ /^\s*$/) {
4121 sub __set_test_option {
4122 my ($name, $i) = @_;
4124 my $option = "$name\[$i\]";
4126 if (option_defined($option)) {
4127 return $opt{$option};
4130 foreach my $test (keys %repeat_tests) {
4132 $i < $test + $repeat_tests{$test}) {
4133 $option = "$name\[$test\]";
4134 if (option_defined($option)) {
4135 return $opt{$option};
4140 if (option_defined($name)) {
4147 sub set_test_option {
4148 my ($name, $i) = @_;
4150 my $option = __set_test_option($name, $i);
4151 return $option if (!defined($option));
4153 return eval_option($name, $option, $i);
4159 my @paths = split /:/, $ENV{PATH};
4161 # sendmail is usually in /usr/sbin
4162 $paths[$#paths + 1] = "/usr/sbin";
4164 foreach my $path (@paths) {
4165 if (-x "$path/$mailer") {
4174 my ($subject, $message) = @_;
4176 if (!defined($mail_path)) {
4178 $mail_path = find_mailer $mailer;
4179 if (!defined($mail_path)) {
4180 die "\nCan not find $mailer in PATH\n";
4184 if (!defined($mail_command)) {
4185 if ($mailer eq "mail" || $mailer eq "mailx") {
4186 $mail_command = "\$MAIL_PATH/\$MAILER -s \'\$SUBJECT\' \$MAILTO <<< \'\$MESSAGE\'";
4187 } elsif ($mailer eq "sendmail" ) {
4188 $mail_command = "echo \'Subject: \$SUBJECT\n\n\$MESSAGE\' | \$MAIL_PATH/\$MAILER -t \$MAILTO";
4190 die "\nYour mailer: $mailer is not supported.\n";
4194 $mail_command =~ s/\$MAILER/$mailer/g;
4195 $mail_command =~ s/\$MAIL_PATH/$mail_path/g;
4196 $mail_command =~ s/\$MAILTO/$mailto/g;
4197 $mail_command =~ s/\$SUBJECT/$subject/g;
4198 $mail_command =~ s/\$MESSAGE/$message/g;
4200 my $ret = run_command $mail_command;
4201 if (!$ret && defined($file)) {
4202 # try again without the file
4203 $message .= "\n\n*** FAILED TO SEND LOG ***\n\n";
4204 do_send_email($subject, $message);
4210 if (defined($mailto)) {
4211 if (!defined($mailer)) {
4212 doprint "No email sent: email or mailer not specified in config.\n";
4220 if ($email_when_canceled) {
4221 my $name = get_test_name;
4222 send_email("KTEST: Your [$name] test was cancelled",
4223 "Your test started at $script_start_time was cancelled: sig int");
4225 die "\nCaught Sig Int, test interrupted: $!\n"
4228 $SIG{INT} = qw(cancel_test);
4230 # First we need to do is the builds
4231 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
4233 # Do not reboot on failing test options
4235 $reboot_success = 0;
4246 undef %force_config;
4248 my $makecmd = set_test_option("MAKE_CMD", $i);
4250 $outputdir = set_test_option("OUTPUT_DIR", $i);
4251 $builddir = set_test_option("BUILD_DIR", $i);
4253 chdir $builddir || dodie "can't change directory to $builddir";
4255 if (!-d $outputdir) {
4256 mkpath($outputdir) or
4257 dodie "can't create $outputdir";
4260 $make = "$makecmd O=$outputdir";
4262 # Load all the options into their mapped variable names
4263 foreach my $opt (keys %option_map) {
4264 ${$option_map{$opt}} = set_test_option($opt, $i);
4267 $start_minconfig_defined = 1;
4269 # The first test may override the PRE_KTEST option
4271 if (defined($pre_ktest)) {
4273 run_command $pre_ktest;
4275 if ($email_when_started) {
4276 my $name = get_test_name;
4277 send_email("KTEST: Your [$name] test was started",
4278 "Your test was started on $script_start_time");
4282 # Any test can override the POST_KTEST option
4283 # The last test takes precedence.
4284 if (defined($post_ktest)) {
4285 $final_post_ktest = $post_ktest;
4288 if (!defined($start_minconfig)) {
4289 $start_minconfig_defined = 0;
4290 $start_minconfig = $minconfig;
4295 dodie "can't create $tmpdir";
4298 $ENV{"SSH_USER"} = $ssh_user;
4299 $ENV{"MACHINE"} = $machine;
4301 $buildlog = "$tmpdir/buildlog-$machine";
4302 $testlog = "$tmpdir/testlog-$machine";
4303 $dmesg = "$tmpdir/dmesg-$machine";
4304 $output_config = "$outputdir/.config";
4307 $target = "$ssh_user\@$machine";
4308 if (($reboot_type eq "grub") or ($reboot_type eq "grub2bls")) {
4309 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
4310 } elsif ($reboot_type eq "grub2") {
4311 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
4312 dodie "GRUB_FILE not defined" if (!defined($grub_file));
4313 } elsif ($reboot_type eq "syslinux") {
4314 dodie "SYSLINUX_LABEL not defined" if (!defined($syslinux_label));
4318 my $run_type = $build_type;
4319 if ($test_type eq "patchcheck") {
4320 $run_type = $patchcheck_type;
4321 } elsif ($test_type eq "bisect") {
4322 $run_type = $bisect_type;
4323 } elsif ($test_type eq "config_bisect") {
4324 $run_type = $config_bisect_type;
4325 } elsif ($test_type eq "make_min_config") {
4327 } elsif ($test_type eq "make_warnings_file") {
4331 # mistake in config file?
4332 if (!defined($run_type)) {
4333 $run_type = "ERROR";
4337 $installme = " no_install" if ($no_install);
4341 if (defined($test_name)) {
4342 $name = " ($test_name)";
4346 doprint "RUNNING TEST $i of $opt{NUM_TESTS}$name with option $test_type $run_type$installme\n\n";
4348 if (defined($pre_test)) {
4349 run_command $pre_test;
4356 if (defined($addconfig)) {
4357 my $min = $minconfig;
4358 if (!defined($minconfig)) {
4361 run_command "cat $addconfig $min > $tmpdir/add_config" or
4362 dodie "Failed to create temp config";
4363 $minconfig = "$tmpdir/add_config";
4366 if (defined($checkout)) {
4367 run_command "git checkout $checkout" or
4368 dodie "failed to checkout $checkout";
4373 # A test may opt to not reboot the box
4374 if ($reboot_on_success) {
4375 $reboot_success = 1;
4378 if ($test_type eq "bisect") {
4381 } elsif ($test_type eq "config_bisect") {
4384 } elsif ($test_type eq "patchcheck") {
4387 } elsif ($test_type eq "make_min_config") {
4390 } elsif ($test_type eq "make_warnings_file") {
4392 make_warnings_file $i;
4396 if ($build_type ne "nobuild") {
4397 build $build_type or next;
4398 check_buildlog or next;
4401 if ($test_type eq "install") {
4408 if ($test_type ne "build") {
4410 start_monitor_and_install or $failed = 1;
4412 if (!$failed && $test_type ne "boot" && defined($run_test)) {
4413 do_run_test or $failed = 1;
4427 if (defined($final_post_ktest)) {
4429 my $cp_final_post_ktest = eval_kernel_version $final_post_ktest;
4430 run_command $cp_final_post_ktest;
4433 if ($opt{"POWEROFF_ON_SUCCESS"}) {
4435 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot && $reboot_success) {
4437 } elsif (defined($switch_to_good)) {
4438 # still need to get to the good kernel
4439 run_command $switch_to_good;
4443 doprint "\n $successes of $opt{NUM_TESTS} tests were successful\n\n";
4445 if ($email_when_finished) {
4446 send_email("KTEST: Your test has finished!",
4447 "$successes of $opt{NUM_TESTS} tests started at $script_start_time were successful!");