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{"BOOTED_TIMEOUT"} = 1;
46 $default{"DIE_ON_FAILURE"} = 1;
47 $default{"SSH_EXEC"} = "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND";
48 $default{"SCP_TO_TARGET"} = "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE";
49 $default{"REBOOT"} = "ssh \$SSH_USER\@\$MACHINE reboot";
50 $default{"STOP_AFTER_SUCCESS"} = 10;
51 $default{"STOP_AFTER_FAILURE"} = 60;
52 $default{"STOP_TEST_AFTER"} = 600;
53 $default{"LOCALVERSION"} = "-test";
75 my $poweroff_on_error;
77 my $powercycle_after_reboot;
78 my $poweroff_after_halt;
90 my $start_minconfig_defined;
99 my $config_bisect_good;
100 my $in_patchcheck = 0;
109 my $bisect_sleep_time;
110 my $patchcheck_sleep_time;
116 my $detect_triplefault;
119 my $stop_after_success;
120 my $stop_after_failure;
133 $config_help{"MACHINE"} = << "EOF"
134 The machine hostname that you will test.
137 $config_help{"SSH_USER"} = << "EOF"
138 The box is expected to have ssh on normal bootup, provide the user
139 (most likely root, since you need privileged operations)
142 $config_help{"BUILD_DIR"} = << "EOF"
143 The directory that contains the Linux source code (full path).
146 $config_help{"OUTPUT_DIR"} = << "EOF"
147 The directory that the objects will be built (full path).
148 (can not be same as BUILD_DIR)
151 $config_help{"BUILD_TARGET"} = << "EOF"
152 The location of the compiled file to copy to the target.
153 (relative to OUTPUT_DIR)
156 $config_help{"TARGET_IMAGE"} = << "EOF"
157 The place to put your image on the test machine.
160 $config_help{"POWER_CYCLE"} = << "EOF"
161 A script or command to reboot the box.
163 Here is a digital loggers power switch example
164 POWER_CYCLE = wget --no-proxy -O /dev/null -q --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL'
166 Here is an example to reboot a virtual box on the current host
167 with the name "Guest".
168 POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest
171 $config_help{"CONSOLE"} = << "EOF"
172 The script or command that reads the console
174 If you use ttywatch server, something like the following would work.
175 CONSOLE = nc -d localhost 3001
177 For a virtual machine with guest name "Guest".
178 CONSOLE = virsh console Guest
181 $config_help{"LOCALVERSION"} = << "EOF"
182 Required version ending to differentiate the test
183 from other linux builds on the system.
186 $config_help{"REBOOT_TYPE"} = << "EOF"
187 Way to reboot the box to the test kernel.
188 Only valid options so far are "grub" and "script".
190 If you specify grub, it will assume grub version 1
191 and will search in /boot/grub/menu.lst for the title \$GRUB_MENU
192 and select that target to reboot to the kernel. If this is not
193 your setup, then specify "script" and have a command or script
194 specified in REBOOT_SCRIPT to boot to the target.
196 The entry in /boot/grub/menu.lst must be entered in manually.
197 The test will not modify that file.
200 $config_help{"GRUB_MENU"} = << "EOF"
201 The grub title name for the test kernel to boot
202 (Only mandatory if REBOOT_TYPE = grub)
204 Note, ktest.pl will not update the grub menu.lst, you need to
205 manually add an option for the test. ktest.pl will search
206 the grub menu.lst for this option to find what kernel to
209 For example, if in the /boot/grub/menu.lst the test kernel title has:
212 GRUB_MENU = Test Kernel
215 $config_help{"REBOOT_SCRIPT"} = << "EOF"
216 A script to reboot the target into the test kernel
217 (Only mandatory if REBOOT_TYPE = script)
227 print "$prompt [Y/n] ";
230 if ($ans =~ /^\s*$/) {
233 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
234 print "Please answer either 'y' or 'n'.\n";
236 if ($ans !~ /^y$/i) {
242 sub get_ktest_config {
245 return if (defined($opt{$config}));
247 if (defined($config_help{$config})) {
249 print $config_help{$config};
254 if (defined($default{$config})) {
255 print "\[$default{$config}\] ";
257 $entered_configs{$config} = <STDIN>;
258 $entered_configs{$config} =~ s/^\s*(.*\S)\s*$/$1/;
259 if ($entered_configs{$config} =~ /^\s*$/) {
260 if ($default{$config}) {
261 $entered_configs{$config} = $default{$config};
263 print "Your answer can not be blank\n";
271 sub get_ktest_configs {
272 get_ktest_config("MACHINE");
273 get_ktest_config("SSH_USER");
274 get_ktest_config("BUILD_DIR");
275 get_ktest_config("OUTPUT_DIR");
276 get_ktest_config("BUILD_TARGET");
277 get_ktest_config("TARGET_IMAGE");
278 get_ktest_config("POWER_CYCLE");
279 get_ktest_config("CONSOLE");
280 get_ktest_config("LOCALVERSION");
282 my $rtype = $opt{"REBOOT_TYPE"};
284 if (!defined($rtype)) {
285 if (!defined($opt{"GRUB_MENU"})) {
286 get_ktest_config("REBOOT_TYPE");
287 $rtype = $entered_configs{"REBOOT_TYPE"};
293 if ($rtype eq "grub") {
294 get_ktest_config("GRUB_MENU");
296 get_ktest_config("REBOOT_SCRIPT");
300 sub process_variables {
304 # We want to check for '\', and it is just easier
305 # to check the previous characet of '$' and not need
306 # to worry if '$' is the first character. By adding
307 # a space to $value, we can just check [^\\]\$ and
308 # it will still work.
311 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
315 # append beginning of value to retval
316 $retval = "$retval$begin";
317 if (defined($variable{$var})) {
318 $retval = "$retval$variable{$var}";
320 # put back the origin piece.
321 $retval = "$retval\$\{$var\}";
325 $retval = "$retval$value";
327 # remove the space added in the beginning
334 my ($lvalue, $rvalue) = @_;
336 if (defined($opt{$lvalue})) {
337 die "Error: Option $lvalue defined more than once!\n";
339 if ($rvalue =~ /^\s*$/) {
340 delete $opt{$lvalue};
342 $rvalue = process_variables($rvalue);
343 $opt{$lvalue} = $rvalue;
348 my ($lvalue, $rvalue) = @_;
350 if ($rvalue =~ /^\s*$/) {
351 delete $variable{$lvalue};
353 $rvalue = process_variables($rvalue);
354 $variable{$lvalue} = $rvalue;
361 open(IN, $config) || die "can't read file $config";
364 $name =~ s,.*/(.*),$1,;
369 my $num_tests_set = 0;
376 # ignore blank lines and comments
377 next if (/^\s*$/ || /\s*\#/);
379 if (/^\s*TEST_START(.*)/) {
383 if ($num_tests_set) {
384 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
387 my $old_test_num = $test_num;
388 my $old_repeat = $repeat;
390 $test_num += $repeat;
394 if ($rest =~ /\s+SKIP(.*)/) {
402 if ($rest =~ /\s+ITERATE\s+(\d+)(.*)$/) {
405 $repeat_tests{"$test_num"} = $repeat;
408 if ($rest =~ /\s+SKIP(.*)/) {
413 if ($rest !~ /^\s*$/) {
414 die "$name: $.: Gargbage found after TEST_START\n$_";
418 $test_num = $old_test_num;
419 $repeat = $old_repeat;
422 } elsif (/^\s*DEFAULTS(.*)$/) {
427 if ($rest =~ /\s+SKIP(.*)/) {
434 if ($rest !~ /^\s*$/) {
435 die "$name: $.: Gargbage found after DEFAULTS\n$_";
438 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
446 ($lvalue eq "NUM_TESTS" ||
447 $lvalue eq "LOG_FILE" ||
448 $lvalue eq "CLEAR_LOG")) {
449 die "$name: $.: $lvalue must be set in DEFAULTS section\n";
452 if ($lvalue eq "NUM_TESTS") {
454 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
457 die "$name: $.: NUM_TESTS must be set in default section\n";
462 if ($default || $lvalue =~ /\[\d+\]$/) {
463 set_value($lvalue, $rvalue);
465 my $val = "$lvalue\[$test_num\]";
466 set_value($val, $rvalue);
469 $repeats{$val} = $repeat;
472 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
478 # process config variables.
479 # Config variables are only active while reading the
480 # config and can be defined anywhere. They also ignore
481 # TEST_START and DEFAULTS, but are skipped if they are in
482 # on of these sections that have SKIP defined.
483 # The save variable can be
484 # defined multiple times and the new one simply overrides
486 set_variable($lvalue, $rvalue);
489 die "$name: $.: Garbage found in config\n$_";
496 $test_num += $repeat - 1;
497 $opt{"NUM_TESTS"} = $test_num;
500 # make sure we have all mandatory configs
503 # was a test specified?
505 print "No test case specified.\n";
506 print "What test case would you like to run?\n";
509 $default{"TEST_TYPE"} = $ans;
514 foreach my $default (keys %default) {
515 if (!defined($opt{$default})) {
516 $opt{$default} = $default{$default};
522 my ($option, $i) = @_;
524 # Add space to evaluate the character before $
525 $option = " $option";
528 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
533 # Append beginning of line
534 $retval = "$retval$start";
536 # If the iteration option OPT[$i] exists, then use that.
537 # otherwise see if the default OPT (without [$i]) exists.
539 my $o = "$var\[$i\]";
541 if (defined($opt{$o})) {
543 $retval = "$retval$o";
544 } elsif (defined($opt{$var})) {
546 $retval = "$retval$o";
548 $retval = "$retval\$\{$var\}";
554 $retval = "$retval$option";
562 my ($option, $i) = @_;
566 # Since an option can evaluate to another option,
567 # keep iterating until we do not evaluate any more
570 while ($prev ne $option) {
571 # Check for recursive evaluations.
572 # 100 deep should be more than enough.
574 die "Over 100 evaluations accurred with $option\n" .
575 "Check for recursive variables\n";
578 $option = __eval_option($option, $i);
585 if (defined($opt{"LOG_FILE"})) {
586 open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
593 if (defined($opt{"LOG_FILE"})) {
608 sub wait_for_monitor;
613 # try to reboot normally
614 if (run_command $reboot) {
615 if (defined($powercycle_after_reboot)) {
616 sleep $powercycle_after_reboot;
617 run_command "$power_cycle";
620 # nope? power cycle it.
621 run_command "$power_cycle";
624 if (defined($time)) {
626 wait_for_monitor $time;
634 return $test_type eq "build" ||
635 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
636 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
640 doprint "CRITICAL FAILURE... ", @_, "\n";
644 if ($reboot_on_error && !do_not_reboot) {
646 doprint "REBOOTING\n";
649 } elsif ($poweroff_on_error && defined($power_off)) {
650 doprint "POWERING OFF\n";
654 if (defined($opt{"LOG_FILE"})) {
655 print " See $opt{LOG_FILE} for more info.\n";
666 my $pid = open($fp, "$console|") or
667 dodie "Can't open console $console";
669 $flags = fcntl($fp, F_GETFL, 0) or
670 dodie "Can't get flags for the socket: $!";
671 $flags = fcntl($fp, F_SETFL, $flags | O_NONBLOCK) or
672 dodie "Can't set flags for the socket: $!";
680 doprint "kill child process $pid\n";
688 if ($monitor_cnt++) {
691 $monitor_fp = \*MONFD;
692 $monitor_pid = open_console $monitor_fp;
696 open(MONFD, "Stop perl from warning about single use of MONFD");
700 if (--$monitor_cnt) {
703 close_console($monitor_fp, $monitor_pid);
706 sub wait_for_monitor {
710 doprint "** Wait for monitor to settle down **\n";
712 # read the monitor and wait for the system to calm down
714 $line = wait_for_input($monitor_fp, $time);
715 print "$line" if (defined($line));
716 } while (defined($line));
717 print "** Monitor flushed **\n";
722 if ($die_on_failure) {
730 # no need to reboot for just building.
731 if (!do_not_reboot) {
732 doprint "REBOOTING\n";
738 if (defined($test_name)) {
739 $name = " ($test_name)";
742 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
743 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
744 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
745 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
746 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
748 return 1 if (!defined($store_failures));
751 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
752 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
754 my $type = $build_type;
755 if ($type =~ /useconfig/) {
759 my $dir = "$machine-$test_type-$type-fail-$date";
760 my $faildir = "$store_failures/$dir";
764 die "can't create $faildir";
766 if (-f "$output_config") {
767 cp "$output_config", "$faildir/config" or
768 die "failed to copy .config";
771 cp $buildlog, "$faildir/buildlog" or
772 die "failed to move $buildlog";
775 cp $dmesg, "$faildir/dmesg" or
776 die "failed to move $dmesg";
779 doprint "*** Saved info to $faildir ***\n";
790 $command =~ s/\$SSH_USER/$ssh_user/g;
791 $command =~ s/\$MACHINE/$machine/g;
793 doprint("$command ... ");
795 $pid = open(CMD, "$command 2>&1 |") or
796 (fail "unable to exec $command" and return 0);
798 if (defined($opt{"LOG_FILE"})) {
799 open(LOG, ">>$opt{LOG_FILE}") or
800 dodie "failed to write to log";
804 if (defined($redirect)) {
805 open (RD, ">$redirect") or
806 dodie "failed to write to redirect $redirect";
811 print LOG if ($dolog);
819 close(LOG) if ($dolog);
820 close(RD) if ($dord);
833 my $cp_exec = $ssh_exec;
835 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
836 return run_command "$cp_exec";
840 my ($src, $dst) = @_;
841 my $cp_scp = $scp_to_target;
843 $cp_scp =~ s/\$SRC_FILE/$src/g;
844 $cp_scp =~ s/\$DST_FILE/$dst/g;
846 return run_command "$cp_scp";
851 if ($reboot_type ne "grub") {
854 return if (defined($grub_number));
856 doprint "Find grub menu ... ";
859 my $ssh_grub = $ssh_exec;
860 $ssh_grub =~ s,\$SSH_COMMAND,cat /boot/grub/menu.lst,g;
862 open(IN, "$ssh_grub |")
863 or die "unable to get menu.lst";
866 if (/^\s*title\s+$grub_menu\s*$/) {
869 } elsif (/^\s*title\s/) {
875 die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
876 if ($grub_number < 0);
877 doprint "$grub_number\n";
882 my ($fp, $time) = @_;
888 if (!defined($time)) {
893 vec($rin, fileno($fp), 1) = 1;
894 $ready = select($rin, undef, undef, $time);
898 # try to read one char at a time
899 while (sysread $fp, $ch, 1) {
901 last if ($ch eq "\n");
904 if (!length($line)) {
912 if ($reboot_type eq "grub") {
913 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch && reboot)'";
917 run_command "$reboot_script";
923 doprint "git rev-list --max-count=1 $commit ... ";
924 my $sha1 = `git rev-list --max-count=1 $commit`;
931 dodie "Failed to get git $commit";
944 my $skip_call_trace = 0;
952 open(DMESG, "> $dmesg") or
953 die "unable to write to $dmesg";
959 my $monitor_start = time;
961 my $version_found = 0;
965 if ($bug && defined($stop_after_failure) &&
966 $stop_after_failure >= 0) {
967 my $time = $stop_after_failure - (time - $failure_start);
968 $line = wait_for_input($monitor_fp, $time);
969 if (!defined($line)) {
970 doprint "bug timed out after $booted_timeout seconds\n";
971 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
975 $line = wait_for_input($monitor_fp, $booted_timeout);
976 if (!defined($line)) {
977 my $s = $booted_timeout == 1 ? "" : "s";
978 doprint "Successful boot found: break after $booted_timeout second$s\n";
982 $line = wait_for_input($monitor_fp);
983 if (!defined($line)) {
984 my $s = $timeout == 1 ? "" : "s";
985 doprint "Timed out after $timeout second$s\n";
993 # we are not guaranteed to get a full line
996 if ($full_line =~ /$success_line/) {
998 $success_start = time;
1001 if ($booted && defined($stop_after_success) &&
1002 $stop_after_success >= 0) {
1004 if ($now - $success_start >= $stop_after_success) {
1005 doprint "Test forced to stop after $stop_after_success seconds after success\n";
1010 if ($full_line =~ /\[ backtrace testing \]/) {
1011 $skip_call_trace = 1;
1014 if ($full_line =~ /call trace:/i) {
1015 if (!$bug && !$skip_call_trace) {
1017 $failure_start = time;
1021 if ($bug && defined($stop_after_failure) &&
1022 $stop_after_failure >= 0) {
1024 if ($now - $failure_start >= $stop_after_failure) {
1025 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1030 if ($full_line =~ /\[ end of backtrace testing \]/) {
1031 $skip_call_trace = 0;
1034 if ($full_line =~ /Kernel panic -/) {
1035 $failure_start = time;
1039 # Detect triple faults by testing the banner
1040 if ($full_line =~ /\bLinux version (\S+).*\n/) {
1041 if ($1 eq $version) {
1043 } elsif ($version_found && $detect_triplefault) {
1044 # We already booted into the kernel we are testing,
1045 # but now we booted into another kernel?
1046 # Consider this a triple fault.
1047 doprint "Aleady booted in Linux kernel $version, but now\n";
1048 doprint "we booted into Linux kernel $1.\n";
1049 doprint "Assuming that this is a triple fault.\n";
1050 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
1055 if ($line =~ /\n/) {
1059 if ($stop_test_after > 0 && !$booted && !$bug) {
1060 if (time - $monitor_start > $stop_test_after) {
1061 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
1070 return 0 if ($in_bisect);
1071 fail "failed - got a bug report" and return 0;
1075 return 0 if ($in_bisect);
1076 fail "failed - never got a boot prompt." and return 0;
1082 sub do_post_install {
1084 return if (!defined($post_install));
1086 my $cp_post_install = $post_install;
1087 $cp_post_install =~ s/\$KERNEL_VERSION/$version/g;
1088 run_command "$cp_post_install" or
1089 dodie "Failed to run post install";
1094 run_scp "$outputdir/$build_target", "$target_image" or
1095 dodie "failed to copy image";
1097 my $install_mods = 0;
1099 # should we process modules?
1101 open(IN, "$output_config") or dodie("Can't read config file");
1103 if (/CONFIG_MODULES(=y)?/) {
1104 $install_mods = 1 if (defined($1));
1110 if (!$install_mods) {
1112 doprint "No modules needed\n";
1116 run_command "$make INSTALL_MOD_PATH=$tmpdir modules_install" or
1117 dodie "Failed to install modules";
1119 my $modlib = "/lib/modules/$version";
1120 my $modtar = "ktest-mods.tar.bz2";
1122 run_ssh "rm -rf $modlib" or
1123 dodie "failed to remove old mods: $modlib";
1125 # would be nice if scp -r did not follow symbolic links
1126 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
1127 dodie "making tarball";
1129 run_scp "$tmpdir/$modtar", "/tmp" or
1130 dodie "failed to copy modules";
1132 unlink "$tmpdir/$modtar";
1134 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
1135 dodie "failed to tar modules";
1137 run_ssh "rm -f /tmp/$modtar";
1143 # get the release name
1144 doprint "$make kernelrelease ... ";
1145 $version = `$make kernelrelease | tail -1`;
1147 doprint "$version\n";
1150 sub start_monitor_and_boot {
1159 sub check_buildlog {
1162 my @files = `git show $patch | diffstat -l`;
1164 open(IN, "git show $patch |") or
1165 dodie "failed to show $patch";
1167 if (m,^--- a/(.*),) {
1169 $files[$#files] = $1;
1174 open(IN, $buildlog) or dodie "Can't open $buildlog";
1176 if (/^\s*(.*?):.*(warning|error)/) {
1178 foreach my $file (@files) {
1179 my $fullpath = "$builddir/$file";
1180 if ($file eq $err || $fullpath eq $err) {
1181 fail "$file built with warnings" and return 0;
1191 sub apply_min_config {
1192 my $outconfig = "$output_config.new";
1194 # Read the config file and remove anything that
1195 # is in the force_config hash (from minconfig and others)
1196 # then add the force config back.
1198 doprint "Applying minimum configurations into $output_config.new\n";
1200 open (OUT, ">$outconfig") or
1201 dodie "Can't create $outconfig";
1203 if (-f $output_config) {
1204 open (IN, $output_config) or
1205 dodie "Failed to open $output_config";
1207 if (/^(# )?(CONFIG_[^\s=]*)/) {
1208 next if (defined($force_config{$2}));
1214 foreach my $config (keys %force_config) {
1215 print OUT "$force_config{$config}\n";
1219 run_command "mv $outconfig $output_config";
1222 sub make_oldconfig {
1224 my @force_list = keys %force_config;
1226 if ($#force_list >= 0) {
1230 if (!run_command "$make oldnoconfig") {
1231 # Perhaps oldnoconfig doesn't exist in this version of the kernel
1232 # try a yes '' | oldconfig
1233 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
1234 run_command "yes '' | $make oldconfig" or
1235 dodie "failed make config oldconfig";
1239 # read a config file and use this to force new configs.
1240 sub load_force_config {
1243 open(IN, $config) or
1244 dodie "failed to read $config";
1247 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
1248 $force_config{$1} = $_;
1249 } elsif (/^# (CONFIG_\S*) is not set/) {
1250 $force_config{$1} = $_;
1261 if (defined($pre_build)) {
1262 my $ret = run_command $pre_build;
1263 if (!$ret && defined($pre_build_die) &&
1265 dodie "failed to pre_build\n";
1269 if ($type =~ /^useconfig:(.*)/) {
1270 run_command "cp $1 $output_config" or
1271 dodie "could not copy $1 to .config";
1273 $type = "oldconfig";
1276 # old config can ask questions
1277 if ($type eq "oldconfig") {
1278 $type = "oldnoconfig";
1280 # allow for empty configs
1281 run_command "touch $output_config";
1284 run_command "mv $output_config $outputdir/config_temp" or
1285 dodie "moving .config";
1287 run_command "$make mrproper" or dodie "make mrproper";
1289 run_command "mv $outputdir/config_temp $output_config" or
1290 dodie "moving config_temp";
1293 } elsif (!$noclean) {
1294 unlink "$output_config";
1295 run_command "$make mrproper" or
1296 dodie "make mrproper";
1299 # add something to distinguish this build
1300 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
1301 print OUT "$localversion\n";
1304 if (defined($minconfig)) {
1305 load_force_config($minconfig);
1308 if ($type ne "oldnoconfig") {
1309 run_command "$make $type" or
1310 dodie "failed make config";
1312 # Run old config regardless, to enforce min configurations
1315 $redirect = "$buildlog";
1316 my $build_ret = run_command "$make $build_options";
1319 if (defined($post_build)) {
1320 my $ret = run_command $post_build;
1321 if (!$ret && defined($post_build_die) &&
1323 dodie "failed to post_build\n";
1328 # bisect may need this to pass
1329 return 0 if ($in_bisect);
1330 fail "failed build" and return 0;
1337 if (!run_ssh "halt" or defined($power_off)) {
1338 if (defined($poweroff_after_halt)) {
1339 sleep $poweroff_after_halt;
1340 run_command "$power_off";
1344 run_command "$power_off";
1355 if (defined($test_name)) {
1356 $name = " ($test_name)";
1359 doprint "\n\n*******************************************\n";
1360 doprint "*******************************************\n";
1361 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
1362 doprint "*******************************************\n";
1363 doprint "*******************************************\n";
1365 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
1366 doprint "Reboot and wait $sleep_time seconds\n";
1373 doprint "Pass or fail? [p/f]";
1376 if ($ans eq "p" || $ans eq "P") {
1378 } elsif ($ans eq "f" || $ans eq "F") {
1381 print "Please answer 'P' or 'F'\n";
1386 sub child_run_test {
1389 # child should have no power
1390 $reboot_on_error = 0;
1391 $poweroff_on_error = 0;
1392 $die_on_failure = 1;
1394 run_command $run_test or $failed = 1;
1400 sub child_finished {
1413 doprint "run test $run_test\n";
1417 $SIG{CHLD} = qw(child_finished);
1421 child_run_test if (!$child_pid);
1426 $line = wait_for_input($monitor_fp, 1);
1427 if (defined($line)) {
1429 # we are not guaranteed to get a full line
1430 $full_line .= $line;
1433 if ($full_line =~ /call trace:/i) {
1437 if ($full_line =~ /Kernel panic -/) {
1441 if ($line =~ /\n/) {
1445 } while (!$child_done && !$bug);
1448 my $failure_start = time;
1451 $line = wait_for_input($monitor_fp, 1);
1452 if (defined($line)) {
1456 if ($now - $failure_start >= $stop_after_failure) {
1459 } while (defined($line));
1461 doprint "Detected kernel crash!\n";
1462 # kill the child with extreme prejudice
1466 waitpid $child_pid, 0;
1469 if ($bug || $child_exit) {
1470 return 0 if $in_bisect;
1471 fail "test failed" and return 0;
1476 sub run_git_bisect {
1479 doprint "$command ... ";
1481 my $output = `$command 2>&1`;
1488 dodie "Failed to git bisect";
1491 doprint "SUCCESS\n";
1492 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
1493 doprint "$1 [$2]\n";
1494 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
1496 doprint "Found bad commit... $1\n";
1499 # we already logged it, just print it now.
1507 doprint "Reboot and sleep $bisect_sleep_time seconds\n";
1508 reboot $bisect_sleep_time;
1511 # returns 1 on success, 0 on failure, -1 on skip
1512 sub run_bisect_test {
1513 my ($type, $buildtype) = @_;
1522 build $buildtype or $failed = 1;
1524 if ($type ne "build") {
1525 if ($failed && $bisect_skip) {
1529 dodie "Failed on build" if $failed;
1532 start_monitor_and_boot or $failed = 1;
1534 if ($type ne "boot") {
1535 if ($failed && $bisect_skip) {
1541 dodie "Failed on boot" if $failed;
1543 do_run_test or $failed = 1;
1554 # reboot the box to a kernel we can ssh to
1555 if ($type ne "build") {
1565 my $buildtype = "oldconfig";
1567 # We should have a minconfig to use?
1568 if (defined($minconfig)) {
1569 $buildtype = "useconfig:$minconfig";
1572 my $ret = run_bisect_test $type, $buildtype;
1574 if ($bisect_manual) {
1575 $ret = answer_bisect;
1578 # Are we looking for where it worked, not failed?
1579 if ($reverse_bisect) {
1585 } elsif ($ret == 0) {
1587 } elsif ($bisect_skip) {
1588 doprint "HIT A BAD COMMIT ... SKIPPING\n";
1598 die "BISECT_GOOD[$i] not defined\n" if (!defined($opt{"BISECT_GOOD[$i]"}));
1599 die "BISECT_BAD[$i] not defined\n" if (!defined($opt{"BISECT_BAD[$i]"}));
1600 die "BISECT_TYPE[$i] not defined\n" if (!defined($opt{"BISECT_TYPE[$i]"}));
1602 my $good = $opt{"BISECT_GOOD[$i]"};
1603 my $bad = $opt{"BISECT_BAD[$i]"};
1604 my $type = $opt{"BISECT_TYPE[$i]"};
1605 my $start = $opt{"BISECT_START[$i]"};
1606 my $replay = $opt{"BISECT_REPLAY[$i]"};
1607 my $start_files = $opt{"BISECT_FILES[$i]"};
1609 if (defined($start_files)) {
1610 $start_files = " -- " . $start_files;
1615 # convert to true sha1's
1616 $good = get_sha1($good);
1617 $bad = get_sha1($bad);
1619 if (defined($opt{"BISECT_REVERSE[$i]"}) &&
1620 $opt{"BISECT_REVERSE[$i]"} == 1) {
1621 doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
1622 $reverse_bisect = 1;
1624 $reverse_bisect = 0;
1627 # Can't have a test without having a test to run
1628 if ($type eq "test" && !defined($run_test)) {
1632 my $check = $opt{"BISECT_CHECK[$i]"};
1633 if (defined($check) && $check ne "0") {
1636 my $head = get_sha1("HEAD");
1638 if ($check ne "good") {
1639 doprint "TESTING BISECT BAD [$bad]\n";
1640 run_command "git checkout $bad" or
1641 die "Failed to checkout $bad";
1643 $result = run_bisect $type;
1645 if ($result ne "bad") {
1646 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
1650 if ($check ne "bad") {
1651 doprint "TESTING BISECT GOOD [$good]\n";
1652 run_command "git checkout $good" or
1653 die "Failed to checkout $good";
1655 $result = run_bisect $type;
1657 if ($result ne "good") {
1658 fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
1662 # checkout where we started
1663 run_command "git checkout $head" or
1664 die "Failed to checkout $head";
1667 run_command "git bisect start$start_files" or
1668 dodie "could not start bisect";
1670 run_command "git bisect good $good" or
1671 dodie "could not set bisect good to $good";
1673 run_git_bisect "git bisect bad $bad" or
1674 dodie "could not set bisect bad to $bad";
1676 if (defined($replay)) {
1677 run_command "git bisect replay $replay" or
1678 dodie "failed to run replay";
1681 if (defined($start)) {
1682 run_command "git checkout $start" or
1683 dodie "failed to checkout $start";
1688 $result = run_bisect $type;
1689 $test = run_git_bisect "git bisect $result";
1692 run_command "git bisect log" or
1693 dodie "could not capture git bisect log";
1695 run_command "git bisect reset" or
1696 dodie "could not reset git bisect";
1698 doprint "Bad commit was [$bisect_bad]\n";
1711 sub assign_configs {
1712 my ($hash, $config) = @_;
1715 or dodie "Failed to read $config";
1718 if (/^((CONFIG\S*)=.*)/) {
1726 sub process_config_ignore {
1729 assign_configs \%config_ignore, $config;
1732 sub read_current_config {
1733 my ($config_ref) = @_;
1735 %{$config_ref} = ();
1736 undef %{$config_ref};
1738 my @key = keys %{$config_ref};
1740 print "did not delete!\n";
1743 open (IN, "$output_config");
1746 if (/^(CONFIG\S+)=(.*)/) {
1747 ${$config_ref}{$1} = $2;
1753 sub get_dependencies {
1756 my $arr = $dependency{$config};
1757 if (!defined($arr)) {
1763 foreach my $dep (@{$arr}) {
1764 print "ADD DEP $dep\n";
1765 @deps = (@deps, get_dependencies $dep);
1774 open(OUT, ">$output_config") or dodie "Can not write to $output_config";
1776 foreach my $config (@configs) {
1777 print OUT "$config_set{$config}\n";
1778 my @deps = get_dependencies $config;
1779 foreach my $dep (@deps) {
1780 print OUT "$config_set{$dep}\n";
1784 foreach my $config (keys %config_ignore) {
1785 print OUT "$config_ignore{$config}\n";
1793 sub compare_configs {
1796 foreach my $item (keys %a) {
1797 if (!defined($b{$item})) {
1798 print "diff $item\n";
1806 print "diff2 $keys[0]\n";
1808 return -1 if ($#keys >= 0);
1813 sub run_config_bisect_test {
1816 return run_bisect_test $type, "oldconfig";
1819 sub process_passed {
1822 doprint "These configs had no failure: (Enabling them for further compiles)\n";
1823 # Passed! All these configs are part of a good compile.
1824 # Add them to the min options.
1825 foreach my $config (keys %configs) {
1826 if (defined($config_list{$config})) {
1827 doprint " removing $config\n";
1828 $config_ignore{$config} = $config_list{$config};
1829 delete $config_list{$config};
1832 doprint "config copied to $outputdir/config_good\n";
1833 run_command "cp -f $output_config $outputdir/config_good";
1836 sub process_failed {
1839 doprint "\n\n***************************************\n";
1840 doprint "Found bad config: $config\n";
1841 doprint "***************************************\n\n";
1844 sub run_config_bisect {
1846 my @start_list = keys %config_list;
1848 if ($#start_list < 0) {
1849 doprint "No more configs to test!!!\n";
1853 doprint "***** RUN TEST ***\n";
1854 my $type = $opt{"CONFIG_BISECT_TYPE[$iteration]"};
1858 my $count = $#start_list + 1;
1859 doprint " $count configs to test\n";
1861 my $half = int($#start_list / 2);
1864 my @tophalf = @start_list[0 .. $half];
1866 create_config @tophalf;
1867 read_current_config \%current_config;
1869 $count = $#tophalf + 1;
1870 doprint "Testing $count configs\n";
1872 # make sure we test something
1873 foreach my $config (@tophalf) {
1874 if (defined($current_config{$config})) {
1880 # try the other half
1881 doprint "Top half produced no set configs, trying bottom half\n";
1882 @tophalf = @start_list[$half + 1 .. $#start_list];
1883 create_config @tophalf;
1884 read_current_config \%current_config;
1885 foreach my $config (@tophalf) {
1886 if (defined($current_config{$config})) {
1892 doprint "Failed: Can't make new config with current configs\n";
1893 foreach my $config (@start_list) {
1894 doprint " CONFIG: $config\n";
1898 $count = $#tophalf + 1;
1899 doprint "Testing $count configs\n";
1902 $ret = run_config_bisect_test $type;
1903 if ($bisect_manual) {
1904 $ret = answer_bisect;
1907 process_passed %current_config;
1911 doprint "This config had a failure.\n";
1912 doprint "Removing these configs that were not set in this config:\n";
1913 doprint "config copied to $outputdir/config_bad\n";
1914 run_command "cp -f $output_config $outputdir/config_bad";
1916 # A config exists in this group that was bad.
1917 foreach my $config (keys %config_list) {
1918 if (!defined($current_config{$config})) {
1919 doprint " removing $config\n";
1920 delete $config_list{$config};
1924 @start_list = @tophalf;
1926 if ($#start_list == 0) {
1927 process_failed $start_list[0];
1931 # remove half the configs we are looking at and see if
1933 $half = int($#start_list / 2);
1934 } while ($#start_list > 0);
1936 # we found a single config, try it again unless we are running manually
1938 if ($bisect_manual) {
1939 process_failed $start_list[0];
1943 my @tophalf = @start_list[0 .. 0];
1945 $ret = run_config_bisect_test $type;
1947 process_passed %current_config;
1951 process_failed $start_list[0];
1958 my $start_config = $opt{"CONFIG_BISECT[$i]"};
1960 my $tmpconfig = "$tmpdir/use_config";
1962 if (defined($config_bisect_good)) {
1963 process_config_ignore $config_bisect_good;
1966 # Make the file with the bad config and the min config
1967 if (defined($minconfig)) {
1968 # read the min config for things to ignore
1969 run_command "cp $minconfig $tmpconfig" or
1970 dodie "failed to copy $minconfig to $tmpconfig";
1975 if (-f $tmpconfig) {
1976 load_force_config($tmpconfig);
1977 process_config_ignore $tmpconfig;
1980 # now process the start config
1981 run_command "cp $start_config $output_config" or
1982 dodie "failed to copy $start_config to $output_config";
1984 # read directly what we want to check
1986 open (IN, $output_config)
1987 or dodie "faied to open $output_config";
1990 if (/^((CONFIG\S*)=.*)/) {
1991 $config_check{$2} = $1;
1996 # Now run oldconfig with the minconfig
1999 # check to see what we lost (or gained)
2000 open (IN, $output_config)
2001 or dodie "Failed to read $start_config";
2003 my %removed_configs;
2007 if (/^((CONFIG\S*)=.*)/) {
2008 # save off all options
2009 $config_set{$2} = $1;
2010 if (defined($config_check{$2})) {
2011 if (defined($config_ignore{$2})) {
2012 $removed_configs{$2} = $1;
2014 $config_list{$2} = $1;
2016 } elsif (!defined($config_ignore{$2})) {
2017 $added_configs{$2} = $1;
2018 $config_list{$2} = $1;
2024 my @confs = keys %removed_configs;
2026 doprint "Configs overridden by default configs and removed from check:\n";
2027 foreach my $config (@confs) {
2028 doprint " $config\n";
2031 @confs = keys %added_configs;
2033 doprint "Configs appearing in make oldconfig and added:\n";
2034 foreach my $config (@confs) {
2035 doprint " $config\n";
2042 # Sometimes kconfig does weird things. We must make sure
2043 # that the config we autocreate has everything we need
2044 # to test, otherwise we may miss testing configs, or
2045 # may not be able to create a new config.
2046 # Here we create a config with everything set.
2047 create_config (keys %config_list);
2048 read_current_config \%config_test;
2049 foreach my $config (keys %config_list) {
2050 if (!defined($config_test{$config})) {
2053 doprint "Configs not produced by kconfig (will not be checked):\n";
2055 doprint " $config\n";
2056 delete $config_list{$config};
2061 $ret = run_config_bisect;
2064 return $ret if ($ret < 0);
2069 sub patchcheck_reboot {
2070 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
2071 reboot $patchcheck_sleep_time;
2077 die "PATCHCHECK_START[$i] not defined\n"
2078 if (!defined($opt{"PATCHCHECK_START[$i]"}));
2079 die "PATCHCHECK_TYPE[$i] not defined\n"
2080 if (!defined($opt{"PATCHCHECK_TYPE[$i]"}));
2082 my $start = $opt{"PATCHCHECK_START[$i]"};
2085 if (defined($opt{"PATCHCHECK_END[$i]"})) {
2086 $end = $opt{"PATCHCHECK_END[$i]"};
2089 # Get the true sha1's since we can use things like HEAD~3
2090 $start = get_sha1($start);
2091 $end = get_sha1($end);
2093 my $type = $opt{"PATCHCHECK_TYPE[$i]"};
2095 # Can't have a test without having a test to run
2096 if ($type eq "test" && !defined($run_test)) {
2100 open (IN, "git log --pretty=oneline $end|") or
2101 dodie "could not get git list";
2107 $list[$#list+1] = $_;
2108 last if (/^$start/);
2112 if ($list[$#list] !~ /^$start/) {
2113 fail "SHA1 $start not found";
2116 # go backwards in the list
2117 @list = reverse @list;
2119 my $save_clean = $noclean;
2120 my %ignored_warnings;
2122 if (defined($ignore_warnings)) {
2123 foreach my $sha1 (split /\s+/, $ignore_warnings) {
2124 $ignored_warnings{$sha1} = 1;
2129 foreach my $item (@list) {
2131 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
2133 doprint "\nProcessing commit $item\n\n";
2135 run_command "git checkout $sha1" or
2136 die "Failed to checkout $sha1";
2138 # only clean on the first and last patch
2139 if ($item eq $list[0] ||
2140 $item eq $list[$#list]) {
2141 $noclean = $save_clean;
2146 if (defined($minconfig)) {
2147 build "useconfig:$minconfig" or return 0;
2149 # ?? no config to use?
2150 build "oldconfig" or return 0;
2154 if (!defined($ignored_warnings{$sha1})) {
2155 check_buildlog $sha1 or return 0;
2158 next if ($type eq "build");
2162 start_monitor_and_boot or $failed = 1;
2164 if (!$failed && $type ne "boot"){
2165 do_run_test or $failed = 1;
2168 return 0 if ($failed);
2186 # taken from streamline_config.pl
2198 if (! -f $kconfig) {
2199 doprint "file $kconfig does not exist, skipping\n";
2203 open(KIN, "$kconfig")
2204 or die "Can't open $kconfig";
2208 # Make sure that lines ending with \ continue
2210 $_ = $line . " " . $_;
2221 # collect any Kconfig sources
2222 if (/^source\s*"(.*)"/) {
2223 $kconfigs[$#kconfigs+1] = $1;
2227 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
2231 for (my $i = 0; $i < $iflevel; $i++) {
2233 $depends{$config} .= " " . $ifdeps[$i];
2235 $depends{$config} = $ifdeps[$i];
2240 # collect the depends for the config
2241 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
2243 if (defined($depends{$1})) {
2244 $depends{$config} .= " " . $1;
2246 $depends{$config} = $1;
2249 # Get the configs that select this config
2250 } elsif ($state ne "NONE" && /^\s*select\s+(\S+)/) {
2251 if (defined($depends{$1})) {
2252 $depends{$1} .= " " . $config;
2254 $depends{$1} = $config;
2257 # Check for if statements
2258 } elsif (/^if\s+(.*\S)\s*$/) {
2260 # remove beginning and ending non text
2261 $deps =~ s/^[^a-zA-Z0-9_]*//;
2262 $deps =~ s/[^a-zA-Z0-9_]*$//;
2264 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
2266 $ifdeps[$iflevel++] = join ':', @deps;
2268 } elsif (/^endif/) {
2270 $iflevel-- if ($iflevel);
2273 } elsif (/^\s*help\s*$/) {
2279 # read in any configs that were found.
2280 foreach $kconfig (@kconfigs) {
2281 if (!defined($read_kconfigs{$kconfig})) {
2282 $read_kconfigs{$kconfig} = 1;
2283 read_kconfig("$builddir/$kconfig");
2289 # find out which arch this is by the kconfig file
2290 open (IN, $output_config)
2291 or dodie "Failed to read $output_config";
2294 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
2301 if (!defined($arch)) {
2302 doprint "Could not find arch from config file\n";
2303 doprint "no dependencies used\n";
2307 # arch is really the subarch, we need to know
2308 # what directory to look at.
2309 if ($arch eq "i386" || $arch eq "x86_64") {
2311 } elsif ($arch =~ /^tile/) {
2315 my $kconfig = "$builddir/arch/$arch/Kconfig";
2317 if (! -f $kconfig && $arch =~ /\d$/) {
2319 # some subarchs have numbers, truncate them
2321 $kconfig = "$builddir/arch/$arch/Kconfig";
2322 if (! -f $kconfig) {
2323 doprint "No idea what arch dir $orig is for\n";
2324 doprint "no dependencies used\n";
2329 read_kconfig($kconfig);
2332 sub read_config_list {
2336 or dodie "Failed to read $config";
2339 if (/^((CONFIG\S*)=.*)/) {
2340 if (!defined($config_ignore{$2})) {
2341 $config_list{$2} = $1;
2349 sub read_output_config {
2352 assign_configs \%config_ignore, $config;
2355 sub make_new_config {
2358 open (OUT, ">$output_config")
2359 or dodie "Failed to write $output_config";
2361 foreach my $config (@configs) {
2362 print OUT "$config\n";
2371 $kconfig =~ s/CONFIG_//;
2373 $dep = $depends{"$kconfig"};
2375 # the dep string we have saves the dependencies as they
2376 # were found, including expressions like ! && ||. We
2377 # want to split this out into just an array of configs.
2379 my $valid = "A-Za-z_0-9";
2383 while ($dep =~ /[$valid]/) {
2385 if ($dep =~ /^[^$valid]*([$valid]+)/) {
2386 my $conf = "CONFIG_" . $1;
2388 $configs[$#configs + 1] = $conf;
2390 $dep =~ s/^[^$valid]*[$valid]+//;
2392 die "this should never happen";
2402 my %processed_configs;
2403 my %nochange_config;
2405 sub test_this_config {
2410 # if we already processed this config, skip it
2411 if (defined($processed_configs{$config})) {
2414 $processed_configs{$config} = 1;
2416 # if this config failed during this round, skip it
2417 if (defined($nochange_config{$config})) {
2421 my $kconfig = $config;
2422 $kconfig =~ s/CONFIG_//;
2424 # Test dependencies first
2425 if (defined($depends{"$kconfig"})) {
2426 my @parents = get_depends $config;
2427 foreach my $parent (@parents) {
2428 # if the parent is in the min config, check it first
2429 next if (!defined($min_configs{$parent}));
2430 $found = test_this_config($parent);
2431 if (defined($found)) {
2437 # Remove this config from the list of configs
2438 # do a make oldnoconfig and then read the resulting
2439 # .config to make sure it is missing the config that
2441 my %configs = %min_configs;
2442 delete $configs{$config};
2443 make_new_config ((values %configs), (values %keep_configs));
2446 assign_configs \%configs, $output_config;
2448 return $config if (!defined($configs{$config}));
2450 doprint "disabling config $config did not change .config\n";
2452 $nochange_config{$config} = 1;
2457 sub make_min_config {
2460 if (!defined($output_minconfig)) {
2461 fail "OUTPUT_MIN_CONFIG not defined" and return;
2464 # If output_minconfig exists, and the start_minconfig
2465 # came from min_config, than ask if we should use
2467 if (-f $output_minconfig && !$start_minconfig_defined) {
2468 print "$output_minconfig exists\n";
2469 if (read_yn " Use it as minconfig?") {
2470 $start_minconfig = $output_minconfig;
2474 if (!defined($start_minconfig)) {
2475 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
2478 my $temp_config = "$tmpdir/temp_config";
2480 # First things first. We build an allnoconfig to find
2481 # out what the defaults are that we can't touch.
2482 # Some are selections, but we really can't handle selections.
2484 my $save_minconfig = $minconfig;
2487 run_command "$make allnoconfig" or return 0;
2491 process_config_ignore $output_config;
2493 undef %save_configs;
2496 if (defined($ignore_config)) {
2497 # make sure the file exists
2498 `touch $ignore_config`;
2499 assign_configs \%save_configs, $ignore_config;
2502 %keep_configs = %save_configs;
2504 doprint "Load initial configs from $start_minconfig\n";
2506 # Look at the current min configs, and save off all the
2507 # ones that were set via the allnoconfig
2508 assign_configs \%min_configs, $start_minconfig;
2510 my @config_keys = keys %min_configs;
2512 # Remove anything that was set by the make allnoconfig
2513 # we shouldn't need them as they get set for us anyway.
2514 foreach my $config (@config_keys) {
2515 # Remove anything in the ignore_config
2516 if (defined($keep_configs{$config})) {
2517 my $file = $ignore_config;
2518 $file =~ s,.*/(.*?)$,$1,;
2519 doprint "$config set by $file ... ignored\n";
2520 delete $min_configs{$config};
2523 # But make sure the settings are the same. If a min config
2524 # sets a selection, we do not want to get rid of it if
2525 # it is not the same as what we have. Just move it into
2527 if (defined($config_ignore{$config})) {
2528 if ($config_ignore{$config} ne $min_configs{$config}) {
2529 doprint "$config is in allnoconfig as '$config_ignore{$config}'";
2530 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
2531 $keep_configs{$config} = $min_configs{$config};
2533 doprint "$config set by allnoconfig ... ignored\n";
2535 delete $min_configs{$config};
2547 # Now disable each config one by one and do a make oldconfig
2548 # till we find a config that changes our list.
2550 # Put configs that did not modify the config at the end.
2551 my @test_configs = keys %min_configs;
2553 for (my $i = 0; $i < $#test_configs; $i++) {
2554 if (!defined($nochange_config{$test_configs[0]})) {
2558 # This config didn't change the .config last time.
2559 # Place it at the end
2560 my $config = shift @test_configs;
2561 push @test_configs, $config;
2564 # if every test config has failed to modify the .config file
2565 # in the past, then reset and start over.
2567 undef %nochange_config;
2570 undef %processed_configs;
2572 foreach my $config (@test_configs) {
2574 $found = test_this_config $config;
2576 last if (defined($found));
2578 # oh well, try another config
2581 if (!defined($found)) {
2582 # we could have failed due to the nochange_config hash
2583 # reset and try again
2585 undef %nochange_config;
2589 doprint "No more configs found that we can disable\n";
2597 doprint "Test with $config disabled\n";
2599 # set in_bisect to keep build and monitor from dieing
2604 start_monitor_and_boot or $failed = 1;
2610 doprint "$min_configs{$config} is needed to boot the box... keeping\n";
2611 # this config is needed, add it to the ignore list.
2612 $keep_configs{$config} = $min_configs{$config};
2613 $save_configs{$config} = $min_configs{$config};
2614 delete $min_configs{$config};
2616 # update new ignore configs
2617 if (defined($ignore_config)) {
2618 open (OUT, ">$temp_config")
2619 or die "Can't write to $temp_config";
2620 foreach my $config (keys %save_configs) {
2621 print OUT "$save_configs{$config}\n";
2624 run_command "mv $temp_config $ignore_config" or
2625 dodie "failed to copy update to $ignore_config";
2629 # We booted without this config, remove it from the minconfigs.
2630 doprint "$config is not needed, disabling\n";
2632 delete $min_configs{$config};
2634 # Also disable anything that is not enabled in this config
2636 assign_configs \%configs, $output_config;
2637 my @config_keys = keys %min_configs;
2638 foreach my $config (@config_keys) {
2639 if (!defined($configs{$config})) {
2640 doprint "$config is not set, disabling\n";
2641 delete $min_configs{$config};
2645 # Save off all the current mandidory configs
2646 open (OUT, ">$temp_config")
2647 or die "Can't write to $temp_config";
2648 foreach my $config (keys %keep_configs) {
2649 print OUT "$keep_configs{$config}\n";
2651 foreach my $config (keys %min_configs) {
2652 print OUT "$min_configs{$config}\n";
2656 run_command "mv $temp_config $output_minconfig" or
2657 dodie "failed to copy update to $output_minconfig";
2660 doprint "Reboot and wait $sleep_time seconds\n";
2668 $#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl config-file\n";
2671 $ktest_config = $ARGV[0];
2672 if (! -f $ktest_config) {
2673 print "$ktest_config does not exist.\n";
2674 if (!read_yn "Create it?") {
2679 $ktest_config = "ktest.conf";
2682 if (! -f $ktest_config) {
2683 open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
2685 # Generated by ktest.pl
2687 # Define each test with TEST_START
2688 # The config options below it will override the defaults
2696 read_config $ktest_config;
2698 if (defined($opt{"LOG_FILE"})) {
2699 $opt{"LOG_FILE"} = eval_option($opt{"LOG_FILE"}, -1);
2702 # Append any configs entered in manually to the config file.
2703 my @new_configs = keys %entered_configs;
2704 if ($#new_configs >= 0) {
2705 print "\nAppending entered in configs to $ktest_config\n";
2706 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
2707 foreach my $config (@new_configs) {
2708 print OUT "$config = $entered_configs{$config}\n";
2709 $opt{$config} = $entered_configs{$config};
2713 if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
2714 unlink $opt{"LOG_FILE"};
2717 doprint "\n\nSTARTING AUTOMATED TESTS\n\n";
2719 for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
2722 doprint "DEFAULT OPTIONS:\n";
2724 doprint "\nTEST $i OPTIONS";
2725 if (defined($repeat_tests{$i})) {
2726 $repeat = $repeat_tests{$i};
2727 doprint " ITERATE $repeat";
2732 foreach my $option (sort keys %opt) {
2734 if ($option =~ /\[(\d+)\]$/) {
2740 doprint "$option = $opt{$option}\n";
2744 sub __set_test_option {
2745 my ($name, $i) = @_;
2747 my $option = "$name\[$i\]";
2749 if (defined($opt{$option})) {
2750 return $opt{$option};
2753 foreach my $test (keys %repeat_tests) {
2755 $i < $test + $repeat_tests{$test}) {
2756 $option = "$name\[$test\]";
2757 if (defined($opt{$option})) {
2758 return $opt{$option};
2763 if (defined($opt{$name})) {
2770 sub set_test_option {
2771 my ($name, $i) = @_;
2773 my $option = __set_test_option($name, $i);
2774 return $option if (!defined($option));
2776 return eval_option($option, $i);
2779 # First we need to do is the builds
2780 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
2784 my $makecmd = set_test_option("MAKE_CMD", $i);
2786 $machine = set_test_option("MACHINE", $i);
2787 $ssh_user = set_test_option("SSH_USER", $i);
2788 $tmpdir = set_test_option("TMP_DIR", $i);
2789 $outputdir = set_test_option("OUTPUT_DIR", $i);
2790 $builddir = set_test_option("BUILD_DIR", $i);
2791 $test_type = set_test_option("TEST_TYPE", $i);
2792 $build_type = set_test_option("BUILD_TYPE", $i);
2793 $build_options = set_test_option("BUILD_OPTIONS", $i);
2794 $pre_build = set_test_option("PRE_BUILD", $i);
2795 $post_build = set_test_option("POST_BUILD", $i);
2796 $pre_build_die = set_test_option("PRE_BUILD_DIE", $i);
2797 $post_build_die = set_test_option("POST_BUILD_DIE", $i);
2798 $power_cycle = set_test_option("POWER_CYCLE", $i);
2799 $reboot = set_test_option("REBOOT", $i);
2800 $noclean = set_test_option("BUILD_NOCLEAN", $i);
2801 $minconfig = set_test_option("MIN_CONFIG", $i);
2802 $output_minconfig = set_test_option("OUTPUT_MIN_CONFIG", $i);
2803 $start_minconfig = set_test_option("START_MIN_CONFIG", $i);
2804 $ignore_config = set_test_option("IGNORE_CONFIG", $i);
2805 $run_test = set_test_option("TEST", $i);
2806 $addconfig = set_test_option("ADD_CONFIG", $i);
2807 $reboot_type = set_test_option("REBOOT_TYPE", $i);
2808 $grub_menu = set_test_option("GRUB_MENU", $i);
2809 $post_install = set_test_option("POST_INSTALL", $i);
2810 $reboot_script = set_test_option("REBOOT_SCRIPT", $i);
2811 $reboot_on_error = set_test_option("REBOOT_ON_ERROR", $i);
2812 $poweroff_on_error = set_test_option("POWEROFF_ON_ERROR", $i);
2813 $die_on_failure = set_test_option("DIE_ON_FAILURE", $i);
2814 $power_off = set_test_option("POWER_OFF", $i);
2815 $powercycle_after_reboot = set_test_option("POWERCYCLE_AFTER_REBOOT", $i);
2816 $poweroff_after_halt = set_test_option("POWEROFF_AFTER_HALT", $i);
2817 $sleep_time = set_test_option("SLEEP_TIME", $i);
2818 $bisect_sleep_time = set_test_option("BISECT_SLEEP_TIME", $i);
2819 $patchcheck_sleep_time = set_test_option("PATCHCHECK_SLEEP_TIME", $i);
2820 $ignore_warnings = set_test_option("IGNORE_WARNINGS", $i);
2821 $bisect_manual = set_test_option("BISECT_MANUAL", $i);
2822 $bisect_skip = set_test_option("BISECT_SKIP", $i);
2823 $config_bisect_good = set_test_option("CONFIG_BISECT_GOOD", $i);
2824 $store_failures = set_test_option("STORE_FAILURES", $i);
2825 $test_name = set_test_option("TEST_NAME", $i);
2826 $timeout = set_test_option("TIMEOUT", $i);
2827 $booted_timeout = set_test_option("BOOTED_TIMEOUT", $i);
2828 $console = set_test_option("CONSOLE", $i);
2829 $detect_triplefault = set_test_option("DETECT_TRIPLE_FAULT", $i);
2830 $success_line = set_test_option("SUCCESS_LINE", $i);
2831 $stop_after_success = set_test_option("STOP_AFTER_SUCCESS", $i);
2832 $stop_after_failure = set_test_option("STOP_AFTER_FAILURE", $i);
2833 $stop_test_after = set_test_option("STOP_TEST_AFTER", $i);
2834 $build_target = set_test_option("BUILD_TARGET", $i);
2835 $ssh_exec = set_test_option("SSH_EXEC", $i);
2836 $scp_to_target = set_test_option("SCP_TO_TARGET", $i);
2837 $target_image = set_test_option("TARGET_IMAGE", $i);
2838 $localversion = set_test_option("LOCALVERSION", $i);
2840 $start_minconfig_defined = 1;
2842 if (!defined($start_minconfig)) {
2843 $start_minconfig_defined = 0;
2844 $start_minconfig = $minconfig;
2847 chdir $builddir || die "can't change directory to $builddir";
2849 foreach my $dir ($tmpdir, $outputdir) {
2852 die "can't create $dir";
2856 $ENV{"SSH_USER"} = $ssh_user;
2857 $ENV{"MACHINE"} = $machine;
2859 $target = "$ssh_user\@$machine";
2861 $buildlog = "$tmpdir/buildlog-$machine";
2862 $dmesg = "$tmpdir/dmesg-$machine";
2863 $make = "$makecmd O=$outputdir";
2864 $output_config = "$outputdir/.config";
2866 if ($reboot_type eq "grub") {
2867 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
2868 } elsif (!defined($reboot_script)) {
2869 dodie "REBOOT_SCRIPT not defined"
2872 my $run_type = $build_type;
2873 if ($test_type eq "patchcheck") {
2874 $run_type = $opt{"PATCHCHECK_TYPE[$i]"};
2875 } elsif ($test_type eq "bisect") {
2876 $run_type = $opt{"BISECT_TYPE[$i]"};
2877 } elsif ($test_type eq "config_bisect") {
2878 $run_type = $opt{"CONFIG_BISECT_TYPE[$i]"};
2881 if ($test_type eq "make_min_config") {
2885 # mistake in config file?
2886 if (!defined($run_type)) {
2887 $run_type = "ERROR";
2891 doprint "RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type\n\n";
2896 if (defined($addconfig)) {
2897 my $min = $minconfig;
2898 if (!defined($minconfig)) {
2901 run_command "cat $addconfig $min > $tmpdir/add_config" or
2902 dodie "Failed to create temp config";
2903 $minconfig = "$tmpdir/add_config";
2906 my $checkout = $opt{"CHECKOUT[$i]"};
2907 if (defined($checkout)) {
2908 run_command "git checkout $checkout" or
2909 die "failed to checkout $checkout";
2912 if ($test_type eq "bisect") {
2915 } elsif ($test_type eq "config_bisect") {
2918 } elsif ($test_type eq "patchcheck") {
2921 } elsif ($test_type eq "make_min_config") {
2926 if ($build_type ne "nobuild") {
2927 build $build_type or next;
2930 if ($test_type eq "install") {
2937 if ($test_type ne "build") {
2939 start_monitor_and_boot or $failed = 1;
2941 if (!$failed && $test_type ne "boot" && defined($run_test)) {
2942 do_run_test or $failed = 1;
2951 if ($opt{"POWEROFF_ON_SUCCESS"}) {
2953 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot) {
2957 doprint "\n $successes of $opt{NUM_TESTS} tests were successful\n\n";