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;
193 my $config_bisect_type;
194 my $config_bisect_check;
197 my $patchcheck_start;
198 my $patchcheck_cherry;
206 # set when a test is something other that just building or install
207 # which would require more options.
210 # tell build not to worry about warnings, even when WARNINGS_FILE is set
213 # set when creating a new config
220 # force_config is the list of configs that we force enabled (or disabled)
221 # in a .config file. The MIN_CONFIG and ADD_CONFIG configs.
224 # do not force reboots on config problems
228 my $reboot_success = 0;
231 "MACHINE" => \
$machine,
232 "SSH_USER" => \
$ssh_user,
233 "TMP_DIR" => \
$tmpdir,
234 "OUTPUT_DIR" => \
$outputdir,
235 "BUILD_DIR" => \
$builddir,
236 "TEST_TYPE" => \
$test_type,
237 "PRE_KTEST" => \
$pre_ktest,
238 "POST_KTEST" => \
$post_ktest,
239 "PRE_TEST" => \
$pre_test,
240 "POST_TEST" => \
$post_test,
241 "BUILD_TYPE" => \
$build_type,
242 "BUILD_OPTIONS" => \
$build_options,
243 "PRE_BUILD" => \
$pre_build,
244 "POST_BUILD" => \
$post_build,
245 "PRE_BUILD_DIE" => \
$pre_build_die,
246 "POST_BUILD_DIE" => \
$post_build_die,
247 "POWER_CYCLE" => \
$power_cycle,
248 "REBOOT" => \
$reboot,
249 "BUILD_NOCLEAN" => \
$noclean,
250 "MIN_CONFIG" => \
$minconfig,
251 "OUTPUT_MIN_CONFIG" => \
$output_minconfig,
252 "START_MIN_CONFIG" => \
$start_minconfig,
253 "MIN_CONFIG_TYPE" => \
$minconfig_type,
254 "USE_OUTPUT_MIN_CONFIG" => \
$use_output_minconfig,
255 "WARNINGS_FILE" => \
$warnings_file,
256 "IGNORE_CONFIG" => \
$ignore_config,
257 "TEST" => \
$run_test,
258 "ADD_CONFIG" => \
$addconfig,
259 "REBOOT_TYPE" => \
$reboot_type,
260 "GRUB_MENU" => \
$grub_menu,
261 "GRUB_FILE" => \
$grub_file,
262 "GRUB_REBOOT" => \
$grub_reboot,
263 "SYSLINUX" => \
$syslinux,
264 "SYSLINUX_PATH" => \
$syslinux_path,
265 "SYSLINUX_LABEL" => \
$syslinux_label,
266 "PRE_INSTALL" => \
$pre_install,
267 "POST_INSTALL" => \
$post_install,
268 "NO_INSTALL" => \
$no_install,
269 "REBOOT_SCRIPT" => \
$reboot_script,
270 "REBOOT_ON_ERROR" => \
$reboot_on_error,
271 "SWITCH_TO_GOOD" => \
$switch_to_good,
272 "SWITCH_TO_TEST" => \
$switch_to_test,
273 "POWEROFF_ON_ERROR" => \
$poweroff_on_error,
274 "REBOOT_ON_SUCCESS" => \
$reboot_on_success,
275 "DIE_ON_FAILURE" => \
$die_on_failure,
276 "POWER_OFF" => \
$power_off,
277 "POWERCYCLE_AFTER_REBOOT" => \
$powercycle_after_reboot,
278 "POWEROFF_AFTER_HALT" => \
$poweroff_after_halt,
279 "MAX_MONITOR_WAIT" => \
$max_monitor_wait,
280 "SLEEP_TIME" => \
$sleep_time,
281 "BISECT_SLEEP_TIME" => \
$bisect_sleep_time,
282 "PATCHCHECK_SLEEP_TIME" => \
$patchcheck_sleep_time,
283 "IGNORE_WARNINGS" => \
$ignore_warnings,
284 "IGNORE_ERRORS" => \
$ignore_errors,
285 "BISECT_MANUAL" => \
$bisect_manual,
286 "BISECT_SKIP" => \
$bisect_skip,
287 "BISECT_TRIES" => \
$bisect_tries,
288 "CONFIG_BISECT_GOOD" => \
$config_bisect_good,
289 "BISECT_RET_GOOD" => \
$bisect_ret_good,
290 "BISECT_RET_BAD" => \
$bisect_ret_bad,
291 "BISECT_RET_SKIP" => \
$bisect_ret_skip,
292 "BISECT_RET_ABORT" => \
$bisect_ret_abort,
293 "BISECT_RET_DEFAULT" => \
$bisect_ret_default,
294 "STORE_FAILURES" => \
$store_failures,
295 "STORE_SUCCESSES" => \
$store_successes,
296 "TEST_NAME" => \
$test_name,
297 "TIMEOUT" => \
$timeout,
298 "BOOTED_TIMEOUT" => \
$booted_timeout,
299 "CONSOLE" => \
$console,
300 "CLOSE_CONSOLE_SIGNAL" => \
$close_console_signal,
301 "DETECT_TRIPLE_FAULT" => \
$detect_triplefault,
302 "SUCCESS_LINE" => \
$success_line,
303 "REBOOT_SUCCESS_LINE" => \
$reboot_success_line,
304 "STOP_AFTER_SUCCESS" => \
$stop_after_success,
305 "STOP_AFTER_FAILURE" => \
$stop_after_failure,
306 "STOP_TEST_AFTER" => \
$stop_test_after,
307 "BUILD_TARGET" => \
$build_target,
308 "SSH_EXEC" => \
$ssh_exec,
309 "SCP_TO_TARGET" => \
$scp_to_target,
310 "SCP_TO_TARGET_INSTALL" => \
$scp_to_target_install,
311 "CHECKOUT" => \
$checkout,
312 "TARGET_IMAGE" => \
$target_image,
313 "LOCALVERSION" => \
$localversion,
315 "BISECT_GOOD" => \
$bisect_good,
316 "BISECT_BAD" => \
$bisect_bad,
317 "BISECT_TYPE" => \
$bisect_type,
318 "BISECT_START" => \
$bisect_start,
319 "BISECT_REPLAY" => \
$bisect_replay,
320 "BISECT_FILES" => \
$bisect_files,
321 "BISECT_REVERSE" => \
$bisect_reverse,
322 "BISECT_CHECK" => \
$bisect_check,
324 "CONFIG_BISECT" => \
$config_bisect,
325 "CONFIG_BISECT_TYPE" => \
$config_bisect_type,
326 "CONFIG_BISECT_CHECK" => \
$config_bisect_check,
328 "PATCHCHECK_TYPE" => \
$patchcheck_type,
329 "PATCHCHECK_START" => \
$patchcheck_start,
330 "PATCHCHECK_CHERRY" => \
$patchcheck_cherry,
331 "PATCHCHECK_END" => \
$patchcheck_end,
334 # Options may be used by other options, record them.
337 # default variables that can be used
338 chomp ($variable{"PWD"} = `pwd`);
340 $config_help{"MACHINE"} = << "EOF"
341 The machine hostname that you will test
.
342 For build only tests
, it is still needed to differentiate
log files
.
345 $config_help{"SSH_USER"} = << "EOF"
346 The box is expected to have ssh on normal bootup
, provide the user
347 (most likely root
, since you need privileged operations
)
350 $config_help{"BUILD_DIR"} = << "EOF"
351 The directory that contains the Linux source code
(full path
).
352 You can
use \
${PWD
} that will be the path where ktest
.pl is run
, or use
353 \
${THIS_DIR
} which is assigned \
${PWD
} but may be changed later
.
356 $config_help{"OUTPUT_DIR"} = << "EOF"
357 The directory that the objects will be built
(full path
).
358 (can
not be same as BUILD_DIR
)
359 You can
use \
${PWD
} that will be the path where ktest
.pl is run
, or use
360 \
${THIS_DIR
} which is assigned \
${PWD
} but may be changed later
.
363 $config_help{"BUILD_TARGET"} = << "EOF"
364 The location of the compiled file to copy to the target
.
365 (relative to OUTPUT_DIR
)
368 $config_help{"BUILD_OPTIONS"} = << "EOF"
369 Options to add to
\"make
\" when building
.
373 $config_help{"TARGET_IMAGE"} = << "EOF"
374 The place to put your image on the test machine
.
377 $config_help{"POWER_CYCLE"} = << "EOF"
378 A script
or command to reboot the box
.
380 Here is a digital loggers power switch example
381 POWER_CYCLE
= wget
--no-proxy
-O
/dev/null
-q
--auth
-no-challenge
'http://admin:admin\@power/outlet?5=CCL'
383 Here is an example to reboot a virtual box on the current host
384 with the name
"Guest".
385 POWER_CYCLE
= virsh destroy Guest
; sleep 5; virsh start Guest
388 $config_help{"CONSOLE"} = << "EOF"
389 The script
or command that reads the console
391 If you
use ttywatch server
, something like the following would work
.
392 CONSOLE
= nc
-d localhost
3001
394 For a virtual machine with guest name
"Guest".
395 CONSOLE
= virsh console Guest
398 $config_help{"LOCALVERSION"} = << "EOF"
399 Required version ending to differentiate the test
400 from other linux builds on the
system.
403 $config_help{"REBOOT_TYPE"} = << "EOF"
404 Way to reboot the box to the test kernel
.
405 Only valid options so far are
"grub", "grub2", "syslinux", and "script".
407 If you specify grub
, it will assume grub version
1
408 and will search
in /boot/grub
/menu
.lst
for the title \
$GRUB_MENU
409 and select that target to reboot to the kernel
. If this is
not
410 your setup
, then specify
"script" and have a command
or script
411 specified
in REBOOT_SCRIPT to boot to the target
.
413 The entry
in /boot/grub
/menu
.lst must be entered
in manually
.
414 The test will
not modify that file
.
416 If you specify grub2
, then you also need to specify both \
$GRUB_MENU
419 If you specify syslinux
, then you may
use SYSLINUX to define the syslinux
420 command
(defaults to extlinux
), and SYSLINUX_PATH to specify the path to
421 the syslinux install
(defaults to
/boot/extlinux
). But you have to specify
422 SYSLINUX_LABEL to define the label to boot to
for the test kernel
.
425 $config_help{"GRUB_MENU"} = << "EOF"
426 The grub title name
for the test kernel to boot
427 (Only mandatory
if REBOOT_TYPE
= grub
or grub2
)
429 Note
, ktest
.pl will
not update the grub menu
.lst
, you need to
430 manually add an option
for the test
. ktest
.pl will search
431 the grub menu
.lst
for this option to find what kernel to
434 For example
, if in the
/boot/grub
/menu
.lst the test kernel title has
:
437 GRUB_MENU
= Test Kernel
439 For grub2
, a search of \
$GRUB_FILE is performed
for the lines
440 that begin with
"menuentry". It will
not detect submenus
. The
441 menu must be a non
-nested menu
. Add the quotes used
in the menu
442 to guarantee your selection
, as the first menuentry with the content
443 of \
$GRUB_MENU that is found will be used
.
446 $config_help{"GRUB_FILE"} = << "EOF"
447 If grub2 is used
, the full path
for the grub
.cfg file is placed
448 here
. Use something like
/boot/grub
2/grub
.cfg to search
.
451 $config_help{"SYSLINUX_LABEL"} = << "EOF"
452 If syslinux is used
, the label that boots the target kernel must
453 be specified with SYSLINUX_LABEL
.
456 $config_help{"REBOOT_SCRIPT"} = << "EOF"
457 A script to reboot the target into the test kernel
458 (Only mandatory
if REBOOT_TYPE
= script
)
463 if (defined($opt{"LOG_FILE"})) {
464 open(OUT
, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
471 if (defined($opt{"LOG_FILE"})) {
484 my ($cancel, $prompt) = @_;
490 print "$prompt [y/n/C] ";
492 print "$prompt [Y/n] ";
496 if ($ans =~ /^\s*$/) {
503 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
505 last if ($ans =~ /^c$/i);
506 print "Please answer either 'y', 'n' or 'c'.\n";
508 print "Please answer either 'y' or 'n'.\n";
514 if ($ans !~ /^y$/i) {
523 return read_prompt
0, $prompt;
529 return read_prompt
1, $prompt;
532 sub get_mandatory_config
{
536 return if (defined($opt{$config}));
538 if (defined($config_help{$config})) {
540 print $config_help{$config};
545 if (defined($default{$config}) && length($default{$config})) {
546 print "\[$default{$config}\] ";
549 $ans =~ s/^\s*(.*\S)\s*$/$1/;
550 if ($ans =~ /^\s*$/) {
551 if ($default{$config}) {
552 $ans = $default{$config};
554 print "Your answer can not be blank\n";
558 $entered_configs{$config} = ${ans
};
570 $hours = int($time / 3600);
571 $time -= $hours * 3600;
574 $minutes = int($time / 60);
575 $time -= $minutes * 60;
579 doprint
"$hours hour";
580 doprint
"s" if ($hours > 1);
585 doprint
"$minutes minute";
586 doprint
"s" if ($minutes > 1);
590 doprint
"$time second";
591 doprint
"s" if ($time != 1);
597 doprint
"Build time: ";
598 show_time
($build_time);
602 doprint
"Install time: ";
603 show_time
($install_time);
607 doprint
"Reboot time: ";
608 show_time
($reboot_time);
612 doprint
"Test time: ";
613 show_time
($test_time);
616 # reset for iterations like bisect
623 sub get_mandatory_configs
{
624 get_mandatory_config
("MACHINE");
625 get_mandatory_config
("BUILD_DIR");
626 get_mandatory_config
("OUTPUT_DIR");
629 get_mandatory_config
("BUILD_OPTIONS");
632 # options required for other than just building a kernel
634 get_mandatory_config
("POWER_CYCLE");
635 get_mandatory_config
("CONSOLE");
638 # options required for install and more
639 if ($buildonly != 1) {
640 get_mandatory_config
("SSH_USER");
641 get_mandatory_config
("BUILD_TARGET");
642 get_mandatory_config
("TARGET_IMAGE");
645 get_mandatory_config
("LOCALVERSION");
647 return if ($buildonly);
649 my $rtype = $opt{"REBOOT_TYPE"};
651 if (!defined($rtype)) {
652 if (!defined($opt{"GRUB_MENU"})) {
653 get_mandatory_config
("REBOOT_TYPE");
654 $rtype = $entered_configs{"REBOOT_TYPE"};
660 if ($rtype eq "grub") {
661 get_mandatory_config
("GRUB_MENU");
664 if ($rtype eq "grub2") {
665 get_mandatory_config
("GRUB_MENU");
666 get_mandatory_config
("GRUB_FILE");
669 if ($rtype eq "syslinux") {
670 get_mandatory_config
("SYSLINUX_LABEL");
674 sub process_variables
{
675 my ($value, $remove_undef) = @_;
678 # We want to check for '\', and it is just easier
679 # to check the previous characet of '$' and not need
680 # to worry if '$' is the first character. By adding
681 # a space to $value, we can just check [^\\]\$ and
682 # it will still work.
685 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
689 # append beginning of value to retval
690 $retval = "$retval$begin";
691 if (defined($variable{$var})) {
692 $retval = "$retval$variable{$var}";
693 } elsif (defined($remove_undef) && $remove_undef) {
694 # for if statements, any variable that is not defined,
695 # we simple convert to 0
696 $retval = "${retval}0";
698 # put back the origin piece.
699 $retval = "$retval\$\{$var\}";
700 # This could be an option that is used later, save
701 # it so we don't warn if this option is not one of
703 $used_options{$var} = 1;
707 $retval = "$retval$value";
709 # remove the space added in the beginning
716 my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
718 my $prvalue = process_variables
($rvalue);
720 if ($buildonly && $lvalue =~ /^TEST_TYPE(\[.*\])?$/ && $prvalue ne "build") {
721 # Note if a test is something other than build, then we
722 # will need other manditory options.
723 if ($prvalue ne "install") {
724 # for bisect, we need to check BISECT_TYPE
725 if ($prvalue ne "bisect") {
729 # install still limits some manditory options.
734 if ($buildonly && $lvalue =~ /^BISECT_TYPE(\[.*\])?$/ && $prvalue ne "build") {
735 if ($prvalue ne "install") {
738 # install still limits some manditory options.
743 if (defined($opt{$lvalue})) {
744 if (!$override || defined(${$overrides}{$lvalue})) {
747 $extra = "In the same override section!\n";
749 die "$name: $.: Option $lvalue defined more than once!\n$extra";
751 ${$overrides}{$lvalue} = $prvalue;
754 $opt{$lvalue} = $prvalue;
758 my ($lvalue, $rvalue, $name) = @_;
760 my $prvalue = process_variables
($rvalue);
763 if (defined($evals{$lvalue})) {
764 $arr = $evals{$lvalue};
767 $evals{$lvalue} = $arr;
770 push @
{$arr}, $rvalue;
774 my ($lvalue, $rvalue) = @_;
776 if ($rvalue =~ /^\s*$/) {
777 delete $variable{$lvalue};
779 $rvalue = process_variables
($rvalue);
780 $variable{$lvalue} = $rvalue;
784 sub process_compare
{
785 my ($lval, $cmp, $rval) = @_;
796 return $lval eq $rval;
797 } elsif ($cmp eq "!=") {
798 return $lval ne $rval;
799 } elsif ($cmp eq "=~") {
800 return $lval =~ m/$rval/;
801 } elsif ($cmp eq "!~") {
802 return $lval !~ m/$rval/;
805 my $statement = "$lval $cmp $rval";
806 my $ret = eval $statement;
808 # $@ stores error of eval
819 return defined($variable{$2}) ||
824 sub process_expression
{
825 my ($name, $val) = @_;
829 while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
832 if (process_expression
($name, $express)) {
833 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
835 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
843 while ($val =~ s/^(.*?)($OR|$AND)//) {
847 if (process_expression
($name, $express)) {
858 if ($val =~ /(.*)(==|\!=|>=|<=|>|<|=~|\!~)(.*)/) {
859 my $ret = process_compare
($1, $2, $3);
861 die "$name: $.: Unable to process comparison\n";
866 if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
868 return !value_defined
($2);
870 return value_defined
($2);
874 if ($val =~ /^\s*0\s*$/) {
876 } elsif ($val =~ /^\s*\d+\s*$/) {
880 die ("$name: $.: Undefined content $val in if statement\n");
884 my ($name, $value) = @_;
886 # Convert variables and replace undefined ones with 0
887 my $val = process_variables
($value, 1);
888 my $ret = process_expression
$name, $val;
894 my ($config, $current_test_num) = @_;
897 open($in, $config) || die "can't read file $config";
900 $name =~ s
,.*/(.*),$1,;
902 my $test_num = $$current_test_num;
905 my $num_tests_set = 0;
918 # ignore blank lines and comments
919 next if (/^\s*$/ || /\s*\#/);
921 if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
931 if ($type eq "TEST_START") {
933 if ($num_tests_set) {
934 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
937 $old_test_num = $test_num;
938 $old_repeat = $repeat;
940 $test_num += $repeat;
947 # If SKIP is anywhere in the line, the command will be skipped
948 if ($rest =~ s/\s+SKIP\b//) {
955 if ($rest =~ s/\sELSE\b//) {
957 die "$name: $.: ELSE found with out matching IF section\n$_";
968 if ($rest =~ s/\sIF\s+(.*)//) {
969 if (process_if
($name, $1)) {
981 if ($type eq "TEST_START") {
982 if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
984 $repeat_tests{"$test_num"} = $repeat;
986 } elsif ($rest =~ s/\sOVERRIDE\b//) {
989 # Clear previous overrides
994 if (!$skip && $rest !~ /^\s*$/) {
995 die "$name: $.: Gargbage found after $type\n$_";
998 if ($skip && $type eq "TEST_START") {
999 $test_num = $old_test_num;
1000 $repeat = $old_repeat;
1003 } elsif (/^\s*ELSE\b(.*)$/) {
1005 die "$name: $.: ELSE found with out matching IF section\n$_";
1014 if ($rest =~ /\sIF\s+(.*)/) {
1015 # May be a ELSE IF section.
1016 if (process_if
($name, $1)) {
1027 if ($rest !~ /^\s*$/) {
1028 die "$name: $.: Gargbage found after DEFAULTS\n$_";
1031 } elsif (/^\s*INCLUDE\s+(\S+)/) {
1036 die "$name: $.: INCLUDE can only be done in default sections\n$_";
1039 my $file = process_variables
($1);
1041 if ($file !~ m
,^/,) {
1042 # check the path of the config file first
1043 if ($config =~ m
,(.*)/,) {
1044 if (-f
"$1/$file") {
1051 die "$name: $.: Can't read file $file\n$_";
1054 if (__read_config
($file, \
$test_num)) {
1058 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=~\s*(.*?)\s*$/) {
1065 if ($default || $lvalue =~ /\[\d+\]$/) {
1066 set_eval
($lvalue, $rvalue, $name);
1068 my $val = "$lvalue\[$test_num\]";
1069 set_eval
($val, $rvalue, $name);
1072 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
1080 ($lvalue eq "NUM_TESTS" ||
1081 $lvalue eq "LOG_FILE" ||
1082 $lvalue eq "CLEAR_LOG")) {
1083 die "$name: $.: $lvalue must be set in DEFAULTS section\n";
1086 if ($lvalue eq "NUM_TESTS") {
1088 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
1091 die "$name: $.: NUM_TESTS must be set in default section\n";
1096 if ($default || $lvalue =~ /\[\d+\]$/) {
1097 set_value
($lvalue, $rvalue, $override, \
%overrides, $name);
1099 my $val = "$lvalue\[$test_num\]";
1100 set_value
($val, $rvalue, $override, \
%overrides, $name);
1103 $repeats{$val} = $repeat;
1106 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
1112 # process config variables.
1113 # Config variables are only active while reading the
1114 # config and can be defined anywhere. They also ignore
1115 # TEST_START and DEFAULTS, but are skipped if they are in
1116 # on of these sections that have SKIP defined.
1117 # The save variable can be
1118 # defined multiple times and the new one simply overrides
1120 set_variable
($lvalue, $rvalue);
1123 die "$name: $.: Garbage found in config\n$_";
1128 $test_num += $repeat - 1;
1129 $opt{"NUM_TESTS"} = $test_num;
1134 $$current_test_num = $test_num;
1140 print "What test case would you like to run?\n";
1141 print " (build, install or boot)\n";
1142 print " Other tests are available but require editing the config file\n";
1145 $default{"TEST_TYPE"} = $ans;
1154 $test_case = __read_config
$config, \
$test_num;
1156 # make sure we have all mandatory configs
1157 get_mandatory_configs
;
1159 # was a test specified?
1161 print "No test case specified.\n";
1167 foreach my $default (keys %default) {
1168 if (!defined($opt{$default})) {
1169 $opt{$default} = $default{$default};
1173 if ($opt{"IGNORE_UNUSED"} == 1) {
1179 # check if there are any stragglers (typos?)
1180 foreach my $option (keys %opt) {
1182 # remove per test labels.
1184 if (!exists($option_map{$op}) &&
1185 !exists($default{$op}) &&
1186 !exists($used_options{$op})) {
1193 $s = " is" if (keys %not_used == 1);
1194 print "The following option$s not used; could be a typo:\n";
1195 foreach my $option (keys %not_used) {
1198 print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";
1199 if (!read_yn
"Do you want to continue?") {
1206 my ($name, $option, $i) = @_;
1208 # Add space to evaluate the character before $
1209 $option = " $option";
1214 foreach my $test (keys %repeat_tests) {
1216 $i < $test + $repeat_tests{$test}) {
1224 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
1229 # Append beginning of line
1230 $retval = "$retval$start";
1232 # If the iteration option OPT[$i] exists, then use that.
1233 # otherwise see if the default OPT (without [$i]) exists.
1235 my $o = "$var\[$i\]";
1236 my $parento = "$var\[$parent\]";
1238 # If a variable contains itself, use the default var
1239 if (($var eq $name) && defined($opt{$var})) {
1241 $retval = "$retval$o";
1242 } elsif (defined($opt{$o})) {
1244 $retval = "$retval$o";
1245 } elsif ($repeated && defined($opt{$parento})) {
1246 $o = $opt{$parento};
1247 $retval = "$retval$o";
1248 } elsif (defined($opt{$var})) {
1250 $retval = "$retval$o";
1251 } elsif ($var eq "KERNEL_VERSION" && defined($make)) {
1252 # special option KERNEL_VERSION uses kernel version
1254 $retval = "$retval$version";
1256 $retval = "$retval\$\{$var\}";
1262 $retval = "$retval$option";
1270 my ($name, $option, $i) = @_;
1272 my $option_name = "$name\[$i\]";
1275 my $old_option = $option;
1277 if (defined($evals{$option_name})) {
1278 $ev = $evals{$option_name};
1279 } elsif (defined($evals{$name})) {
1280 $ev = $evals{$name};
1285 for my $e (@
{$ev}) {
1286 eval "\$option =~ $e";
1289 if ($option ne $old_option) {
1290 doprint
("$name changed from '$old_option' to '$option'\n");
1297 my ($name, $option, $i) = @_;
1301 # Since an option can evaluate to another option,
1302 # keep iterating until we do not evaluate any more
1305 while ($prev ne $option) {
1306 # Check for recursive evaluations.
1307 # 100 deep should be more than enough.
1309 die "Over 100 evaluations accurred with $option\n" .
1310 "Check for recursive variables\n";
1313 $option = __eval_option
($name, $option, $i);
1316 $option = process_evals
($name, $option, $i);
1324 sub wait_for_monitor
;
1329 # Make sure everything has been written to disk
1332 if (defined($time)) {
1334 # flush out current monitor
1335 # May contain the reboot success line
1339 # try to reboot normally
1340 if (run_command
$reboot) {
1341 if (defined($powercycle_after_reboot)) {
1342 sleep $powercycle_after_reboot;
1343 run_command
"$power_cycle";
1346 # nope? power cycle it.
1347 run_command
"$power_cycle";
1350 if (defined($time)) {
1352 # We only want to get to the new kernel, don't fail
1353 # if we stumble over a call trace.
1354 my $save_ignore_errors = $ignore_errors;
1357 # Look for the good kernel to boot
1358 if (wait_for_monitor
($time, "Linux version")) {
1360 doprint
"Reboot did not finish. Forcing power cycle\n";
1361 run_command
"$power_cycle";
1364 $ignore_errors = $save_ignore_errors;
1366 # Still need to wait for the reboot to finish
1367 wait_for_monitor
($time, $reboot_success_line);
1373 sub reboot_to_good
{
1376 if (defined($switch_to_good)) {
1377 run_command
$switch_to_good;
1386 return $test_type eq "build" || $no_reboot ||
1387 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
1388 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
1392 doprint
"CRITICAL FAILURE... ", @_, "\n";
1396 if ($reboot_on_error && !do_not_reboot
) {
1398 doprint
"REBOOTING\n";
1401 } elsif ($poweroff_on_error && defined($power_off)) {
1402 doprint
"POWERING OFF\n";
1406 if (defined($opt{"LOG_FILE"})) {
1407 print " See $opt{LOG_FILE} for more info.\n";
1414 my ($ptm, $pts) = @_;
1416 my $TIOCSPTLCK = 0x40045431;
1417 my $TIOCGPTN = 0x80045430;
1419 sysopen($ptm, "/dev/ptmx", O_RDWR
| O_NONBLOCK
) or
1420 dodie
"Cant open /dev/ptmx";
1423 $tmp = pack("i", 0);
1424 ioctl($ptm, $TIOCSPTLCK, $tmp) or
1425 dodie
"ioctl TIOCSPTLCK for /dev/ptmx failed";
1428 ioctl($ptm, $TIOCGPTN, $tmp) or
1429 dodie
"ioctl TIOCGPTN for /dev/ptmx failed";
1430 $tmp = unpack("i", $tmp);
1432 sysopen($pts, "/dev/pts/$tmp", O_RDWR
| O_NONBLOCK
) or
1433 dodie
"Can't open /dev/pts/$tmp";
1437 my ($ptm, $pts) = @_;
1445 open(\
*STDIN
, '<&', $pts);
1446 open(\
*STDOUT
, '>&', $pts);
1447 open(\
*STDERR
, '>&', $pts);
1452 dodie
"Can't open console $console";
1460 # save terminal settings
1461 $stty_orig = `stty -g`;
1463 # place terminal in cbreak mode so that stdin can be read one character at
1464 # a time without having to wait for a newline
1465 system("stty -icanon -echo -icrnl");
1467 create_pty
($ptm, $pts);
1473 exec_console
($ptm, $pts)
1481 open(PTSFD
, "Stop perl from warning about single use of PTSFD");
1485 my ($fp, $pid) = @_;
1487 doprint
"kill child process $pid\n";
1488 kill $close_console_signal, $pid;
1493 # restore terminal settings
1494 system("stty $stty_orig");
1498 if ($monitor_cnt++) {
1501 $monitor_fp = \
*MONFD
;
1502 $monitor_pid = open_console
$monitor_fp;
1506 open(MONFD
, "Stop perl from warning about single use of MONFD");
1510 return if (!defined $console);
1511 if (--$monitor_cnt) {
1514 close_console
($monitor_fp, $monitor_pid);
1517 sub wait_for_monitor
{
1518 my ($time, $stop) = @_;
1522 my $start_time = time;
1523 my $skip_call_trace = 0;
1525 my $bug_ignored = 0;
1528 doprint
"** Wait for monitor to settle down **\n";
1530 # read the monitor and wait for the system to calm down
1532 $line = wait_for_input
($monitor_fp, $time);
1533 last if (!defined($line));
1535 $full_line .= $line;
1537 if (defined($stop) && $full_line =~ /$stop/) {
1538 doprint
"wait for monitor detected $stop\n";
1542 if ($full_line =~ /\[ backtrace testing \]/) {
1543 $skip_call_trace = 1;
1546 if ($full_line =~ /call trace:/i) {
1547 if (!$bug && !$skip_call_trace) {
1548 if ($ignore_errors) {
1556 if ($full_line =~ /\[ end of backtrace testing \]/) {
1557 $skip_call_trace = 0;
1560 if ($full_line =~ /Kernel panic -/) {
1564 if ($line =~ /\n/) {
1568 if ($now - $start_time >= $max_monitor_wait) {
1569 doprint
"Exiting monitor flush due to hitting MAX_MONITOR_WAIT\n";
1573 print "** Monitor flushed **\n";
1575 # if stop is defined but wasn't hit, return error
1576 # used by reboot (which wants to see a reboot)
1577 if (defined($stop) && !$booted) {
1584 my ($result, $basedir) = @_;
1586 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
1587 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
1589 my $type = $build_type;
1590 if ($type =~ /useconfig/) {
1591 $type = "useconfig";
1594 my $dir = "$machine-$test_type-$type-$result-$date";
1596 $dir = "$basedir/$dir";
1600 die "can't create $dir";
1604 "config" => $output_config,
1605 "buildlog" => $buildlog,
1607 "testlog" => $testlog,
1610 while (my ($name, $source) = each(%files)) {
1612 cp
"$source", "$dir/$name" or
1613 die "failed to copy $source";
1617 doprint
"*** Saved info to $dir ***\n";
1622 if (defined($post_test)) {
1623 run_command
$post_test;
1626 if ($die_on_failure) {
1634 # no need to reboot for just building.
1635 if (!do_not_reboot
) {
1636 doprint
"REBOOTING\n";
1637 reboot_to_good
$sleep_time;
1642 if (defined($test_name)) {
1643 $name = " ($test_name)";
1648 doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1649 doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1650 doprint
"KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
1651 doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1652 doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1654 if (defined($store_failures)) {
1655 save_logs
"fail", $store_failures;
1662 my ($command, $redirect) = @_;
1671 $command =~ s/\$SSH_USER/$ssh_user/g;
1672 $command =~ s/\$MACHINE/$machine/g;
1674 doprint
("$command ... ");
1676 $pid = open(CMD
, "$command 2>&1 |") or
1677 (fail
"unable to exec $command" and return 0);
1679 if (defined($opt{"LOG_FILE"})) {
1680 open(LOG
, ">>$opt{LOG_FILE}") or
1681 dodie
"failed to write to log";
1685 if (defined($redirect)) {
1686 open (RD
, ">$redirect") or
1687 dodie
"failed to write to redirect $redirect";
1692 print LOG
if ($dolog);
1693 print RD
if ($dord);
1700 close(LOG
) if ($dolog);
1701 close(RD
) if ($dord);
1704 my $delta = $end_time - $start_time;
1707 doprint
"[1 second] ";
1709 doprint
"[$delta seconds] ";
1713 doprint
"FAILED!\n";
1715 doprint
"SUCCESS\n";
1723 my $cp_exec = $ssh_exec;
1725 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
1726 return run_command
"$cp_exec";
1730 my ($src, $dst, $cp_scp) = @_;
1732 $cp_scp =~ s/\$SRC_FILE/$src/g;
1733 $cp_scp =~ s/\$DST_FILE/$dst/g;
1735 return run_command
"$cp_scp";
1738 sub run_scp_install
{
1739 my ($src, $dst) = @_;
1741 my $cp_scp = $scp_to_target_install;
1743 return run_scp
($src, $dst, $cp_scp);
1747 my ($src, $dst) = @_;
1749 my $cp_scp = $scp_to_target;
1751 return run_scp
($src, $dst, $cp_scp);
1754 sub get_grub2_index
{
1756 return if (defined($grub_number) && defined($last_grub_menu) &&
1757 $last_grub_menu eq $grub_menu && defined($last_machine) &&
1758 $last_machine eq $machine);
1760 doprint
"Find grub2 menu ... ";
1763 my $ssh_grub = $ssh_exec;
1764 $ssh_grub =~ s
,\
$SSH_COMMAND,cat
$grub_file,g
;
1766 open(IN
, "$ssh_grub |")
1767 or die "unable to get $grub_file";
1772 if (/^menuentry.*$grub_menu/) {
1776 } elsif (/^menuentry\s/) {
1782 die "Could not find '$grub_menu' in $grub_file on $machine"
1784 doprint
"$grub_number\n";
1785 $last_grub_menu = $grub_menu;
1786 $last_machine = $machine;
1789 sub get_grub_index
{
1791 if ($reboot_type eq "grub2") {
1796 if ($reboot_type ne "grub") {
1799 return if (defined($grub_number) && defined($last_grub_menu) &&
1800 $last_grub_menu eq $grub_menu && defined($last_machine) &&
1801 $last_machine eq $machine);
1803 doprint
"Find grub menu ... ";
1806 my $ssh_grub = $ssh_exec;
1807 $ssh_grub =~ s
,\
$SSH_COMMAND,cat
/boot/grub
/menu
.lst
,g
;
1809 open(IN
, "$ssh_grub |")
1810 or die "unable to get menu.lst";
1815 if (/^\s*title\s+$grub_menu\s*$/) {
1819 } elsif (/^\s*title\s/) {
1825 die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
1827 doprint
"$grub_number\n";
1828 $last_grub_menu = $grub_menu;
1829 $last_machine = $machine;
1834 my ($fp, $time) = @_;
1842 if (!defined($time)) {
1847 vec($rin, fileno($fp), 1) = 1;
1848 vec($rin, fileno(\
*STDIN
), 1) = 1;
1851 $nr = select($rout=$rin, undef, undef, $time);
1857 # copy data from stdin to the console
1858 if (vec($rout, fileno(\
*STDIN
), 1) == 1) {
1859 sysread(\
*STDIN
, $buf, 1000);
1860 syswrite($fp, $buf, 1000);
1866 # try to read one char at a time
1867 while (sysread $fp, $ch, 1) {
1869 last if ($ch eq "\n");
1872 if (!length($line)) {
1881 if (defined($switch_to_test)) {
1882 run_command
$switch_to_test;
1885 if ($reboot_type eq "grub") {
1886 run_ssh
"'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
1887 } elsif ($reboot_type eq "grub2") {
1888 run_ssh
"$grub_reboot $grub_number";
1889 } elsif ($reboot_type eq "syslinux") {
1890 run_ssh
"$syslinux --once \\\"$syslinux_label\\\" $syslinux_path";
1891 } elsif (defined $reboot_script) {
1892 run_command
"$reboot_script";
1900 doprint
"git rev-list --max-count=1 $commit ... ";
1901 my $sha1 = `git rev-list --max-count=1 $commit`;
1908 dodie
"Failed to get git $commit";
1921 my $bug_ignored = 0;
1922 my $skip_call_trace = 0;
1925 my $start_time = time;
1932 open(DMESG
, "> $dmesg") or
1933 die "unable to write to $dmesg";
1939 my $monitor_start = time;
1941 my $version_found = 0;
1945 if ($bug && defined($stop_after_failure) &&
1946 $stop_after_failure >= 0) {
1947 my $time = $stop_after_failure - (time - $failure_start);
1948 $line = wait_for_input
($monitor_fp, $time);
1949 if (!defined($line)) {
1950 doprint
"bug timed out after $booted_timeout seconds\n";
1951 doprint
"Test forced to stop after $stop_after_failure seconds after failure\n";
1955 $line = wait_for_input
($monitor_fp, $booted_timeout);
1956 if (!defined($line)) {
1957 my $s = $booted_timeout == 1 ?
"" : "s";
1958 doprint
"Successful boot found: break after $booted_timeout second$s\n";
1962 $line = wait_for_input
($monitor_fp);
1963 if (!defined($line)) {
1964 my $s = $timeout == 1 ?
"" : "s";
1965 doprint
"Timed out after $timeout second$s\n";
1973 # we are not guaranteed to get a full line
1974 $full_line .= $line;
1976 if ($full_line =~ /$success_line/) {
1978 $success_start = time;
1981 if ($booted && defined($stop_after_success) &&
1982 $stop_after_success >= 0) {
1984 if ($now - $success_start >= $stop_after_success) {
1985 doprint
"Test forced to stop after $stop_after_success seconds after success\n";
1990 if ($full_line =~ /\[ backtrace testing \]/) {
1991 $skip_call_trace = 1;
1994 if ($full_line =~ /call trace:/i) {
1995 if (!$bug && !$skip_call_trace) {
1996 if ($ignore_errors) {
2000 $failure_start = time;
2005 if ($bug && defined($stop_after_failure) &&
2006 $stop_after_failure >= 0) {
2008 if ($now - $failure_start >= $stop_after_failure) {
2009 doprint
"Test forced to stop after $stop_after_failure seconds after failure\n";
2014 if ($full_line =~ /\[ end of backtrace testing \]/) {
2015 $skip_call_trace = 0;
2018 if ($full_line =~ /Kernel panic -/) {
2019 $failure_start = time;
2023 # Detect triple faults by testing the banner
2024 if ($full_line =~ /\bLinux version (\S+).*\n/) {
2025 if ($1 eq $version) {
2027 } elsif ($version_found && $detect_triplefault) {
2028 # We already booted into the kernel we are testing,
2029 # but now we booted into another kernel?
2030 # Consider this a triple fault.
2031 doprint
"Already booted in Linux kernel $version, but now\n";
2032 doprint
"we booted into Linux kernel $1.\n";
2033 doprint
"Assuming that this is a triple fault.\n";
2034 doprint
"To disable this: set DETECT_TRIPLE_FAULT to 0\n";
2039 if ($line =~ /\n/) {
2043 if ($stop_test_after > 0 && !$booted && !$bug) {
2044 if (time - $monitor_start > $stop_test_after) {
2045 doprint
"STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
2051 my $end_time = time;
2052 $reboot_time = $end_time - $start_time;
2057 return 0 if ($in_bisect);
2058 fail
"failed - got a bug report" and return 0;
2062 return 0 if ($in_bisect);
2063 fail
"failed - never got a boot prompt." and return 0;
2067 doprint
"WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2073 sub eval_kernel_version
{
2076 $option =~ s/\$KERNEL_VERSION/$version/g;
2081 sub do_post_install
{
2083 return if (!defined($post_install));
2085 my $cp_post_install = eval_kernel_version
$post_install;
2086 run_command
"$cp_post_install" or
2087 dodie
"Failed to run post install";
2090 # Sometimes the reboot fails, and will hang. We try to ssh to the box
2091 # and if we fail, we force another reboot, that should powercycle it.
2093 if (!run_ssh
"echo testing connection") {
2100 return if ($no_install);
2102 my $start_time = time;
2104 if (defined($pre_install)) {
2105 my $cp_pre_install = eval_kernel_version
$pre_install;
2106 run_command
"$cp_pre_install" or
2107 dodie
"Failed to run pre install";
2110 my $cp_target = eval_kernel_version
$target_image;
2114 run_scp_install
"$outputdir/$build_target", "$cp_target" or
2115 dodie
"failed to copy image";
2117 my $install_mods = 0;
2119 # should we process modules?
2121 open(IN
, "$output_config") or dodie
("Can't read config file");
2123 if (/CONFIG_MODULES(=y)?/) {
2132 if (!$install_mods) {
2134 doprint
"No modules needed\n";
2135 my $end_time = time;
2136 $install_time = $end_time - $start_time;
2140 run_command
"$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or
2141 dodie
"Failed to install modules";
2143 my $modlib = "/lib/modules/$version";
2144 my $modtar = "ktest-mods.tar.bz2";
2146 run_ssh
"rm -rf $modlib" or
2147 dodie
"failed to remove old mods: $modlib";
2149 # would be nice if scp -r did not follow symbolic links
2150 run_command
"cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
2151 dodie
"making tarball";
2153 run_scp_mod
"$tmpdir/$modtar", "/tmp" or
2154 dodie
"failed to copy modules";
2156 unlink "$tmpdir/$modtar";
2158 run_ssh
"'(cd / && tar xjf /tmp/$modtar)'" or
2159 dodie
"failed to tar modules";
2161 run_ssh
"rm -f /tmp/$modtar";
2165 my $end_time = time;
2166 $install_time = $end_time - $start_time;
2170 # get the release name
2171 return if ($have_version);
2172 doprint
"$make kernelrelease ... ";
2173 $version = `$make -s kernelrelease | tail -1`;
2175 doprint
"$version\n";
2179 sub start_monitor_and_install
{
2180 # Make sure the stable kernel has finished booting
2182 # Install bisects, don't need console
2183 if (defined $console) {
2193 start_monitor
if (defined $console);
2197 my $check_build_re = ".*:.*(warning|error|Error):.*";
2198 my $utf8_quote = "\\x{e2}\\x{80}(\\x{98}|\\x{99})";
2200 sub process_warning_line
{
2205 # for distcc heterogeneous systems, some compilers
2206 # do things differently causing warning lines
2207 # to be slightly different. This makes an attempt
2208 # to fixe those issues.
2210 # chop off the index into the line
2211 # using distcc, some compilers give different indexes
2212 # depending on white space
2213 $line =~ s/^(\s*\S+:\d+:)\d+/$1/;
2215 # Some compilers use UTF-8 extended for quotes and some don't.
2216 $line =~ s/$utf8_quote/'/g;
2221 # Read buildlog and check against warnings file for any
2226 sub check_buildlog
{
2227 return 1 if (!defined $warnings_file);
2231 # Failed builds should not reboot the target
2232 my $save_no_reboot = $no_reboot;
2235 if (-f
$warnings_file) {
2236 open(IN
, $warnings_file) or
2237 dodie
"Error opening $warnings_file";
2240 if (/$check_build_re/) {
2241 my $warning = process_warning_line
$_;
2243 $warnings_list{$warning} = 1;
2249 # If warnings file didn't exist, and WARNINGS_FILE exist,
2250 # then we fail on any warning!
2252 open(IN
, $buildlog) or dodie
"Can't open $buildlog";
2254 if (/$check_build_re/) {
2255 my $warning = process_warning_line
$_;
2257 if (!defined $warnings_list{$warning}) {
2258 fail
"New warning found (not in $warnings_file)\n$_\n";
2259 $no_reboot = $save_no_reboot;
2264 $no_reboot = $save_no_reboot;
2268 sub check_patch_buildlog
{
2271 my @files = `git show $patch | diffstat -l`;
2273 foreach my $file (@files) {
2277 open(IN
, "git show $patch |") or
2278 dodie
"failed to show $patch";
2280 if (m
,^--- a
/(.*),) {
2282 $files[$#files] = $1;
2287 open(IN
, $buildlog) or dodie
"Can't open $buildlog";
2289 if (/^\s*(.*?):.*(warning|error)/) {
2291 foreach my $file (@files) {
2292 my $fullpath = "$builddir/$file";
2293 if ($file eq $err || $fullpath eq $err) {
2294 fail
"$file built with warnings" and return 0;
2304 sub apply_min_config
{
2305 my $outconfig = "$output_config.new";
2307 # Read the config file and remove anything that
2308 # is in the force_config hash (from minconfig and others)
2309 # then add the force config back.
2311 doprint
"Applying minimum configurations into $output_config.new\n";
2313 open (OUT
, ">$outconfig") or
2314 dodie
"Can't create $outconfig";
2316 if (-f
$output_config) {
2317 open (IN
, $output_config) or
2318 dodie
"Failed to open $output_config";
2320 if (/^(# )?(CONFIG_[^\s=]*)/) {
2321 next if (defined($force_config{$2}));
2327 foreach my $config (keys %force_config) {
2328 print OUT
"$force_config{$config}\n";
2332 run_command
"mv $outconfig $output_config";
2335 sub make_oldconfig
{
2337 my @force_list = keys %force_config;
2339 if ($#force_list >= 0) {
2343 if (!run_command
"$make olddefconfig") {
2344 # Perhaps olddefconfig doesn't exist in this version of the kernel
2346 doprint
"olddefconfig failed, trying make oldnoconfig\n";
2347 if (!run_command
"$make oldnoconfig") {
2348 doprint
"oldnoconfig failed, trying yes '' | make oldconfig\n";
2349 # try a yes '' | oldconfig
2350 run_command
"yes '' | $make oldconfig" or
2351 dodie
"failed make config oldconfig";
2356 # read a config file and use this to force new configs.
2357 sub load_force_config
{
2360 doprint
"Loading force configs from $config\n";
2361 open(IN
, $config) or
2362 dodie
"failed to read $config";
2365 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
2366 $force_config{$1} = $_;
2367 } elsif (/^# (CONFIG_\S*) is not set/) {
2368 $force_config{$1} = $_;
2379 my $start_time = time;
2381 # Failed builds should not reboot the target
2382 my $save_no_reboot = $no_reboot;
2385 # Calculate a new version from here.
2388 if (defined($pre_build)) {
2389 my $ret = run_command
$pre_build;
2390 if (!$ret && defined($pre_build_die) &&
2392 dodie
"failed to pre_build\n";
2396 if ($type =~ /^useconfig:(.*)/) {
2397 run_command
"cp $1 $output_config" or
2398 dodie
"could not copy $1 to .config";
2400 $type = "oldconfig";
2403 # old config can ask questions
2404 if ($type eq "oldconfig") {
2405 $type = "olddefconfig";
2407 # allow for empty configs
2408 run_command
"touch $output_config";
2411 run_command
"mv $output_config $outputdir/config_temp" or
2412 dodie
"moving .config";
2414 run_command
"$make mrproper" or dodie
"make mrproper";
2416 run_command
"mv $outputdir/config_temp $output_config" or
2417 dodie
"moving config_temp";
2420 } elsif (!$noclean) {
2421 unlink "$output_config";
2422 run_command
"$make mrproper" or
2423 dodie
"make mrproper";
2426 # add something to distinguish this build
2427 open(OUT
, "> $outputdir/localversion") or dodie
("Can't make localversion file");
2428 print OUT
"$localversion\n";
2431 if (defined($minconfig)) {
2432 load_force_config
($minconfig);
2435 if ($type ne "olddefconfig") {
2436 run_command
"$make $type" or
2437 dodie
"failed make config";
2439 # Run old config regardless, to enforce min configurations
2442 my $build_ret = run_command
"$make $build_options", $buildlog;
2444 if (defined($post_build)) {
2445 # Because a post build may change the kernel version
2448 my $ret = run_command
$post_build;
2449 if (!$ret && defined($post_build_die) &&
2451 dodie
"failed to post_build\n";
2456 # bisect may need this to pass
2458 $no_reboot = $save_no_reboot;
2461 fail
"failed build" and return 0;
2464 $no_reboot = $save_no_reboot;
2466 my $end_time = time;
2467 $build_time = $end_time - $start_time;
2473 if (!run_ssh
"halt" or defined($power_off)) {
2474 if (defined($poweroff_after_halt)) {
2475 sleep $poweroff_after_halt;
2476 run_command
"$power_off";
2480 run_command
"$power_off";
2487 if (defined($post_test)) {
2488 run_command
$post_test;
2495 if (defined($test_name)) {
2496 $name = " ($test_name)";
2501 doprint
"\n\n*******************************************\n";
2502 doprint
"*******************************************\n";
2503 doprint
"KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
2504 doprint
"*******************************************\n";
2505 doprint
"*******************************************\n";
2507 if (defined($store_successes)) {
2508 save_logs
"success", $store_successes;
2511 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot
) {
2512 doprint
"Reboot and wait $sleep_time seconds\n";
2513 reboot_to_good
$sleep_time;
2519 doprint
"Pass, fail, or skip? [p/f/s]";
2522 if ($ans eq "p" || $ans eq "P") {
2524 } elsif ($ans eq "f" || $ans eq "F") {
2526 } elsif ($ans eq "s" || $ans eq "S") {
2529 print "Please answer 'p', 'f', or 's'\n";
2534 sub child_run_test
{
2537 # child should have no power
2538 $reboot_on_error = 0;
2539 $poweroff_on_error = 0;
2540 $die_on_failure = 1;
2542 run_command
$run_test, $testlog or $failed = 1;
2549 sub child_finished
{
2559 my $bug_ignored = 0;
2561 my $start_time = time;
2565 doprint
"run test $run_test\n";
2569 $SIG{CHLD
} = qw(child_finished);
2573 child_run_test
if (!$child_pid);
2578 $line = wait_for_input
($monitor_fp, 1);
2579 if (defined($line)) {
2581 # we are not guaranteed to get a full line
2582 $full_line .= $line;
2585 if ($full_line =~ /call trace:/i) {
2586 if ($ignore_errors) {
2593 if ($full_line =~ /Kernel panic -/) {
2597 if ($line =~ /\n/) {
2601 } while (!$child_done && !$bug);
2603 if (!$bug && $bug_ignored) {
2604 doprint
"WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2608 my $failure_start = time;
2611 $line = wait_for_input
($monitor_fp, 1);
2612 if (defined($line)) {
2616 if ($now - $failure_start >= $stop_after_failure) {
2619 } while (defined($line));
2621 doprint
"Detected kernel crash!\n";
2622 # kill the child with extreme prejudice
2626 waitpid $child_pid, 0;
2629 my $end_time = time;
2630 $test_time = $end_time - $start_time;
2632 if (!$bug && $in_bisect) {
2633 if (defined($bisect_ret_good)) {
2634 if ($child_exit == $bisect_ret_good) {
2638 if (defined($bisect_ret_skip)) {
2639 if ($child_exit == $bisect_ret_skip) {
2643 if (defined($bisect_ret_abort)) {
2644 if ($child_exit == $bisect_ret_abort) {
2645 fail
"test abort" and return -2;
2648 if (defined($bisect_ret_bad)) {
2649 if ($child_exit == $bisect_ret_skip) {
2653 if (defined($bisect_ret_default)) {
2654 if ($bisect_ret_default eq "good") {
2656 } elsif ($bisect_ret_default eq "bad") {
2658 } elsif ($bisect_ret_default eq "skip") {
2660 } elsif ($bisect_ret_default eq "abort") {
2663 fail
"unknown default action: $bisect_ret_default"
2669 if ($bug || $child_exit) {
2670 return 0 if $in_bisect;
2671 fail
"test failed" and return 0;
2676 sub run_git_bisect
{
2679 doprint
"$command ... ";
2681 my $output = `$command 2>&1`;
2688 dodie
"Failed to git bisect";
2691 doprint
"SUCCESS\n";
2692 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
2693 doprint
"$1 [$2]\n";
2694 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
2695 $bisect_bad_commit = $1;
2696 doprint
"Found bad commit... $1\n";
2699 # we already logged it, just print it now.
2707 doprint
"Reboot and sleep $bisect_sleep_time seconds\n";
2708 reboot_to_good
$bisect_sleep_time;
2711 # returns 1 on success, 0 on failure, -1 on skip
2712 sub run_bisect_test
{
2713 my ($type, $buildtype) = @_;
2722 build
$buildtype or $failed = 1;
2724 if ($type ne "build") {
2725 if ($failed && $bisect_skip) {
2729 dodie
"Failed on build" if $failed;
2732 start_monitor_and_install
or $failed = 1;
2734 if ($type ne "boot") {
2735 if ($failed && $bisect_skip) {
2741 dodie
"Failed on boot" if $failed;
2743 do_run_test
or $failed = 1;
2754 # reboot the box to a kernel we can ssh to
2755 if ($type ne "build") {
2765 my $buildtype = "oldconfig";
2767 # We should have a minconfig to use?
2768 if (defined($minconfig)) {
2769 $buildtype = "useconfig:$minconfig";
2772 # If the user sets bisect_tries to less than 1, then no tries
2776 # Still let the user manually decide that though.
2777 if ($bisect_tries < 1 && $bisect_manual) {
2778 $ret = answer_bisect
;
2781 for (my $i = 0; $i < $bisect_tries; $i++) {
2782 if ($bisect_tries > 1) {
2784 doprint
("Running bisect trial $t of $bisect_tries:\n");
2786 $ret = run_bisect_test
$type, $buildtype;
2788 if ($bisect_manual) {
2789 $ret = answer_bisect
;
2795 # Are we looking for where it worked, not failed?
2796 if ($reverse_bisect && $ret >= 0) {
2802 } elsif ($ret == 0) {
2804 } elsif ($bisect_skip) {
2805 doprint
"HIT A BAD COMMIT ... SKIPPING\n";
2810 sub update_bisect_replay
{
2811 my $tmp_log = "$tmpdir/ktest_bisect_log";
2812 run_command
"git bisect log > $tmp_log" or
2813 die "can't create bisect log";
2822 die "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good));
2823 die "BISECT_BAD[$i] not defined\n" if (!defined($bisect_bad));
2824 die "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type));
2826 my $good = $bisect_good;
2827 my $bad = $bisect_bad;
2828 my $type = $bisect_type;
2829 my $start = $bisect_start;
2830 my $replay = $bisect_replay;
2831 my $start_files = $bisect_files;
2833 if (defined($start_files)) {
2834 $start_files = " -- " . $start_files;
2839 # convert to true sha1's
2840 $good = get_sha1
($good);
2841 $bad = get_sha1
($bad);
2843 if (defined($bisect_reverse) && $bisect_reverse == 1) {
2844 doprint
"Performing a reverse bisect (bad is good, good is bad!)\n";
2845 $reverse_bisect = 1;
2847 $reverse_bisect = 0;
2850 # Can't have a test without having a test to run
2851 if ($type eq "test" && !defined($run_test)) {
2855 # Check if a bisect was running
2856 my $bisect_start_file = "$builddir/.git/BISECT_START";
2858 my $check = $bisect_check;
2859 my $do_check = defined($check) && $check ne "0";
2861 if ( -f
$bisect_start_file ) {
2862 print "Bisect in progress found\n";
2864 print " If you say yes, then no checks of good or bad will be done\n";
2866 if (defined($replay)) {
2867 print "** BISECT_REPLAY is defined in config file **";
2868 print " Ignore config option and perform new git bisect log?\n";
2869 if (read_ync
" (yes, no, or cancel) ") {
2870 $replay = update_bisect_replay
;
2873 } elsif (read_yn
"read git log and continue?") {
2874 $replay = update_bisect_replay
;
2882 my $head = get_sha1
("HEAD");
2884 if ($check ne "good") {
2885 doprint
"TESTING BISECT BAD [$bad]\n";
2886 run_command
"git checkout $bad" or
2887 die "Failed to checkout $bad";
2889 $result = run_bisect
$type;
2891 if ($result ne "bad") {
2892 fail
"Tested BISECT_BAD [$bad] and it succeeded" and return 0;
2896 if ($check ne "bad") {
2897 doprint
"TESTING BISECT GOOD [$good]\n";
2898 run_command
"git checkout $good" or
2899 die "Failed to checkout $good";
2901 $result = run_bisect
$type;
2903 if ($result ne "good") {
2904 fail
"Tested BISECT_GOOD [$good] and it failed" and return 0;
2908 # checkout where we started
2909 run_command
"git checkout $head" or
2910 die "Failed to checkout $head";
2913 run_command
"git bisect start$start_files" or
2914 dodie
"could not start bisect";
2916 if (defined($replay)) {
2917 run_command
"git bisect replay $replay" or
2918 dodie
"failed to run replay";
2921 run_command
"git bisect good $good" or
2922 dodie
"could not set bisect good to $good";
2924 run_git_bisect
"git bisect bad $bad" or
2925 dodie
"could not set bisect bad to $bad";
2929 if (defined($start)) {
2930 run_command
"git checkout $start" or
2931 dodie
"failed to checkout $start";
2936 $result = run_bisect
$type;
2937 $test = run_git_bisect
"git bisect $result";
2941 run_command
"git bisect log" or
2942 dodie
"could not capture git bisect log";
2944 run_command
"git bisect reset" or
2945 dodie
"could not reset git bisect";
2947 doprint
"Bad commit was [$bisect_bad_commit]\n";
2952 # config_ignore holds the configs that were set (or unset) for
2953 # a good config and we will ignore these configs for the rest
2954 # of a config bisect. These configs stay as they were.
2957 # config_set holds what all configs were set as.
2960 # config_off holds the set of configs that the bad config had disabled.
2961 # We need to record them and set them in the .config when running
2962 # olddefconfig, because olddefconfig keeps the defaults.
2965 # config_off_tmp holds a set of configs to turn off for now
2968 # config_list is the set of configs that are being tested
2974 sub assign_configs
{
2975 my ($hash, $config) = @_;
2977 doprint
"Reading configs from $config\n";
2980 or dodie
"Failed to read $config";
2984 if (/^((CONFIG\S*)=.*)/) {
2986 } elsif (/^(# (CONFIG\S*) is not set)/) {
2994 sub process_config_ignore
{
2997 assign_configs \
%config_ignore, $config;
3000 sub get_dependencies
{
3003 my $arr = $dependency{$config};
3004 if (!defined($arr)) {
3010 foreach my $dep (@
{$arr}) {
3011 print "ADD DEP $dep\n";
3012 @deps = (@deps, get_dependencies
$dep);
3019 my ($pc, $file) = @_;
3021 my %configs = %{$pc};
3023 doprint
"Saving configs into $file\n";
3025 open(OUT
, ">$file") or dodie
"Can not write to $file";
3027 foreach my $config (keys %configs) {
3028 print OUT
"$configs{$config}\n";
3034 my ($name, $pc) = @_;
3036 doprint
"Creating old config from $name configs\n";
3038 save_config
$pc, $output_config;
3043 # compare two config hashes, and return configs with different vals.
3044 # It returns B's config values, but you can use A to see what A was.
3045 sub diff_config_vals
{
3048 # crappy Perl way to pass in hashes.
3054 foreach my $item (keys %a) {
3055 if (defined($b{$item}) && $b{$item} ne $a{$item}) {
3056 $ret{$item} = $b{$item};
3063 # compare two config hashes and return the configs in B but not A
3069 # crappy Perl way to pass in hashes.
3073 foreach my $item (keys %b) {
3074 if (!defined($a{$item})) {
3075 $ret{$item} = $b{$item};
3082 # return if two configs are equal or not
3083 # 0 is equal +1 b has something a does not
3084 # +1 if a and b have a different item.
3085 # -1 if a has something b does not
3086 sub compare_configs
{
3091 # crappy Perl way to pass in hashes.
3095 foreach my $item (keys %b) {
3096 if (!defined($a{$item})) {
3099 if ($a{$item} ne $b{$item}) {
3104 foreach my $item (keys %a) {
3105 if (!defined($b{$item})) {
3113 sub run_config_bisect_test
{
3116 my $ret = run_bisect_test
$type, "oldconfig";
3118 if ($bisect_manual) {
3119 $ret = answer_bisect
;
3125 sub process_failed
{
3128 doprint
"\n\n***************************************\n";
3129 doprint
"Found bad config: $config\n";
3130 doprint
"***************************************\n\n";
3133 # used for config bisecting
3137 sub process_new_config
{
3138 my ($tc, $nc, $gc, $bc) = @_;
3140 my %tmp_config = %{$tc};
3141 my %good_configs = %{$gc};
3142 my %bad_configs = %{$bc};
3149 create_config
"tmp_configs", \
%tmp_config;
3150 assign_configs \
%new_configs, $output_config;
3152 $ret = compare_configs \
%new_configs, \
%bad_configs;
3154 doprint
"New config equals bad config, try next test\n";
3159 $ret = compare_configs \
%new_configs, \
%good_configs;
3161 doprint
"New config equals good config, try next test\n";
3166 %{$nc} = %new_configs;
3171 sub run_config_bisect
{
3172 my ($pgood, $pbad) = @_;
3174 my $type = $config_bisect_type;
3176 my %good_configs = %{$pgood};
3177 my %bad_configs = %{$pbad};
3179 my %diff_configs = diff_config_vals \
%good_configs, \
%bad_configs;
3180 my %b_configs = diff_configs \
%good_configs, \
%bad_configs;
3181 my %g_configs = diff_configs \
%bad_configs, \
%good_configs;
3183 my @diff_arr = keys %diff_configs;
3184 my $len_diff = $#diff_arr + 1;
3186 my @b_arr = keys %b_configs;
3187 my $len_b = $#b_arr + 1;
3189 my @g_arr = keys %g_configs;
3190 my $len_g = $#g_arr + 1;
3196 # First, lets get it down to a single subset.
3197 # Is the problem with a difference in values?
3198 # Is the problem with a missing config?
3199 # Is the problem with a config that breaks things?
3201 # Enable all of one set and see if we get a new bad
3204 # first set the good config to the bad values.
3206 doprint
"d=$len_diff g=$len_g b=$len_b\n";
3208 # first lets enable things in bad config that are enabled in good config
3210 if ($len_diff > 0) {
3211 if ($len_b > 0 || $len_g > 0) {
3212 my %tmp_config = %bad_configs;
3214 doprint
"Set tmp config to be bad config with good config values\n";
3215 foreach my $item (@diff_arr) {
3216 $tmp_config{$item} = $good_configs{$item};
3219 $runtest = process_new_config \
%tmp_config, \
%new_configs,
3220 \
%good_configs, \
%bad_configs;
3224 if (!$runtest && $len_diff > 0) {
3226 if ($len_diff == 1) {
3227 process_failed
$diff_arr[0];
3230 my %tmp_config = %bad_configs;
3232 my $half = int($#diff_arr / 2);
3233 my @tophalf = @diff_arr[0 .. $half];
3235 doprint
"Settings bisect with top half:\n";
3236 doprint
"Set tmp config to be bad config with some good config values\n";
3237 foreach my $item (@tophalf) {
3238 $tmp_config{$item} = $good_configs{$item};
3241 $runtest = process_new_config \
%tmp_config, \
%new_configs,
3242 \
%good_configs, \
%bad_configs;
3245 my %tmp_config = %bad_configs;
3247 doprint
"Try bottom half\n";
3249 my @bottomhalf = @diff_arr[$half+1 .. $#diff_arr];
3251 foreach my $item (@bottomhalf) {
3252 $tmp_config{$item} = $good_configs{$item};
3255 $runtest = process_new_config \
%tmp_config, \
%new_configs,
3256 \
%good_configs, \
%bad_configs;
3261 $ret = run_config_bisect_test
$type;
3263 doprint
"NEW GOOD CONFIG\n";
3264 %good_configs = %new_configs;
3265 run_command
"mv $good_config ${good_config}.last";
3266 save_config \
%good_configs, $good_config;
3267 %{$pgood} = %good_configs;
3269 doprint
"NEW BAD CONFIG\n";
3270 %bad_configs = %new_configs;
3271 run_command
"mv $bad_config ${bad_config}.last";
3272 save_config \
%bad_configs, $bad_config;
3273 %{$pbad} = %bad_configs;
3278 fail
"Hmm, need to do a mix match?\n";
3285 my $type = $config_bisect_type;
3288 $bad_config = $config_bisect;
3290 if (defined($config_bisect_good)) {
3291 $good_config = $config_bisect_good;
3292 } elsif (defined($minconfig)) {
3293 $good_config = $minconfig;
3295 doprint
"No config specified, checking if defconfig works";
3296 $ret = run_bisect_test
$type, "defconfig";
3298 fail
"Have no good config to compare with, please set CONFIG_BISECT_GOOD";
3301 $good_config = $output_config;
3304 # we don't want min configs to cause issues here.
3305 doprint
"Disabling 'MIN_CONFIG' for this test\n";
3312 doprint
"Run good configs through make oldconfig\n";
3313 assign_configs \
%tmp_configs, $good_config;
3314 create_config
"$good_config", \
%tmp_configs;
3315 assign_configs \
%good_configs, $output_config;
3317 doprint
"Run bad configs through make oldconfig\n";
3318 assign_configs \
%tmp_configs, $bad_config;
3319 create_config
"$bad_config", \
%tmp_configs;
3320 assign_configs \
%bad_configs, $output_config;
3322 $good_config = "$tmpdir/good_config";
3323 $bad_config = "$tmpdir/bad_config";
3325 save_config \
%good_configs, $good_config;
3326 save_config \
%bad_configs, $bad_config;
3329 if (defined($config_bisect_check) && $config_bisect_check ne "0") {
3330 if ($config_bisect_check ne "good") {
3331 doprint
"Testing bad config\n";
3333 $ret = run_bisect_test
$type, "useconfig:$bad_config";
3335 fail
"Bad config succeeded when expected to fail!";
3339 if ($config_bisect_check ne "bad") {
3340 doprint
"Testing good config\n";
3342 $ret = run_bisect_test
$type, "useconfig:$good_config";
3344 fail
"Good config failed when expected to succeed!";
3351 $ret = run_config_bisect \
%good_configs, \
%bad_configs;
3355 return $ret if ($ret < 0);
3360 sub patchcheck_reboot
{
3361 doprint
"Reboot and sleep $patchcheck_sleep_time seconds\n";
3362 reboot_to_good
$patchcheck_sleep_time;
3368 die "PATCHCHECK_START[$i] not defined\n"
3369 if (!defined($patchcheck_start));
3370 die "PATCHCHECK_TYPE[$i] not defined\n"
3371 if (!defined($patchcheck_type));
3373 my $start = $patchcheck_start;
3375 my $cherry = $patchcheck_cherry;
3376 if (!defined($cherry)) {
3381 if (defined($patchcheck_end)) {
3382 $end = $patchcheck_end;
3384 die "PATCHCHECK_END must be defined with PATCHCHECK_CHERRY\n";
3387 # Get the true sha1's since we can use things like HEAD~3
3388 $start = get_sha1
($start);
3389 $end = get_sha1
($end);
3391 my $type = $patchcheck_type;
3393 # Can't have a test without having a test to run
3394 if ($type eq "test" && !defined($run_test)) {
3399 open (IN
, "git cherry -v $start $end|") or
3400 dodie
"could not get git list";
3402 open (IN
, "git log --pretty=oneline $end|") or
3403 dodie
"could not get git list";
3410 # git cherry adds a '+' we want to remove
3412 $list[$#list+1] = $_;
3413 last if (/^$start/);
3418 if ($list[$#list] !~ /^$start/) {
3419 fail
"SHA1 $start not found";
3422 # go backwards in the list
3423 @list = reverse @list;
3426 doprint
("Going to test the following commits:\n");
3427 foreach my $l (@list) {
3431 my $save_clean = $noclean;
3432 my %ignored_warnings;
3434 if (defined($ignore_warnings)) {
3435 foreach my $sha1 (split /\s+/, $ignore_warnings) {
3436 $ignored_warnings{$sha1} = 1;
3441 foreach my $item (@list) {
3443 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
3445 doprint
"\nProcessing commit $item\n\n";
3447 run_command
"git checkout $sha1" or
3448 die "Failed to checkout $sha1";
3450 # only clean on the first and last patch
3451 if ($item eq $list[0] ||
3452 $item eq $list[$#list]) {
3453 $noclean = $save_clean;
3458 if (defined($minconfig)) {
3459 build
"useconfig:$minconfig" or return 0;
3461 # ?? no config to use?
3462 build
"oldconfig" or return 0;
3465 # No need to do per patch checking if warnings file exists
3466 if (!defined($warnings_file) && !defined($ignored_warnings{$sha1})) {
3467 check_patch_buildlog
$sha1 or return 0;
3470 check_buildlog
or return 0;
3472 next if ($type eq "build");
3476 start_monitor_and_install
or $failed = 1;
3478 if (!$failed && $type ne "boot"){
3479 do_run_test
or $failed = 1;
3504 # $config depends on $dep
3505 my ($config, $dep) = @_;
3507 if (defined($depends{$config})) {
3508 $depends{$config} .= " " . $dep;
3510 $depends{$config} = $dep;
3513 # record the number of configs depending on $dep
3514 if (defined $depcount{$dep}) {
3517 $depcount{$dep} = 1;
3521 # taken from streamline_config.pl
3533 if (! -f
$kconfig) {
3534 doprint
"file $kconfig does not exist, skipping\n";
3538 open(KIN
, "$kconfig")
3539 or die "Can't open $kconfig";
3543 # Make sure that lines ending with \ continue
3545 $_ = $line . " " . $_;
3556 # collect any Kconfig sources
3557 if (/^source\s*"(.*)"/) {
3558 $kconfigs[$#kconfigs+1] = $1;
3562 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
3566 for (my $i = 0; $i < $iflevel; $i++) {
3567 add_dep
$config, $ifdeps[$i];
3570 # collect the depends for the config
3571 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
3573 add_dep
$config, $1;
3575 # Get the configs that select this config
3576 } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {
3578 # selected by depends on config
3579 add_dep
$1, $config;
3581 # Check for if statements
3582 } elsif (/^if\s+(.*\S)\s*$/) {
3584 # remove beginning and ending non text
3585 $deps =~ s/^[^a-zA-Z0-9_]*//;
3586 $deps =~ s/[^a-zA-Z0-9_]*$//;
3588 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
3590 $ifdeps[$iflevel++] = join ':', @deps;
3592 } elsif (/^endif/) {
3594 $iflevel-- if ($iflevel);
3597 } elsif (/^\s*help\s*$/) {
3603 # read in any configs that were found.
3604 foreach $kconfig (@kconfigs) {
3605 if (!defined($read_kconfigs{$kconfig})) {
3606 $read_kconfigs{$kconfig} = 1;
3607 read_kconfig
("$builddir/$kconfig");
3613 # find out which arch this is by the kconfig file
3614 open (IN
, $output_config)
3615 or dodie
"Failed to read $output_config";
3618 if (m
,Linux
/(\S
+)\s
+\S
+\s
+Kernel Configuration
,) {
3625 if (!defined($arch)) {
3626 doprint
"Could not find arch from config file\n";
3627 doprint
"no dependencies used\n";
3631 # arch is really the subarch, we need to know
3632 # what directory to look at.
3633 if ($arch eq "i386" || $arch eq "x86_64") {
3635 } elsif ($arch =~ /^tile/) {
3639 my $kconfig = "$builddir/arch/$arch/Kconfig";
3641 if (! -f
$kconfig && $arch =~ /\d$/) {
3643 # some subarchs have numbers, truncate them
3645 $kconfig = "$builddir/arch/$arch/Kconfig";
3646 if (! -f
$kconfig) {
3647 doprint
"No idea what arch dir $orig is for\n";
3648 doprint
"no dependencies used\n";
3653 read_kconfig
($kconfig);
3656 sub make_new_config
{
3659 open (OUT
, ">$output_config")
3660 or dodie
"Failed to write $output_config";
3662 foreach my $config (@configs) {
3663 print OUT
"$config\n";
3671 $config =~ s/CONFIG_//;
3679 my $kconfig = chomp_config
$dep;
3681 $dep = $depends{"$kconfig"};
3683 # the dep string we have saves the dependencies as they
3684 # were found, including expressions like ! && ||. We
3685 # want to split this out into just an array of configs.
3687 my $valid = "A-Za-z_0-9";
3691 while ($dep =~ /[$valid]/) {
3693 if ($dep =~ /^[^$valid]*([$valid]+)/) {
3694 my $conf = "CONFIG_" . $1;
3696 $configs[$#configs + 1] = $conf;
3698 $dep =~ s/^[^$valid]*[$valid]+//;
3700 die "this should never happen";
3710 my %processed_configs;
3711 my %nochange_config;
3713 sub test_this_config
{
3718 # if we already processed this config, skip it
3719 if (defined($processed_configs{$config})) {
3722 $processed_configs{$config} = 1;
3724 # if this config failed during this round, skip it
3725 if (defined($nochange_config{$config})) {
3729 my $kconfig = chomp_config
$config;
3731 # Test dependencies first
3732 if (defined($depends{"$kconfig"})) {
3733 my @parents = get_depends
$config;
3734 foreach my $parent (@parents) {
3735 # if the parent is in the min config, check it first
3736 next if (!defined($min_configs{$parent}));
3737 $found = test_this_config
($parent);
3738 if (defined($found)) {
3744 # Remove this config from the list of configs
3745 # do a make olddefconfig and then read the resulting
3746 # .config to make sure it is missing the config that
3748 my %configs = %min_configs;
3749 delete $configs{$config};
3750 make_new_config
((values %configs), (values %keep_configs));
3753 assign_configs \
%configs, $output_config;
3755 if (!defined($configs{$config}) || $configs{$config} =~ /^#/) {
3759 doprint
"disabling config $config did not change .config\n";
3761 $nochange_config{$config} = 1;
3766 sub make_min_config
{
3769 my $type = $minconfig_type;
3770 if ($type ne "boot" && $type ne "test") {
3771 fail
"Invalid MIN_CONFIG_TYPE '$minconfig_type'\n" .
3772 " make_min_config works only with 'boot' and 'test'\n" and return;
3775 if (!defined($output_minconfig)) {
3776 fail
"OUTPUT_MIN_CONFIG not defined" and return;
3779 # If output_minconfig exists, and the start_minconfig
3780 # came from min_config, than ask if we should use
3782 if (-f
$output_minconfig && !$start_minconfig_defined) {
3783 print "$output_minconfig exists\n";
3784 if (!defined($use_output_minconfig)) {
3785 if (read_yn
" Use it as minconfig?") {
3786 $start_minconfig = $output_minconfig;
3788 } elsif ($use_output_minconfig > 0) {
3789 doprint
"Using $output_minconfig as MIN_CONFIG\n";
3790 $start_minconfig = $output_minconfig;
3792 doprint
"Set to still use MIN_CONFIG as starting point\n";
3796 if (!defined($start_minconfig)) {
3797 fail
"START_MIN_CONFIG or MIN_CONFIG not defined" and return;
3800 my $temp_config = "$tmpdir/temp_config";
3802 # First things first. We build an allnoconfig to find
3803 # out what the defaults are that we can't touch.
3804 # Some are selections, but we really can't handle selections.
3806 my $save_minconfig = $minconfig;
3809 run_command
"$make allnoconfig" or return 0;
3813 process_config_ignore
$output_config;
3815 undef %save_configs;
3818 if (defined($ignore_config)) {
3819 # make sure the file exists
3820 `touch $ignore_config`;
3821 assign_configs \
%save_configs, $ignore_config;
3824 %keep_configs = %save_configs;
3826 doprint
"Load initial configs from $start_minconfig\n";
3828 # Look at the current min configs, and save off all the
3829 # ones that were set via the allnoconfig
3830 assign_configs \
%min_configs, $start_minconfig;
3832 my @config_keys = keys %min_configs;
3834 # All configs need a depcount
3835 foreach my $config (@config_keys) {
3836 my $kconfig = chomp_config
$config;
3837 if (!defined $depcount{$kconfig}) {
3838 $depcount{$kconfig} = 0;
3842 # Remove anything that was set by the make allnoconfig
3843 # we shouldn't need them as they get set for us anyway.
3844 foreach my $config (@config_keys) {
3845 # Remove anything in the ignore_config
3846 if (defined($keep_configs{$config})) {
3847 my $file = $ignore_config;
3848 $file =~ s
,.*/(.*?
)$,$1,;
3849 doprint
"$config set by $file ... ignored\n";
3850 delete $min_configs{$config};
3853 # But make sure the settings are the same. If a min config
3854 # sets a selection, we do not want to get rid of it if
3855 # it is not the same as what we have. Just move it into
3857 if (defined($config_ignore{$config})) {
3858 if ($config_ignore{$config} ne $min_configs{$config}) {
3859 doprint
"$config is in allnoconfig as '$config_ignore{$config}'";
3860 doprint
" but it is '$min_configs{$config}' in minconfig .. keeping\n";
3861 $keep_configs{$config} = $min_configs{$config};
3863 doprint
"$config set by allnoconfig ... ignored\n";
3865 delete $min_configs{$config};
3877 # Now disable each config one by one and do a make oldconfig
3878 # till we find a config that changes our list.
3880 my @test_configs = keys %min_configs;
3882 # Sort keys by who is most dependent on
3883 @test_configs = sort { $depcount{chomp_config
($b)} <=> $depcount{chomp_config
($a)} }
3886 # Put configs that did not modify the config at the end.
3888 for (my $i = 0; $i < $#test_configs; $i++) {
3889 if (!defined($nochange_config{$test_configs[0]})) {
3893 # This config didn't change the .config last time.
3894 # Place it at the end
3895 my $config = shift @test_configs;
3896 push @test_configs, $config;
3899 # if every test config has failed to modify the .config file
3900 # in the past, then reset and start over.
3902 undef %nochange_config;
3905 undef %processed_configs;
3907 foreach my $config (@test_configs) {
3909 $found = test_this_config
$config;
3911 last if (defined($found));
3913 # oh well, try another config
3916 if (!defined($found)) {
3917 # we could have failed due to the nochange_config hash
3918 # reset and try again
3920 undef %nochange_config;
3924 doprint
"No more configs found that we can disable\n";
3932 doprint
"Test with $config disabled\n";
3934 # set in_bisect to keep build and monitor from dieing
3938 build
"oldconfig" or $failed = 1;
3940 start_monitor_and_install
or $failed = 1;
3942 if ($type eq "test" && !$failed) {
3943 do_run_test
or $failed = 1;
3952 doprint
"$min_configs{$config} is needed to boot the box... keeping\n";
3953 # this config is needed, add it to the ignore list.
3954 $keep_configs{$config} = $min_configs{$config};
3955 $save_configs{$config} = $min_configs{$config};
3956 delete $min_configs{$config};
3958 # update new ignore configs
3959 if (defined($ignore_config)) {
3960 open (OUT
, ">$temp_config")
3961 or die "Can't write to $temp_config";
3962 foreach my $config (keys %save_configs) {
3963 print OUT
"$save_configs{$config}\n";
3966 run_command
"mv $temp_config $ignore_config" or
3967 dodie
"failed to copy update to $ignore_config";
3971 # We booted without this config, remove it from the minconfigs.
3972 doprint
"$config is not needed, disabling\n";
3974 delete $min_configs{$config};
3976 # Also disable anything that is not enabled in this config
3978 assign_configs \
%configs, $output_config;
3979 my @config_keys = keys %min_configs;
3980 foreach my $config (@config_keys) {
3981 if (!defined($configs{$config})) {
3982 doprint
"$config is not set, disabling\n";
3983 delete $min_configs{$config};
3987 # Save off all the current mandidory configs
3988 open (OUT
, ">$temp_config")
3989 or die "Can't write to $temp_config";
3990 foreach my $config (keys %keep_configs) {
3991 print OUT
"$keep_configs{$config}\n";
3993 foreach my $config (keys %min_configs) {
3994 print OUT
"$min_configs{$config}\n";
3998 run_command
"mv $temp_config $output_minconfig" or
3999 dodie
"failed to copy update to $output_minconfig";
4002 doprint
"Reboot and wait $sleep_time seconds\n";
4003 reboot_to_good
$sleep_time;
4010 sub make_warnings_file
{
4013 if (!defined($warnings_file)) {
4014 dodie
"Must define WARNINGS_FILE for make_warnings_file test";
4017 if ($build_type eq "nobuild") {
4018 dodie
"BUILD_TYPE can not be 'nobuild' for make_warnings_file test";
4021 build
$build_type or dodie
"Failed to build";
4023 open(OUT
, ">$warnings_file") or dodie
"Can't create $warnings_file";
4025 open(IN
, $buildlog) or dodie
"Can't open $buildlog";
4028 # Some compilers use UTF-8 extended for quotes
4029 # for distcc heterogeneous systems, this causes issues
4032 if (/$check_build_re/) {
4043 $#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl [config-file]\n";
4046 $ktest_config = $ARGV[0];
4047 if (! -f
$ktest_config) {
4048 print "$ktest_config does not exist.\n";
4049 if (!read_yn
"Create it?") {
4055 if (! -f
$ktest_config) {
4058 open(OUT
, ">$ktest_config") or die "Can not create $ktest_config";
4060 # Generated by ktest.pl
4063 # PWD is a ktest.pl variable that will result in the process working
4064 # directory that ktest.pl is executed in.
4066 # THIS_DIR is automatically assigned the PWD of the path that generated
4067 # the config file. It is best to use this variable when assigning other
4068 # directory paths within this directory. This allows you to easily
4069 # move the test cases to other locations or to other machines.
4071 THIS_DIR
:= $variable{"PWD"}
4073 # Define each test with TEST_START
4074 # The config options below it will override the defaults
4076 TEST_TYPE
= $default{"TEST_TYPE"}
4083 read_config
$ktest_config;
4085 if (defined($opt{"LOG_FILE"})) {
4086 $opt{"LOG_FILE"} = eval_option
("LOG_FILE", $opt{"LOG_FILE"}, -1);
4089 # Append any configs entered in manually to the config file.
4090 my @new_configs = keys %entered_configs;
4091 if ($#new_configs >= 0) {
4092 print "\nAppending entered in configs to $ktest_config\n";
4093 open(OUT
, ">>$ktest_config") or die "Can not append to $ktest_config";
4094 foreach my $config (@new_configs) {
4095 print OUT
"$config = $entered_configs{$config}\n";
4096 $opt{$config} = process_variables
($entered_configs{$config});
4100 if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
4101 unlink $opt{"LOG_FILE"};
4104 doprint
"\n\nSTARTING AUTOMATED TESTS\n\n";
4106 for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
4109 doprint
"DEFAULT OPTIONS:\n";
4111 doprint
"\nTEST $i OPTIONS";
4112 if (defined($repeat_tests{$i})) {
4113 $repeat = $repeat_tests{$i};
4114 doprint
" ITERATE $repeat";
4119 foreach my $option (sort keys %opt) {
4121 if ($option =~ /\[(\d+)\]$/) {
4127 doprint
"$option = $opt{$option}\n";
4131 sub option_defined
{
4134 if (defined($opt{$option}) && $opt{$option} !~ /^\s*$/) {
4141 sub __set_test_option
{
4142 my ($name, $i) = @_;
4144 my $option = "$name\[$i\]";
4146 if (option_defined
($option)) {
4147 return $opt{$option};
4150 foreach my $test (keys %repeat_tests) {
4152 $i < $test + $repeat_tests{$test}) {
4153 $option = "$name\[$test\]";
4154 if (option_defined
($option)) {
4155 return $opt{$option};
4160 if (option_defined
($name)) {
4167 sub set_test_option
{
4168 my ($name, $i) = @_;
4170 my $option = __set_test_option
($name, $i);
4171 return $option if (!defined($option));
4173 return eval_option
($name, $option, $i);
4176 # First we need to do is the builds
4177 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
4179 # Do not reboot on failing test options
4181 $reboot_success = 0;
4192 undef %force_config;
4194 my $makecmd = set_test_option
("MAKE_CMD", $i);
4196 $outputdir = set_test_option
("OUTPUT_DIR", $i);
4197 $builddir = set_test_option
("BUILD_DIR", $i);
4199 chdir $builddir || die "can't change directory to $builddir";
4201 if (!-d
$outputdir) {
4202 mkpath
($outputdir) or
4203 die "can't create $outputdir";
4206 $make = "$makecmd O=$outputdir";
4208 # Load all the options into their mapped variable names
4209 foreach my $opt (keys %option_map) {
4210 ${$option_map{$opt}} = set_test_option
($opt, $i);
4213 $start_minconfig_defined = 1;
4215 # The first test may override the PRE_KTEST option
4216 if (defined($pre_ktest) && $i == 1) {
4218 run_command
$pre_ktest;
4221 # Any test can override the POST_KTEST option
4222 # The last test takes precedence.
4223 if (defined($post_ktest)) {
4224 $final_post_ktest = $post_ktest;
4227 if (!defined($start_minconfig)) {
4228 $start_minconfig_defined = 0;
4229 $start_minconfig = $minconfig;
4234 die "can't create $tmpdir";
4237 $ENV{"SSH_USER"} = $ssh_user;
4238 $ENV{"MACHINE"} = $machine;
4240 $buildlog = "$tmpdir/buildlog-$machine";
4241 $testlog = "$tmpdir/testlog-$machine";
4242 $dmesg = "$tmpdir/dmesg-$machine";
4243 $output_config = "$outputdir/.config";
4246 $target = "$ssh_user\@$machine";
4247 if ($reboot_type eq "grub") {
4248 dodie
"GRUB_MENU not defined" if (!defined($grub_menu));
4249 } elsif ($reboot_type eq "grub2") {
4250 dodie
"GRUB_MENU not defined" if (!defined($grub_menu));
4251 dodie
"GRUB_FILE not defined" if (!defined($grub_file));
4252 } elsif ($reboot_type eq "syslinux") {
4253 dodie
"SYSLINUX_LABEL not defined" if (!defined($syslinux_label));
4257 my $run_type = $build_type;
4258 if ($test_type eq "patchcheck") {
4259 $run_type = $patchcheck_type;
4260 } elsif ($test_type eq "bisect") {
4261 $run_type = $bisect_type;
4262 } elsif ($test_type eq "config_bisect") {
4263 $run_type = $config_bisect_type;
4264 } elsif ($test_type eq "make_min_config") {
4266 } elsif ($test_type eq "make_warnings_file") {
4270 # mistake in config file?
4271 if (!defined($run_type)) {
4272 $run_type = "ERROR";
4276 $installme = " no_install" if ($no_install);
4280 if (defined($test_name)) {
4281 $name = " ($test_name)";
4285 doprint
"RUNNING TEST $i of $opt{NUM_TESTS}$name with option $test_type $run_type$installme\n\n";
4287 if (defined($pre_test)) {
4288 run_command
$pre_test;
4295 if (defined($addconfig)) {
4296 my $min = $minconfig;
4297 if (!defined($minconfig)) {
4300 run_command
"cat $addconfig $min > $tmpdir/add_config" or
4301 dodie
"Failed to create temp config";
4302 $minconfig = "$tmpdir/add_config";
4305 if (defined($checkout)) {
4306 run_command
"git checkout $checkout" or
4307 die "failed to checkout $checkout";
4312 # A test may opt to not reboot the box
4313 if ($reboot_on_success) {
4314 $reboot_success = 1;
4317 if ($test_type eq "bisect") {
4320 } elsif ($test_type eq "config_bisect") {
4323 } elsif ($test_type eq "patchcheck") {
4326 } elsif ($test_type eq "make_min_config") {
4329 } elsif ($test_type eq "make_warnings_file") {
4331 make_warnings_file
$i;
4335 if ($build_type ne "nobuild") {
4336 build
$build_type or next;
4337 check_buildlog
or next;
4340 if ($test_type eq "install") {
4347 if ($test_type ne "build") {
4349 start_monitor_and_install
or $failed = 1;
4351 if (!$failed && $test_type ne "boot" && defined($run_test)) {
4352 do_run_test
or $failed = 1;
4366 if (defined($final_post_ktest)) {
4367 run_command
$final_post_ktest;
4370 if ($opt{"POWEROFF_ON_SUCCESS"}) {
4372 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot
&& $reboot_success) {
4374 } elsif (defined($switch_to_good)) {
4375 # still need to get to the good kernel
4376 run_command
$switch_to_good;
4380 doprint
"\n $successes of $opt{NUM_TESTS} tests were successful\n\n";