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);
24 $default{"NUM_TESTS"} = 1;
25 $default{"REBOOT_TYPE"} = "grub";
26 $default{"TEST_TYPE"} = "test";
27 $default{"BUILD_TYPE"} = "randconfig";
28 $default{"MAKE_CMD"} = "make";
29 $default{"TIMEOUT"} = 120;
30 $default{"TMP_DIR"} = "/tmp/ktest/\${MACHINE}";
31 $default{"SLEEP_TIME"} = 60; # sleep time between tests
32 $default{"BUILD_NOCLEAN"} = 0;
33 $default{"REBOOT_ON_ERROR"} = 0;
34 $default{"POWEROFF_ON_ERROR"} = 0;
35 $default{"REBOOT_ON_SUCCESS"} = 1;
36 $default{"POWEROFF_ON_SUCCESS"} = 0;
37 $default{"BUILD_OPTIONS"} = "";
38 $default{"BISECT_SLEEP_TIME"} = 60; # sleep time between bisects
39 $default{"PATCHCHECK_SLEEP_TIME"} = 60; # sleep time between patch checks
40 $default{"CLEAR_LOG"} = 0;
41 $default{"BISECT_MANUAL"} = 0;
42 $default{"BISECT_SKIP"} = 1;
43 $default{"SUCCESS_LINE"} = "login:";
44 $default{"DETECT_TRIPLE_FAULT"} = 1;
45 $default{"NO_INSTALL"} = 0;
46 $default{"BOOTED_TIMEOUT"} = 1;
47 $default{"DIE_ON_FAILURE"} = 1;
48 $default{"SSH_EXEC"} = "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND";
49 $default{"SCP_TO_TARGET"} = "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE";
50 $default{"REBOOT"} = "ssh \$SSH_USER\@\$MACHINE reboot";
51 $default{"STOP_AFTER_SUCCESS"} = 10;
52 $default{"STOP_AFTER_FAILURE"} = 60;
53 $default{"STOP_TEST_AFTER"} = 600;
54 $default{"LOCALVERSION"} = "-test";
76 my $poweroff_on_error;
78 my $powercycle_after_reboot;
79 my $poweroff_after_halt;
92 my $start_minconfig_defined;
101 my $config_bisect_good;
102 my $in_patchcheck = 0;
111 my $bisect_sleep_time;
112 my $patchcheck_sleep_time;
118 my $detect_triplefault;
120 my $reboot_success_line;
122 my $stop_after_success;
123 my $stop_after_failure;
136 # do not force reboots on config problems
139 $config_help{"MACHINE"} = << "EOF"
140 The machine hostname that you will test.
143 $config_help{"SSH_USER"} = << "EOF"
144 The box is expected to have ssh on normal bootup, provide the user
145 (most likely root, since you need privileged operations)
148 $config_help{"BUILD_DIR"} = << "EOF"
149 The directory that contains the Linux source code (full path).
152 $config_help{"OUTPUT_DIR"} = << "EOF"
153 The directory that the objects will be built (full path).
154 (can not be same as BUILD_DIR)
157 $config_help{"BUILD_TARGET"} = << "EOF"
158 The location of the compiled file to copy to the target.
159 (relative to OUTPUT_DIR)
162 $config_help{"TARGET_IMAGE"} = << "EOF"
163 The place to put your image on the test machine.
166 $config_help{"POWER_CYCLE"} = << "EOF"
167 A script or command to reboot the box.
169 Here is a digital loggers power switch example
170 POWER_CYCLE = wget --no-proxy -O /dev/null -q --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL'
172 Here is an example to reboot a virtual box on the current host
173 with the name "Guest".
174 POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest
177 $config_help{"CONSOLE"} = << "EOF"
178 The script or command that reads the console
180 If you use ttywatch server, something like the following would work.
181 CONSOLE = nc -d localhost 3001
183 For a virtual machine with guest name "Guest".
184 CONSOLE = virsh console Guest
187 $config_help{"LOCALVERSION"} = << "EOF"
188 Required version ending to differentiate the test
189 from other linux builds on the system.
192 $config_help{"REBOOT_TYPE"} = << "EOF"
193 Way to reboot the box to the test kernel.
194 Only valid options so far are "grub" and "script".
196 If you specify grub, it will assume grub version 1
197 and will search in /boot/grub/menu.lst for the title \$GRUB_MENU
198 and select that target to reboot to the kernel. If this is not
199 your setup, then specify "script" and have a command or script
200 specified in REBOOT_SCRIPT to boot to the target.
202 The entry in /boot/grub/menu.lst must be entered in manually.
203 The test will not modify that file.
206 $config_help{"GRUB_MENU"} = << "EOF"
207 The grub title name for the test kernel to boot
208 (Only mandatory if REBOOT_TYPE = grub)
210 Note, ktest.pl will not update the grub menu.lst, you need to
211 manually add an option for the test. ktest.pl will search
212 the grub menu.lst for this option to find what kernel to
215 For example, if in the /boot/grub/menu.lst the test kernel title has:
218 GRUB_MENU = Test Kernel
221 $config_help{"REBOOT_SCRIPT"} = << "EOF"
222 A script to reboot the target into the test kernel
223 (Only mandatory if REBOOT_TYPE = script)
233 print "$prompt [Y/n] ";
236 if ($ans =~ /^\s*$/) {
239 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
240 print "Please answer either 'y' or 'n'.\n";
242 if ($ans !~ /^y$/i) {
248 sub get_ktest_config {
251 return if (defined($opt{$config}));
253 if (defined($config_help{$config})) {
255 print $config_help{$config};
260 if (defined($default{$config})) {
261 print "\[$default{$config}\] ";
263 $entered_configs{$config} = <STDIN>;
264 $entered_configs{$config} =~ s/^\s*(.*\S)\s*$/$1/;
265 if ($entered_configs{$config} =~ /^\s*$/) {
266 if ($default{$config}) {
267 $entered_configs{$config} = $default{$config};
269 print "Your answer can not be blank\n";
277 sub get_ktest_configs {
278 get_ktest_config("MACHINE");
279 get_ktest_config("SSH_USER");
280 get_ktest_config("BUILD_DIR");
281 get_ktest_config("OUTPUT_DIR");
282 get_ktest_config("BUILD_TARGET");
283 get_ktest_config("TARGET_IMAGE");
284 get_ktest_config("POWER_CYCLE");
285 get_ktest_config("CONSOLE");
286 get_ktest_config("LOCALVERSION");
288 my $rtype = $opt{"REBOOT_TYPE"};
290 if (!defined($rtype)) {
291 if (!defined($opt{"GRUB_MENU"})) {
292 get_ktest_config("REBOOT_TYPE");
293 $rtype = $entered_configs{"REBOOT_TYPE"};
299 if ($rtype eq "grub") {
300 get_ktest_config("GRUB_MENU");
302 get_ktest_config("REBOOT_SCRIPT");
306 sub process_variables {
310 # We want to check for '\', and it is just easier
311 # to check the previous characet of '$' and not need
312 # to worry if '$' is the first character. By adding
313 # a space to $value, we can just check [^\\]\$ and
314 # it will still work.
317 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
321 # append beginning of value to retval
322 $retval = "$retval$begin";
323 if (defined($variable{$var})) {
324 $retval = "$retval$variable{$var}";
326 # put back the origin piece.
327 $retval = "$retval\$\{$var\}";
331 $retval = "$retval$value";
333 # remove the space added in the beginning
340 my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
342 if (defined($opt{$lvalue})) {
343 if (!$override || defined(${$overrides}{$lvalue})) {
346 $extra = "In the same override section!\n";
348 die "$name: $.: Option $lvalue defined more than once!\n$extra";
350 ${$overrides}{$lvalue} = $rvalue;
352 if ($rvalue =~ /^\s*$/) {
353 delete $opt{$lvalue};
355 $rvalue = process_variables($rvalue);
356 $opt{$lvalue} = $rvalue;
361 my ($lvalue, $rvalue) = @_;
363 if ($rvalue =~ /^\s*$/) {
364 delete $variable{$lvalue};
366 $rvalue = process_variables($rvalue);
367 $variable{$lvalue} = $rvalue;
371 sub process_compare {
372 my ($lval, $cmp, $rval) = @_;
383 return $lval eq $rval;
384 } elsif ($cmp eq "!=") {
385 return $lval ne $rval;
388 my $statement = "$lval $cmp $rval";
389 my $ret = eval $statement;
391 # $@ stores error of eval
400 my ($name, $value) = @_;
402 my $val = process_variables($value);
404 if ($val =~ /(.*)(==|\!=|>=|<=|>|<)(.*)/) {
405 my $ret = process_compare($1, $2, $3);
407 die "$name: $.: Unable to process comparison\n";
412 if ($val =~ /^\s*0\s*$/) {
414 } elsif ($val =~ /^\s*\d+\s*$/) {
418 die ("$name: $.: Undefined variable $val in if statement\n");
423 my ($config, $current_test_num) = @_;
426 open($in, $config) || die "can't read file $config";
429 $name =~ s,.*/(.*),$1,;
431 my $test_num = $$current_test_num;
434 my $num_tests_set = 0;
446 # ignore blank lines and comments
447 next if (/^\s*$/ || /\s*\#/);
449 if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
458 if ($type eq "TEST_START") {
460 if ($num_tests_set) {
461 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
464 $old_test_num = $test_num;
465 $old_repeat = $repeat;
467 $test_num += $repeat;
474 if ($rest =~ /\s+SKIP\b(.*)/) {
483 if ($type eq "TEST_START") {
484 if ($rest =~ /\s+ITERATE\s+(\d+)(.*)$/) {
487 $repeat_tests{"$test_num"} = $repeat;
489 } elsif ($rest =~ /\sOVERRIDE\b(.*)/) {
493 # Clear previous overrides
498 if ($rest =~ /\sIF\s+(.*)/) {
500 if (process_if($name, $1)) {
510 if ($rest !~ /^\s*$/) {
511 die "$name: $.: Gargbage found after $type\n$_";
514 if ($skip && $type eq "TEST_START") {
515 $test_num = $old_test_num;
516 $repeat = $old_repeat;
519 } elsif (/^\s*ELSE\b(.*)$/) {
521 die "$name: $.: ELSE found with out matching IF section\n$_";
530 if ($rest =~ /\sIF\s+(.*)/) {
531 # May be a ELSE IF section.
532 if (!process_if($name, $1)) {
541 if ($rest !~ /^\s*$/) {
542 die "$name: $.: Gargbage found after DEFAULTS\n$_";
545 } elsif (/^\s*INCLUDE\s+(\S+)/) {
550 die "$name: $.: INCLUDE can only be done in default sections\n$_";
553 my $file = process_variables($1);
555 if ($file !~ m,^/,) {
556 # check the path of the config file first
557 if ($config =~ m,(.*)/,) {
565 die "$name: $.: Can't read file $file\n$_";
568 if (__read_config($file, \$test_num)) {
572 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
580 ($lvalue eq "NUM_TESTS" ||
581 $lvalue eq "LOG_FILE" ||
582 $lvalue eq "CLEAR_LOG")) {
583 die "$name: $.: $lvalue must be set in DEFAULTS section\n";
586 if ($lvalue eq "NUM_TESTS") {
588 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
591 die "$name: $.: NUM_TESTS must be set in default section\n";
596 if ($default || $lvalue =~ /\[\d+\]$/) {
597 set_value($lvalue, $rvalue, $override, \%overrides, $name);
599 my $val = "$lvalue\[$test_num\]";
600 set_value($val, $rvalue, $override, \%overrides, $name);
603 $repeats{$val} = $repeat;
606 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
612 # process config variables.
613 # Config variables are only active while reading the
614 # config and can be defined anywhere. They also ignore
615 # TEST_START and DEFAULTS, but are skipped if they are in
616 # on of these sections that have SKIP defined.
617 # The save variable can be
618 # defined multiple times and the new one simply overrides
620 set_variable($lvalue, $rvalue);
623 die "$name: $.: Garbage found in config\n$_";
628 $test_num += $repeat - 1;
629 $opt{"NUM_TESTS"} = $test_num;
634 $$current_test_num = $test_num;
645 $test_case = __read_config $config, \$test_num;
647 # make sure we have all mandatory configs
650 # was a test specified?
652 print "No test case specified.\n";
653 print "What test case would you like to run?\n";
656 $default{"TEST_TYPE"} = $ans;
661 foreach my $default (keys %default) {
662 if (!defined($opt{$default})) {
663 $opt{$default} = $default{$default};
669 my ($option, $i) = @_;
671 # Add space to evaluate the character before $
672 $option = " $option";
675 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
680 # Append beginning of line
681 $retval = "$retval$start";
683 # If the iteration option OPT[$i] exists, then use that.
684 # otherwise see if the default OPT (without [$i]) exists.
686 my $o = "$var\[$i\]";
688 if (defined($opt{$o})) {
690 $retval = "$retval$o";
691 } elsif (defined($opt{$var})) {
693 $retval = "$retval$o";
695 $retval = "$retval\$\{$var\}";
701 $retval = "$retval$option";
709 my ($option, $i) = @_;
713 # Since an option can evaluate to another option,
714 # keep iterating until we do not evaluate any more
717 while ($prev ne $option) {
718 # Check for recursive evaluations.
719 # 100 deep should be more than enough.
721 die "Over 100 evaluations accurred with $option\n" .
722 "Check for recursive variables\n";
725 $option = __eval_option($option, $i);
732 if (defined($opt{"LOG_FILE"})) {
733 open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
740 if (defined($opt{"LOG_FILE"})) {
755 sub wait_for_monitor;
760 if (defined($time)) {
762 # flush out current monitor
763 # May contain the reboot success line
767 # try to reboot normally
768 if (run_command $reboot) {
769 if (defined($powercycle_after_reboot)) {
770 sleep $powercycle_after_reboot;
771 run_command "$power_cycle";
774 # nope? power cycle it.
775 run_command "$power_cycle";
778 if (defined($time)) {
779 wait_for_monitor($time, $reboot_success_line);
787 return $test_type eq "build" || $no_reboot ||
788 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
789 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
793 doprint "CRITICAL FAILURE... ", @_, "\n";
797 if ($reboot_on_error && !do_not_reboot) {
799 doprint "REBOOTING\n";
802 } elsif ($poweroff_on_error && defined($power_off)) {
803 doprint "POWERING OFF\n";
807 if (defined($opt{"LOG_FILE"})) {
808 print " See $opt{LOG_FILE} for more info.\n";
819 my $pid = open($fp, "$console|") or
820 dodie "Can't open console $console";
822 $flags = fcntl($fp, F_GETFL, 0) or
823 dodie "Can't get flags for the socket: $!";
824 $flags = fcntl($fp, F_SETFL, $flags | O_NONBLOCK) or
825 dodie "Can't set flags for the socket: $!";
833 doprint "kill child process $pid\n";
841 if ($monitor_cnt++) {
844 $monitor_fp = \*MONFD;
845 $monitor_pid = open_console $monitor_fp;
849 open(MONFD, "Stop perl from warning about single use of MONFD");
853 if (--$monitor_cnt) {
856 close_console($monitor_fp, $monitor_pid);
859 sub wait_for_monitor {
860 my ($time, $stop) = @_;
865 doprint "** Wait for monitor to settle down **\n";
867 # read the monitor and wait for the system to calm down
869 $line = wait_for_input($monitor_fp, $time);
870 last if (!defined($line));
874 if (defined($stop) && $full_line =~ /$stop/) {
875 doprint "wait for monitor detected $stop\n";
883 print "** Monitor flushed **\n";
888 if ($die_on_failure) {
896 # no need to reboot for just building.
897 if (!do_not_reboot) {
898 doprint "REBOOTING\n";
904 if (defined($test_name)) {
905 $name = " ($test_name)";
908 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
909 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
910 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
911 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
912 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
914 return 1 if (!defined($store_failures));
917 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
918 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
920 my $type = $build_type;
921 if ($type =~ /useconfig/) {
925 my $dir = "$machine-$test_type-$type-fail-$date";
926 my $faildir = "$store_failures/$dir";
930 die "can't create $faildir";
932 if (-f "$output_config") {
933 cp "$output_config", "$faildir/config" or
934 die "failed to copy .config";
937 cp $buildlog, "$faildir/buildlog" or
938 die "failed to move $buildlog";
941 cp $dmesg, "$faildir/dmesg" or
942 die "failed to move $dmesg";
945 doprint "*** Saved info to $faildir ***\n";
956 $command =~ s/\$SSH_USER/$ssh_user/g;
957 $command =~ s/\$MACHINE/$machine/g;
959 doprint("$command ... ");
961 $pid = open(CMD, "$command 2>&1 |") or
962 (fail "unable to exec $command" and return 0);
964 if (defined($opt{"LOG_FILE"})) {
965 open(LOG, ">>$opt{LOG_FILE}") or
966 dodie "failed to write to log";
970 if (defined($redirect)) {
971 open (RD, ">$redirect") or
972 dodie "failed to write to redirect $redirect";
977 print LOG if ($dolog);
985 close(LOG) if ($dolog);
986 close(RD) if ($dord);
999 my $cp_exec = $ssh_exec;
1001 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
1002 return run_command "$cp_exec";
1006 my ($src, $dst) = @_;
1007 my $cp_scp = $scp_to_target;
1009 $cp_scp =~ s/\$SRC_FILE/$src/g;
1010 $cp_scp =~ s/\$DST_FILE/$dst/g;
1012 return run_command "$cp_scp";
1015 sub get_grub_index {
1017 if ($reboot_type ne "grub") {
1020 return if (defined($grub_number));
1022 doprint "Find grub menu ... ";
1025 my $ssh_grub = $ssh_exec;
1026 $ssh_grub =~ s,\$SSH_COMMAND,cat /boot/grub/menu.lst,g;
1028 open(IN, "$ssh_grub |")
1029 or die "unable to get menu.lst";
1034 if (/^\s*title\s+$grub_menu\s*$/) {
1038 } elsif (/^\s*title\s/) {
1044 die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
1046 doprint "$grub_number\n";
1051 my ($fp, $time) = @_;
1057 if (!defined($time)) {
1062 vec($rin, fileno($fp), 1) = 1;
1063 $ready = select($rin, undef, undef, $time);
1067 # try to read one char at a time
1068 while (sysread $fp, $ch, 1) {
1070 last if ($ch eq "\n");
1073 if (!length($line)) {
1081 if ($reboot_type eq "grub") {
1082 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch && reboot)'";
1086 run_command "$reboot_script";
1092 doprint "git rev-list --max-count=1 $commit ... ";
1093 my $sha1 = `git rev-list --max-count=1 $commit`;
1100 dodie "Failed to get git $commit";
1113 my $skip_call_trace = 0;
1121 open(DMESG, "> $dmesg") or
1122 die "unable to write to $dmesg";
1128 my $monitor_start = time;
1130 my $version_found = 0;
1134 if ($bug && defined($stop_after_failure) &&
1135 $stop_after_failure >= 0) {
1136 my $time = $stop_after_failure - (time - $failure_start);
1137 $line = wait_for_input($monitor_fp, $time);
1138 if (!defined($line)) {
1139 doprint "bug timed out after $booted_timeout seconds\n";
1140 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1144 $line = wait_for_input($monitor_fp, $booted_timeout);
1145 if (!defined($line)) {
1146 my $s = $booted_timeout == 1 ? "" : "s";
1147 doprint "Successful boot found: break after $booted_timeout second$s\n";
1151 $line = wait_for_input($monitor_fp);
1152 if (!defined($line)) {
1153 my $s = $timeout == 1 ? "" : "s";
1154 doprint "Timed out after $timeout second$s\n";
1162 # we are not guaranteed to get a full line
1163 $full_line .= $line;
1165 if ($full_line =~ /$success_line/) {
1167 $success_start = time;
1170 if ($booted && defined($stop_after_success) &&
1171 $stop_after_success >= 0) {
1173 if ($now - $success_start >= $stop_after_success) {
1174 doprint "Test forced to stop after $stop_after_success seconds after success\n";
1179 if ($full_line =~ /\[ backtrace testing \]/) {
1180 $skip_call_trace = 1;
1183 if ($full_line =~ /call trace:/i) {
1184 if (!$bug && !$skip_call_trace) {
1186 $failure_start = time;
1190 if ($bug && defined($stop_after_failure) &&
1191 $stop_after_failure >= 0) {
1193 if ($now - $failure_start >= $stop_after_failure) {
1194 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1199 if ($full_line =~ /\[ end of backtrace testing \]/) {
1200 $skip_call_trace = 0;
1203 if ($full_line =~ /Kernel panic -/) {
1204 $failure_start = time;
1208 # Detect triple faults by testing the banner
1209 if ($full_line =~ /\bLinux version (\S+).*\n/) {
1210 if ($1 eq $version) {
1212 } elsif ($version_found && $detect_triplefault) {
1213 # We already booted into the kernel we are testing,
1214 # but now we booted into another kernel?
1215 # Consider this a triple fault.
1216 doprint "Aleady booted in Linux kernel $version, but now\n";
1217 doprint "we booted into Linux kernel $1.\n";
1218 doprint "Assuming that this is a triple fault.\n";
1219 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
1224 if ($line =~ /\n/) {
1228 if ($stop_test_after > 0 && !$booted && !$bug) {
1229 if (time - $monitor_start > $stop_test_after) {
1230 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
1239 return 0 if ($in_bisect);
1240 fail "failed - got a bug report" and return 0;
1244 return 0 if ($in_bisect);
1245 fail "failed - never got a boot prompt." and return 0;
1251 sub do_post_install {
1253 return if (!defined($post_install));
1255 my $cp_post_install = $post_install;
1256 $cp_post_install =~ s/\$KERNEL_VERSION/$version/g;
1257 run_command "$cp_post_install" or
1258 dodie "Failed to run post install";
1263 return if ($no_install);
1265 run_scp "$outputdir/$build_target", "$target_image" or
1266 dodie "failed to copy image";
1268 my $install_mods = 0;
1270 # should we process modules?
1272 open(IN, "$output_config") or dodie("Can't read config file");
1274 if (/CONFIG_MODULES(=y)?/) {
1275 $install_mods = 1 if (defined($1));
1281 if (!$install_mods) {
1283 doprint "No modules needed\n";
1287 run_command "$make INSTALL_MOD_PATH=$tmpdir modules_install" or
1288 dodie "Failed to install modules";
1290 my $modlib = "/lib/modules/$version";
1291 my $modtar = "ktest-mods.tar.bz2";
1293 run_ssh "rm -rf $modlib" or
1294 dodie "failed to remove old mods: $modlib";
1296 # would be nice if scp -r did not follow symbolic links
1297 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
1298 dodie "making tarball";
1300 run_scp "$tmpdir/$modtar", "/tmp" or
1301 dodie "failed to copy modules";
1303 unlink "$tmpdir/$modtar";
1305 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
1306 dodie "failed to tar modules";
1308 run_ssh "rm -f /tmp/$modtar";
1314 # get the release name
1315 doprint "$make kernelrelease ... ";
1316 $version = `$make kernelrelease | tail -1`;
1318 doprint "$version\n";
1321 sub start_monitor_and_boot {
1330 sub check_buildlog {
1333 my @files = `git show $patch | diffstat -l`;
1335 open(IN, "git show $patch |") or
1336 dodie "failed to show $patch";
1338 if (m,^--- a/(.*),) {
1340 $files[$#files] = $1;
1345 open(IN, $buildlog) or dodie "Can't open $buildlog";
1347 if (/^\s*(.*?):.*(warning|error)/) {
1349 foreach my $file (@files) {
1350 my $fullpath = "$builddir/$file";
1351 if ($file eq $err || $fullpath eq $err) {
1352 fail "$file built with warnings" and return 0;
1362 sub apply_min_config {
1363 my $outconfig = "$output_config.new";
1365 # Read the config file and remove anything that
1366 # is in the force_config hash (from minconfig and others)
1367 # then add the force config back.
1369 doprint "Applying minimum configurations into $output_config.new\n";
1371 open (OUT, ">$outconfig") or
1372 dodie "Can't create $outconfig";
1374 if (-f $output_config) {
1375 open (IN, $output_config) or
1376 dodie "Failed to open $output_config";
1378 if (/^(# )?(CONFIG_[^\s=]*)/) {
1379 next if (defined($force_config{$2}));
1385 foreach my $config (keys %force_config) {
1386 print OUT "$force_config{$config}\n";
1390 run_command "mv $outconfig $output_config";
1393 sub make_oldconfig {
1395 my @force_list = keys %force_config;
1397 if ($#force_list >= 0) {
1401 if (!run_command "$make oldnoconfig") {
1402 # Perhaps oldnoconfig doesn't exist in this version of the kernel
1403 # try a yes '' | oldconfig
1404 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
1405 run_command "yes '' | $make oldconfig" or
1406 dodie "failed make config oldconfig";
1410 # read a config file and use this to force new configs.
1411 sub load_force_config {
1414 open(IN, $config) or
1415 dodie "failed to read $config";
1418 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
1419 $force_config{$1} = $_;
1420 } elsif (/^# (CONFIG_\S*) is not set/) {
1421 $force_config{$1} = $_;
1432 # Failed builds should not reboot the target
1433 my $save_no_reboot = $no_reboot;
1436 if (defined($pre_build)) {
1437 my $ret = run_command $pre_build;
1438 if (!$ret && defined($pre_build_die) &&
1440 dodie "failed to pre_build\n";
1444 if ($type =~ /^useconfig:(.*)/) {
1445 run_command "cp $1 $output_config" or
1446 dodie "could not copy $1 to .config";
1448 $type = "oldconfig";
1451 # old config can ask questions
1452 if ($type eq "oldconfig") {
1453 $type = "oldnoconfig";
1455 # allow for empty configs
1456 run_command "touch $output_config";
1459 run_command "mv $output_config $outputdir/config_temp" or
1460 dodie "moving .config";
1462 run_command "$make mrproper" or dodie "make mrproper";
1464 run_command "mv $outputdir/config_temp $output_config" or
1465 dodie "moving config_temp";
1468 } elsif (!$noclean) {
1469 unlink "$output_config";
1470 run_command "$make mrproper" or
1471 dodie "make mrproper";
1474 # add something to distinguish this build
1475 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
1476 print OUT "$localversion\n";
1479 if (defined($minconfig)) {
1480 load_force_config($minconfig);
1483 if ($type ne "oldnoconfig") {
1484 run_command "$make $type" or
1485 dodie "failed make config";
1487 # Run old config regardless, to enforce min configurations
1490 $redirect = "$buildlog";
1491 my $build_ret = run_command "$make $build_options";
1494 if (defined($post_build)) {
1495 my $ret = run_command $post_build;
1496 if (!$ret && defined($post_build_die) &&
1498 dodie "failed to post_build\n";
1503 # bisect may need this to pass
1505 $no_reboot = $save_no_reboot;
1508 fail "failed build" and return 0;
1511 $no_reboot = $save_no_reboot;
1517 if (!run_ssh "halt" or defined($power_off)) {
1518 if (defined($poweroff_after_halt)) {
1519 sleep $poweroff_after_halt;
1520 run_command "$power_off";
1524 run_command "$power_off";
1535 if (defined($test_name)) {
1536 $name = " ($test_name)";
1539 doprint "\n\n*******************************************\n";
1540 doprint "*******************************************\n";
1541 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
1542 doprint "*******************************************\n";
1543 doprint "*******************************************\n";
1545 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
1546 doprint "Reboot and wait $sleep_time seconds\n";
1553 doprint "Pass or fail? [p/f]";
1556 if ($ans eq "p" || $ans eq "P") {
1558 } elsif ($ans eq "f" || $ans eq "F") {
1561 print "Please answer 'P' or 'F'\n";
1566 sub child_run_test {
1569 # child should have no power
1570 $reboot_on_error = 0;
1571 $poweroff_on_error = 0;
1572 $die_on_failure = 1;
1574 run_command $run_test or $failed = 1;
1580 sub child_finished {
1593 doprint "run test $run_test\n";
1597 $SIG{CHLD} = qw(child_finished);
1601 child_run_test if (!$child_pid);
1606 $line = wait_for_input($monitor_fp, 1);
1607 if (defined($line)) {
1609 # we are not guaranteed to get a full line
1610 $full_line .= $line;
1613 if ($full_line =~ /call trace:/i) {
1617 if ($full_line =~ /Kernel panic -/) {
1621 if ($line =~ /\n/) {
1625 } while (!$child_done && !$bug);
1628 my $failure_start = time;
1631 $line = wait_for_input($monitor_fp, 1);
1632 if (defined($line)) {
1636 if ($now - $failure_start >= $stop_after_failure) {
1639 } while (defined($line));
1641 doprint "Detected kernel crash!\n";
1642 # kill the child with extreme prejudice
1646 waitpid $child_pid, 0;
1649 if ($bug || $child_exit) {
1650 return 0 if $in_bisect;
1651 fail "test failed" and return 0;
1656 sub run_git_bisect {
1659 doprint "$command ... ";
1661 my $output = `$command 2>&1`;
1668 dodie "Failed to git bisect";
1671 doprint "SUCCESS\n";
1672 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
1673 doprint "$1 [$2]\n";
1674 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
1676 doprint "Found bad commit... $1\n";
1679 # we already logged it, just print it now.
1687 doprint "Reboot and sleep $bisect_sleep_time seconds\n";
1688 reboot $bisect_sleep_time;
1691 # returns 1 on success, 0 on failure, -1 on skip
1692 sub run_bisect_test {
1693 my ($type, $buildtype) = @_;
1702 build $buildtype or $failed = 1;
1704 if ($type ne "build") {
1705 if ($failed && $bisect_skip) {
1709 dodie "Failed on build" if $failed;
1712 start_monitor_and_boot or $failed = 1;
1714 if ($type ne "boot") {
1715 if ($failed && $bisect_skip) {
1721 dodie "Failed on boot" if $failed;
1723 do_run_test or $failed = 1;
1734 # reboot the box to a kernel we can ssh to
1735 if ($type ne "build") {
1745 my $buildtype = "oldconfig";
1747 # We should have a minconfig to use?
1748 if (defined($minconfig)) {
1749 $buildtype = "useconfig:$minconfig";
1752 my $ret = run_bisect_test $type, $buildtype;
1754 if ($bisect_manual) {
1755 $ret = answer_bisect;
1758 # Are we looking for where it worked, not failed?
1759 if ($reverse_bisect) {
1765 } elsif ($ret == 0) {
1767 } elsif ($bisect_skip) {
1768 doprint "HIT A BAD COMMIT ... SKIPPING\n";
1778 die "BISECT_GOOD[$i] not defined\n" if (!defined($opt{"BISECT_GOOD[$i]"}));
1779 die "BISECT_BAD[$i] not defined\n" if (!defined($opt{"BISECT_BAD[$i]"}));
1780 die "BISECT_TYPE[$i] not defined\n" if (!defined($opt{"BISECT_TYPE[$i]"}));
1782 my $good = $opt{"BISECT_GOOD[$i]"};
1783 my $bad = $opt{"BISECT_BAD[$i]"};
1784 my $type = $opt{"BISECT_TYPE[$i]"};
1785 my $start = $opt{"BISECT_START[$i]"};
1786 my $replay = $opt{"BISECT_REPLAY[$i]"};
1787 my $start_files = $opt{"BISECT_FILES[$i]"};
1789 if (defined($start_files)) {
1790 $start_files = " -- " . $start_files;
1795 # convert to true sha1's
1796 $good = get_sha1($good);
1797 $bad = get_sha1($bad);
1799 if (defined($opt{"BISECT_REVERSE[$i]"}) &&
1800 $opt{"BISECT_REVERSE[$i]"} == 1) {
1801 doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
1802 $reverse_bisect = 1;
1804 $reverse_bisect = 0;
1807 # Can't have a test without having a test to run
1808 if ($type eq "test" && !defined($run_test)) {
1812 my $check = $opt{"BISECT_CHECK[$i]"};
1813 if (defined($check) && $check ne "0") {
1816 my $head = get_sha1("HEAD");
1818 if ($check ne "good") {
1819 doprint "TESTING BISECT BAD [$bad]\n";
1820 run_command "git checkout $bad" or
1821 die "Failed to checkout $bad";
1823 $result = run_bisect $type;
1825 if ($result ne "bad") {
1826 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
1830 if ($check ne "bad") {
1831 doprint "TESTING BISECT GOOD [$good]\n";
1832 run_command "git checkout $good" or
1833 die "Failed to checkout $good";
1835 $result = run_bisect $type;
1837 if ($result ne "good") {
1838 fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
1842 # checkout where we started
1843 run_command "git checkout $head" or
1844 die "Failed to checkout $head";
1847 run_command "git bisect start$start_files" or
1848 dodie "could not start bisect";
1850 run_command "git bisect good $good" or
1851 dodie "could not set bisect good to $good";
1853 run_git_bisect "git bisect bad $bad" or
1854 dodie "could not set bisect bad to $bad";
1856 if (defined($replay)) {
1857 run_command "git bisect replay $replay" or
1858 dodie "failed to run replay";
1861 if (defined($start)) {
1862 run_command "git checkout $start" or
1863 dodie "failed to checkout $start";
1868 $result = run_bisect $type;
1869 $test = run_git_bisect "git bisect $result";
1872 run_command "git bisect log" or
1873 dodie "could not capture git bisect log";
1875 run_command "git bisect reset" or
1876 dodie "could not reset git bisect";
1878 doprint "Bad commit was [$bisect_bad]\n";
1891 sub assign_configs {
1892 my ($hash, $config) = @_;
1895 or dodie "Failed to read $config";
1898 if (/^((CONFIG\S*)=.*)/) {
1906 sub process_config_ignore {
1909 assign_configs \%config_ignore, $config;
1912 sub read_current_config {
1913 my ($config_ref) = @_;
1915 %{$config_ref} = ();
1916 undef %{$config_ref};
1918 my @key = keys %{$config_ref};
1920 print "did not delete!\n";
1923 open (IN, "$output_config");
1926 if (/^(CONFIG\S+)=(.*)/) {
1927 ${$config_ref}{$1} = $2;
1933 sub get_dependencies {
1936 my $arr = $dependency{$config};
1937 if (!defined($arr)) {
1943 foreach my $dep (@{$arr}) {
1944 print "ADD DEP $dep\n";
1945 @deps = (@deps, get_dependencies $dep);
1954 open(OUT, ">$output_config") or dodie "Can not write to $output_config";
1956 foreach my $config (@configs) {
1957 print OUT "$config_set{$config}\n";
1958 my @deps = get_dependencies $config;
1959 foreach my $dep (@deps) {
1960 print OUT "$config_set{$dep}\n";
1964 foreach my $config (keys %config_ignore) {
1965 print OUT "$config_ignore{$config}\n";
1973 sub compare_configs {
1976 foreach my $item (keys %a) {
1977 if (!defined($b{$item})) {
1978 print "diff $item\n";
1986 print "diff2 $keys[0]\n";
1988 return -1 if ($#keys >= 0);
1993 sub run_config_bisect_test {
1996 return run_bisect_test $type, "oldconfig";
1999 sub process_passed {
2002 doprint "These configs had no failure: (Enabling them for further compiles)\n";
2003 # Passed! All these configs are part of a good compile.
2004 # Add them to the min options.
2005 foreach my $config (keys %configs) {
2006 if (defined($config_list{$config})) {
2007 doprint " removing $config\n";
2008 $config_ignore{$config} = $config_list{$config};
2009 delete $config_list{$config};
2012 doprint "config copied to $outputdir/config_good\n";
2013 run_command "cp -f $output_config $outputdir/config_good";
2016 sub process_failed {
2019 doprint "\n\n***************************************\n";
2020 doprint "Found bad config: $config\n";
2021 doprint "***************************************\n\n";
2024 sub run_config_bisect {
2026 my @start_list = keys %config_list;
2028 if ($#start_list < 0) {
2029 doprint "No more configs to test!!!\n";
2033 doprint "***** RUN TEST ***\n";
2034 my $type = $opt{"CONFIG_BISECT_TYPE[$iteration]"};
2038 my $count = $#start_list + 1;
2039 doprint " $count configs to test\n";
2041 my $half = int($#start_list / 2);
2044 my @tophalf = @start_list[0 .. $half];
2046 create_config @tophalf;
2047 read_current_config \%current_config;
2049 $count = $#tophalf + 1;
2050 doprint "Testing $count configs\n";
2052 # make sure we test something
2053 foreach my $config (@tophalf) {
2054 if (defined($current_config{$config})) {
2060 # try the other half
2061 doprint "Top half produced no set configs, trying bottom half\n";
2062 @tophalf = @start_list[$half + 1 .. $#start_list];
2063 create_config @tophalf;
2064 read_current_config \%current_config;
2065 foreach my $config (@tophalf) {
2066 if (defined($current_config{$config})) {
2072 doprint "Failed: Can't make new config with current configs\n";
2073 foreach my $config (@start_list) {
2074 doprint " CONFIG: $config\n";
2078 $count = $#tophalf + 1;
2079 doprint "Testing $count configs\n";
2082 $ret = run_config_bisect_test $type;
2083 if ($bisect_manual) {
2084 $ret = answer_bisect;
2087 process_passed %current_config;
2091 doprint "This config had a failure.\n";
2092 doprint "Removing these configs that were not set in this config:\n";
2093 doprint "config copied to $outputdir/config_bad\n";
2094 run_command "cp -f $output_config $outputdir/config_bad";
2096 # A config exists in this group that was bad.
2097 foreach my $config (keys %config_list) {
2098 if (!defined($current_config{$config})) {
2099 doprint " removing $config\n";
2100 delete $config_list{$config};
2104 @start_list = @tophalf;
2106 if ($#start_list == 0) {
2107 process_failed $start_list[0];
2111 # remove half the configs we are looking at and see if
2113 $half = int($#start_list / 2);
2114 } while ($#start_list > 0);
2116 # we found a single config, try it again unless we are running manually
2118 if ($bisect_manual) {
2119 process_failed $start_list[0];
2123 my @tophalf = @start_list[0 .. 0];
2125 $ret = run_config_bisect_test $type;
2127 process_passed %current_config;
2131 process_failed $start_list[0];
2138 my $start_config = $opt{"CONFIG_BISECT[$i]"};
2140 my $tmpconfig = "$tmpdir/use_config";
2142 if (defined($config_bisect_good)) {
2143 process_config_ignore $config_bisect_good;
2146 # Make the file with the bad config and the min config
2147 if (defined($minconfig)) {
2148 # read the min config for things to ignore
2149 run_command "cp $minconfig $tmpconfig" or
2150 dodie "failed to copy $minconfig to $tmpconfig";
2155 if (-f $tmpconfig) {
2156 load_force_config($tmpconfig);
2157 process_config_ignore $tmpconfig;
2160 # now process the start config
2161 run_command "cp $start_config $output_config" or
2162 dodie "failed to copy $start_config to $output_config";
2164 # read directly what we want to check
2166 open (IN, $output_config)
2167 or dodie "faied to open $output_config";
2170 if (/^((CONFIG\S*)=.*)/) {
2171 $config_check{$2} = $1;
2176 # Now run oldconfig with the minconfig
2179 # check to see what we lost (or gained)
2180 open (IN, $output_config)
2181 or dodie "Failed to read $start_config";
2183 my %removed_configs;
2187 if (/^((CONFIG\S*)=.*)/) {
2188 # save off all options
2189 $config_set{$2} = $1;
2190 if (defined($config_check{$2})) {
2191 if (defined($config_ignore{$2})) {
2192 $removed_configs{$2} = $1;
2194 $config_list{$2} = $1;
2196 } elsif (!defined($config_ignore{$2})) {
2197 $added_configs{$2} = $1;
2198 $config_list{$2} = $1;
2204 my @confs = keys %removed_configs;
2206 doprint "Configs overridden by default configs and removed from check:\n";
2207 foreach my $config (@confs) {
2208 doprint " $config\n";
2211 @confs = keys %added_configs;
2213 doprint "Configs appearing in make oldconfig and added:\n";
2214 foreach my $config (@confs) {
2215 doprint " $config\n";
2222 # Sometimes kconfig does weird things. We must make sure
2223 # that the config we autocreate has everything we need
2224 # to test, otherwise we may miss testing configs, or
2225 # may not be able to create a new config.
2226 # Here we create a config with everything set.
2227 create_config (keys %config_list);
2228 read_current_config \%config_test;
2229 foreach my $config (keys %config_list) {
2230 if (!defined($config_test{$config})) {
2233 doprint "Configs not produced by kconfig (will not be checked):\n";
2235 doprint " $config\n";
2236 delete $config_list{$config};
2241 $ret = run_config_bisect;
2244 return $ret if ($ret < 0);
2249 sub patchcheck_reboot {
2250 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
2251 reboot $patchcheck_sleep_time;
2257 die "PATCHCHECK_START[$i] not defined\n"
2258 if (!defined($opt{"PATCHCHECK_START[$i]"}));
2259 die "PATCHCHECK_TYPE[$i] not defined\n"
2260 if (!defined($opt{"PATCHCHECK_TYPE[$i]"}));
2262 my $start = $opt{"PATCHCHECK_START[$i]"};
2265 if (defined($opt{"PATCHCHECK_END[$i]"})) {
2266 $end = $opt{"PATCHCHECK_END[$i]"};
2269 # Get the true sha1's since we can use things like HEAD~3
2270 $start = get_sha1($start);
2271 $end = get_sha1($end);
2273 my $type = $opt{"PATCHCHECK_TYPE[$i]"};
2275 # Can't have a test without having a test to run
2276 if ($type eq "test" && !defined($run_test)) {
2280 open (IN, "git log --pretty=oneline $end|") or
2281 dodie "could not get git list";
2287 $list[$#list+1] = $_;
2288 last if (/^$start/);
2292 if ($list[$#list] !~ /^$start/) {
2293 fail "SHA1 $start not found";
2296 # go backwards in the list
2297 @list = reverse @list;
2299 my $save_clean = $noclean;
2300 my %ignored_warnings;
2302 if (defined($ignore_warnings)) {
2303 foreach my $sha1 (split /\s+/, $ignore_warnings) {
2304 $ignored_warnings{$sha1} = 1;
2309 foreach my $item (@list) {
2311 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
2313 doprint "\nProcessing commit $item\n\n";
2315 run_command "git checkout $sha1" or
2316 die "Failed to checkout $sha1";
2318 # only clean on the first and last patch
2319 if ($item eq $list[0] ||
2320 $item eq $list[$#list]) {
2321 $noclean = $save_clean;
2326 if (defined($minconfig)) {
2327 build "useconfig:$minconfig" or return 0;
2329 # ?? no config to use?
2330 build "oldconfig" or return 0;
2334 if (!defined($ignored_warnings{$sha1})) {
2335 check_buildlog $sha1 or return 0;
2338 next if ($type eq "build");
2342 start_monitor_and_boot or $failed = 1;
2344 if (!$failed && $type ne "boot"){
2345 do_run_test or $failed = 1;
2348 return 0 if ($failed);
2366 # taken from streamline_config.pl
2378 if (! -f $kconfig) {
2379 doprint "file $kconfig does not exist, skipping\n";
2383 open(KIN, "$kconfig")
2384 or die "Can't open $kconfig";
2388 # Make sure that lines ending with \ continue
2390 $_ = $line . " " . $_;
2401 # collect any Kconfig sources
2402 if (/^source\s*"(.*)"/) {
2403 $kconfigs[$#kconfigs+1] = $1;
2407 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
2411 for (my $i = 0; $i < $iflevel; $i++) {
2413 $depends{$config} .= " " . $ifdeps[$i];
2415 $depends{$config} = $ifdeps[$i];
2420 # collect the depends for the config
2421 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
2423 if (defined($depends{$1})) {
2424 $depends{$config} .= " " . $1;
2426 $depends{$config} = $1;
2429 # Get the configs that select this config
2430 } elsif ($state ne "NONE" && /^\s*select\s+(\S+)/) {
2431 if (defined($depends{$1})) {
2432 $depends{$1} .= " " . $config;
2434 $depends{$1} = $config;
2437 # Check for if statements
2438 } elsif (/^if\s+(.*\S)\s*$/) {
2440 # remove beginning and ending non text
2441 $deps =~ s/^[^a-zA-Z0-9_]*//;
2442 $deps =~ s/[^a-zA-Z0-9_]*$//;
2444 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
2446 $ifdeps[$iflevel++] = join ':', @deps;
2448 } elsif (/^endif/) {
2450 $iflevel-- if ($iflevel);
2453 } elsif (/^\s*help\s*$/) {
2459 # read in any configs that were found.
2460 foreach $kconfig (@kconfigs) {
2461 if (!defined($read_kconfigs{$kconfig})) {
2462 $read_kconfigs{$kconfig} = 1;
2463 read_kconfig("$builddir/$kconfig");
2469 # find out which arch this is by the kconfig file
2470 open (IN, $output_config)
2471 or dodie "Failed to read $output_config";
2474 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
2481 if (!defined($arch)) {
2482 doprint "Could not find arch from config file\n";
2483 doprint "no dependencies used\n";
2487 # arch is really the subarch, we need to know
2488 # what directory to look at.
2489 if ($arch eq "i386" || $arch eq "x86_64") {
2491 } elsif ($arch =~ /^tile/) {
2495 my $kconfig = "$builddir/arch/$arch/Kconfig";
2497 if (! -f $kconfig && $arch =~ /\d$/) {
2499 # some subarchs have numbers, truncate them
2501 $kconfig = "$builddir/arch/$arch/Kconfig";
2502 if (! -f $kconfig) {
2503 doprint "No idea what arch dir $orig is for\n";
2504 doprint "no dependencies used\n";
2509 read_kconfig($kconfig);
2512 sub read_config_list {
2516 or dodie "Failed to read $config";
2519 if (/^((CONFIG\S*)=.*)/) {
2520 if (!defined($config_ignore{$2})) {
2521 $config_list{$2} = $1;
2529 sub read_output_config {
2532 assign_configs \%config_ignore, $config;
2535 sub make_new_config {
2538 open (OUT, ">$output_config")
2539 or dodie "Failed to write $output_config";
2541 foreach my $config (@configs) {
2542 print OUT "$config\n";
2551 $kconfig =~ s/CONFIG_//;
2553 $dep = $depends{"$kconfig"};
2555 # the dep string we have saves the dependencies as they
2556 # were found, including expressions like ! && ||. We
2557 # want to split this out into just an array of configs.
2559 my $valid = "A-Za-z_0-9";
2563 while ($dep =~ /[$valid]/) {
2565 if ($dep =~ /^[^$valid]*([$valid]+)/) {
2566 my $conf = "CONFIG_" . $1;
2568 $configs[$#configs + 1] = $conf;
2570 $dep =~ s/^[^$valid]*[$valid]+//;
2572 die "this should never happen";
2582 my %processed_configs;
2583 my %nochange_config;
2585 sub test_this_config {
2590 # if we already processed this config, skip it
2591 if (defined($processed_configs{$config})) {
2594 $processed_configs{$config} = 1;
2596 # if this config failed during this round, skip it
2597 if (defined($nochange_config{$config})) {
2601 my $kconfig = $config;
2602 $kconfig =~ s/CONFIG_//;
2604 # Test dependencies first
2605 if (defined($depends{"$kconfig"})) {
2606 my @parents = get_depends $config;
2607 foreach my $parent (@parents) {
2608 # if the parent is in the min config, check it first
2609 next if (!defined($min_configs{$parent}));
2610 $found = test_this_config($parent);
2611 if (defined($found)) {
2617 # Remove this config from the list of configs
2618 # do a make oldnoconfig and then read the resulting
2619 # .config to make sure it is missing the config that
2621 my %configs = %min_configs;
2622 delete $configs{$config};
2623 make_new_config ((values %configs), (values %keep_configs));
2626 assign_configs \%configs, $output_config;
2628 return $config if (!defined($configs{$config}));
2630 doprint "disabling config $config did not change .config\n";
2632 $nochange_config{$config} = 1;
2637 sub make_min_config {
2640 if (!defined($output_minconfig)) {
2641 fail "OUTPUT_MIN_CONFIG not defined" and return;
2644 # If output_minconfig exists, and the start_minconfig
2645 # came from min_config, than ask if we should use
2647 if (-f $output_minconfig && !$start_minconfig_defined) {
2648 print "$output_minconfig exists\n";
2649 if (read_yn " Use it as minconfig?") {
2650 $start_minconfig = $output_minconfig;
2654 if (!defined($start_minconfig)) {
2655 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
2658 my $temp_config = "$tmpdir/temp_config";
2660 # First things first. We build an allnoconfig to find
2661 # out what the defaults are that we can't touch.
2662 # Some are selections, but we really can't handle selections.
2664 my $save_minconfig = $minconfig;
2667 run_command "$make allnoconfig" or return 0;
2671 process_config_ignore $output_config;
2673 undef %save_configs;
2676 if (defined($ignore_config)) {
2677 # make sure the file exists
2678 `touch $ignore_config`;
2679 assign_configs \%save_configs, $ignore_config;
2682 %keep_configs = %save_configs;
2684 doprint "Load initial configs from $start_minconfig\n";
2686 # Look at the current min configs, and save off all the
2687 # ones that were set via the allnoconfig
2688 assign_configs \%min_configs, $start_minconfig;
2690 my @config_keys = keys %min_configs;
2692 # Remove anything that was set by the make allnoconfig
2693 # we shouldn't need them as they get set for us anyway.
2694 foreach my $config (@config_keys) {
2695 # Remove anything in the ignore_config
2696 if (defined($keep_configs{$config})) {
2697 my $file = $ignore_config;
2698 $file =~ s,.*/(.*?)$,$1,;
2699 doprint "$config set by $file ... ignored\n";
2700 delete $min_configs{$config};
2703 # But make sure the settings are the same. If a min config
2704 # sets a selection, we do not want to get rid of it if
2705 # it is not the same as what we have. Just move it into
2707 if (defined($config_ignore{$config})) {
2708 if ($config_ignore{$config} ne $min_configs{$config}) {
2709 doprint "$config is in allnoconfig as '$config_ignore{$config}'";
2710 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
2711 $keep_configs{$config} = $min_configs{$config};
2713 doprint "$config set by allnoconfig ... ignored\n";
2715 delete $min_configs{$config};
2727 # Now disable each config one by one and do a make oldconfig
2728 # till we find a config that changes our list.
2730 # Put configs that did not modify the config at the end.
2731 my @test_configs = keys %min_configs;
2733 for (my $i = 0; $i < $#test_configs; $i++) {
2734 if (!defined($nochange_config{$test_configs[0]})) {
2738 # This config didn't change the .config last time.
2739 # Place it at the end
2740 my $config = shift @test_configs;
2741 push @test_configs, $config;
2744 # if every test config has failed to modify the .config file
2745 # in the past, then reset and start over.
2747 undef %nochange_config;
2750 undef %processed_configs;
2752 foreach my $config (@test_configs) {
2754 $found = test_this_config $config;
2756 last if (defined($found));
2758 # oh well, try another config
2761 if (!defined($found)) {
2762 # we could have failed due to the nochange_config hash
2763 # reset and try again
2765 undef %nochange_config;
2769 doprint "No more configs found that we can disable\n";
2777 doprint "Test with $config disabled\n";
2779 # set in_bisect to keep build and monitor from dieing
2784 start_monitor_and_boot or $failed = 1;
2790 doprint "$min_configs{$config} is needed to boot the box... keeping\n";
2791 # this config is needed, add it to the ignore list.
2792 $keep_configs{$config} = $min_configs{$config};
2793 $save_configs{$config} = $min_configs{$config};
2794 delete $min_configs{$config};
2796 # update new ignore configs
2797 if (defined($ignore_config)) {
2798 open (OUT, ">$temp_config")
2799 or die "Can't write to $temp_config";
2800 foreach my $config (keys %save_configs) {
2801 print OUT "$save_configs{$config}\n";
2804 run_command "mv $temp_config $ignore_config" or
2805 dodie "failed to copy update to $ignore_config";
2809 # We booted without this config, remove it from the minconfigs.
2810 doprint "$config is not needed, disabling\n";
2812 delete $min_configs{$config};
2814 # Also disable anything that is not enabled in this config
2816 assign_configs \%configs, $output_config;
2817 my @config_keys = keys %min_configs;
2818 foreach my $config (@config_keys) {
2819 if (!defined($configs{$config})) {
2820 doprint "$config is not set, disabling\n";
2821 delete $min_configs{$config};
2825 # Save off all the current mandidory configs
2826 open (OUT, ">$temp_config")
2827 or die "Can't write to $temp_config";
2828 foreach my $config (keys %keep_configs) {
2829 print OUT "$keep_configs{$config}\n";
2831 foreach my $config (keys %min_configs) {
2832 print OUT "$min_configs{$config}\n";
2836 run_command "mv $temp_config $output_minconfig" or
2837 dodie "failed to copy update to $output_minconfig";
2840 doprint "Reboot and wait $sleep_time seconds\n";
2848 $#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl config-file\n";
2851 $ktest_config = $ARGV[0];
2852 if (! -f $ktest_config) {
2853 print "$ktest_config does not exist.\n";
2854 if (!read_yn "Create it?") {
2859 $ktest_config = "ktest.conf";
2862 if (! -f $ktest_config) {
2863 open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
2865 # Generated by ktest.pl
2867 # Define each test with TEST_START
2868 # The config options below it will override the defaults
2876 read_config $ktest_config;
2878 if (defined($opt{"LOG_FILE"})) {
2879 $opt{"LOG_FILE"} = eval_option($opt{"LOG_FILE"}, -1);
2882 # Append any configs entered in manually to the config file.
2883 my @new_configs = keys %entered_configs;
2884 if ($#new_configs >= 0) {
2885 print "\nAppending entered in configs to $ktest_config\n";
2886 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
2887 foreach my $config (@new_configs) {
2888 print OUT "$config = $entered_configs{$config}\n";
2889 $opt{$config} = $entered_configs{$config};
2893 if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
2894 unlink $opt{"LOG_FILE"};
2897 doprint "\n\nSTARTING AUTOMATED TESTS\n\n";
2899 for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
2902 doprint "DEFAULT OPTIONS:\n";
2904 doprint "\nTEST $i OPTIONS";
2905 if (defined($repeat_tests{$i})) {
2906 $repeat = $repeat_tests{$i};
2907 doprint " ITERATE $repeat";
2912 foreach my $option (sort keys %opt) {
2914 if ($option =~ /\[(\d+)\]$/) {
2920 doprint "$option = $opt{$option}\n";
2924 sub __set_test_option {
2925 my ($name, $i) = @_;
2927 my $option = "$name\[$i\]";
2929 if (defined($opt{$option})) {
2930 return $opt{$option};
2933 foreach my $test (keys %repeat_tests) {
2935 $i < $test + $repeat_tests{$test}) {
2936 $option = "$name\[$test\]";
2937 if (defined($opt{$option})) {
2938 return $opt{$option};
2943 if (defined($opt{$name})) {
2950 sub set_test_option {
2951 my ($name, $i) = @_;
2953 my $option = __set_test_option($name, $i);
2954 return $option if (!defined($option));
2956 return eval_option($option, $i);
2959 # First we need to do is the builds
2960 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
2962 # Do not reboot on failing test options
2967 my $makecmd = set_test_option("MAKE_CMD", $i);
2969 $machine = set_test_option("MACHINE", $i);
2970 $ssh_user = set_test_option("SSH_USER", $i);
2971 $tmpdir = set_test_option("TMP_DIR", $i);
2972 $outputdir = set_test_option("OUTPUT_DIR", $i);
2973 $builddir = set_test_option("BUILD_DIR", $i);
2974 $test_type = set_test_option("TEST_TYPE", $i);
2975 $build_type = set_test_option("BUILD_TYPE", $i);
2976 $build_options = set_test_option("BUILD_OPTIONS", $i);
2977 $pre_build = set_test_option("PRE_BUILD", $i);
2978 $post_build = set_test_option("POST_BUILD", $i);
2979 $pre_build_die = set_test_option("PRE_BUILD_DIE", $i);
2980 $post_build_die = set_test_option("POST_BUILD_DIE", $i);
2981 $power_cycle = set_test_option("POWER_CYCLE", $i);
2982 $reboot = set_test_option("REBOOT", $i);
2983 $noclean = set_test_option("BUILD_NOCLEAN", $i);
2984 $minconfig = set_test_option("MIN_CONFIG", $i);
2985 $output_minconfig = set_test_option("OUTPUT_MIN_CONFIG", $i);
2986 $start_minconfig = set_test_option("START_MIN_CONFIG", $i);
2987 $ignore_config = set_test_option("IGNORE_CONFIG", $i);
2988 $run_test = set_test_option("TEST", $i);
2989 $addconfig = set_test_option("ADD_CONFIG", $i);
2990 $reboot_type = set_test_option("REBOOT_TYPE", $i);
2991 $grub_menu = set_test_option("GRUB_MENU", $i);
2992 $post_install = set_test_option("POST_INSTALL", $i);
2993 $no_install = set_test_option("NO_INSTALL", $i);
2994 $reboot_script = set_test_option("REBOOT_SCRIPT", $i);
2995 $reboot_on_error = set_test_option("REBOOT_ON_ERROR", $i);
2996 $poweroff_on_error = set_test_option("POWEROFF_ON_ERROR", $i);
2997 $die_on_failure = set_test_option("DIE_ON_FAILURE", $i);
2998 $power_off = set_test_option("POWER_OFF", $i);
2999 $powercycle_after_reboot = set_test_option("POWERCYCLE_AFTER_REBOOT", $i);
3000 $poweroff_after_halt = set_test_option("POWEROFF_AFTER_HALT", $i);
3001 $sleep_time = set_test_option("SLEEP_TIME", $i);
3002 $bisect_sleep_time = set_test_option("BISECT_SLEEP_TIME", $i);
3003 $patchcheck_sleep_time = set_test_option("PATCHCHECK_SLEEP_TIME", $i);
3004 $ignore_warnings = set_test_option("IGNORE_WARNINGS", $i);
3005 $bisect_manual = set_test_option("BISECT_MANUAL", $i);
3006 $bisect_skip = set_test_option("BISECT_SKIP", $i);
3007 $config_bisect_good = set_test_option("CONFIG_BISECT_GOOD", $i);
3008 $store_failures = set_test_option("STORE_FAILURES", $i);
3009 $test_name = set_test_option("TEST_NAME", $i);
3010 $timeout = set_test_option("TIMEOUT", $i);
3011 $booted_timeout = set_test_option("BOOTED_TIMEOUT", $i);
3012 $console = set_test_option("CONSOLE", $i);
3013 $detect_triplefault = set_test_option("DETECT_TRIPLE_FAULT", $i);
3014 $success_line = set_test_option("SUCCESS_LINE", $i);
3015 $reboot_success_line = set_test_option("REBOOT_SUCCESS_LINE", $i);
3016 $stop_after_success = set_test_option("STOP_AFTER_SUCCESS", $i);
3017 $stop_after_failure = set_test_option("STOP_AFTER_FAILURE", $i);
3018 $stop_test_after = set_test_option("STOP_TEST_AFTER", $i);
3019 $build_target = set_test_option("BUILD_TARGET", $i);
3020 $ssh_exec = set_test_option("SSH_EXEC", $i);
3021 $scp_to_target = set_test_option("SCP_TO_TARGET", $i);
3022 $target_image = set_test_option("TARGET_IMAGE", $i);
3023 $localversion = set_test_option("LOCALVERSION", $i);
3025 $start_minconfig_defined = 1;
3027 if (!defined($start_minconfig)) {
3028 $start_minconfig_defined = 0;
3029 $start_minconfig = $minconfig;
3032 chdir $builddir || die "can't change directory to $builddir";
3034 foreach my $dir ($tmpdir, $outputdir) {
3037 die "can't create $dir";
3041 $ENV{"SSH_USER"} = $ssh_user;
3042 $ENV{"MACHINE"} = $machine;
3044 $target = "$ssh_user\@$machine";
3046 $buildlog = "$tmpdir/buildlog-$machine";
3047 $dmesg = "$tmpdir/dmesg-$machine";
3048 $make = "$makecmd O=$outputdir";
3049 $output_config = "$outputdir/.config";
3051 if ($reboot_type eq "grub") {
3052 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
3053 } elsif (!defined($reboot_script)) {
3054 dodie "REBOOT_SCRIPT not defined"
3057 my $run_type = $build_type;
3058 if ($test_type eq "patchcheck") {
3059 $run_type = $opt{"PATCHCHECK_TYPE[$i]"};
3060 } elsif ($test_type eq "bisect") {
3061 $run_type = $opt{"BISECT_TYPE[$i]"};
3062 } elsif ($test_type eq "config_bisect") {
3063 $run_type = $opt{"CONFIG_BISECT_TYPE[$i]"};
3066 if ($test_type eq "make_min_config") {
3070 # mistake in config file?
3071 if (!defined($run_type)) {
3072 $run_type = "ERROR";
3076 $installme = " no_install" if ($no_install);
3079 doprint "RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type$installme\n\n";
3084 if (defined($addconfig)) {
3085 my $min = $minconfig;
3086 if (!defined($minconfig)) {
3089 run_command "cat $addconfig $min > $tmpdir/add_config" or
3090 dodie "Failed to create temp config";
3091 $minconfig = "$tmpdir/add_config";
3094 my $checkout = $opt{"CHECKOUT[$i]"};
3095 if (defined($checkout)) {
3096 run_command "git checkout $checkout" or
3097 die "failed to checkout $checkout";
3103 if ($test_type eq "bisect") {
3106 } elsif ($test_type eq "config_bisect") {
3109 } elsif ($test_type eq "patchcheck") {
3112 } elsif ($test_type eq "make_min_config") {
3117 if ($build_type ne "nobuild") {
3118 build $build_type or next;
3121 if ($test_type eq "install") {
3128 if ($test_type ne "build") {
3130 start_monitor_and_boot or $failed = 1;
3132 if (!$failed && $test_type ne "boot" && defined($run_test)) {
3133 do_run_test or $failed = 1;
3142 if ($opt{"POWEROFF_ON_SUCCESS"}) {
3144 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot) {
3148 doprint "\n $successes of $opt{NUM_TESTS} tests were successful\n\n";