Loading...
1#!/usr/bin/perl -w
2#
3# Copyright 2010 - Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
4# Licensed under the terms of the GNU GPL License version 2
5#
6
7use strict;
8use IPC::Open2;
9use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
10use File::Path qw(mkpath);
11use File::Copy qw(cp);
12use FileHandle;
13
14my $VERSION = "0.2";
15
16$| = 1;
17
18my %opt;
19my %repeat_tests;
20my %repeats;
21my %default;
22
23#default opts
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";
54
55my $ktest_config;
56my $version;
57my $machine;
58my $ssh_user;
59my $tmpdir;
60my $builddir;
61my $outputdir;
62my $output_config;
63my $test_type;
64my $build_type;
65my $build_options;
66my $pre_build;
67my $post_build;
68my $pre_build_die;
69my $post_build_die;
70my $reboot_type;
71my $reboot_script;
72my $power_cycle;
73my $reboot;
74my $reboot_on_error;
75my $poweroff_on_error;
76my $die_on_failure;
77my $powercycle_after_reboot;
78my $poweroff_after_halt;
79my $ssh_exec;
80my $scp_to_target;
81my $power_off;
82my $grub_menu;
83my $grub_number;
84my $target;
85my $make;
86my $post_install;
87my $noclean;
88my $minconfig;
89my $start_minconfig;
90my $start_minconfig_defined;
91my $output_minconfig;
92my $ignore_config;
93my $addconfig;
94my $in_bisect = 0;
95my $bisect_bad = "";
96my $reverse_bisect;
97my $bisect_manual;
98my $bisect_skip;
99my $config_bisect_good;
100my $in_patchcheck = 0;
101my $run_test;
102my $redirect;
103my $buildlog;
104my $dmesg;
105my $monitor_fp;
106my $monitor_pid;
107my $monitor_cnt = 0;
108my $sleep_time;
109my $bisect_sleep_time;
110my $patchcheck_sleep_time;
111my $ignore_warnings;
112my $store_failures;
113my $test_name;
114my $timeout;
115my $booted_timeout;
116my $detect_triplefault;
117my $console;
118my $success_line;
119my $stop_after_success;
120my $stop_after_failure;
121my $stop_test_after;
122my $build_target;
123my $target_image;
124my $localversion;
125my $iteration = 0;
126my $successes = 0;
127
128my %entered_configs;
129my %config_help;
130my %variable;
131my %force_config;
132
133$config_help{"MACHINE"} = << "EOF"
134 The machine hostname that you will test.
135EOF
136 ;
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)
140EOF
141 ;
142$config_help{"BUILD_DIR"} = << "EOF"
143 The directory that contains the Linux source code (full path).
144EOF
145 ;
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)
149EOF
150 ;
151$config_help{"BUILD_TARGET"} = << "EOF"
152 The location of the compiled file to copy to the target.
153 (relative to OUTPUT_DIR)
154EOF
155 ;
156$config_help{"TARGET_IMAGE"} = << "EOF"
157 The place to put your image on the test machine.
158EOF
159 ;
160$config_help{"POWER_CYCLE"} = << "EOF"
161 A script or command to reboot the box.
162
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'
165
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
169EOF
170 ;
171$config_help{"CONSOLE"} = << "EOF"
172 The script or command that reads the console
173
174 If you use ttywatch server, something like the following would work.
175CONSOLE = nc -d localhost 3001
176
177 For a virtual machine with guest name "Guest".
178CONSOLE = virsh console Guest
179EOF
180 ;
181$config_help{"LOCALVERSION"} = << "EOF"
182 Required version ending to differentiate the test
183 from other linux builds on the system.
184EOF
185 ;
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".
189
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.
195
196 The entry in /boot/grub/menu.lst must be entered in manually.
197 The test will not modify that file.
198EOF
199 ;
200$config_help{"GRUB_MENU"} = << "EOF"
201 The grub title name for the test kernel to boot
202 (Only mandatory if REBOOT_TYPE = grub)
203
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
207 reboot into.
208
209 For example, if in the /boot/grub/menu.lst the test kernel title has:
210 title Test Kernel
211 kernel vmlinuz-test
212 GRUB_MENU = Test Kernel
213EOF
214 ;
215$config_help{"REBOOT_SCRIPT"} = << "EOF"
216 A script to reboot the target into the test kernel
217 (Only mandatory if REBOOT_TYPE = script)
218EOF
219 ;
220
221sub read_yn {
222 my ($prompt) = @_;
223
224 my $ans;
225
226 for (;;) {
227 print "$prompt [Y/n] ";
228 $ans = <STDIN>;
229 chomp $ans;
230 if ($ans =~ /^\s*$/) {
231 $ans = "y";
232 }
233 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
234 print "Please answer either 'y' or 'n'.\n";
235 }
236 if ($ans !~ /^y$/i) {
237 return 0;
238 }
239 return 1;
240}
241
242sub get_ktest_config {
243 my ($config) = @_;
244
245 return if (defined($opt{$config}));
246
247 if (defined($config_help{$config})) {
248 print "\n";
249 print $config_help{$config};
250 }
251
252 for (;;) {
253 print "$config = ";
254 if (defined($default{$config})) {
255 print "\[$default{$config}\] ";
256 }
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};
262 } else {
263 print "Your answer can not be blank\n";
264 next;
265 }
266 }
267 last;
268 }
269}
270
271sub 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");
281
282 my $rtype = $opt{"REBOOT_TYPE"};
283
284 if (!defined($rtype)) {
285 if (!defined($opt{"GRUB_MENU"})) {
286 get_ktest_config("REBOOT_TYPE");
287 $rtype = $entered_configs{"REBOOT_TYPE"};
288 } else {
289 $rtype = "grub";
290 }
291 }
292
293 if ($rtype eq "grub") {
294 get_ktest_config("GRUB_MENU");
295 } else {
296 get_ktest_config("REBOOT_SCRIPT");
297 }
298}
299
300sub process_variables {
301 my ($value) = @_;
302 my $retval = "";
303
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.
309 $value = " $value";
310
311 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
312 my $begin = $1;
313 my $var = $2;
314 my $end = $3;
315 # append beginning of value to retval
316 $retval = "$retval$begin";
317 if (defined($variable{$var})) {
318 $retval = "$retval$variable{$var}";
319 } else {
320 # put back the origin piece.
321 $retval = "$retval\$\{$var\}";
322 }
323 $value = $end;
324 }
325 $retval = "$retval$value";
326
327 # remove the space added in the beginning
328 $retval =~ s/ //;
329
330 return "$retval"
331}
332
333sub set_value {
334 my ($lvalue, $rvalue) = @_;
335
336 if (defined($opt{$lvalue})) {
337 die "Error: Option $lvalue defined more than once!\n";
338 }
339 if ($rvalue =~ /^\s*$/) {
340 delete $opt{$lvalue};
341 } else {
342 $rvalue = process_variables($rvalue);
343 $opt{$lvalue} = $rvalue;
344 }
345}
346
347sub set_variable {
348 my ($lvalue, $rvalue) = @_;
349
350 if ($rvalue =~ /^\s*$/) {
351 delete $variable{$lvalue};
352 } else {
353 $rvalue = process_variables($rvalue);
354 $variable{$lvalue} = $rvalue;
355 }
356}
357
358sub read_config {
359 my ($config) = @_;
360
361 open(IN, $config) || die "can't read file $config";
362
363 my $name = $config;
364 $name =~ s,.*/(.*),$1,;
365
366 my $test_num = 0;
367 my $default = 1;
368 my $repeat = 1;
369 my $num_tests_set = 0;
370 my $skip = 0;
371 my $rest;
372 my $test_case = 0;
373
374 while (<IN>) {
375
376 # ignore blank lines and comments
377 next if (/^\s*$/ || /\s*\#/);
378
379 if (/^\s*TEST_START(.*)/) {
380
381 $rest = $1;
382
383 if ($num_tests_set) {
384 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
385 }
386
387 my $old_test_num = $test_num;
388 my $old_repeat = $repeat;
389
390 $test_num += $repeat;
391 $default = 0;
392 $repeat = 1;
393
394 if ($rest =~ /\s+SKIP(.*)/) {
395 $rest = $1;
396 $skip = 1;
397 } else {
398 $test_case = 1;
399 $skip = 0;
400 }
401
402 if ($rest =~ /\s+ITERATE\s+(\d+)(.*)$/) {
403 $repeat = $1;
404 $rest = $2;
405 $repeat_tests{"$test_num"} = $repeat;
406 }
407
408 if ($rest =~ /\s+SKIP(.*)/) {
409 $rest = $1;
410 $skip = 1;
411 }
412
413 if ($rest !~ /^\s*$/) {
414 die "$name: $.: Gargbage found after TEST_START\n$_";
415 }
416
417 if ($skip) {
418 $test_num = $old_test_num;
419 $repeat = $old_repeat;
420 }
421
422 } elsif (/^\s*DEFAULTS(.*)$/) {
423 $default = 1;
424
425 $rest = $1;
426
427 if ($rest =~ /\s+SKIP(.*)/) {
428 $rest = $1;
429 $skip = 1;
430 } else {
431 $skip = 0;
432 }
433
434 if ($rest !~ /^\s*$/) {
435 die "$name: $.: Gargbage found after DEFAULTS\n$_";
436 }
437
438 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
439
440 next if ($skip);
441
442 my $lvalue = $1;
443 my $rvalue = $2;
444
445 if (!$default &&
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";
450 }
451
452 if ($lvalue eq "NUM_TESTS") {
453 if ($test_num) {
454 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
455 }
456 if (!$default) {
457 die "$name: $.: NUM_TESTS must be set in default section\n";
458 }
459 $num_tests_set = 1;
460 }
461
462 if ($default || $lvalue =~ /\[\d+\]$/) {
463 set_value($lvalue, $rvalue);
464 } else {
465 my $val = "$lvalue\[$test_num\]";
466 set_value($val, $rvalue);
467
468 if ($repeat > 1) {
469 $repeats{$val} = $repeat;
470 }
471 }
472 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
473 next if ($skip);
474
475 my $lvalue = $1;
476 my $rvalue = $2;
477
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
485 # the prevous one.
486 set_variable($lvalue, $rvalue);
487
488 } else {
489 die "$name: $.: Garbage found in config\n$_";
490 }
491 }
492
493 close(IN);
494
495 if ($test_num) {
496 $test_num += $repeat - 1;
497 $opt{"NUM_TESTS"} = $test_num;
498 }
499
500 # make sure we have all mandatory configs
501 get_ktest_configs;
502
503 # was a test specified?
504 if (!$test_case) {
505 print "No test case specified.\n";
506 print "What test case would you like to run?\n";
507 my $ans = <STDIN>;
508 chomp $ans;
509 $default{"TEST_TYPE"} = $ans;
510 }
511
512 # set any defaults
513
514 foreach my $default (keys %default) {
515 if (!defined($opt{$default})) {
516 $opt{$default} = $default{$default};
517 }
518 }
519}
520
521sub __eval_option {
522 my ($option, $i) = @_;
523
524 # Add space to evaluate the character before $
525 $option = " $option";
526 my $retval = "";
527
528 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
529 my $start = $1;
530 my $var = $2;
531 my $end = $3;
532
533 # Append beginning of line
534 $retval = "$retval$start";
535
536 # If the iteration option OPT[$i] exists, then use that.
537 # otherwise see if the default OPT (without [$i]) exists.
538
539 my $o = "$var\[$i\]";
540
541 if (defined($opt{$o})) {
542 $o = $opt{$o};
543 $retval = "$retval$o";
544 } elsif (defined($opt{$var})) {
545 $o = $opt{$var};
546 $retval = "$retval$o";
547 } else {
548 $retval = "$retval\$\{$var\}";
549 }
550
551 $option = $end;
552 }
553
554 $retval = "$retval$option";
555
556 $retval =~ s/^ //;
557
558 return $retval;
559}
560
561sub eval_option {
562 my ($option, $i) = @_;
563
564 my $prev = "";
565
566 # Since an option can evaluate to another option,
567 # keep iterating until we do not evaluate any more
568 # options.
569 my $r = 0;
570 while ($prev ne $option) {
571 # Check for recursive evaluations.
572 # 100 deep should be more than enough.
573 if ($r++ > 100) {
574 die "Over 100 evaluations accurred with $option\n" .
575 "Check for recursive variables\n";
576 }
577 $prev = $option;
578 $option = __eval_option($option, $i);
579 }
580
581 return $option;
582}
583
584sub _logit {
585 if (defined($opt{"LOG_FILE"})) {
586 open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
587 print OUT @_;
588 close(OUT);
589 }
590}
591
592sub logit {
593 if (defined($opt{"LOG_FILE"})) {
594 _logit @_;
595 } else {
596 print @_;
597 }
598}
599
600sub doprint {
601 print @_;
602 _logit @_;
603}
604
605sub run_command;
606
607sub reboot {
608 # try to reboot normally
609 if (run_command $reboot) {
610 if (defined($powercycle_after_reboot)) {
611 sleep $powercycle_after_reboot;
612 run_command "$power_cycle";
613 }
614 } else {
615 # nope? power cycle it.
616 run_command "$power_cycle";
617 }
618}
619
620sub do_not_reboot {
621 my $i = $iteration;
622
623 return $test_type eq "build" ||
624 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
625 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
626}
627
628sub dodie {
629 doprint "CRITICAL FAILURE... ", @_, "\n";
630
631 my $i = $iteration;
632
633 if ($reboot_on_error && !do_not_reboot) {
634
635 doprint "REBOOTING\n";
636 reboot;
637
638 } elsif ($poweroff_on_error && defined($power_off)) {
639 doprint "POWERING OFF\n";
640 `$power_off`;
641 }
642
643 if (defined($opt{"LOG_FILE"})) {
644 print " See $opt{LOG_FILE} for more info.\n";
645 }
646
647 die @_, "\n";
648}
649
650sub open_console {
651 my ($fp) = @_;
652
653 my $flags;
654
655 my $pid = open($fp, "$console|") or
656 dodie "Can't open console $console";
657
658 $flags = fcntl($fp, F_GETFL, 0) or
659 dodie "Can't get flags for the socket: $!";
660 $flags = fcntl($fp, F_SETFL, $flags | O_NONBLOCK) or
661 dodie "Can't set flags for the socket: $!";
662
663 return $pid;
664}
665
666sub close_console {
667 my ($fp, $pid) = @_;
668
669 doprint "kill child process $pid\n";
670 kill 2, $pid;
671
672 print "closing!\n";
673 close($fp);
674}
675
676sub start_monitor {
677 if ($monitor_cnt++) {
678 return;
679 }
680 $monitor_fp = \*MONFD;
681 $monitor_pid = open_console $monitor_fp;
682
683 return;
684
685 open(MONFD, "Stop perl from warning about single use of MONFD");
686}
687
688sub end_monitor {
689 if (--$monitor_cnt) {
690 return;
691 }
692 close_console($monitor_fp, $monitor_pid);
693}
694
695sub wait_for_monitor {
696 my ($time) = @_;
697 my $line;
698
699 doprint "** Wait for monitor to settle down **\n";
700
701 # read the monitor and wait for the system to calm down
702 do {
703 $line = wait_for_input($monitor_fp, $time);
704 print "$line" if (defined($line));
705 } while (defined($line));
706 print "** Monitor flushed **\n";
707}
708
709sub fail {
710
711 if ($die_on_failure) {
712 dodie @_;
713 }
714
715 doprint "FAILED\n";
716
717 my $i = $iteration;
718
719 # no need to reboot for just building.
720 if (!do_not_reboot) {
721 doprint "REBOOTING\n";
722 reboot;
723 start_monitor;
724 wait_for_monitor $sleep_time;
725 end_monitor;
726 }
727
728 my $name = "";
729
730 if (defined($test_name)) {
731 $name = " ($test_name)";
732 }
733
734 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
735 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
736 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
737 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
738 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
739
740 return 1 if (!defined($store_failures));
741
742 my @t = localtime;
743 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
744 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
745
746 my $type = $build_type;
747 if ($type =~ /useconfig/) {
748 $type = "useconfig";
749 }
750
751 my $dir = "$machine-$test_type-$type-fail-$date";
752 my $faildir = "$store_failures/$dir";
753
754 if (!-d $faildir) {
755 mkpath($faildir) or
756 die "can't create $faildir";
757 }
758 if (-f "$output_config") {
759 cp "$output_config", "$faildir/config" or
760 die "failed to copy .config";
761 }
762 if (-f $buildlog) {
763 cp $buildlog, "$faildir/buildlog" or
764 die "failed to move $buildlog";
765 }
766 if (-f $dmesg) {
767 cp $dmesg, "$faildir/dmesg" or
768 die "failed to move $dmesg";
769 }
770
771 doprint "*** Saved info to $faildir ***\n";
772
773 return 1;
774}
775
776sub run_command {
777 my ($command) = @_;
778 my $dolog = 0;
779 my $dord = 0;
780 my $pid;
781
782 $command =~ s/\$SSH_USER/$ssh_user/g;
783 $command =~ s/\$MACHINE/$machine/g;
784
785 doprint("$command ... ");
786
787 $pid = open(CMD, "$command 2>&1 |") or
788 (fail "unable to exec $command" and return 0);
789
790 if (defined($opt{"LOG_FILE"})) {
791 open(LOG, ">>$opt{LOG_FILE}") or
792 dodie "failed to write to log";
793 $dolog = 1;
794 }
795
796 if (defined($redirect)) {
797 open (RD, ">$redirect") or
798 dodie "failed to write to redirect $redirect";
799 $dord = 1;
800 }
801
802 while (<CMD>) {
803 print LOG if ($dolog);
804 print RD if ($dord);
805 }
806
807 waitpid($pid, 0);
808 my $failed = $?;
809
810 close(CMD);
811 close(LOG) if ($dolog);
812 close(RD) if ($dord);
813
814 if ($failed) {
815 doprint "FAILED!\n";
816 } else {
817 doprint "SUCCESS\n";
818 }
819
820 return !$failed;
821}
822
823sub run_ssh {
824 my ($cmd) = @_;
825 my $cp_exec = $ssh_exec;
826
827 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
828 return run_command "$cp_exec";
829}
830
831sub run_scp {
832 my ($src, $dst) = @_;
833 my $cp_scp = $scp_to_target;
834
835 $cp_scp =~ s/\$SRC_FILE/$src/g;
836 $cp_scp =~ s/\$DST_FILE/$dst/g;
837
838 return run_command "$cp_scp";
839}
840
841sub get_grub_index {
842
843 if ($reboot_type ne "grub") {
844 return;
845 }
846 return if (defined($grub_number));
847
848 doprint "Find grub menu ... ";
849 $grub_number = -1;
850
851 my $ssh_grub = $ssh_exec;
852 $ssh_grub =~ s,\$SSH_COMMAND,cat /boot/grub/menu.lst,g;
853
854 open(IN, "$ssh_grub |")
855 or die "unable to get menu.lst";
856
857 while (<IN>) {
858 if (/^\s*title\s+$grub_menu\s*$/) {
859 $grub_number++;
860 last;
861 } elsif (/^\s*title\s/) {
862 $grub_number++;
863 }
864 }
865 close(IN);
866
867 die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
868 if ($grub_number < 0);
869 doprint "$grub_number\n";
870}
871
872sub wait_for_input
873{
874 my ($fp, $time) = @_;
875 my $rin;
876 my $ready;
877 my $line;
878 my $ch;
879
880 if (!defined($time)) {
881 $time = $timeout;
882 }
883
884 $rin = '';
885 vec($rin, fileno($fp), 1) = 1;
886 $ready = select($rin, undef, undef, $time);
887
888 $line = "";
889
890 # try to read one char at a time
891 while (sysread $fp, $ch, 1) {
892 $line .= $ch;
893 last if ($ch eq "\n");
894 }
895
896 if (!length($line)) {
897 return undef;
898 }
899
900 return $line;
901}
902
903sub reboot_to {
904 if ($reboot_type eq "grub") {
905 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch && reboot)'";
906 return;
907 }
908
909 run_command "$reboot_script";
910}
911
912sub get_sha1 {
913 my ($commit) = @_;
914
915 doprint "git rev-list --max-count=1 $commit ... ";
916 my $sha1 = `git rev-list --max-count=1 $commit`;
917 my $ret = $?;
918
919 logit $sha1;
920
921 if ($ret) {
922 doprint "FAILED\n";
923 dodie "Failed to get git $commit";
924 }
925
926 print "SUCCESS\n";
927
928 chomp $sha1;
929
930 return $sha1;
931}
932
933sub monitor {
934 my $booted = 0;
935 my $bug = 0;
936 my $skip_call_trace = 0;
937 my $loops;
938
939 wait_for_monitor 5;
940
941 my $line;
942 my $full_line = "";
943
944 open(DMESG, "> $dmesg") or
945 die "unable to write to $dmesg";
946
947 reboot_to;
948
949 my $success_start;
950 my $failure_start;
951 my $monitor_start = time;
952 my $done = 0;
953 my $version_found = 0;
954
955 while (!$done) {
956
957 if ($bug && defined($stop_after_failure) &&
958 $stop_after_failure >= 0) {
959 my $time = $stop_after_failure - (time - $failure_start);
960 $line = wait_for_input($monitor_fp, $time);
961 if (!defined($line)) {
962 doprint "bug timed out after $booted_timeout seconds\n";
963 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
964 last;
965 }
966 } elsif ($booted) {
967 $line = wait_for_input($monitor_fp, $booted_timeout);
968 if (!defined($line)) {
969 my $s = $booted_timeout == 1 ? "" : "s";
970 doprint "Successful boot found: break after $booted_timeout second$s\n";
971 last;
972 }
973 } else {
974 $line = wait_for_input($monitor_fp);
975 if (!defined($line)) {
976 my $s = $timeout == 1 ? "" : "s";
977 doprint "Timed out after $timeout second$s\n";
978 last;
979 }
980 }
981
982 doprint $line;
983 print DMESG $line;
984
985 # we are not guaranteed to get a full line
986 $full_line .= $line;
987
988 if ($full_line =~ /$success_line/) {
989 $booted = 1;
990 $success_start = time;
991 }
992
993 if ($booted && defined($stop_after_success) &&
994 $stop_after_success >= 0) {
995 my $now = time;
996 if ($now - $success_start >= $stop_after_success) {
997 doprint "Test forced to stop after $stop_after_success seconds after success\n";
998 last;
999 }
1000 }
1001
1002 if ($full_line =~ /\[ backtrace testing \]/) {
1003 $skip_call_trace = 1;
1004 }
1005
1006 if ($full_line =~ /call trace:/i) {
1007 if (!$bug && !$skip_call_trace) {
1008 $bug = 1;
1009 $failure_start = time;
1010 }
1011 }
1012
1013 if ($bug && defined($stop_after_failure) &&
1014 $stop_after_failure >= 0) {
1015 my $now = time;
1016 if ($now - $failure_start >= $stop_after_failure) {
1017 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1018 last;
1019 }
1020 }
1021
1022 if ($full_line =~ /\[ end of backtrace testing \]/) {
1023 $skip_call_trace = 0;
1024 }
1025
1026 if ($full_line =~ /Kernel panic -/) {
1027 $failure_start = time;
1028 $bug = 1;
1029 }
1030
1031 # Detect triple faults by testing the banner
1032 if ($full_line =~ /\bLinux version (\S+).*\n/) {
1033 if ($1 eq $version) {
1034 $version_found = 1;
1035 } elsif ($version_found && $detect_triplefault) {
1036 # We already booted into the kernel we are testing,
1037 # but now we booted into another kernel?
1038 # Consider this a triple fault.
1039 doprint "Aleady booted in Linux kernel $version, but now\n";
1040 doprint "we booted into Linux kernel $1.\n";
1041 doprint "Assuming that this is a triple fault.\n";
1042 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
1043 last;
1044 }
1045 }
1046
1047 if ($line =~ /\n/) {
1048 $full_line = "";
1049 }
1050
1051 if ($stop_test_after > 0 && !$booted && !$bug) {
1052 if (time - $monitor_start > $stop_test_after) {
1053 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
1054 $done = 1;
1055 }
1056 }
1057 }
1058
1059 close(DMESG);
1060
1061 if ($bug) {
1062 return 0 if ($in_bisect);
1063 fail "failed - got a bug report" and return 0;
1064 }
1065
1066 if (!$booted) {
1067 return 0 if ($in_bisect);
1068 fail "failed - never got a boot prompt." and return 0;
1069 }
1070
1071 return 1;
1072}
1073
1074sub do_post_install {
1075
1076 return if (!defined($post_install));
1077
1078 my $cp_post_install = $post_install;
1079 $cp_post_install =~ s/\$KERNEL_VERSION/$version/g;
1080 run_command "$cp_post_install" or
1081 dodie "Failed to run post install";
1082}
1083
1084sub install {
1085
1086 run_scp "$outputdir/$build_target", "$target_image" or
1087 dodie "failed to copy image";
1088
1089 my $install_mods = 0;
1090
1091 # should we process modules?
1092 $install_mods = 0;
1093 open(IN, "$output_config") or dodie("Can't read config file");
1094 while (<IN>) {
1095 if (/CONFIG_MODULES(=y)?/) {
1096 $install_mods = 1 if (defined($1));
1097 last;
1098 }
1099 }
1100 close(IN);
1101
1102 if (!$install_mods) {
1103 do_post_install;
1104 doprint "No modules needed\n";
1105 return;
1106 }
1107
1108 run_command "$make INSTALL_MOD_PATH=$tmpdir modules_install" or
1109 dodie "Failed to install modules";
1110
1111 my $modlib = "/lib/modules/$version";
1112 my $modtar = "ktest-mods.tar.bz2";
1113
1114 run_ssh "rm -rf $modlib" or
1115 dodie "failed to remove old mods: $modlib";
1116
1117 # would be nice if scp -r did not follow symbolic links
1118 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
1119 dodie "making tarball";
1120
1121 run_scp "$tmpdir/$modtar", "/tmp" or
1122 dodie "failed to copy modules";
1123
1124 unlink "$tmpdir/$modtar";
1125
1126 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
1127 dodie "failed to tar modules";
1128
1129 run_ssh "rm -f /tmp/$modtar";
1130
1131 do_post_install;
1132}
1133
1134sub get_version {
1135 # get the release name
1136 doprint "$make kernelrelease ... ";
1137 $version = `$make kernelrelease | tail -1`;
1138 chomp($version);
1139 doprint "$version\n";
1140}
1141
1142sub start_monitor_and_boot {
1143 get_grub_index;
1144 get_version;
1145 install;
1146
1147 start_monitor;
1148 return monitor;
1149}
1150
1151sub check_buildlog {
1152 my ($patch) = @_;
1153
1154 my @files = `git show $patch | diffstat -l`;
1155
1156 open(IN, "git show $patch |") or
1157 dodie "failed to show $patch";
1158 while (<IN>) {
1159 if (m,^--- a/(.*),) {
1160 chomp $1;
1161 $files[$#files] = $1;
1162 }
1163 }
1164 close(IN);
1165
1166 open(IN, $buildlog) or dodie "Can't open $buildlog";
1167 while (<IN>) {
1168 if (/^\s*(.*?):.*(warning|error)/) {
1169 my $err = $1;
1170 foreach my $file (@files) {
1171 my $fullpath = "$builddir/$file";
1172 if ($file eq $err || $fullpath eq $err) {
1173 fail "$file built with warnings" and return 0;
1174 }
1175 }
1176 }
1177 }
1178 close(IN);
1179
1180 return 1;
1181}
1182
1183sub apply_min_config {
1184 my $outconfig = "$output_config.new";
1185
1186 # Read the config file and remove anything that
1187 # is in the force_config hash (from minconfig and others)
1188 # then add the force config back.
1189
1190 doprint "Applying minimum configurations into $output_config.new\n";
1191
1192 open (OUT, ">$outconfig") or
1193 dodie "Can't create $outconfig";
1194
1195 if (-f $output_config) {
1196 open (IN, $output_config) or
1197 dodie "Failed to open $output_config";
1198 while (<IN>) {
1199 if (/^(# )?(CONFIG_[^\s=]*)/) {
1200 next if (defined($force_config{$2}));
1201 }
1202 print OUT;
1203 }
1204 close IN;
1205 }
1206 foreach my $config (keys %force_config) {
1207 print OUT "$force_config{$config}\n";
1208 }
1209 close OUT;
1210
1211 run_command "mv $outconfig $output_config";
1212}
1213
1214sub make_oldconfig {
1215
1216 my @force_list = keys %force_config;
1217
1218 if ($#force_list >= 0) {
1219 apply_min_config;
1220 }
1221
1222 if (!run_command "$make oldnoconfig") {
1223 # Perhaps oldnoconfig doesn't exist in this version of the kernel
1224 # try a yes '' | oldconfig
1225 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
1226 run_command "yes '' | $make oldconfig" or
1227 dodie "failed make config oldconfig";
1228 }
1229}
1230
1231# read a config file and use this to force new configs.
1232sub load_force_config {
1233 my ($config) = @_;
1234
1235 open(IN, $config) or
1236 dodie "failed to read $config";
1237 while (<IN>) {
1238 chomp;
1239 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
1240 $force_config{$1} = $_;
1241 } elsif (/^# (CONFIG_\S*) is not set/) {
1242 $force_config{$1} = $_;
1243 }
1244 }
1245 close IN;
1246}
1247
1248sub build {
1249 my ($type) = @_;
1250
1251 unlink $buildlog;
1252
1253 if (defined($pre_build)) {
1254 my $ret = run_command $pre_build;
1255 if (!$ret && defined($pre_build_die) &&
1256 $pre_build_die) {
1257 dodie "failed to pre_build\n";
1258 }
1259 }
1260
1261 if ($type =~ /^useconfig:(.*)/) {
1262 run_command "cp $1 $output_config" or
1263 dodie "could not copy $1 to .config";
1264
1265 $type = "oldconfig";
1266 }
1267
1268 # old config can ask questions
1269 if ($type eq "oldconfig") {
1270 $type = "oldnoconfig";
1271
1272 # allow for empty configs
1273 run_command "touch $output_config";
1274
1275 run_command "mv $output_config $outputdir/config_temp" or
1276 dodie "moving .config";
1277
1278 if (!$noclean && !run_command "$make mrproper") {
1279 dodie "make mrproper";
1280 }
1281
1282 run_command "mv $outputdir/config_temp $output_config" or
1283 dodie "moving config_temp";
1284
1285 } elsif (!$noclean) {
1286 unlink "$output_config";
1287 run_command "$make mrproper" or
1288 dodie "make mrproper";
1289 }
1290
1291 # add something to distinguish this build
1292 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
1293 print OUT "$localversion\n";
1294 close(OUT);
1295
1296 if (defined($minconfig)) {
1297 load_force_config($minconfig);
1298 }
1299
1300 if ($type ne "oldnoconfig") {
1301 run_command "$make $type" or
1302 dodie "failed make config";
1303 }
1304 # Run old config regardless, to enforce min configurations
1305 make_oldconfig;
1306
1307 $redirect = "$buildlog";
1308 my $build_ret = run_command "$make $build_options";
1309 undef $redirect;
1310
1311 if (defined($post_build)) {
1312 my $ret = run_command $post_build;
1313 if (!$ret && defined($post_build_die) &&
1314 $post_build_die) {
1315 dodie "failed to post_build\n";
1316 }
1317 }
1318
1319 if (!$build_ret) {
1320 # bisect may need this to pass
1321 return 0 if ($in_bisect);
1322 fail "failed build" and return 0;
1323 }
1324
1325 return 1;
1326}
1327
1328sub halt {
1329 if (!run_ssh "halt" or defined($power_off)) {
1330 if (defined($poweroff_after_halt)) {
1331 sleep $poweroff_after_halt;
1332 run_command "$power_off";
1333 }
1334 } else {
1335 # nope? the zap it!
1336 run_command "$power_off";
1337 }
1338}
1339
1340sub success {
1341 my ($i) = @_;
1342
1343 $successes++;
1344
1345 my $name = "";
1346
1347 if (defined($test_name)) {
1348 $name = " ($test_name)";
1349 }
1350
1351 doprint "\n\n*******************************************\n";
1352 doprint "*******************************************\n";
1353 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
1354 doprint "*******************************************\n";
1355 doprint "*******************************************\n";
1356
1357 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
1358 doprint "Reboot and wait $sleep_time seconds\n";
1359 reboot;
1360 start_monitor;
1361 wait_for_monitor $sleep_time;
1362 end_monitor;
1363 }
1364}
1365
1366sub answer_bisect {
1367 for (;;) {
1368 doprint "Pass or fail? [p/f]";
1369 my $ans = <STDIN>;
1370 chomp $ans;
1371 if ($ans eq "p" || $ans eq "P") {
1372 return 1;
1373 } elsif ($ans eq "f" || $ans eq "F") {
1374 return 0;
1375 } else {
1376 print "Please answer 'P' or 'F'\n";
1377 }
1378 }
1379}
1380
1381sub child_run_test {
1382 my $failed = 0;
1383
1384 # child should have no power
1385 $reboot_on_error = 0;
1386 $poweroff_on_error = 0;
1387 $die_on_failure = 1;
1388
1389 run_command $run_test or $failed = 1;
1390 exit $failed;
1391}
1392
1393my $child_done;
1394
1395sub child_finished {
1396 $child_done = 1;
1397}
1398
1399sub do_run_test {
1400 my $child_pid;
1401 my $child_exit;
1402 my $line;
1403 my $full_line;
1404 my $bug = 0;
1405
1406 wait_for_monitor 1;
1407
1408 doprint "run test $run_test\n";
1409
1410 $child_done = 0;
1411
1412 $SIG{CHLD} = qw(child_finished);
1413
1414 $child_pid = fork;
1415
1416 child_run_test if (!$child_pid);
1417
1418 $full_line = "";
1419
1420 do {
1421 $line = wait_for_input($monitor_fp, 1);
1422 if (defined($line)) {
1423
1424 # we are not guaranteed to get a full line
1425 $full_line .= $line;
1426 doprint $line;
1427
1428 if ($full_line =~ /call trace:/i) {
1429 $bug = 1;
1430 }
1431
1432 if ($full_line =~ /Kernel panic -/) {
1433 $bug = 1;
1434 }
1435
1436 if ($line =~ /\n/) {
1437 $full_line = "";
1438 }
1439 }
1440 } while (!$child_done && !$bug);
1441
1442 if ($bug) {
1443 my $failure_start = time;
1444 my $now;
1445 do {
1446 $line = wait_for_input($monitor_fp, 1);
1447 if (defined($line)) {
1448 doprint $line;
1449 }
1450 $now = time;
1451 if ($now - $failure_start >= $stop_after_failure) {
1452 last;
1453 }
1454 } while (defined($line));
1455
1456 doprint "Detected kernel crash!\n";
1457 # kill the child with extreme prejudice
1458 kill 9, $child_pid;
1459 }
1460
1461 waitpid $child_pid, 0;
1462 $child_exit = $?;
1463
1464 if ($bug || $child_exit) {
1465 return 0 if $in_bisect;
1466 fail "test failed" and return 0;
1467 }
1468 return 1;
1469}
1470
1471sub run_git_bisect {
1472 my ($command) = @_;
1473
1474 doprint "$command ... ";
1475
1476 my $output = `$command 2>&1`;
1477 my $ret = $?;
1478
1479 logit $output;
1480
1481 if ($ret) {
1482 doprint "FAILED\n";
1483 dodie "Failed to git bisect";
1484 }
1485
1486 doprint "SUCCESS\n";
1487 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
1488 doprint "$1 [$2]\n";
1489 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
1490 $bisect_bad = $1;
1491 doprint "Found bad commit... $1\n";
1492 return 0;
1493 } else {
1494 # we already logged it, just print it now.
1495 print $output;
1496 }
1497
1498 return 1;
1499}
1500
1501sub bisect_reboot {
1502 doprint "Reboot and sleep $bisect_sleep_time seconds\n";
1503 reboot;
1504 start_monitor;
1505 wait_for_monitor $bisect_sleep_time;
1506 end_monitor;
1507}
1508
1509# returns 1 on success, 0 on failure, -1 on skip
1510sub run_bisect_test {
1511 my ($type, $buildtype) = @_;
1512
1513 my $failed = 0;
1514 my $result;
1515 my $output;
1516 my $ret;
1517
1518 $in_bisect = 1;
1519
1520 build $buildtype or $failed = 1;
1521
1522 if ($type ne "build") {
1523 if ($failed && $bisect_skip) {
1524 $in_bisect = 0;
1525 return -1;
1526 }
1527 dodie "Failed on build" if $failed;
1528
1529 # Now boot the box
1530 start_monitor_and_boot or $failed = 1;
1531
1532 if ($type ne "boot") {
1533 if ($failed && $bisect_skip) {
1534 end_monitor;
1535 bisect_reboot;
1536 $in_bisect = 0;
1537 return -1;
1538 }
1539 dodie "Failed on boot" if $failed;
1540
1541 do_run_test or $failed = 1;
1542 }
1543 end_monitor;
1544 }
1545
1546 if ($failed) {
1547 $result = 0;
1548 } else {
1549 $result = 1;
1550 }
1551
1552 # reboot the box to a kernel we can ssh to
1553 if ($type ne "build") {
1554 bisect_reboot;
1555 }
1556 $in_bisect = 0;
1557
1558 return $result;
1559}
1560
1561sub run_bisect {
1562 my ($type) = @_;
1563 my $buildtype = "oldconfig";
1564
1565 # We should have a minconfig to use?
1566 if (defined($minconfig)) {
1567 $buildtype = "useconfig:$minconfig";
1568 }
1569
1570 my $ret = run_bisect_test $type, $buildtype;
1571
1572 if ($bisect_manual) {
1573 $ret = answer_bisect;
1574 }
1575
1576 # Are we looking for where it worked, not failed?
1577 if ($reverse_bisect) {
1578 $ret = !$ret;
1579 }
1580
1581 if ($ret > 0) {
1582 return "good";
1583 } elsif ($ret == 0) {
1584 return "bad";
1585 } elsif ($bisect_skip) {
1586 doprint "HIT A BAD COMMIT ... SKIPPING\n";
1587 return "skip";
1588 }
1589}
1590
1591sub bisect {
1592 my ($i) = @_;
1593
1594 my $result;
1595
1596 die "BISECT_GOOD[$i] not defined\n" if (!defined($opt{"BISECT_GOOD[$i]"}));
1597 die "BISECT_BAD[$i] not defined\n" if (!defined($opt{"BISECT_BAD[$i]"}));
1598 die "BISECT_TYPE[$i] not defined\n" if (!defined($opt{"BISECT_TYPE[$i]"}));
1599
1600 my $good = $opt{"BISECT_GOOD[$i]"};
1601 my $bad = $opt{"BISECT_BAD[$i]"};
1602 my $type = $opt{"BISECT_TYPE[$i]"};
1603 my $start = $opt{"BISECT_START[$i]"};
1604 my $replay = $opt{"BISECT_REPLAY[$i]"};
1605 my $start_files = $opt{"BISECT_FILES[$i]"};
1606
1607 if (defined($start_files)) {
1608 $start_files = " -- " . $start_files;
1609 } else {
1610 $start_files = "";
1611 }
1612
1613 # convert to true sha1's
1614 $good = get_sha1($good);
1615 $bad = get_sha1($bad);
1616
1617 if (defined($opt{"BISECT_REVERSE[$i]"}) &&
1618 $opt{"BISECT_REVERSE[$i]"} == 1) {
1619 doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
1620 $reverse_bisect = 1;
1621 } else {
1622 $reverse_bisect = 0;
1623 }
1624
1625 # Can't have a test without having a test to run
1626 if ($type eq "test" && !defined($run_test)) {
1627 $type = "boot";
1628 }
1629
1630 my $check = $opt{"BISECT_CHECK[$i]"};
1631 if (defined($check) && $check ne "0") {
1632
1633 # get current HEAD
1634 my $head = get_sha1("HEAD");
1635
1636 if ($check ne "good") {
1637 doprint "TESTING BISECT BAD [$bad]\n";
1638 run_command "git checkout $bad" or
1639 die "Failed to checkout $bad";
1640
1641 $result = run_bisect $type;
1642
1643 if ($result ne "bad") {
1644 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
1645 }
1646 }
1647
1648 if ($check ne "bad") {
1649 doprint "TESTING BISECT GOOD [$good]\n";
1650 run_command "git checkout $good" or
1651 die "Failed to checkout $good";
1652
1653 $result = run_bisect $type;
1654
1655 if ($result ne "good") {
1656 fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
1657 }
1658 }
1659
1660 # checkout where we started
1661 run_command "git checkout $head" or
1662 die "Failed to checkout $head";
1663 }
1664
1665 run_command "git bisect start$start_files" or
1666 dodie "could not start bisect";
1667
1668 run_command "git bisect good $good" or
1669 dodie "could not set bisect good to $good";
1670
1671 run_git_bisect "git bisect bad $bad" or
1672 dodie "could not set bisect bad to $bad";
1673
1674 if (defined($replay)) {
1675 run_command "git bisect replay $replay" or
1676 dodie "failed to run replay";
1677 }
1678
1679 if (defined($start)) {
1680 run_command "git checkout $start" or
1681 dodie "failed to checkout $start";
1682 }
1683
1684 my $test;
1685 do {
1686 $result = run_bisect $type;
1687 $test = run_git_bisect "git bisect $result";
1688 } while ($test);
1689
1690 run_command "git bisect log" or
1691 dodie "could not capture git bisect log";
1692
1693 run_command "git bisect reset" or
1694 dodie "could not reset git bisect";
1695
1696 doprint "Bad commit was [$bisect_bad]\n";
1697
1698 success $i;
1699}
1700
1701my %config_ignore;
1702my %config_set;
1703
1704my %config_list;
1705my %null_config;
1706
1707my %dependency;
1708
1709sub assign_configs {
1710 my ($hash, $config) = @_;
1711
1712 open (IN, $config)
1713 or dodie "Failed to read $config";
1714
1715 while (<IN>) {
1716 if (/^((CONFIG\S*)=.*)/) {
1717 ${$hash}{$2} = $1;
1718 }
1719 }
1720
1721 close(IN);
1722}
1723
1724sub process_config_ignore {
1725 my ($config) = @_;
1726
1727 assign_configs \%config_ignore, $config;
1728}
1729
1730sub read_current_config {
1731 my ($config_ref) = @_;
1732
1733 %{$config_ref} = ();
1734 undef %{$config_ref};
1735
1736 my @key = keys %{$config_ref};
1737 if ($#key >= 0) {
1738 print "did not delete!\n";
1739 exit;
1740 }
1741 open (IN, "$output_config");
1742
1743 while (<IN>) {
1744 if (/^(CONFIG\S+)=(.*)/) {
1745 ${$config_ref}{$1} = $2;
1746 }
1747 }
1748 close(IN);
1749}
1750
1751sub get_dependencies {
1752 my ($config) = @_;
1753
1754 my $arr = $dependency{$config};
1755 if (!defined($arr)) {
1756 return ();
1757 }
1758
1759 my @deps = @{$arr};
1760
1761 foreach my $dep (@{$arr}) {
1762 print "ADD DEP $dep\n";
1763 @deps = (@deps, get_dependencies $dep);
1764 }
1765
1766 return @deps;
1767}
1768
1769sub create_config {
1770 my @configs = @_;
1771
1772 open(OUT, ">$output_config") or dodie "Can not write to $output_config";
1773
1774 foreach my $config (@configs) {
1775 print OUT "$config_set{$config}\n";
1776 my @deps = get_dependencies $config;
1777 foreach my $dep (@deps) {
1778 print OUT "$config_set{$dep}\n";
1779 }
1780 }
1781
1782 foreach my $config (keys %config_ignore) {
1783 print OUT "$config_ignore{$config}\n";
1784 }
1785 close(OUT);
1786
1787# exit;
1788 make_oldconfig;
1789}
1790
1791sub compare_configs {
1792 my (%a, %b) = @_;
1793
1794 foreach my $item (keys %a) {
1795 if (!defined($b{$item})) {
1796 print "diff $item\n";
1797 return 1;
1798 }
1799 delete $b{$item};
1800 }
1801
1802 my @keys = keys %b;
1803 if ($#keys) {
1804 print "diff2 $keys[0]\n";
1805 }
1806 return -1 if ($#keys >= 0);
1807
1808 return 0;
1809}
1810
1811sub run_config_bisect_test {
1812 my ($type) = @_;
1813
1814 return run_bisect_test $type, "oldconfig";
1815}
1816
1817sub process_passed {
1818 my (%configs) = @_;
1819
1820 doprint "These configs had no failure: (Enabling them for further compiles)\n";
1821 # Passed! All these configs are part of a good compile.
1822 # Add them to the min options.
1823 foreach my $config (keys %configs) {
1824 if (defined($config_list{$config})) {
1825 doprint " removing $config\n";
1826 $config_ignore{$config} = $config_list{$config};
1827 delete $config_list{$config};
1828 }
1829 }
1830 doprint "config copied to $outputdir/config_good\n";
1831 run_command "cp -f $output_config $outputdir/config_good";
1832}
1833
1834sub process_failed {
1835 my ($config) = @_;
1836
1837 doprint "\n\n***************************************\n";
1838 doprint "Found bad config: $config\n";
1839 doprint "***************************************\n\n";
1840}
1841
1842sub run_config_bisect {
1843
1844 my @start_list = keys %config_list;
1845
1846 if ($#start_list < 0) {
1847 doprint "No more configs to test!!!\n";
1848 return -1;
1849 }
1850
1851 doprint "***** RUN TEST ***\n";
1852 my $type = $opt{"CONFIG_BISECT_TYPE[$iteration]"};
1853 my $ret;
1854 my %current_config;
1855
1856 my $count = $#start_list + 1;
1857 doprint " $count configs to test\n";
1858
1859 my $half = int($#start_list / 2);
1860
1861 do {
1862 my @tophalf = @start_list[0 .. $half];
1863
1864 create_config @tophalf;
1865 read_current_config \%current_config;
1866
1867 $count = $#tophalf + 1;
1868 doprint "Testing $count configs\n";
1869 my $found = 0;
1870 # make sure we test something
1871 foreach my $config (@tophalf) {
1872 if (defined($current_config{$config})) {
1873 logit " $config\n";
1874 $found = 1;
1875 }
1876 }
1877 if (!$found) {
1878 # try the other half
1879 doprint "Top half produced no set configs, trying bottom half\n";
1880 @tophalf = @start_list[$half + 1 .. $#start_list];
1881 create_config @tophalf;
1882 read_current_config \%current_config;
1883 foreach my $config (@tophalf) {
1884 if (defined($current_config{$config})) {
1885 logit " $config\n";
1886 $found = 1;
1887 }
1888 }
1889 if (!$found) {
1890 doprint "Failed: Can't make new config with current configs\n";
1891 foreach my $config (@start_list) {
1892 doprint " CONFIG: $config\n";
1893 }
1894 return -1;
1895 }
1896 $count = $#tophalf + 1;
1897 doprint "Testing $count configs\n";
1898 }
1899
1900 $ret = run_config_bisect_test $type;
1901 if ($bisect_manual) {
1902 $ret = answer_bisect;
1903 }
1904 if ($ret) {
1905 process_passed %current_config;
1906 return 0;
1907 }
1908
1909 doprint "This config had a failure.\n";
1910 doprint "Removing these configs that were not set in this config:\n";
1911 doprint "config copied to $outputdir/config_bad\n";
1912 run_command "cp -f $output_config $outputdir/config_bad";
1913
1914 # A config exists in this group that was bad.
1915 foreach my $config (keys %config_list) {
1916 if (!defined($current_config{$config})) {
1917 doprint " removing $config\n";
1918 delete $config_list{$config};
1919 }
1920 }
1921
1922 @start_list = @tophalf;
1923
1924 if ($#start_list == 0) {
1925 process_failed $start_list[0];
1926 return 1;
1927 }
1928
1929 # remove half the configs we are looking at and see if
1930 # they are good.
1931 $half = int($#start_list / 2);
1932 } while ($#start_list > 0);
1933
1934 # we found a single config, try it again unless we are running manually
1935
1936 if ($bisect_manual) {
1937 process_failed $start_list[0];
1938 return 1;
1939 }
1940
1941 my @tophalf = @start_list[0 .. 0];
1942
1943 $ret = run_config_bisect_test $type;
1944 if ($ret) {
1945 process_passed %current_config;
1946 return 0;
1947 }
1948
1949 process_failed $start_list[0];
1950 return 1;
1951}
1952
1953sub config_bisect {
1954 my ($i) = @_;
1955
1956 my $start_config = $opt{"CONFIG_BISECT[$i]"};
1957
1958 my $tmpconfig = "$tmpdir/use_config";
1959
1960 if (defined($config_bisect_good)) {
1961 process_config_ignore $config_bisect_good;
1962 }
1963
1964 # Make the file with the bad config and the min config
1965 if (defined($minconfig)) {
1966 # read the min config for things to ignore
1967 run_command "cp $minconfig $tmpconfig" or
1968 dodie "failed to copy $minconfig to $tmpconfig";
1969 } else {
1970 unlink $tmpconfig;
1971 }
1972
1973 if (-f $tmpconfig) {
1974 load_force_config($tmpconfig);
1975 process_config_ignore $tmpconfig;
1976 }
1977
1978 # now process the start config
1979 run_command "cp $start_config $output_config" or
1980 dodie "failed to copy $start_config to $output_config";
1981
1982 # read directly what we want to check
1983 my %config_check;
1984 open (IN, $output_config)
1985 or dodie "faied to open $output_config";
1986
1987 while (<IN>) {
1988 if (/^((CONFIG\S*)=.*)/) {
1989 $config_check{$2} = $1;
1990 }
1991 }
1992 close(IN);
1993
1994 # Now run oldconfig with the minconfig
1995 make_oldconfig;
1996
1997 # check to see what we lost (or gained)
1998 open (IN, $output_config)
1999 or dodie "Failed to read $start_config";
2000
2001 my %removed_configs;
2002 my %added_configs;
2003
2004 while (<IN>) {
2005 if (/^((CONFIG\S*)=.*)/) {
2006 # save off all options
2007 $config_set{$2} = $1;
2008 if (defined($config_check{$2})) {
2009 if (defined($config_ignore{$2})) {
2010 $removed_configs{$2} = $1;
2011 } else {
2012 $config_list{$2} = $1;
2013 }
2014 } elsif (!defined($config_ignore{$2})) {
2015 $added_configs{$2} = $1;
2016 $config_list{$2} = $1;
2017 }
2018 }
2019 }
2020 close(IN);
2021
2022 my @confs = keys %removed_configs;
2023 if ($#confs >= 0) {
2024 doprint "Configs overridden by default configs and removed from check:\n";
2025 foreach my $config (@confs) {
2026 doprint " $config\n";
2027 }
2028 }
2029 @confs = keys %added_configs;
2030 if ($#confs >= 0) {
2031 doprint "Configs appearing in make oldconfig and added:\n";
2032 foreach my $config (@confs) {
2033 doprint " $config\n";
2034 }
2035 }
2036
2037 my %config_test;
2038 my $once = 0;
2039
2040 # Sometimes kconfig does weird things. We must make sure
2041 # that the config we autocreate has everything we need
2042 # to test, otherwise we may miss testing configs, or
2043 # may not be able to create a new config.
2044 # Here we create a config with everything set.
2045 create_config (keys %config_list);
2046 read_current_config \%config_test;
2047 foreach my $config (keys %config_list) {
2048 if (!defined($config_test{$config})) {
2049 if (!$once) {
2050 $once = 1;
2051 doprint "Configs not produced by kconfig (will not be checked):\n";
2052 }
2053 doprint " $config\n";
2054 delete $config_list{$config};
2055 }
2056 }
2057 my $ret;
2058 do {
2059 $ret = run_config_bisect;
2060 } while (!$ret);
2061
2062 return $ret if ($ret < 0);
2063
2064 success $i;
2065}
2066
2067sub patchcheck_reboot {
2068 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
2069 reboot;
2070 start_monitor;
2071 wait_for_monitor $patchcheck_sleep_time;
2072 end_monitor;
2073}
2074
2075sub patchcheck {
2076 my ($i) = @_;
2077
2078 die "PATCHCHECK_START[$i] not defined\n"
2079 if (!defined($opt{"PATCHCHECK_START[$i]"}));
2080 die "PATCHCHECK_TYPE[$i] not defined\n"
2081 if (!defined($opt{"PATCHCHECK_TYPE[$i]"}));
2082
2083 my $start = $opt{"PATCHCHECK_START[$i]"};
2084
2085 my $end = "HEAD";
2086 if (defined($opt{"PATCHCHECK_END[$i]"})) {
2087 $end = $opt{"PATCHCHECK_END[$i]"};
2088 }
2089
2090 # Get the true sha1's since we can use things like HEAD~3
2091 $start = get_sha1($start);
2092 $end = get_sha1($end);
2093
2094 my $type = $opt{"PATCHCHECK_TYPE[$i]"};
2095
2096 # Can't have a test without having a test to run
2097 if ($type eq "test" && !defined($run_test)) {
2098 $type = "boot";
2099 }
2100
2101 open (IN, "git log --pretty=oneline $end|") or
2102 dodie "could not get git list";
2103
2104 my @list;
2105
2106 while (<IN>) {
2107 chomp;
2108 $list[$#list+1] = $_;
2109 last if (/^$start/);
2110 }
2111 close(IN);
2112
2113 if ($list[$#list] !~ /^$start/) {
2114 fail "SHA1 $start not found";
2115 }
2116
2117 # go backwards in the list
2118 @list = reverse @list;
2119
2120 my $save_clean = $noclean;
2121 my %ignored_warnings;
2122
2123 if (defined($ignore_warnings)) {
2124 foreach my $sha1 (split /\s+/, $ignore_warnings) {
2125 $ignored_warnings{$sha1} = 1;
2126 }
2127 }
2128
2129 $in_patchcheck = 1;
2130 foreach my $item (@list) {
2131 my $sha1 = $item;
2132 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
2133
2134 doprint "\nProcessing commit $item\n\n";
2135
2136 run_command "git checkout $sha1" or
2137 die "Failed to checkout $sha1";
2138
2139 # only clean on the first and last patch
2140 if ($item eq $list[0] ||
2141 $item eq $list[$#list]) {
2142 $noclean = $save_clean;
2143 } else {
2144 $noclean = 1;
2145 }
2146
2147 if (defined($minconfig)) {
2148 build "useconfig:$minconfig" or return 0;
2149 } else {
2150 # ?? no config to use?
2151 build "oldconfig" or return 0;
2152 }
2153
2154
2155 if (!defined($ignored_warnings{$sha1})) {
2156 check_buildlog $sha1 or return 0;
2157 }
2158
2159 next if ($type eq "build");
2160
2161 my $failed = 0;
2162
2163 start_monitor_and_boot or $failed = 1;
2164
2165 if (!$failed && $type ne "boot"){
2166 do_run_test or $failed = 1;
2167 }
2168 end_monitor;
2169 return 0 if ($failed);
2170
2171 patchcheck_reboot;
2172
2173 }
2174 $in_patchcheck = 0;
2175 success $i;
2176
2177 return 1;
2178}
2179
2180my %depends;
2181my $iflevel = 0;
2182my @ifdeps;
2183
2184# prevent recursion
2185my %read_kconfigs;
2186
2187# taken from streamline_config.pl
2188sub read_kconfig {
2189 my ($kconfig) = @_;
2190
2191 my $state = "NONE";
2192 my $config;
2193 my @kconfigs;
2194
2195 my $cont = 0;
2196 my $line;
2197
2198
2199 if (! -f $kconfig) {
2200 doprint "file $kconfig does not exist, skipping\n";
2201 return;
2202 }
2203
2204 open(KIN, "$kconfig")
2205 or die "Can't open $kconfig";
2206 while (<KIN>) {
2207 chomp;
2208
2209 # Make sure that lines ending with \ continue
2210 if ($cont) {
2211 $_ = $line . " " . $_;
2212 }
2213
2214 if (s/\\$//) {
2215 $cont = 1;
2216 $line = $_;
2217 next;
2218 }
2219
2220 $cont = 0;
2221
2222 # collect any Kconfig sources
2223 if (/^source\s*"(.*)"/) {
2224 $kconfigs[$#kconfigs+1] = $1;
2225 }
2226
2227 # configs found
2228 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
2229 $state = "NEW";
2230 $config = $2;
2231
2232 for (my $i = 0; $i < $iflevel; $i++) {
2233 if ($i) {
2234 $depends{$config} .= " " . $ifdeps[$i];
2235 } else {
2236 $depends{$config} = $ifdeps[$i];
2237 }
2238 $state = "DEP";
2239 }
2240
2241 # collect the depends for the config
2242 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
2243
2244 if (defined($depends{$1})) {
2245 $depends{$config} .= " " . $1;
2246 } else {
2247 $depends{$config} = $1;
2248 }
2249
2250 # Get the configs that select this config
2251 } elsif ($state ne "NONE" && /^\s*select\s+(\S+)/) {
2252 if (defined($depends{$1})) {
2253 $depends{$1} .= " " . $config;
2254 } else {
2255 $depends{$1} = $config;
2256 }
2257
2258 # Check for if statements
2259 } elsif (/^if\s+(.*\S)\s*$/) {
2260 my $deps = $1;
2261 # remove beginning and ending non text
2262 $deps =~ s/^[^a-zA-Z0-9_]*//;
2263 $deps =~ s/[^a-zA-Z0-9_]*$//;
2264
2265 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
2266
2267 $ifdeps[$iflevel++] = join ':', @deps;
2268
2269 } elsif (/^endif/) {
2270
2271 $iflevel-- if ($iflevel);
2272
2273 # stop on "help"
2274 } elsif (/^\s*help\s*$/) {
2275 $state = "NONE";
2276 }
2277 }
2278 close(KIN);
2279
2280 # read in any configs that were found.
2281 foreach $kconfig (@kconfigs) {
2282 if (!defined($read_kconfigs{$kconfig})) {
2283 $read_kconfigs{$kconfig} = 1;
2284 read_kconfig("$builddir/$kconfig");
2285 }
2286 }
2287}
2288
2289sub read_depends {
2290 # find out which arch this is by the kconfig file
2291 open (IN, $output_config)
2292 or dodie "Failed to read $output_config";
2293 my $arch;
2294 while (<IN>) {
2295 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
2296 $arch = $1;
2297 last;
2298 }
2299 }
2300 close IN;
2301
2302 if (!defined($arch)) {
2303 doprint "Could not find arch from config file\n";
2304 doprint "no dependencies used\n";
2305 return;
2306 }
2307
2308 # arch is really the subarch, we need to know
2309 # what directory to look at.
2310 if ($arch eq "i386" || $arch eq "x86_64") {
2311 $arch = "x86";
2312 } elsif ($arch =~ /^tile/) {
2313 $arch = "tile";
2314 }
2315
2316 my $kconfig = "$builddir/arch/$arch/Kconfig";
2317
2318 if (! -f $kconfig && $arch =~ /\d$/) {
2319 my $orig = $arch;
2320 # some subarchs have numbers, truncate them
2321 $arch =~ s/\d*$//;
2322 $kconfig = "$builddir/arch/$arch/Kconfig";
2323 if (! -f $kconfig) {
2324 doprint "No idea what arch dir $orig is for\n";
2325 doprint "no dependencies used\n";
2326 return;
2327 }
2328 }
2329
2330 read_kconfig($kconfig);
2331}
2332
2333sub read_config_list {
2334 my ($config) = @_;
2335
2336 open (IN, $config)
2337 or dodie "Failed to read $config";
2338
2339 while (<IN>) {
2340 if (/^((CONFIG\S*)=.*)/) {
2341 if (!defined($config_ignore{$2})) {
2342 $config_list{$2} = $1;
2343 }
2344 }
2345 }
2346
2347 close(IN);
2348}
2349
2350sub read_output_config {
2351 my ($config) = @_;
2352
2353 assign_configs \%config_ignore, $config;
2354}
2355
2356sub make_new_config {
2357 my @configs = @_;
2358
2359 open (OUT, ">$output_config")
2360 or dodie "Failed to write $output_config";
2361
2362 foreach my $config (@configs) {
2363 print OUT "$config\n";
2364 }
2365 close OUT;
2366}
2367
2368sub get_depends {
2369 my ($dep) = @_;
2370
2371 my $kconfig = $dep;
2372 $kconfig =~ s/CONFIG_//;
2373
2374 $dep = $depends{"$kconfig"};
2375
2376 # the dep string we have saves the dependencies as they
2377 # were found, including expressions like ! && ||. We
2378 # want to split this out into just an array of configs.
2379
2380 my $valid = "A-Za-z_0-9";
2381
2382 my @configs;
2383
2384 while ($dep =~ /[$valid]/) {
2385
2386 if ($dep =~ /^[^$valid]*([$valid]+)/) {
2387 my $conf = "CONFIG_" . $1;
2388
2389 $configs[$#configs + 1] = $conf;
2390
2391 $dep =~ s/^[^$valid]*[$valid]+//;
2392 } else {
2393 die "this should never happen";
2394 }
2395 }
2396
2397 return @configs;
2398}
2399
2400my %min_configs;
2401my %keep_configs;
2402my %save_configs;
2403my %processed_configs;
2404my %nochange_config;
2405
2406sub test_this_config {
2407 my ($config) = @_;
2408
2409 my $found;
2410
2411 # if we already processed this config, skip it
2412 if (defined($processed_configs{$config})) {
2413 return undef;
2414 }
2415 $processed_configs{$config} = 1;
2416
2417 # if this config failed during this round, skip it
2418 if (defined($nochange_config{$config})) {
2419 return undef;
2420 }
2421
2422 my $kconfig = $config;
2423 $kconfig =~ s/CONFIG_//;
2424
2425 # Test dependencies first
2426 if (defined($depends{"$kconfig"})) {
2427 my @parents = get_depends $config;
2428 foreach my $parent (@parents) {
2429 # if the parent is in the min config, check it first
2430 next if (!defined($min_configs{$parent}));
2431 $found = test_this_config($parent);
2432 if (defined($found)) {
2433 return $found;
2434 }
2435 }
2436 }
2437
2438 # Remove this config from the list of configs
2439 # do a make oldnoconfig and then read the resulting
2440 # .config to make sure it is missing the config that
2441 # we had before
2442 my %configs = %min_configs;
2443 delete $configs{$config};
2444 make_new_config ((values %configs), (values %keep_configs));
2445 make_oldconfig;
2446 undef %configs;
2447 assign_configs \%configs, $output_config;
2448
2449 return $config if (!defined($configs{$config}));
2450
2451 doprint "disabling config $config did not change .config\n";
2452
2453 $nochange_config{$config} = 1;
2454
2455 return undef;
2456}
2457
2458sub make_min_config {
2459 my ($i) = @_;
2460
2461 if (!defined($output_minconfig)) {
2462 fail "OUTPUT_MIN_CONFIG not defined" and return;
2463 }
2464
2465 # If output_minconfig exists, and the start_minconfig
2466 # came from min_config, than ask if we should use
2467 # that instead.
2468 if (-f $output_minconfig && !$start_minconfig_defined) {
2469 print "$output_minconfig exists\n";
2470 if (read_yn " Use it as minconfig?") {
2471 $start_minconfig = $output_minconfig;
2472 }
2473 }
2474
2475 if (!defined($start_minconfig)) {
2476 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
2477 }
2478
2479 my $temp_config = "$tmpdir/temp_config";
2480
2481 # First things first. We build an allnoconfig to find
2482 # out what the defaults are that we can't touch.
2483 # Some are selections, but we really can't handle selections.
2484
2485 my $save_minconfig = $minconfig;
2486 undef $minconfig;
2487
2488 run_command "$make allnoconfig" or return 0;
2489
2490 read_depends;
2491
2492 process_config_ignore $output_config;
2493
2494 undef %save_configs;
2495 undef %min_configs;
2496
2497 if (defined($ignore_config)) {
2498 # make sure the file exists
2499 `touch $ignore_config`;
2500 assign_configs \%save_configs, $ignore_config;
2501 }
2502
2503 %keep_configs = %save_configs;
2504
2505 doprint "Load initial configs from $start_minconfig\n";
2506
2507 # Look at the current min configs, and save off all the
2508 # ones that were set via the allnoconfig
2509 assign_configs \%min_configs, $start_minconfig;
2510
2511 my @config_keys = keys %min_configs;
2512
2513 # Remove anything that was set by the make allnoconfig
2514 # we shouldn't need them as they get set for us anyway.
2515 foreach my $config (@config_keys) {
2516 # Remove anything in the ignore_config
2517 if (defined($keep_configs{$config})) {
2518 my $file = $ignore_config;
2519 $file =~ s,.*/(.*?)$,$1,;
2520 doprint "$config set by $file ... ignored\n";
2521 delete $min_configs{$config};
2522 next;
2523 }
2524 # But make sure the settings are the same. If a min config
2525 # sets a selection, we do not want to get rid of it if
2526 # it is not the same as what we have. Just move it into
2527 # the keep configs.
2528 if (defined($config_ignore{$config})) {
2529 if ($config_ignore{$config} ne $min_configs{$config}) {
2530 doprint "$config is in allnoconfig as '$config_ignore{$config}'";
2531 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
2532 $keep_configs{$config} = $min_configs{$config};
2533 } else {
2534 doprint "$config set by allnoconfig ... ignored\n";
2535 }
2536 delete $min_configs{$config};
2537 }
2538 }
2539
2540 my $done = 0;
2541 my $take_two = 0;
2542
2543 while (!$done) {
2544
2545 my $config;
2546 my $found;
2547
2548 # Now disable each config one by one and do a make oldconfig
2549 # till we find a config that changes our list.
2550
2551 # Put configs that did not modify the config at the end.
2552 my @test_configs = keys %min_configs;
2553 my $reset = 1;
2554 for (my $i = 0; $i < $#test_configs; $i++) {
2555 if (!defined($nochange_config{$test_configs[0]})) {
2556 $reset = 0;
2557 last;
2558 }
2559 # This config didn't change the .config last time.
2560 # Place it at the end
2561 my $config = shift @test_configs;
2562 push @test_configs, $config;
2563 }
2564
2565 # if every test config has failed to modify the .config file
2566 # in the past, then reset and start over.
2567 if ($reset) {
2568 undef %nochange_config;
2569 }
2570
2571 undef %processed_configs;
2572
2573 foreach my $config (@test_configs) {
2574
2575 $found = test_this_config $config;
2576
2577 last if (defined($found));
2578
2579 # oh well, try another config
2580 }
2581
2582 if (!defined($found)) {
2583 # we could have failed due to the nochange_config hash
2584 # reset and try again
2585 if (!$take_two) {
2586 undef %nochange_config;
2587 $take_two = 1;
2588 next;
2589 }
2590 doprint "No more configs found that we can disable\n";
2591 $done = 1;
2592 last;
2593 }
2594 $take_two = 0;
2595
2596 $config = $found;
2597
2598 doprint "Test with $config disabled\n";
2599
2600 # set in_bisect to keep build and monitor from dieing
2601 $in_bisect = 1;
2602
2603 my $failed = 0;
2604 build "oldconfig";
2605 start_monitor_and_boot or $failed = 1;
2606 end_monitor;
2607
2608 $in_bisect = 0;
2609
2610 if ($failed) {
2611 doprint "$min_configs{$config} is needed to boot the box... keeping\n";
2612 # this config is needed, add it to the ignore list.
2613 $keep_configs{$config} = $min_configs{$config};
2614 $save_configs{$config} = $min_configs{$config};
2615 delete $min_configs{$config};
2616
2617 # update new ignore configs
2618 if (defined($ignore_config)) {
2619 open (OUT, ">$temp_config")
2620 or die "Can't write to $temp_config";
2621 foreach my $config (keys %save_configs) {
2622 print OUT "$save_configs{$config}\n";
2623 }
2624 close OUT;
2625 run_command "mv $temp_config $ignore_config" or
2626 dodie "failed to copy update to $ignore_config";
2627 }
2628
2629 } else {
2630 # We booted without this config, remove it from the minconfigs.
2631 doprint "$config is not needed, disabling\n";
2632
2633 delete $min_configs{$config};
2634
2635 # Also disable anything that is not enabled in this config
2636 my %configs;
2637 assign_configs \%configs, $output_config;
2638 my @config_keys = keys %min_configs;
2639 foreach my $config (@config_keys) {
2640 if (!defined($configs{$config})) {
2641 doprint "$config is not set, disabling\n";
2642 delete $min_configs{$config};
2643 }
2644 }
2645
2646 # Save off all the current mandidory configs
2647 open (OUT, ">$temp_config")
2648 or die "Can't write to $temp_config";
2649 foreach my $config (keys %keep_configs) {
2650 print OUT "$keep_configs{$config}\n";
2651 }
2652 foreach my $config (keys %min_configs) {
2653 print OUT "$min_configs{$config}\n";
2654 }
2655 close OUT;
2656
2657 run_command "mv $temp_config $output_minconfig" or
2658 dodie "failed to copy update to $output_minconfig";
2659 }
2660
2661 doprint "Reboot and wait $sleep_time seconds\n";
2662 reboot;
2663 start_monitor;
2664 wait_for_monitor $sleep_time;
2665 end_monitor;
2666 }
2667
2668 success $i;
2669 return 1;
2670}
2671
2672$#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl config-file\n";
2673
2674if ($#ARGV == 0) {
2675 $ktest_config = $ARGV[0];
2676 if (! -f $ktest_config) {
2677 print "$ktest_config does not exist.\n";
2678 if (!read_yn "Create it?") {
2679 exit 0;
2680 }
2681 }
2682} else {
2683 $ktest_config = "ktest.conf";
2684}
2685
2686if (! -f $ktest_config) {
2687 open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
2688 print OUT << "EOF"
2689# Generated by ktest.pl
2690#
2691# Define each test with TEST_START
2692# The config options below it will override the defaults
2693TEST_START
2694
2695DEFAULTS
2696EOF
2697;
2698 close(OUT);
2699}
2700read_config $ktest_config;
2701
2702if (defined($opt{"LOG_FILE"})) {
2703 $opt{"LOG_FILE"} = eval_option($opt{"LOG_FILE"}, -1);
2704}
2705
2706# Append any configs entered in manually to the config file.
2707my @new_configs = keys %entered_configs;
2708if ($#new_configs >= 0) {
2709 print "\nAppending entered in configs to $ktest_config\n";
2710 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
2711 foreach my $config (@new_configs) {
2712 print OUT "$config = $entered_configs{$config}\n";
2713 $opt{$config} = $entered_configs{$config};
2714 }
2715}
2716
2717if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
2718 unlink $opt{"LOG_FILE"};
2719}
2720
2721doprint "\n\nSTARTING AUTOMATED TESTS\n\n";
2722
2723for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
2724
2725 if (!$i) {
2726 doprint "DEFAULT OPTIONS:\n";
2727 } else {
2728 doprint "\nTEST $i OPTIONS";
2729 if (defined($repeat_tests{$i})) {
2730 $repeat = $repeat_tests{$i};
2731 doprint " ITERATE $repeat";
2732 }
2733 doprint "\n";
2734 }
2735
2736 foreach my $option (sort keys %opt) {
2737
2738 if ($option =~ /\[(\d+)\]$/) {
2739 next if ($i != $1);
2740 } else {
2741 next if ($i);
2742 }
2743
2744 doprint "$option = $opt{$option}\n";
2745 }
2746}
2747
2748sub __set_test_option {
2749 my ($name, $i) = @_;
2750
2751 my $option = "$name\[$i\]";
2752
2753 if (defined($opt{$option})) {
2754 return $opt{$option};
2755 }
2756
2757 foreach my $test (keys %repeat_tests) {
2758 if ($i >= $test &&
2759 $i < $test + $repeat_tests{$test}) {
2760 $option = "$name\[$test\]";
2761 if (defined($opt{$option})) {
2762 return $opt{$option};
2763 }
2764 }
2765 }
2766
2767 if (defined($opt{$name})) {
2768 return $opt{$name};
2769 }
2770
2771 return undef;
2772}
2773
2774sub set_test_option {
2775 my ($name, $i) = @_;
2776
2777 my $option = __set_test_option($name, $i);
2778 return $option if (!defined($option));
2779
2780 return eval_option($option, $i);
2781}
2782
2783# First we need to do is the builds
2784for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
2785
2786 $iteration = $i;
2787
2788 my $makecmd = set_test_option("MAKE_CMD", $i);
2789
2790 $machine = set_test_option("MACHINE", $i);
2791 $ssh_user = set_test_option("SSH_USER", $i);
2792 $tmpdir = set_test_option("TMP_DIR", $i);
2793 $outputdir = set_test_option("OUTPUT_DIR", $i);
2794 $builddir = set_test_option("BUILD_DIR", $i);
2795 $test_type = set_test_option("TEST_TYPE", $i);
2796 $build_type = set_test_option("BUILD_TYPE", $i);
2797 $build_options = set_test_option("BUILD_OPTIONS", $i);
2798 $pre_build = set_test_option("PRE_BUILD", $i);
2799 $post_build = set_test_option("POST_BUILD", $i);
2800 $pre_build_die = set_test_option("PRE_BUILD_DIE", $i);
2801 $post_build_die = set_test_option("POST_BUILD_DIE", $i);
2802 $power_cycle = set_test_option("POWER_CYCLE", $i);
2803 $reboot = set_test_option("REBOOT", $i);
2804 $noclean = set_test_option("BUILD_NOCLEAN", $i);
2805 $minconfig = set_test_option("MIN_CONFIG", $i);
2806 $output_minconfig = set_test_option("OUTPUT_MIN_CONFIG", $i);
2807 $start_minconfig = set_test_option("START_MIN_CONFIG", $i);
2808 $ignore_config = set_test_option("IGNORE_CONFIG", $i);
2809 $run_test = set_test_option("TEST", $i);
2810 $addconfig = set_test_option("ADD_CONFIG", $i);
2811 $reboot_type = set_test_option("REBOOT_TYPE", $i);
2812 $grub_menu = set_test_option("GRUB_MENU", $i);
2813 $post_install = set_test_option("POST_INSTALL", $i);
2814 $reboot_script = set_test_option("REBOOT_SCRIPT", $i);
2815 $reboot_on_error = set_test_option("REBOOT_ON_ERROR", $i);
2816 $poweroff_on_error = set_test_option("POWEROFF_ON_ERROR", $i);
2817 $die_on_failure = set_test_option("DIE_ON_FAILURE", $i);
2818 $power_off = set_test_option("POWER_OFF", $i);
2819 $powercycle_after_reboot = set_test_option("POWERCYCLE_AFTER_REBOOT", $i);
2820 $poweroff_after_halt = set_test_option("POWEROFF_AFTER_HALT", $i);
2821 $sleep_time = set_test_option("SLEEP_TIME", $i);
2822 $bisect_sleep_time = set_test_option("BISECT_SLEEP_TIME", $i);
2823 $patchcheck_sleep_time = set_test_option("PATCHCHECK_SLEEP_TIME", $i);
2824 $ignore_warnings = set_test_option("IGNORE_WARNINGS", $i);
2825 $bisect_manual = set_test_option("BISECT_MANUAL", $i);
2826 $bisect_skip = set_test_option("BISECT_SKIP", $i);
2827 $config_bisect_good = set_test_option("CONFIG_BISECT_GOOD", $i);
2828 $store_failures = set_test_option("STORE_FAILURES", $i);
2829 $test_name = set_test_option("TEST_NAME", $i);
2830 $timeout = set_test_option("TIMEOUT", $i);
2831 $booted_timeout = set_test_option("BOOTED_TIMEOUT", $i);
2832 $console = set_test_option("CONSOLE", $i);
2833 $detect_triplefault = set_test_option("DETECT_TRIPLE_FAULT", $i);
2834 $success_line = set_test_option("SUCCESS_LINE", $i);
2835 $stop_after_success = set_test_option("STOP_AFTER_SUCCESS", $i);
2836 $stop_after_failure = set_test_option("STOP_AFTER_FAILURE", $i);
2837 $stop_test_after = set_test_option("STOP_TEST_AFTER", $i);
2838 $build_target = set_test_option("BUILD_TARGET", $i);
2839 $ssh_exec = set_test_option("SSH_EXEC", $i);
2840 $scp_to_target = set_test_option("SCP_TO_TARGET", $i);
2841 $target_image = set_test_option("TARGET_IMAGE", $i);
2842 $localversion = set_test_option("LOCALVERSION", $i);
2843
2844 $start_minconfig_defined = 1;
2845
2846 if (!defined($start_minconfig)) {
2847 $start_minconfig_defined = 0;
2848 $start_minconfig = $minconfig;
2849 }
2850
2851 chdir $builddir || die "can't change directory to $builddir";
2852
2853 if (!-d $tmpdir) {
2854 mkpath($tmpdir) or
2855 die "can't create $tmpdir";
2856 }
2857
2858 $ENV{"SSH_USER"} = $ssh_user;
2859 $ENV{"MACHINE"} = $machine;
2860
2861 $target = "$ssh_user\@$machine";
2862
2863 $buildlog = "$tmpdir/buildlog-$machine";
2864 $dmesg = "$tmpdir/dmesg-$machine";
2865 $make = "$makecmd O=$outputdir";
2866 $output_config = "$outputdir/.config";
2867
2868 if ($reboot_type eq "grub") {
2869 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
2870 } elsif (!defined($reboot_script)) {
2871 dodie "REBOOT_SCRIPT not defined"
2872 }
2873
2874 my $run_type = $build_type;
2875 if ($test_type eq "patchcheck") {
2876 $run_type = $opt{"PATCHCHECK_TYPE[$i]"};
2877 } elsif ($test_type eq "bisect") {
2878 $run_type = $opt{"BISECT_TYPE[$i]"};
2879 } elsif ($test_type eq "config_bisect") {
2880 $run_type = $opt{"CONFIG_BISECT_TYPE[$i]"};
2881 }
2882
2883 if ($test_type eq "make_min_config") {
2884 $run_type = "";
2885 }
2886
2887 # mistake in config file?
2888 if (!defined($run_type)) {
2889 $run_type = "ERROR";
2890 }
2891
2892 doprint "\n\n";
2893 doprint "RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type\n\n";
2894
2895 unlink $dmesg;
2896 unlink $buildlog;
2897
2898 if (defined($addconfig)) {
2899 my $min = $minconfig;
2900 if (!defined($minconfig)) {
2901 $min = "";
2902 }
2903 run_command "cat $addconfig $min > $tmpdir/add_config" or
2904 dodie "Failed to create temp config";
2905 $minconfig = "$tmpdir/add_config";
2906 }
2907
2908 my $checkout = $opt{"CHECKOUT[$i]"};
2909 if (defined($checkout)) {
2910 run_command "git checkout $checkout" or
2911 die "failed to checkout $checkout";
2912 }
2913
2914 if ($test_type eq "bisect") {
2915 bisect $i;
2916 next;
2917 } elsif ($test_type eq "config_bisect") {
2918 config_bisect $i;
2919 next;
2920 } elsif ($test_type eq "patchcheck") {
2921 patchcheck $i;
2922 next;
2923 } elsif ($test_type eq "make_min_config") {
2924 make_min_config $i;
2925 next;
2926 }
2927
2928 if ($build_type ne "nobuild") {
2929 build $build_type or next;
2930 }
2931
2932 if ($test_type ne "build") {
2933 my $failed = 0;
2934 start_monitor_and_boot or $failed = 1;
2935
2936 if (!$failed && $test_type ne "boot" && defined($run_test)) {
2937 do_run_test or $failed = 1;
2938 }
2939 end_monitor;
2940 next if ($failed);
2941 }
2942
2943 success $i;
2944}
2945
2946if ($opt{"POWEROFF_ON_SUCCESS"}) {
2947 halt;
2948} elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot) {
2949 reboot;
2950}
2951
2952doprint "\n $successes of $opt{NUM_TESTS} tests were successful\n\n";
2953
2954exit 0;
1#!/usr/bin/perl -w
2# SPDX-License-Identifier: GPL-2.0-only
3#
4# Copyright 2010 - Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
5#
6
7use strict;
8use IPC::Open2;
9use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
10use File::Path qw(mkpath);
11use File::Copy qw(cp);
12use FileHandle;
13use FindBin;
14
15my $VERSION = "0.2";
16
17$| = 1;
18
19my %opt;
20my %repeat_tests;
21my %repeats;
22my %evals;
23
24#default opts
25my %default = (
26 "MAILER" => "sendmail", # default mailer
27 "EMAIL_ON_ERROR" => 1,
28 "EMAIL_WHEN_FINISHED" => 1,
29 "EMAIL_WHEN_CANCELED" => 0,
30 "EMAIL_WHEN_STARTED" => 0,
31 "NUM_TESTS" => 1,
32 "TEST_TYPE" => "build",
33 "BUILD_TYPE" => "randconfig",
34 "MAKE_CMD" => "make",
35 "CLOSE_CONSOLE_SIGNAL" => "INT",
36 "TIMEOUT" => 120,
37 "TMP_DIR" => "/tmp/ktest/\${MACHINE}",
38 "SLEEP_TIME" => 60, # sleep time between tests
39 "BUILD_NOCLEAN" => 0,
40 "REBOOT_ON_ERROR" => 0,
41 "POWEROFF_ON_ERROR" => 0,
42 "REBOOT_ON_SUCCESS" => 1,
43 "POWEROFF_ON_SUCCESS" => 0,
44 "BUILD_OPTIONS" => "",
45 "BISECT_SLEEP_TIME" => 60, # sleep time between bisects
46 "PATCHCHECK_SLEEP_TIME" => 60, # sleep time between patch checks
47 "CLEAR_LOG" => 0,
48 "BISECT_MANUAL" => 0,
49 "BISECT_SKIP" => 1,
50 "BISECT_TRIES" => 1,
51 "MIN_CONFIG_TYPE" => "boot",
52 "SUCCESS_LINE" => "login:",
53 "DETECT_TRIPLE_FAULT" => 1,
54 "NO_INSTALL" => 0,
55 "BOOTED_TIMEOUT" => 1,
56 "DIE_ON_FAILURE" => 1,
57 "SSH_EXEC" => "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND",
58 "SCP_TO_TARGET" => "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE",
59 "SCP_TO_TARGET_INSTALL" => "\${SCP_TO_TARGET}",
60 "REBOOT" => "ssh \$SSH_USER\@\$MACHINE reboot",
61 "REBOOT_RETURN_CODE" => 255,
62 "STOP_AFTER_SUCCESS" => 10,
63 "STOP_AFTER_FAILURE" => 60,
64 "STOP_TEST_AFTER" => 600,
65 "MAX_MONITOR_WAIT" => 1800,
66 "GRUB_REBOOT" => "grub2-reboot",
67 "GRUB_BLS_GET" => "grubby --info=ALL",
68 "SYSLINUX" => "extlinux",
69 "SYSLINUX_PATH" => "/boot/extlinux",
70 "CONNECT_TIMEOUT" => 25,
71
72# required, and we will ask users if they don't have them but we keep the default
73# value something that is common.
74 "REBOOT_TYPE" => "grub",
75 "LOCALVERSION" => "-test",
76 "SSH_USER" => "root",
77 "BUILD_TARGET" => "arch/x86/boot/bzImage",
78 "TARGET_IMAGE" => "/boot/vmlinuz-test",
79
80 "LOG_FILE" => undef,
81 "IGNORE_UNUSED" => 0,
82);
83
84my $ktest_config = "ktest.conf";
85my $version;
86my $have_version = 0;
87my $machine;
88my $last_machine;
89my $ssh_user;
90my $tmpdir;
91my $builddir;
92my $outputdir;
93my $output_config;
94my $test_type;
95my $build_type;
96my $build_options;
97my $final_post_ktest;
98my $pre_ktest;
99my $post_ktest;
100my $pre_test;
101my $post_test;
102my $pre_build;
103my $post_build;
104my $pre_build_die;
105my $post_build_die;
106my $reboot_type;
107my $reboot_script;
108my $power_cycle;
109my $reboot;
110my $reboot_return_code;
111my $reboot_on_error;
112my $switch_to_good;
113my $switch_to_test;
114my $poweroff_on_error;
115my $reboot_on_success;
116my $die_on_failure;
117my $powercycle_after_reboot;
118my $poweroff_after_halt;
119my $max_monitor_wait;
120my $ssh_exec;
121my $scp_to_target;
122my $scp_to_target_install;
123my $power_off;
124my $grub_menu;
125my $last_grub_menu;
126my $grub_file;
127my $grub_number;
128my $grub_reboot;
129my $grub_bls_get;
130my $syslinux;
131my $syslinux_path;
132my $syslinux_label;
133my $target;
134my $make;
135my $pre_install;
136my $post_install;
137my $no_install;
138my $noclean;
139my $minconfig;
140my $start_minconfig;
141my $start_minconfig_defined;
142my $output_minconfig;
143my $minconfig_type;
144my $use_output_minconfig;
145my $warnings_file;
146my $ignore_config;
147my $ignore_errors;
148my $addconfig;
149my $in_bisect = 0;
150my $bisect_bad_commit = "";
151my $reverse_bisect;
152my $bisect_manual;
153my $bisect_skip;
154my $bisect_tries;
155my $config_bisect_good;
156my $bisect_ret_good;
157my $bisect_ret_bad;
158my $bisect_ret_skip;
159my $bisect_ret_abort;
160my $bisect_ret_default;
161my $in_patchcheck = 0;
162my $run_test;
163my $buildlog;
164my $testlog;
165my $dmesg;
166my $monitor_fp;
167my $monitor_pid;
168my $monitor_cnt = 0;
169my $sleep_time;
170my $bisect_sleep_time;
171my $patchcheck_sleep_time;
172my $ignore_warnings;
173my $store_failures;
174my $store_successes;
175my $test_name;
176my $timeout;
177my $connect_timeout;
178my $config_bisect_exec;
179my $booted_timeout;
180my $detect_triplefault;
181my $console;
182my $close_console_signal;
183my $reboot_success_line;
184my $success_line;
185my $stop_after_success;
186my $stop_after_failure;
187my $stop_test_after;
188my $build_target;
189my $target_image;
190my $checkout;
191my $localversion;
192my $iteration = 0;
193my $successes = 0;
194my $stty_orig;
195my $run_command_status = 0;
196
197my $bisect_good;
198my $bisect_bad;
199my $bisect_type;
200my $bisect_start;
201my $bisect_replay;
202my $bisect_files;
203my $bisect_reverse;
204my $bisect_check;
205
206my $config_bisect;
207my $config_bisect_type;
208my $config_bisect_check;
209
210my $patchcheck_type;
211my $patchcheck_start;
212my $patchcheck_cherry;
213my $patchcheck_end;
214
215my $build_time;
216my $install_time;
217my $reboot_time;
218my $test_time;
219
220my $pwd;
221my $dirname = $FindBin::Bin;
222
223my $mailto;
224my $mailer;
225my $mail_path;
226my $mail_command;
227my $email_on_error;
228my $email_when_finished;
229my $email_when_started;
230my $email_when_canceled;
231
232my $script_start_time = localtime();
233
234# set when a test is something other that just building or install
235# which would require more options.
236my $buildonly = 1;
237
238# tell build not to worry about warnings, even when WARNINGS_FILE is set
239my $warnings_ok = 0;
240
241# set when creating a new config
242my $newconfig = 0;
243
244my %entered_configs;
245my %config_help;
246my %variable;
247
248# force_config is the list of configs that we force enabled (or disabled)
249# in a .config file. The MIN_CONFIG and ADD_CONFIG configs.
250my %force_config;
251
252# do not force reboots on config problems
253my $no_reboot = 1;
254
255# reboot on success
256my $reboot_success = 0;
257
258my %option_map = (
259 "MAILTO" => \$mailto,
260 "MAILER" => \$mailer,
261 "MAIL_PATH" => \$mail_path,
262 "MAIL_COMMAND" => \$mail_command,
263 "EMAIL_ON_ERROR" => \$email_on_error,
264 "EMAIL_WHEN_FINISHED" => \$email_when_finished,
265 "EMAIL_WHEN_STARTED" => \$email_when_started,
266 "EMAIL_WHEN_CANCELED" => \$email_when_canceled,
267 "MACHINE" => \$machine,
268 "SSH_USER" => \$ssh_user,
269 "TMP_DIR" => \$tmpdir,
270 "OUTPUT_DIR" => \$outputdir,
271 "BUILD_DIR" => \$builddir,
272 "TEST_TYPE" => \$test_type,
273 "PRE_KTEST" => \$pre_ktest,
274 "POST_KTEST" => \$post_ktest,
275 "PRE_TEST" => \$pre_test,
276 "POST_TEST" => \$post_test,
277 "BUILD_TYPE" => \$build_type,
278 "BUILD_OPTIONS" => \$build_options,
279 "PRE_BUILD" => \$pre_build,
280 "POST_BUILD" => \$post_build,
281 "PRE_BUILD_DIE" => \$pre_build_die,
282 "POST_BUILD_DIE" => \$post_build_die,
283 "POWER_CYCLE" => \$power_cycle,
284 "REBOOT" => \$reboot,
285 "REBOOT_RETURN_CODE" => \$reboot_return_code,
286 "BUILD_NOCLEAN" => \$noclean,
287 "MIN_CONFIG" => \$minconfig,
288 "OUTPUT_MIN_CONFIG" => \$output_minconfig,
289 "START_MIN_CONFIG" => \$start_minconfig,
290 "MIN_CONFIG_TYPE" => \$minconfig_type,
291 "USE_OUTPUT_MIN_CONFIG" => \$use_output_minconfig,
292 "WARNINGS_FILE" => \$warnings_file,
293 "IGNORE_CONFIG" => \$ignore_config,
294 "TEST" => \$run_test,
295 "ADD_CONFIG" => \$addconfig,
296 "REBOOT_TYPE" => \$reboot_type,
297 "GRUB_MENU" => \$grub_menu,
298 "GRUB_FILE" => \$grub_file,
299 "GRUB_REBOOT" => \$grub_reboot,
300 "GRUB_BLS_GET" => \$grub_bls_get,
301 "SYSLINUX" => \$syslinux,
302 "SYSLINUX_PATH" => \$syslinux_path,
303 "SYSLINUX_LABEL" => \$syslinux_label,
304 "PRE_INSTALL" => \$pre_install,
305 "POST_INSTALL" => \$post_install,
306 "NO_INSTALL" => \$no_install,
307 "REBOOT_SCRIPT" => \$reboot_script,
308 "REBOOT_ON_ERROR" => \$reboot_on_error,
309 "SWITCH_TO_GOOD" => \$switch_to_good,
310 "SWITCH_TO_TEST" => \$switch_to_test,
311 "POWEROFF_ON_ERROR" => \$poweroff_on_error,
312 "REBOOT_ON_SUCCESS" => \$reboot_on_success,
313 "DIE_ON_FAILURE" => \$die_on_failure,
314 "POWER_OFF" => \$power_off,
315 "POWERCYCLE_AFTER_REBOOT" => \$powercycle_after_reboot,
316 "POWEROFF_AFTER_HALT" => \$poweroff_after_halt,
317 "MAX_MONITOR_WAIT" => \$max_monitor_wait,
318 "SLEEP_TIME" => \$sleep_time,
319 "BISECT_SLEEP_TIME" => \$bisect_sleep_time,
320 "PATCHCHECK_SLEEP_TIME" => \$patchcheck_sleep_time,
321 "IGNORE_WARNINGS" => \$ignore_warnings,
322 "IGNORE_ERRORS" => \$ignore_errors,
323 "BISECT_MANUAL" => \$bisect_manual,
324 "BISECT_SKIP" => \$bisect_skip,
325 "BISECT_TRIES" => \$bisect_tries,
326 "CONFIG_BISECT_GOOD" => \$config_bisect_good,
327 "BISECT_RET_GOOD" => \$bisect_ret_good,
328 "BISECT_RET_BAD" => \$bisect_ret_bad,
329 "BISECT_RET_SKIP" => \$bisect_ret_skip,
330 "BISECT_RET_ABORT" => \$bisect_ret_abort,
331 "BISECT_RET_DEFAULT" => \$bisect_ret_default,
332 "STORE_FAILURES" => \$store_failures,
333 "STORE_SUCCESSES" => \$store_successes,
334 "TEST_NAME" => \$test_name,
335 "TIMEOUT" => \$timeout,
336 "CONNECT_TIMEOUT" => \$connect_timeout,
337 "CONFIG_BISECT_EXEC" => \$config_bisect_exec,
338 "BOOTED_TIMEOUT" => \$booted_timeout,
339 "CONSOLE" => \$console,
340 "CLOSE_CONSOLE_SIGNAL" => \$close_console_signal,
341 "DETECT_TRIPLE_FAULT" => \$detect_triplefault,
342 "SUCCESS_LINE" => \$success_line,
343 "REBOOT_SUCCESS_LINE" => \$reboot_success_line,
344 "STOP_AFTER_SUCCESS" => \$stop_after_success,
345 "STOP_AFTER_FAILURE" => \$stop_after_failure,
346 "STOP_TEST_AFTER" => \$stop_test_after,
347 "BUILD_TARGET" => \$build_target,
348 "SSH_EXEC" => \$ssh_exec,
349 "SCP_TO_TARGET" => \$scp_to_target,
350 "SCP_TO_TARGET_INSTALL" => \$scp_to_target_install,
351 "CHECKOUT" => \$checkout,
352 "TARGET_IMAGE" => \$target_image,
353 "LOCALVERSION" => \$localversion,
354
355 "BISECT_GOOD" => \$bisect_good,
356 "BISECT_BAD" => \$bisect_bad,
357 "BISECT_TYPE" => \$bisect_type,
358 "BISECT_START" => \$bisect_start,
359 "BISECT_REPLAY" => \$bisect_replay,
360 "BISECT_FILES" => \$bisect_files,
361 "BISECT_REVERSE" => \$bisect_reverse,
362 "BISECT_CHECK" => \$bisect_check,
363
364 "CONFIG_BISECT" => \$config_bisect,
365 "CONFIG_BISECT_TYPE" => \$config_bisect_type,
366 "CONFIG_BISECT_CHECK" => \$config_bisect_check,
367
368 "PATCHCHECK_TYPE" => \$patchcheck_type,
369 "PATCHCHECK_START" => \$patchcheck_start,
370 "PATCHCHECK_CHERRY" => \$patchcheck_cherry,
371 "PATCHCHECK_END" => \$patchcheck_end,
372);
373
374# Options may be used by other options, record them.
375my %used_options;
376
377# default variables that can be used
378chomp ($variable{"PWD"} = `pwd`);
379$pwd = $variable{"PWD"};
380
381$config_help{"MACHINE"} = << "EOF"
382 The machine hostname that you will test.
383 For build only tests, it is still needed to differentiate log files.
384EOF
385 ;
386$config_help{"SSH_USER"} = << "EOF"
387 The box is expected to have ssh on normal bootup, provide the user
388 (most likely root, since you need privileged operations)
389EOF
390 ;
391$config_help{"BUILD_DIR"} = << "EOF"
392 The directory that contains the Linux source code (full path).
393 You can use \${PWD} that will be the path where ktest.pl is run, or use
394 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
395EOF
396 ;
397$config_help{"OUTPUT_DIR"} = << "EOF"
398 The directory that the objects will be built (full path).
399 (can not be same as BUILD_DIR)
400 You can use \${PWD} that will be the path where ktest.pl is run, or use
401 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
402EOF
403 ;
404$config_help{"BUILD_TARGET"} = << "EOF"
405 The location of the compiled file to copy to the target.
406 (relative to OUTPUT_DIR)
407EOF
408 ;
409$config_help{"BUILD_OPTIONS"} = << "EOF"
410 Options to add to \"make\" when building.
411 i.e. -j20
412EOF
413 ;
414$config_help{"TARGET_IMAGE"} = << "EOF"
415 The place to put your image on the test machine.
416EOF
417 ;
418$config_help{"POWER_CYCLE"} = << "EOF"
419 A script or command to reboot the box.
420
421 Here is a digital loggers power switch example
422 POWER_CYCLE = wget --no-proxy -O /dev/null -q --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL'
423
424 Here is an example to reboot a virtual box on the current host
425 with the name "Guest".
426 POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest
427EOF
428 ;
429$config_help{"CONSOLE"} = << "EOF"
430 The script or command that reads the console
431
432 If you use ttywatch server, something like the following would work.
433CONSOLE = nc -d localhost 3001
434
435 For a virtual machine with guest name "Guest".
436CONSOLE = virsh console Guest
437EOF
438 ;
439$config_help{"LOCALVERSION"} = << "EOF"
440 Required version ending to differentiate the test
441 from other linux builds on the system.
442EOF
443 ;
444$config_help{"REBOOT_TYPE"} = << "EOF"
445 Way to reboot the box to the test kernel.
446 Only valid options so far are "grub", "grub2", "grub2bls", "syslinux", and "script".
447
448 If you specify grub, it will assume grub version 1
449 and will search in /boot/grub/menu.lst for the title \$GRUB_MENU
450 and select that target to reboot to the kernel. If this is not
451 your setup, then specify "script" and have a command or script
452 specified in REBOOT_SCRIPT to boot to the target.
453
454 The entry in /boot/grub/menu.lst must be entered in manually.
455 The test will not modify that file.
456
457 If you specify grub2, then you also need to specify both \$GRUB_MENU
458 and \$GRUB_FILE.
459
460 If you specify grub2bls, then you also need to specify \$GRUB_MENU.
461
462 If you specify syslinux, then you may use SYSLINUX to define the syslinux
463 command (defaults to extlinux), and SYSLINUX_PATH to specify the path to
464 the syslinux install (defaults to /boot/extlinux). But you have to specify
465 SYSLINUX_LABEL to define the label to boot to for the test kernel.
466EOF
467 ;
468$config_help{"GRUB_MENU"} = << "EOF"
469 The grub title name for the test kernel to boot
470 (Only mandatory if REBOOT_TYPE = grub or grub2)
471
472 Note, ktest.pl will not update the grub menu.lst, you need to
473 manually add an option for the test. ktest.pl will search
474 the grub menu.lst for this option to find what kernel to
475 reboot into.
476
477 For example, if in the /boot/grub/menu.lst the test kernel title has:
478 title Test Kernel
479 kernel vmlinuz-test
480 GRUB_MENU = Test Kernel
481
482 For grub2, a search of \$GRUB_FILE is performed for the lines
483 that begin with "menuentry". It will not detect submenus. The
484 menu must be a non-nested menu. Add the quotes used in the menu
485 to guarantee your selection, as the first menuentry with the content
486 of \$GRUB_MENU that is found will be used.
487
488 For grub2bls, \$GRUB_MENU is searched on the result of \$GRUB_BLS_GET
489 command for the lines that begin with "title".
490EOF
491 ;
492$config_help{"GRUB_FILE"} = << "EOF"
493 If grub2 is used, the full path for the grub.cfg file is placed
494 here. Use something like /boot/grub2/grub.cfg to search.
495EOF
496 ;
497$config_help{"SYSLINUX_LABEL"} = << "EOF"
498 If syslinux is used, the label that boots the target kernel must
499 be specified with SYSLINUX_LABEL.
500EOF
501 ;
502$config_help{"REBOOT_SCRIPT"} = << "EOF"
503 A script to reboot the target into the test kernel
504 (Only mandatory if REBOOT_TYPE = script)
505EOF
506 ;
507
508sub _logit {
509 if (defined($opt{"LOG_FILE"})) {
510 open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
511 print OUT @_;
512 close(OUT);
513 }
514}
515
516sub logit {
517 if (defined($opt{"LOG_FILE"})) {
518 _logit @_;
519 } else {
520 print @_;
521 }
522}
523
524sub doprint {
525 print @_;
526 _logit @_;
527}
528
529sub read_prompt {
530 my ($cancel, $prompt) = @_;
531
532 my $ans;
533
534 for (;;) {
535 if ($cancel) {
536 print "$prompt [y/n/C] ";
537 } else {
538 print "$prompt [Y/n] ";
539 }
540 $ans = <STDIN>;
541 chomp $ans;
542 if ($ans =~ /^\s*$/) {
543 if ($cancel) {
544 $ans = "c";
545 } else {
546 $ans = "y";
547 }
548 }
549 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
550 if ($cancel) {
551 last if ($ans =~ /^c$/i);
552 print "Please answer either 'y', 'n' or 'c'.\n";
553 } else {
554 print "Please answer either 'y' or 'n'.\n";
555 }
556 }
557 if ($ans =~ /^c/i) {
558 exit;
559 }
560 if ($ans !~ /^y$/i) {
561 return 0;
562 }
563 return 1;
564}
565
566sub read_yn {
567 my ($prompt) = @_;
568
569 return read_prompt 0, $prompt;
570}
571
572sub read_ync {
573 my ($prompt) = @_;
574
575 return read_prompt 1, $prompt;
576}
577
578sub get_mandatory_config {
579 my ($config) = @_;
580 my $ans;
581
582 return if (defined($opt{$config}));
583
584 if (defined($config_help{$config})) {
585 print "\n";
586 print $config_help{$config};
587 }
588
589 for (;;) {
590 print "$config = ";
591 if (defined($default{$config}) && length($default{$config})) {
592 print "\[$default{$config}\] ";
593 }
594 $ans = <STDIN>;
595 $ans =~ s/^\s*(.*\S)\s*$/$1/;
596 if ($ans =~ /^\s*$/) {
597 if ($default{$config}) {
598 $ans = $default{$config};
599 } else {
600 print "Your answer can not be blank\n";
601 next;
602 }
603 }
604 $entered_configs{$config} = ${ans};
605 last;
606 }
607}
608
609sub show_time {
610 my ($time) = @_;
611
612 my $hours = 0;
613 my $minutes = 0;
614
615 if ($time > 3600) {
616 $hours = int($time / 3600);
617 $time -= $hours * 3600;
618 }
619 if ($time > 60) {
620 $minutes = int($time / 60);
621 $time -= $minutes * 60;
622 }
623
624 if ($hours > 0) {
625 doprint "$hours hour";
626 doprint "s" if ($hours > 1);
627 doprint " ";
628 }
629
630 if ($minutes > 0) {
631 doprint "$minutes minute";
632 doprint "s" if ($minutes > 1);
633 doprint " ";
634 }
635
636 doprint "$time second";
637 doprint "s" if ($time != 1);
638}
639
640sub print_times {
641 doprint "\n";
642 if ($build_time) {
643 doprint "Build time: ";
644 show_time($build_time);
645 doprint "\n";
646 }
647 if ($install_time) {
648 doprint "Install time: ";
649 show_time($install_time);
650 doprint "\n";
651 }
652 if ($reboot_time) {
653 doprint "Reboot time: ";
654 show_time($reboot_time);
655 doprint "\n";
656 }
657 if ($test_time) {
658 doprint "Test time: ";
659 show_time($test_time);
660 doprint "\n";
661 }
662 # reset for iterations like bisect
663 $build_time = 0;
664 $install_time = 0;
665 $reboot_time = 0;
666 $test_time = 0;
667}
668
669sub get_mandatory_configs {
670 get_mandatory_config("MACHINE");
671 get_mandatory_config("BUILD_DIR");
672 get_mandatory_config("OUTPUT_DIR");
673
674 if ($newconfig) {
675 get_mandatory_config("BUILD_OPTIONS");
676 }
677
678 # options required for other than just building a kernel
679 if (!$buildonly) {
680 get_mandatory_config("POWER_CYCLE");
681 get_mandatory_config("CONSOLE");
682 }
683
684 # options required for install and more
685 if ($buildonly != 1) {
686 get_mandatory_config("SSH_USER");
687 get_mandatory_config("BUILD_TARGET");
688 get_mandatory_config("TARGET_IMAGE");
689 }
690
691 get_mandatory_config("LOCALVERSION");
692
693 return if ($buildonly);
694
695 my $rtype = $opt{"REBOOT_TYPE"};
696
697 if (!defined($rtype)) {
698 if (!defined($opt{"GRUB_MENU"})) {
699 get_mandatory_config("REBOOT_TYPE");
700 $rtype = $entered_configs{"REBOOT_TYPE"};
701 } else {
702 $rtype = "grub";
703 }
704 }
705
706 if (($rtype eq "grub") or ($rtype eq "grub2bls")) {
707 get_mandatory_config("GRUB_MENU");
708 }
709
710 if ($rtype eq "grub2") {
711 get_mandatory_config("GRUB_MENU");
712 get_mandatory_config("GRUB_FILE");
713 }
714
715 if ($rtype eq "syslinux") {
716 get_mandatory_config("SYSLINUX_LABEL");
717 }
718}
719
720sub process_variables {
721 my ($value, $remove_undef) = @_;
722 my $retval = "";
723
724 # We want to check for '\', and it is just easier
725 # to check the previous characet of '$' and not need
726 # to worry if '$' is the first character. By adding
727 # a space to $value, we can just check [^\\]\$ and
728 # it will still work.
729 $value = " $value";
730
731 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
732 my $begin = $1;
733 my $var = $2;
734 my $end = $3;
735 # append beginning of value to retval
736 $retval = "$retval$begin";
737 if (defined($variable{$var})) {
738 $retval = "$retval$variable{$var}";
739 } elsif (defined($remove_undef) && $remove_undef) {
740 # for if statements, any variable that is not defined,
741 # we simple convert to 0
742 $retval = "${retval}0";
743 } else {
744 # put back the origin piece.
745 $retval = "$retval\$\{$var\}";
746 # This could be an option that is used later, save
747 # it so we don't warn if this option is not one of
748 # ktests options.
749 $used_options{$var} = 1;
750 }
751 $value = $end;
752 }
753 $retval = "$retval$value";
754
755 # remove the space added in the beginning
756 $retval =~ s/ //;
757
758 return "$retval"
759}
760
761sub set_value {
762 my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
763
764 my $prvalue = process_variables($rvalue);
765
766 if ($lvalue =~ /^(TEST|BISECT|CONFIG_BISECT)_TYPE(\[.*\])?$/ &&
767 $prvalue !~ /^(config_|)bisect$/ &&
768 $prvalue !~ /^build$/ &&
769 $buildonly) {
770
771 # Note if a test is something other than build, then we
772 # will need other mandatory options.
773 if ($prvalue ne "install") {
774 $buildonly = 0;
775 } else {
776 # install still limits some mandatory options.
777 $buildonly = 2;
778 }
779 }
780
781 if (defined($opt{$lvalue})) {
782 if (!$override || defined(${$overrides}{$lvalue})) {
783 my $extra = "";
784 if ($override) {
785 $extra = "In the same override section!\n";
786 }
787 die "$name: $.: Option $lvalue defined more than once!\n$extra";
788 }
789 ${$overrides}{$lvalue} = $prvalue;
790 }
791
792 $opt{$lvalue} = $prvalue;
793}
794
795sub set_eval {
796 my ($lvalue, $rvalue, $name) = @_;
797
798 my $prvalue = process_variables($rvalue);
799 my $arr;
800
801 if (defined($evals{$lvalue})) {
802 $arr = $evals{$lvalue};
803 } else {
804 $arr = [];
805 $evals{$lvalue} = $arr;
806 }
807
808 push @{$arr}, $rvalue;
809}
810
811sub set_variable {
812 my ($lvalue, $rvalue) = @_;
813
814 if ($rvalue =~ /^\s*$/) {
815 delete $variable{$lvalue};
816 } else {
817 $rvalue = process_variables($rvalue);
818 $variable{$lvalue} = $rvalue;
819 }
820}
821
822sub process_compare {
823 my ($lval, $cmp, $rval) = @_;
824
825 # remove whitespace
826
827 $lval =~ s/^\s*//;
828 $lval =~ s/\s*$//;
829
830 $rval =~ s/^\s*//;
831 $rval =~ s/\s*$//;
832
833 if ($cmp eq "==") {
834 return $lval eq $rval;
835 } elsif ($cmp eq "!=") {
836 return $lval ne $rval;
837 } elsif ($cmp eq "=~") {
838 return $lval =~ m/$rval/;
839 } elsif ($cmp eq "!~") {
840 return $lval !~ m/$rval/;
841 }
842
843 my $statement = "$lval $cmp $rval";
844 my $ret = eval $statement;
845
846 # $@ stores error of eval
847 if ($@) {
848 return -1;
849 }
850
851 return $ret;
852}
853
854sub value_defined {
855 my ($val) = @_;
856
857 return defined($variable{$2}) ||
858 defined($opt{$2});
859}
860
861my $d = 0;
862sub process_expression {
863 my ($name, $val) = @_;
864
865 my $c = $d++;
866
867 while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
868 my $express = $1;
869
870 if (process_expression($name, $express)) {
871 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
872 } else {
873 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
874 }
875 }
876
877 $d--;
878 my $OR = "\\|\\|";
879 my $AND = "\\&\\&";
880
881 while ($val =~ s/^(.*?)($OR|$AND)//) {
882 my $express = $1;
883 my $op = $2;
884
885 if (process_expression($name, $express)) {
886 if ($op eq "||") {
887 return 1;
888 }
889 } else {
890 if ($op eq "&&") {
891 return 0;
892 }
893 }
894 }
895
896 if ($val =~ /(.*)(==|\!=|>=|<=|>|<|=~|\!~)(.*)/) {
897 my $ret = process_compare($1, $2, $3);
898 if ($ret < 0) {
899 die "$name: $.: Unable to process comparison\n";
900 }
901 return $ret;
902 }
903
904 if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
905 if (defined $1) {
906 return !value_defined($2);
907 } else {
908 return value_defined($2);
909 }
910 }
911
912 if ($val =~ /^\s*0\s*$/) {
913 return 0;
914 } elsif ($val =~ /^\s*\d+\s*$/) {
915 return 1;
916 }
917
918 die ("$name: $.: Undefined content $val in if statement\n");
919}
920
921sub process_if {
922 my ($name, $value) = @_;
923
924 # Convert variables and replace undefined ones with 0
925 my $val = process_variables($value, 1);
926 my $ret = process_expression $name, $val;
927
928 return $ret;
929}
930
931sub __read_config {
932 my ($config, $current_test_num) = @_;
933
934 my $in;
935 open($in, $config) || die "can't read file $config";
936
937 my $name = $config;
938 $name =~ s,.*/(.*),$1,;
939
940 my $test_num = $$current_test_num;
941 my $default = 1;
942 my $repeat = 1;
943 my $num_tests_set = 0;
944 my $skip = 0;
945 my $rest;
946 my $line;
947 my $test_case = 0;
948 my $if = 0;
949 my $if_set = 0;
950 my $override = 0;
951
952 my %overrides;
953
954 while (<$in>) {
955
956 # ignore blank lines and comments
957 next if (/^\s*$/ || /\s*\#/);
958
959 if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
960
961 my $type = $1;
962 $rest = $2;
963 $line = $2;
964
965 my $old_test_num;
966 my $old_repeat;
967 $override = 0;
968
969 if ($type eq "TEST_START") {
970
971 if ($num_tests_set) {
972 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
973 }
974
975 $old_test_num = $test_num;
976 $old_repeat = $repeat;
977
978 $test_num += $repeat;
979 $default = 0;
980 $repeat = 1;
981 } else {
982 $default = 1;
983 }
984
985 # If SKIP is anywhere in the line, the command will be skipped
986 if ($rest =~ s/\s+SKIP\b//) {
987 $skip = 1;
988 } else {
989 $test_case = 1;
990 $skip = 0;
991 }
992
993 if ($rest =~ s/\sELSE\b//) {
994 if (!$if) {
995 die "$name: $.: ELSE found with out matching IF section\n$_";
996 }
997 $if = 0;
998
999 if ($if_set) {
1000 $skip = 1;
1001 } else {
1002 $skip = 0;
1003 }
1004 }
1005
1006 if ($rest =~ s/\sIF\s+(.*)//) {
1007 if (process_if($name, $1)) {
1008 $if_set = 1;
1009 } else {
1010 $skip = 1;
1011 }
1012 $if = 1;
1013 } else {
1014 $if = 0;
1015 $if_set = 0;
1016 }
1017
1018 if (!$skip) {
1019 if ($type eq "TEST_START") {
1020 if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
1021 $repeat = $1;
1022 $repeat_tests{"$test_num"} = $repeat;
1023 }
1024 } elsif ($rest =~ s/\sOVERRIDE\b//) {
1025 # DEFAULT only
1026 $override = 1;
1027 # Clear previous overrides
1028 %overrides = ();
1029 }
1030 }
1031
1032 if (!$skip && $rest !~ /^\s*$/) {
1033 die "$name: $.: Gargbage found after $type\n$_";
1034 }
1035
1036 if ($skip && $type eq "TEST_START") {
1037 $test_num = $old_test_num;
1038 $repeat = $old_repeat;
1039 }
1040
1041 } elsif (/^\s*ELSE\b(.*)$/) {
1042 if (!$if) {
1043 die "$name: $.: ELSE found with out matching IF section\n$_";
1044 }
1045 $rest = $1;
1046 if ($if_set) {
1047 $skip = 1;
1048 $rest = "";
1049 } else {
1050 $skip = 0;
1051
1052 if ($rest =~ /\sIF\s+(.*)/) {
1053 # May be a ELSE IF section.
1054 if (process_if($name, $1)) {
1055 $if_set = 1;
1056 } else {
1057 $skip = 1;
1058 }
1059 $rest = "";
1060 } else {
1061 $if = 0;
1062 }
1063 }
1064
1065 if ($rest !~ /^\s*$/) {
1066 die "$name: $.: Gargbage found after DEFAULTS\n$_";
1067 }
1068
1069 } elsif (/^\s*INCLUDE\s+(\S+)/) {
1070
1071 next if ($skip);
1072
1073 if (!$default) {
1074 die "$name: $.: INCLUDE can only be done in default sections\n$_";
1075 }
1076
1077 my $file = process_variables($1);
1078
1079 if ($file !~ m,^/,) {
1080 # check the path of the config file first
1081 if ($config =~ m,(.*)/,) {
1082 if (-f "$1/$file") {
1083 $file = "$1/$file";
1084 }
1085 }
1086 }
1087
1088 if ( ! -r $file ) {
1089 die "$name: $.: Can't read file $file\n$_";
1090 }
1091
1092 if (__read_config($file, \$test_num)) {
1093 $test_case = 1;
1094 }
1095
1096 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=~\s*(.*?)\s*$/) {
1097
1098 next if ($skip);
1099
1100 my $lvalue = $1;
1101 my $rvalue = $2;
1102
1103 if ($default || $lvalue =~ /\[\d+\]$/) {
1104 set_eval($lvalue, $rvalue, $name);
1105 } else {
1106 my $val = "$lvalue\[$test_num\]";
1107 set_eval($val, $rvalue, $name);
1108 }
1109
1110 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
1111
1112 next if ($skip);
1113
1114 my $lvalue = $1;
1115 my $rvalue = $2;
1116
1117 if (!$default &&
1118 ($lvalue eq "NUM_TESTS" ||
1119 $lvalue eq "LOG_FILE" ||
1120 $lvalue eq "CLEAR_LOG")) {
1121 die "$name: $.: $lvalue must be set in DEFAULTS section\n";
1122 }
1123
1124 if ($lvalue eq "NUM_TESTS") {
1125 if ($test_num) {
1126 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
1127 }
1128 if (!$default) {
1129 die "$name: $.: NUM_TESTS must be set in default section\n";
1130 }
1131 $num_tests_set = 1;
1132 }
1133
1134 if ($default || $lvalue =~ /\[\d+\]$/) {
1135 set_value($lvalue, $rvalue, $override, \%overrides, $name);
1136 } else {
1137 my $val = "$lvalue\[$test_num\]";
1138 set_value($val, $rvalue, $override, \%overrides, $name);
1139
1140 if ($repeat > 1) {
1141 $repeats{$val} = $repeat;
1142 }
1143 }
1144 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
1145 next if ($skip);
1146
1147 my $lvalue = $1;
1148 my $rvalue = $2;
1149
1150 # process config variables.
1151 # Config variables are only active while reading the
1152 # config and can be defined anywhere. They also ignore
1153 # TEST_START and DEFAULTS, but are skipped if they are in
1154 # on of these sections that have SKIP defined.
1155 # The save variable can be
1156 # defined multiple times and the new one simply overrides
1157 # the prevous one.
1158 set_variable($lvalue, $rvalue);
1159
1160 } else {
1161 die "$name: $.: Garbage found in config\n$_";
1162 }
1163 }
1164
1165 if ($test_num) {
1166 $test_num += $repeat - 1;
1167 $opt{"NUM_TESTS"} = $test_num;
1168 }
1169
1170 close($in);
1171
1172 $$current_test_num = $test_num;
1173
1174 return $test_case;
1175}
1176
1177sub get_test_case {
1178 print "What test case would you like to run?\n";
1179 print " (build, install or boot)\n";
1180 print " Other tests are available but require editing ktest.conf\n";
1181 print " (see tools/testing/ktest/sample.conf)\n";
1182 my $ans = <STDIN>;
1183 chomp $ans;
1184 $default{"TEST_TYPE"} = $ans;
1185}
1186
1187sub read_config {
1188 my ($config) = @_;
1189
1190 my $test_case;
1191 my $test_num = 0;
1192
1193 $test_case = __read_config $config, \$test_num;
1194
1195 # make sure we have all mandatory configs
1196 get_mandatory_configs;
1197
1198 # was a test specified?
1199 if (!$test_case) {
1200 print "No test case specified.\n";
1201 get_test_case;
1202 }
1203
1204 # set any defaults
1205
1206 foreach my $default (keys %default) {
1207 if (!defined($opt{$default})) {
1208 $opt{$default} = $default{$default};
1209 }
1210 }
1211
1212 if ($opt{"IGNORE_UNUSED"} == 1) {
1213 return;
1214 }
1215
1216 my %not_used;
1217
1218 # check if there are any stragglers (typos?)
1219 foreach my $option (keys %opt) {
1220 my $op = $option;
1221 # remove per test labels.
1222 $op =~ s/\[.*\]//;
1223 if (!exists($option_map{$op}) &&
1224 !exists($default{$op}) &&
1225 !exists($used_options{$op})) {
1226 $not_used{$op} = 1;
1227 }
1228 }
1229
1230 if (%not_used) {
1231 my $s = "s are";
1232 $s = " is" if (keys %not_used == 1);
1233 print "The following option$s not used; could be a typo:\n";
1234 foreach my $option (keys %not_used) {
1235 print "$option\n";
1236 }
1237 print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";
1238 if (!read_yn "Do you want to continue?") {
1239 exit -1;
1240 }
1241 }
1242}
1243
1244sub __eval_option {
1245 my ($name, $option, $i) = @_;
1246
1247 # Add space to evaluate the character before $
1248 $option = " $option";
1249 my $retval = "";
1250 my $repeated = 0;
1251 my $parent = 0;
1252
1253 foreach my $test (keys %repeat_tests) {
1254 if ($i >= $test &&
1255 $i < $test + $repeat_tests{$test}) {
1256
1257 $repeated = 1;
1258 $parent = $test;
1259 last;
1260 }
1261 }
1262
1263 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
1264 my $start = $1;
1265 my $var = $2;
1266 my $end = $3;
1267
1268 # Append beginning of line
1269 $retval = "$retval$start";
1270
1271 # If the iteration option OPT[$i] exists, then use that.
1272 # otherwise see if the default OPT (without [$i]) exists.
1273
1274 my $o = "$var\[$i\]";
1275 my $parento = "$var\[$parent\]";
1276
1277 # If a variable contains itself, use the default var
1278 if (($var eq $name) && defined($opt{$var})) {
1279 $o = $opt{$var};
1280 $retval = "$retval$o";
1281 } elsif (defined($opt{$o})) {
1282 $o = $opt{$o};
1283 $retval = "$retval$o";
1284 } elsif ($repeated && defined($opt{$parento})) {
1285 $o = $opt{$parento};
1286 $retval = "$retval$o";
1287 } elsif (defined($opt{$var})) {
1288 $o = $opt{$var};
1289 $retval = "$retval$o";
1290 } elsif ($var eq "KERNEL_VERSION" && defined($make)) {
1291 # special option KERNEL_VERSION uses kernel version
1292 get_version();
1293 $retval = "$retval$version";
1294 } else {
1295 $retval = "$retval\$\{$var\}";
1296 }
1297
1298 $option = $end;
1299 }
1300
1301 $retval = "$retval$option";
1302
1303 $retval =~ s/^ //;
1304
1305 return $retval;
1306}
1307
1308sub process_evals {
1309 my ($name, $option, $i) = @_;
1310
1311 my $option_name = "$name\[$i\]";
1312 my $ev;
1313
1314 my $old_option = $option;
1315
1316 if (defined($evals{$option_name})) {
1317 $ev = $evals{$option_name};
1318 } elsif (defined($evals{$name})) {
1319 $ev = $evals{$name};
1320 } else {
1321 return $option;
1322 }
1323
1324 for my $e (@{$ev}) {
1325 eval "\$option =~ $e";
1326 }
1327
1328 if ($option ne $old_option) {
1329 doprint("$name changed from '$old_option' to '$option'\n");
1330 }
1331
1332 return $option;
1333}
1334
1335sub eval_option {
1336 my ($name, $option, $i) = @_;
1337
1338 my $prev = "";
1339
1340 # Since an option can evaluate to another option,
1341 # keep iterating until we do not evaluate any more
1342 # options.
1343 my $r = 0;
1344 while ($prev ne $option) {
1345 # Check for recursive evaluations.
1346 # 100 deep should be more than enough.
1347 if ($r++ > 100) {
1348 die "Over 100 evaluations accurred with $option\n" .
1349 "Check for recursive variables\n";
1350 }
1351 $prev = $option;
1352 $option = __eval_option($name, $option, $i);
1353 }
1354
1355 $option = process_evals($name, $option, $i);
1356
1357 return $option;
1358}
1359
1360sub run_command;
1361sub start_monitor;
1362sub end_monitor;
1363sub wait_for_monitor;
1364
1365sub reboot {
1366 my ($time) = @_;
1367 my $powercycle = 0;
1368
1369 # test if the machine can be connected to within a few seconds
1370 my $stat = run_ssh("echo check machine status", $connect_timeout);
1371 if (!$stat) {
1372 doprint("power cycle\n");
1373 $powercycle = 1;
1374 }
1375
1376 if ($powercycle) {
1377 run_command "$power_cycle";
1378
1379 start_monitor;
1380 # flush out current monitor
1381 # May contain the reboot success line
1382 wait_for_monitor 1;
1383
1384 } else {
1385 # Make sure everything has been written to disk
1386 run_ssh("sync");
1387
1388 if (defined($time)) {
1389 start_monitor;
1390 # flush out current monitor
1391 # May contain the reboot success line
1392 wait_for_monitor 1;
1393 }
1394
1395 # try to reboot normally
1396 if (run_command $reboot) {
1397 if (defined($powercycle_after_reboot)) {
1398 sleep $powercycle_after_reboot;
1399 run_command "$power_cycle";
1400 }
1401 } else {
1402 # nope? power cycle it.
1403 run_command "$power_cycle";
1404 }
1405 }
1406
1407 if (defined($time)) {
1408
1409 # We only want to get to the new kernel, don't fail
1410 # if we stumble over a call trace.
1411 my $save_ignore_errors = $ignore_errors;
1412 $ignore_errors = 1;
1413
1414 # Look for the good kernel to boot
1415 if (wait_for_monitor($time, "Linux version")) {
1416 # reboot got stuck?
1417 doprint "Reboot did not finish. Forcing power cycle\n";
1418 run_command "$power_cycle";
1419 }
1420
1421 $ignore_errors = $save_ignore_errors;
1422
1423 # Still need to wait for the reboot to finish
1424 wait_for_monitor($time, $reboot_success_line);
1425
1426 end_monitor;
1427 }
1428}
1429
1430sub reboot_to_good {
1431 my ($time) = @_;
1432
1433 if (defined($switch_to_good)) {
1434 run_command $switch_to_good;
1435 }
1436
1437 reboot $time;
1438}
1439
1440sub do_not_reboot {
1441 my $i = $iteration;
1442
1443 return $test_type eq "build" || $no_reboot ||
1444 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
1445 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build") ||
1446 ($test_type eq "config_bisect" && $opt{"CONFIG_BISECT_TYPE[$i]"} eq "build");
1447}
1448
1449my $in_die = 0;
1450
1451sub get_test_name() {
1452 my $name;
1453
1454 if (defined($test_name)) {
1455 $name = "$test_name:$test_type";
1456 } else {
1457 $name = $test_type;
1458 }
1459 return $name;
1460}
1461
1462sub dodie {
1463
1464 # avoid recusion
1465 return if ($in_die);
1466 $in_die = 1;
1467
1468 my $i = $iteration;
1469
1470 doprint "CRITICAL FAILURE... [TEST $i] ", @_, "\n";
1471
1472 if ($reboot_on_error && !do_not_reboot) {
1473
1474 doprint "REBOOTING\n";
1475 reboot_to_good;
1476
1477 } elsif ($poweroff_on_error && defined($power_off)) {
1478 doprint "POWERING OFF\n";
1479 `$power_off`;
1480 }
1481
1482 if (defined($opt{"LOG_FILE"})) {
1483 print " See $opt{LOG_FILE} for more info.\n";
1484 }
1485
1486 if ($email_on_error) {
1487 my $name = get_test_name;
1488 send_email("KTEST: critical failure for test $i [$name]",
1489 "Your test started at $script_start_time has failed with:\n@_\n");
1490 }
1491
1492 if ($monitor_cnt) {
1493 # restore terminal settings
1494 system("stty $stty_orig");
1495 }
1496
1497 if (defined($post_test)) {
1498 run_command $post_test;
1499 }
1500
1501 die @_, "\n";
1502}
1503
1504sub create_pty {
1505 my ($ptm, $pts) = @_;
1506 my $tmp;
1507 my $TIOCSPTLCK = 0x40045431;
1508 my $TIOCGPTN = 0x80045430;
1509
1510 sysopen($ptm, "/dev/ptmx", O_RDWR | O_NONBLOCK) or
1511 dodie "Cant open /dev/ptmx";
1512
1513 # unlockpt()
1514 $tmp = pack("i", 0);
1515 ioctl($ptm, $TIOCSPTLCK, $tmp) or
1516 dodie "ioctl TIOCSPTLCK for /dev/ptmx failed";
1517
1518 # ptsname()
1519 ioctl($ptm, $TIOCGPTN, $tmp) or
1520 dodie "ioctl TIOCGPTN for /dev/ptmx failed";
1521 $tmp = unpack("i", $tmp);
1522
1523 sysopen($pts, "/dev/pts/$tmp", O_RDWR | O_NONBLOCK) or
1524 dodie "Can't open /dev/pts/$tmp";
1525}
1526
1527sub exec_console {
1528 my ($ptm, $pts) = @_;
1529
1530 close($ptm);
1531
1532 close(\*STDIN);
1533 close(\*STDOUT);
1534 close(\*STDERR);
1535
1536 open(\*STDIN, '<&', $pts);
1537 open(\*STDOUT, '>&', $pts);
1538 open(\*STDERR, '>&', $pts);
1539
1540 close($pts);
1541
1542 exec $console or
1543 dodie "Can't open console $console";
1544}
1545
1546sub open_console {
1547 my ($ptm) = @_;
1548 my $pts = \*PTSFD;
1549 my $pid;
1550
1551 # save terminal settings
1552 $stty_orig = `stty -g`;
1553
1554 # place terminal in cbreak mode so that stdin can be read one character at
1555 # a time without having to wait for a newline
1556 system("stty -icanon -echo -icrnl");
1557
1558 create_pty($ptm, $pts);
1559
1560 $pid = fork;
1561
1562 if (!$pid) {
1563 # child
1564 exec_console($ptm, $pts)
1565 }
1566
1567 # parent
1568 close($pts);
1569
1570 return $pid;
1571
1572 open(PTSFD, "Stop perl from warning about single use of PTSFD");
1573}
1574
1575sub close_console {
1576 my ($fp, $pid) = @_;
1577
1578 doprint "kill child process $pid\n";
1579 kill $close_console_signal, $pid;
1580
1581 doprint "wait for child process $pid to exit\n";
1582 waitpid($pid, 0);
1583
1584 print "closing!\n";
1585 close($fp);
1586
1587 # restore terminal settings
1588 system("stty $stty_orig");
1589}
1590
1591sub start_monitor {
1592 if ($monitor_cnt++) {
1593 return;
1594 }
1595 $monitor_fp = \*MONFD;
1596 $monitor_pid = open_console $monitor_fp;
1597
1598 return;
1599
1600 open(MONFD, "Stop perl from warning about single use of MONFD");
1601}
1602
1603sub end_monitor {
1604 return if (!defined $console);
1605 if (--$monitor_cnt) {
1606 return;
1607 }
1608 close_console($monitor_fp, $monitor_pid);
1609}
1610
1611sub wait_for_monitor {
1612 my ($time, $stop) = @_;
1613 my $full_line = "";
1614 my $line;
1615 my $booted = 0;
1616 my $start_time = time;
1617 my $skip_call_trace = 0;
1618 my $bug = 0;
1619 my $bug_ignored = 0;
1620 my $now;
1621
1622 doprint "** Wait for monitor to settle down **\n";
1623
1624 # read the monitor and wait for the system to calm down
1625 while (!$booted) {
1626 $line = wait_for_input($monitor_fp, $time);
1627 last if (!defined($line));
1628 print "$line";
1629 $full_line .= $line;
1630
1631 if (defined($stop) && $full_line =~ /$stop/) {
1632 doprint "wait for monitor detected $stop\n";
1633 $booted = 1;
1634 }
1635
1636 if ($full_line =~ /\[ backtrace testing \]/) {
1637 $skip_call_trace = 1;
1638 }
1639
1640 if ($full_line =~ /call trace:/i) {
1641 if (!$bug && !$skip_call_trace) {
1642 if ($ignore_errors) {
1643 $bug_ignored = 1;
1644 } else {
1645 $bug = 1;
1646 }
1647 }
1648 }
1649
1650 if ($full_line =~ /\[ end of backtrace testing \]/) {
1651 $skip_call_trace = 0;
1652 }
1653
1654 if ($full_line =~ /Kernel panic -/) {
1655 $bug = 1;
1656 }
1657
1658 if ($line =~ /\n/) {
1659 $full_line = "";
1660 }
1661 $now = time;
1662 if ($now - $start_time >= $max_monitor_wait) {
1663 doprint "Exiting monitor flush due to hitting MAX_MONITOR_WAIT\n";
1664 return 1;
1665 }
1666 }
1667 print "** Monitor flushed **\n";
1668
1669 # if stop is defined but wasn't hit, return error
1670 # used by reboot (which wants to see a reboot)
1671 if (defined($stop) && !$booted) {
1672 $bug = 1;
1673 }
1674 return $bug;
1675}
1676
1677sub save_logs {
1678 my ($result, $basedir) = @_;
1679 my @t = localtime;
1680 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
1681 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
1682
1683 my $type = $build_type;
1684 if ($type =~ /useconfig/) {
1685 $type = "useconfig";
1686 }
1687
1688 my $dir = "$machine-$test_type-$type-$result-$date";
1689
1690 $dir = "$basedir/$dir";
1691
1692 if (!-d $dir) {
1693 mkpath($dir) or
1694 dodie "can't create $dir";
1695 }
1696
1697 my %files = (
1698 "config" => $output_config,
1699 "buildlog" => $buildlog,
1700 "dmesg" => $dmesg,
1701 "testlog" => $testlog,
1702 );
1703
1704 while (my ($name, $source) = each(%files)) {
1705 if (-f "$source") {
1706 cp "$source", "$dir/$name" or
1707 dodie "failed to copy $source";
1708 }
1709 }
1710
1711 doprint "*** Saved info to $dir ***\n";
1712}
1713
1714sub fail {
1715
1716 if ($die_on_failure) {
1717 dodie @_;
1718 }
1719
1720 doprint "FAILED\n";
1721
1722 my $i = $iteration;
1723
1724 # no need to reboot for just building.
1725 if (!do_not_reboot) {
1726 doprint "REBOOTING\n";
1727 reboot_to_good $sleep_time;
1728 }
1729
1730 my $name = "";
1731
1732 if (defined($test_name)) {
1733 $name = " ($test_name)";
1734 }
1735
1736 print_times;
1737
1738 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1739 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1740 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
1741 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1742 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1743
1744 if (defined($store_failures)) {
1745 save_logs "fail", $store_failures;
1746 }
1747
1748 if (defined($post_test)) {
1749 run_command $post_test;
1750 }
1751
1752 return 1;
1753}
1754
1755sub run_command {
1756 my ($command, $redirect, $timeout) = @_;
1757 my $start_time;
1758 my $end_time;
1759 my $dolog = 0;
1760 my $dord = 0;
1761 my $dostdout = 0;
1762 my $pid;
1763 my $command_orig = $command;
1764
1765 $command =~ s/\$SSH_USER/$ssh_user/g;
1766 $command =~ s/\$MACHINE/$machine/g;
1767
1768 doprint("$command ... ");
1769 $start_time = time;
1770
1771 $pid = open(CMD, "$command 2>&1 |") or
1772 (fail "unable to exec $command" and return 0);
1773
1774 if (defined($opt{"LOG_FILE"})) {
1775 open(LOG, ">>$opt{LOG_FILE}") or
1776 dodie "failed to write to log";
1777 $dolog = 1;
1778 }
1779
1780 if (defined($redirect)) {
1781 if ($redirect eq 1) {
1782 $dostdout = 1;
1783 # Have the output of the command on its own line
1784 doprint "\n";
1785 } else {
1786 open (RD, ">$redirect") or
1787 dodie "failed to write to redirect $redirect";
1788 $dord = 1;
1789 }
1790 }
1791
1792 my $hit_timeout = 0;
1793
1794 while (1) {
1795 my $fp = \*CMD;
1796 if (defined($timeout)) {
1797 doprint "timeout = $timeout\n";
1798 }
1799 my $line = wait_for_input($fp, $timeout);
1800 if (!defined($line)) {
1801 my $now = time;
1802 if (defined($timeout) && (($now - $start_time) >= $timeout)) {
1803 doprint "Hit timeout of $timeout, killing process\n";
1804 $hit_timeout = 1;
1805 kill 9, $pid;
1806 }
1807 last;
1808 }
1809 print LOG $line if ($dolog);
1810 print RD $line if ($dord);
1811 print $line if ($dostdout);
1812 }
1813
1814 waitpid($pid, 0);
1815 # shift 8 for real exit status
1816 $run_command_status = $? >> 8;
1817
1818 if ($command_orig eq $default{REBOOT} &&
1819 $run_command_status == $reboot_return_code) {
1820 $run_command_status = 0;
1821 }
1822
1823 close(CMD);
1824 close(LOG) if ($dolog);
1825 close(RD) if ($dord);
1826
1827 $end_time = time;
1828 my $delta = $end_time - $start_time;
1829
1830 if ($delta == 1) {
1831 doprint "[1 second] ";
1832 } else {
1833 doprint "[$delta seconds] ";
1834 }
1835
1836 if ($hit_timeout) {
1837 $run_command_status = 1;
1838 }
1839
1840 if ($run_command_status) {
1841 doprint "FAILED!\n";
1842 } else {
1843 doprint "SUCCESS\n";
1844 }
1845
1846 return !$run_command_status;
1847}
1848
1849sub run_ssh {
1850 my ($cmd, $timeout) = @_;
1851 my $cp_exec = $ssh_exec;
1852
1853 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
1854 return run_command "$cp_exec", undef , $timeout;
1855}
1856
1857sub run_scp {
1858 my ($src, $dst, $cp_scp) = @_;
1859
1860 $cp_scp =~ s/\$SRC_FILE/$src/g;
1861 $cp_scp =~ s/\$DST_FILE/$dst/g;
1862
1863 return run_command "$cp_scp";
1864}
1865
1866sub run_scp_install {
1867 my ($src, $dst) = @_;
1868
1869 my $cp_scp = $scp_to_target_install;
1870
1871 return run_scp($src, $dst, $cp_scp);
1872}
1873
1874sub run_scp_mod {
1875 my ($src, $dst) = @_;
1876
1877 my $cp_scp = $scp_to_target;
1878
1879 return run_scp($src, $dst, $cp_scp);
1880}
1881
1882sub _get_grub_index {
1883
1884 my ($command, $target, $skip) = @_;
1885
1886 return if (defined($grub_number) && defined($last_grub_menu) &&
1887 $last_grub_menu eq $grub_menu && defined($last_machine) &&
1888 $last_machine eq $machine);
1889
1890 doprint "Find $reboot_type menu ... ";
1891 $grub_number = -1;
1892
1893 my $ssh_grub = $ssh_exec;
1894 $ssh_grub =~ s,\$SSH_COMMAND,$command,g;
1895
1896 open(IN, "$ssh_grub |")
1897 or dodie "unable to execute $command";
1898
1899 my $found = 0;
1900
1901 while (<IN>) {
1902 if (/$target/) {
1903 $grub_number++;
1904 $found = 1;
1905 last;
1906 } elsif (/$skip/) {
1907 $grub_number++;
1908 }
1909 }
1910 close(IN);
1911
1912 dodie "Could not find '$grub_menu' through $command on $machine"
1913 if (!$found);
1914 doprint "$grub_number\n";
1915 $last_grub_menu = $grub_menu;
1916 $last_machine = $machine;
1917}
1918
1919sub get_grub_index {
1920
1921 my $command;
1922 my $target;
1923 my $skip;
1924 my $grub_menu_qt;
1925
1926 if ($reboot_type !~ /^grub/) {
1927 return;
1928 }
1929
1930 $grub_menu_qt = quotemeta($grub_menu);
1931
1932 if ($reboot_type eq "grub") {
1933 $command = "cat /boot/grub/menu.lst";
1934 $target = '^\s*title\s+' . $grub_menu_qt . '\s*$';
1935 $skip = '^\s*title\s';
1936 } elsif ($reboot_type eq "grub2") {
1937 $command = "cat $grub_file";
1938 $target = '^menuentry.*' . $grub_menu_qt;
1939 $skip = '^menuentry\s|^submenu\s';
1940 } elsif ($reboot_type eq "grub2bls") {
1941 $command = $grub_bls_get;
1942 $target = '^title=.*' . $grub_menu_qt;
1943 $skip = '^title=';
1944 } else {
1945 return;
1946 }
1947
1948 _get_grub_index($command, $target, $skip);
1949}
1950
1951sub wait_for_input
1952{
1953 my ($fp, $time) = @_;
1954 my $start_time;
1955 my $rin;
1956 my $rout;
1957 my $nr;
1958 my $buf;
1959 my $line;
1960 my $ch;
1961
1962 if (!defined($time)) {
1963 $time = $timeout;
1964 }
1965
1966 $rin = '';
1967 vec($rin, fileno($fp), 1) = 1;
1968 vec($rin, fileno(\*STDIN), 1) = 1;
1969
1970 $start_time = time;
1971
1972 while (1) {
1973 $nr = select($rout=$rin, undef, undef, $time);
1974
1975 last if ($nr <= 0);
1976
1977 # copy data from stdin to the console
1978 if (vec($rout, fileno(\*STDIN), 1) == 1) {
1979 $nr = sysread(\*STDIN, $buf, 1000);
1980 syswrite($fp, $buf, $nr) if ($nr > 0);
1981 }
1982
1983 # The timeout is based on time waiting for the fp data
1984 if (vec($rout, fileno($fp), 1) != 1) {
1985 last if (defined($time) && (time - $start_time > $time));
1986 next;
1987 }
1988
1989 $line = "";
1990
1991 # try to read one char at a time
1992 while (sysread $fp, $ch, 1) {
1993 $line .= $ch;
1994 last if ($ch eq "\n");
1995 }
1996
1997 last if (!length($line));
1998
1999 return $line;
2000 }
2001 return undef;
2002}
2003
2004sub reboot_to {
2005 if (defined($switch_to_test)) {
2006 run_command $switch_to_test;
2007 }
2008
2009 if ($reboot_type eq "grub") {
2010 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
2011 } elsif ($reboot_type eq "grub2") {
2012 run_ssh "$grub_reboot $grub_number";
2013 } elsif ($reboot_type eq "syslinux") {
2014 run_ssh "$syslinux --once \\\"$syslinux_label\\\" $syslinux_path";
2015 } elsif (defined $reboot_script) {
2016 run_command "$reboot_script";
2017 }
2018 reboot;
2019}
2020
2021sub get_sha1 {
2022 my ($commit) = @_;
2023
2024 doprint "git rev-list --max-count=1 $commit ... ";
2025 my $sha1 = `git rev-list --max-count=1 $commit`;
2026 my $ret = $?;
2027
2028 logit $sha1;
2029
2030 if ($ret) {
2031 doprint "FAILED\n";
2032 dodie "Failed to get git $commit";
2033 }
2034
2035 print "SUCCESS\n";
2036
2037 chomp $sha1;
2038
2039 return $sha1;
2040}
2041
2042sub monitor {
2043 my $booted = 0;
2044 my $bug = 0;
2045 my $bug_ignored = 0;
2046 my $skip_call_trace = 0;
2047 my $loops;
2048
2049 my $start_time = time;
2050
2051 wait_for_monitor 5;
2052
2053 my $line;
2054 my $full_line = "";
2055
2056 open(DMESG, "> $dmesg") or
2057 dodie "unable to write to $dmesg";
2058
2059 reboot_to;
2060
2061 my $success_start;
2062 my $failure_start;
2063 my $monitor_start = time;
2064 my $done = 0;
2065 my $version_found = 0;
2066
2067 while (!$done) {
2068
2069 if ($bug && defined($stop_after_failure) &&
2070 $stop_after_failure >= 0) {
2071 my $time = $stop_after_failure - (time - $failure_start);
2072 $line = wait_for_input($monitor_fp, $time);
2073 if (!defined($line)) {
2074 doprint "bug timed out after $booted_timeout seconds\n";
2075 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
2076 last;
2077 }
2078 } elsif ($booted) {
2079 $line = wait_for_input($monitor_fp, $booted_timeout);
2080 if (!defined($line)) {
2081 my $s = $booted_timeout == 1 ? "" : "s";
2082 doprint "Successful boot found: break after $booted_timeout second$s\n";
2083 last;
2084 }
2085 } else {
2086 $line = wait_for_input($monitor_fp);
2087 if (!defined($line)) {
2088 my $s = $timeout == 1 ? "" : "s";
2089 doprint "Timed out after $timeout second$s\n";
2090 last;
2091 }
2092 }
2093
2094 doprint $line;
2095 print DMESG $line;
2096
2097 # we are not guaranteed to get a full line
2098 $full_line .= $line;
2099
2100 if ($full_line =~ /$success_line/) {
2101 $booted = 1;
2102 $success_start = time;
2103 }
2104
2105 if ($booted && defined($stop_after_success) &&
2106 $stop_after_success >= 0) {
2107 my $now = time;
2108 if ($now - $success_start >= $stop_after_success) {
2109 doprint "Test forced to stop after $stop_after_success seconds after success\n";
2110 last;
2111 }
2112 }
2113
2114 if ($full_line =~ /\[ backtrace testing \]/) {
2115 $skip_call_trace = 1;
2116 }
2117
2118 if ($full_line =~ /call trace:/i) {
2119 if (!$bug && !$skip_call_trace) {
2120 if ($ignore_errors) {
2121 $bug_ignored = 1;
2122 } else {
2123 $bug = 1;
2124 $failure_start = time;
2125 }
2126 }
2127 }
2128
2129 if ($bug && defined($stop_after_failure) &&
2130 $stop_after_failure >= 0) {
2131 my $now = time;
2132 if ($now - $failure_start >= $stop_after_failure) {
2133 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
2134 last;
2135 }
2136 }
2137
2138 if ($full_line =~ /\[ end of backtrace testing \]/) {
2139 $skip_call_trace = 0;
2140 }
2141
2142 if ($full_line =~ /Kernel panic -/) {
2143 $failure_start = time;
2144 $bug = 1;
2145 }
2146
2147 # Detect triple faults by testing the banner
2148 if ($full_line =~ /\bLinux version (\S+).*\n/) {
2149 if ($1 eq $version) {
2150 $version_found = 1;
2151 } elsif ($version_found && $detect_triplefault) {
2152 # We already booted into the kernel we are testing,
2153 # but now we booted into another kernel?
2154 # Consider this a triple fault.
2155 doprint "Already booted in Linux kernel $version, but now\n";
2156 doprint "we booted into Linux kernel $1.\n";
2157 doprint "Assuming that this is a triple fault.\n";
2158 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
2159 last;
2160 }
2161 }
2162
2163 if ($line =~ /\n/) {
2164 $full_line = "";
2165 }
2166
2167 if ($stop_test_after > 0 && !$booted && !$bug) {
2168 if (time - $monitor_start > $stop_test_after) {
2169 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
2170 $done = 1;
2171 }
2172 }
2173 }
2174
2175 my $end_time = time;
2176 $reboot_time = $end_time - $start_time;
2177
2178 close(DMESG);
2179
2180 if ($bug) {
2181 return 0 if ($in_bisect);
2182 fail "failed - got a bug report" and return 0;
2183 }
2184
2185 if (!$booted) {
2186 return 0 if ($in_bisect);
2187 fail "failed - never got a boot prompt." and return 0;
2188 }
2189
2190 if ($bug_ignored) {
2191 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2192 }
2193
2194 return 1;
2195}
2196
2197sub eval_kernel_version {
2198 my ($option) = @_;
2199
2200 $option =~ s/\$KERNEL_VERSION/$version/g;
2201
2202 return $option;
2203}
2204
2205sub do_post_install {
2206
2207 return if (!defined($post_install));
2208
2209 my $cp_post_install = eval_kernel_version $post_install;
2210 run_command "$cp_post_install" or
2211 dodie "Failed to run post install";
2212}
2213
2214# Sometimes the reboot fails, and will hang. We try to ssh to the box
2215# and if we fail, we force another reboot, that should powercycle it.
2216sub test_booted {
2217 if (!run_ssh "echo testing connection") {
2218 reboot $sleep_time;
2219 }
2220}
2221
2222sub install {
2223
2224 return if ($no_install);
2225
2226 my $start_time = time;
2227
2228 if (defined($pre_install)) {
2229 my $cp_pre_install = eval_kernel_version $pre_install;
2230 run_command "$cp_pre_install" or
2231 dodie "Failed to run pre install";
2232 }
2233
2234 my $cp_target = eval_kernel_version $target_image;
2235
2236 test_booted;
2237
2238 run_scp_install "$outputdir/$build_target", "$cp_target" or
2239 dodie "failed to copy image";
2240
2241 my $install_mods = 0;
2242
2243 # should we process modules?
2244 $install_mods = 0;
2245 open(IN, "$output_config") or dodie("Can't read config file");
2246 while (<IN>) {
2247 if (/CONFIG_MODULES(=y)?/) {
2248 if (defined($1)) {
2249 $install_mods = 1;
2250 last;
2251 }
2252 }
2253 }
2254 close(IN);
2255
2256 if (!$install_mods) {
2257 do_post_install;
2258 doprint "No modules needed\n";
2259 my $end_time = time;
2260 $install_time = $end_time - $start_time;
2261 return;
2262 }
2263
2264 run_command "$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or
2265 dodie "Failed to install modules";
2266
2267 my $modlib = "/lib/modules/$version";
2268 my $modtar = "ktest-mods.tar.bz2";
2269
2270 run_ssh "rm -rf $modlib" or
2271 dodie "failed to remove old mods: $modlib";
2272
2273 # would be nice if scp -r did not follow symbolic links
2274 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
2275 dodie "making tarball";
2276
2277 run_scp_mod "$tmpdir/$modtar", "/tmp" or
2278 dodie "failed to copy modules";
2279
2280 unlink "$tmpdir/$modtar";
2281
2282 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
2283 dodie "failed to tar modules";
2284
2285 run_ssh "rm -f /tmp/$modtar";
2286
2287 do_post_install;
2288
2289 my $end_time = time;
2290 $install_time = $end_time - $start_time;
2291}
2292
2293sub get_version {
2294 # get the release name
2295 return if ($have_version);
2296 doprint "$make kernelrelease ... ";
2297 $version = `$make -s kernelrelease | tail -1`;
2298 chomp($version);
2299 doprint "$version\n";
2300 $have_version = 1;
2301}
2302
2303sub start_monitor_and_install {
2304 # Make sure the stable kernel has finished booting
2305
2306 # Install bisects, don't need console
2307 if (defined $console) {
2308 start_monitor;
2309 wait_for_monitor 5;
2310 end_monitor;
2311 }
2312
2313 get_grub_index;
2314 get_version;
2315 install;
2316
2317 start_monitor if (defined $console);
2318 return monitor;
2319}
2320
2321my $check_build_re = ".*:.*(warning|error|Error):.*";
2322my $utf8_quote = "\\x{e2}\\x{80}(\\x{98}|\\x{99})";
2323
2324sub process_warning_line {
2325 my ($line) = @_;
2326
2327 chomp $line;
2328
2329 # for distcc heterogeneous systems, some compilers
2330 # do things differently causing warning lines
2331 # to be slightly different. This makes an attempt
2332 # to fixe those issues.
2333
2334 # chop off the index into the line
2335 # using distcc, some compilers give different indexes
2336 # depending on white space
2337 $line =~ s/^(\s*\S+:\d+:)\d+/$1/;
2338
2339 # Some compilers use UTF-8 extended for quotes and some don't.
2340 $line =~ s/$utf8_quote/'/g;
2341
2342 return $line;
2343}
2344
2345# Read buildlog and check against warnings file for any
2346# new warnings.
2347#
2348# Returns 1 if OK
2349# 0 otherwise
2350sub check_buildlog {
2351 return 1 if (!defined $warnings_file);
2352
2353 my %warnings_list;
2354
2355 # Failed builds should not reboot the target
2356 my $save_no_reboot = $no_reboot;
2357 $no_reboot = 1;
2358
2359 if (-f $warnings_file) {
2360 open(IN, $warnings_file) or
2361 dodie "Error opening $warnings_file";
2362
2363 while (<IN>) {
2364 if (/$check_build_re/) {
2365 my $warning = process_warning_line $_;
2366
2367 $warnings_list{$warning} = 1;
2368 }
2369 }
2370 close(IN);
2371 }
2372
2373 # If warnings file didn't exist, and WARNINGS_FILE exist,
2374 # then we fail on any warning!
2375
2376 open(IN, $buildlog) or dodie "Can't open $buildlog";
2377 while (<IN>) {
2378 if (/$check_build_re/) {
2379 my $warning = process_warning_line $_;
2380
2381 if (!defined $warnings_list{$warning}) {
2382 fail "New warning found (not in $warnings_file)\n$_\n";
2383 $no_reboot = $save_no_reboot;
2384 return 0;
2385 }
2386 }
2387 }
2388 $no_reboot = $save_no_reboot;
2389 close(IN);
2390}
2391
2392sub check_patch_buildlog {
2393 my ($patch) = @_;
2394
2395 my @files = `git show $patch | diffstat -l`;
2396
2397 foreach my $file (@files) {
2398 chomp $file;
2399 }
2400
2401 open(IN, "git show $patch |") or
2402 dodie "failed to show $patch";
2403 while (<IN>) {
2404 if (m,^--- a/(.*),) {
2405 chomp $1;
2406 $files[$#files] = $1;
2407 }
2408 }
2409 close(IN);
2410
2411 open(IN, $buildlog) or dodie "Can't open $buildlog";
2412 while (<IN>) {
2413 if (/^\s*(.*?):.*(warning|error)/) {
2414 my $err = $1;
2415 foreach my $file (@files) {
2416 my $fullpath = "$builddir/$file";
2417 if ($file eq $err || $fullpath eq $err) {
2418 fail "$file built with warnings" and return 0;
2419 }
2420 }
2421 }
2422 }
2423 close(IN);
2424
2425 return 1;
2426}
2427
2428sub apply_min_config {
2429 my $outconfig = "$output_config.new";
2430
2431 # Read the config file and remove anything that
2432 # is in the force_config hash (from minconfig and others)
2433 # then add the force config back.
2434
2435 doprint "Applying minimum configurations into $output_config.new\n";
2436
2437 open (OUT, ">$outconfig") or
2438 dodie "Can't create $outconfig";
2439
2440 if (-f $output_config) {
2441 open (IN, $output_config) or
2442 dodie "Failed to open $output_config";
2443 while (<IN>) {
2444 if (/^(# )?(CONFIG_[^\s=]*)/) {
2445 next if (defined($force_config{$2}));
2446 }
2447 print OUT;
2448 }
2449 close IN;
2450 }
2451 foreach my $config (keys %force_config) {
2452 print OUT "$force_config{$config}\n";
2453 }
2454 close OUT;
2455
2456 run_command "mv $outconfig $output_config";
2457}
2458
2459sub make_oldconfig {
2460
2461 my @force_list = keys %force_config;
2462
2463 if ($#force_list >= 0) {
2464 apply_min_config;
2465 }
2466
2467 if (!run_command "$make olddefconfig") {
2468 # Perhaps olddefconfig doesn't exist in this version of the kernel
2469 # try oldnoconfig
2470 doprint "olddefconfig failed, trying make oldnoconfig\n";
2471 if (!run_command "$make oldnoconfig") {
2472 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
2473 # try a yes '' | oldconfig
2474 run_command "yes '' | $make oldconfig" or
2475 dodie "failed make config oldconfig";
2476 }
2477 }
2478}
2479
2480# read a config file and use this to force new configs.
2481sub load_force_config {
2482 my ($config) = @_;
2483
2484 doprint "Loading force configs from $config\n";
2485 open(IN, $config) or
2486 dodie "failed to read $config";
2487 while (<IN>) {
2488 chomp;
2489 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
2490 $force_config{$1} = $_;
2491 } elsif (/^# (CONFIG_\S*) is not set/) {
2492 $force_config{$1} = $_;
2493 }
2494 }
2495 close IN;
2496}
2497
2498sub build {
2499 my ($type) = @_;
2500
2501 unlink $buildlog;
2502
2503 my $start_time = time;
2504
2505 # Failed builds should not reboot the target
2506 my $save_no_reboot = $no_reboot;
2507 $no_reboot = 1;
2508
2509 # Calculate a new version from here.
2510 $have_version = 0;
2511
2512 if (defined($pre_build)) {
2513 my $ret = run_command $pre_build;
2514 if (!$ret && defined($pre_build_die) &&
2515 $pre_build_die) {
2516 dodie "failed to pre_build\n";
2517 }
2518 }
2519
2520 if ($type =~ /^useconfig:(.*)/) {
2521 run_command "cp $1 $output_config" or
2522 dodie "could not copy $1 to .config";
2523
2524 $type = "oldconfig";
2525 }
2526
2527 # old config can ask questions
2528 if ($type eq "oldconfig") {
2529 $type = "olddefconfig";
2530
2531 # allow for empty configs
2532 run_command "touch $output_config";
2533
2534 if (!$noclean) {
2535 run_command "mv $output_config $outputdir/config_temp" or
2536 dodie "moving .config";
2537
2538 run_command "$make mrproper" or dodie "make mrproper";
2539
2540 run_command "mv $outputdir/config_temp $output_config" or
2541 dodie "moving config_temp";
2542 }
2543
2544 } elsif (!$noclean) {
2545 unlink "$output_config";
2546 run_command "$make mrproper" or
2547 dodie "make mrproper";
2548 }
2549
2550 # add something to distinguish this build
2551 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
2552 print OUT "$localversion\n";
2553 close(OUT);
2554
2555 if (defined($minconfig)) {
2556 load_force_config($minconfig);
2557 }
2558
2559 if ($type ne "olddefconfig") {
2560 run_command "$make $type" or
2561 dodie "failed make config";
2562 }
2563 # Run old config regardless, to enforce min configurations
2564 make_oldconfig;
2565
2566 my $build_ret = run_command "$make $build_options", $buildlog;
2567
2568 if (defined($post_build)) {
2569 # Because a post build may change the kernel version
2570 # do it now.
2571 get_version;
2572 my $ret = run_command $post_build;
2573 if (!$ret && defined($post_build_die) &&
2574 $post_build_die) {
2575 dodie "failed to post_build\n";
2576 }
2577 }
2578
2579 if (!$build_ret) {
2580 # bisect may need this to pass
2581 if ($in_bisect) {
2582 $no_reboot = $save_no_reboot;
2583 return 0;
2584 }
2585 fail "failed build" and return 0;
2586 }
2587
2588 $no_reboot = $save_no_reboot;
2589
2590 my $end_time = time;
2591 $build_time = $end_time - $start_time;
2592
2593 return 1;
2594}
2595
2596sub halt {
2597 if (!run_ssh "halt" or defined($power_off)) {
2598 if (defined($poweroff_after_halt)) {
2599 sleep $poweroff_after_halt;
2600 run_command "$power_off";
2601 }
2602 } else {
2603 # nope? the zap it!
2604 run_command "$power_off";
2605 }
2606}
2607
2608sub success {
2609 my ($i) = @_;
2610
2611 $successes++;
2612
2613 my $name = "";
2614
2615 if (defined($test_name)) {
2616 $name = " ($test_name)";
2617 }
2618
2619 print_times;
2620
2621 doprint "\n\n*******************************************\n";
2622 doprint "*******************************************\n";
2623 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
2624 doprint "*******************************************\n";
2625 doprint "*******************************************\n";
2626
2627 if (defined($store_successes)) {
2628 save_logs "success", $store_successes;
2629 }
2630
2631 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
2632 doprint "Reboot and wait $sleep_time seconds\n";
2633 reboot_to_good $sleep_time;
2634 }
2635
2636 if (defined($post_test)) {
2637 run_command $post_test;
2638 }
2639}
2640
2641sub answer_bisect {
2642 for (;;) {
2643 doprint "Pass, fail, or skip? [p/f/s]";
2644 my $ans = <STDIN>;
2645 chomp $ans;
2646 if ($ans eq "p" || $ans eq "P") {
2647 return 1;
2648 } elsif ($ans eq "f" || $ans eq "F") {
2649 return 0;
2650 } elsif ($ans eq "s" || $ans eq "S") {
2651 return -1;
2652 } else {
2653 print "Please answer 'p', 'f', or 's'\n";
2654 }
2655 }
2656}
2657
2658sub child_run_test {
2659
2660 # child should have no power
2661 $reboot_on_error = 0;
2662 $poweroff_on_error = 0;
2663 $die_on_failure = 1;
2664
2665 run_command $run_test, $testlog;
2666
2667 exit $run_command_status;
2668}
2669
2670my $child_done;
2671
2672sub child_finished {
2673 $child_done = 1;
2674}
2675
2676sub do_run_test {
2677 my $child_pid;
2678 my $child_exit;
2679 my $line;
2680 my $full_line;
2681 my $bug = 0;
2682 my $bug_ignored = 0;
2683
2684 my $start_time = time;
2685
2686 wait_for_monitor 1;
2687
2688 doprint "run test $run_test\n";
2689
2690 $child_done = 0;
2691
2692 $SIG{CHLD} = qw(child_finished);
2693
2694 $child_pid = fork;
2695
2696 child_run_test if (!$child_pid);
2697
2698 $full_line = "";
2699
2700 do {
2701 $line = wait_for_input($monitor_fp, 1);
2702 if (defined($line)) {
2703
2704 # we are not guaranteed to get a full line
2705 $full_line .= $line;
2706 doprint $line;
2707
2708 if ($full_line =~ /call trace:/i) {
2709 if ($ignore_errors) {
2710 $bug_ignored = 1;
2711 } else {
2712 $bug = 1;
2713 }
2714 }
2715
2716 if ($full_line =~ /Kernel panic -/) {
2717 $bug = 1;
2718 }
2719
2720 if ($line =~ /\n/) {
2721 $full_line = "";
2722 }
2723 }
2724 } while (!$child_done && !$bug);
2725
2726 if (!$bug && $bug_ignored) {
2727 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2728 }
2729
2730 if ($bug) {
2731 my $failure_start = time;
2732 my $now;
2733 do {
2734 $line = wait_for_input($monitor_fp, 1);
2735 if (defined($line)) {
2736 doprint $line;
2737 }
2738 $now = time;
2739 if ($now - $failure_start >= $stop_after_failure) {
2740 last;
2741 }
2742 } while (defined($line));
2743
2744 doprint "Detected kernel crash!\n";
2745 # kill the child with extreme prejudice
2746 kill 9, $child_pid;
2747 }
2748
2749 waitpid $child_pid, 0;
2750 $child_exit = $? >> 8;
2751
2752 my $end_time = time;
2753 $test_time = $end_time - $start_time;
2754
2755 if (!$bug && $in_bisect) {
2756 if (defined($bisect_ret_good)) {
2757 if ($child_exit == $bisect_ret_good) {
2758 return 1;
2759 }
2760 }
2761 if (defined($bisect_ret_skip)) {
2762 if ($child_exit == $bisect_ret_skip) {
2763 return -1;
2764 }
2765 }
2766 if (defined($bisect_ret_abort)) {
2767 if ($child_exit == $bisect_ret_abort) {
2768 fail "test abort" and return -2;
2769 }
2770 }
2771 if (defined($bisect_ret_bad)) {
2772 if ($child_exit == $bisect_ret_skip) {
2773 return 0;
2774 }
2775 }
2776 if (defined($bisect_ret_default)) {
2777 if ($bisect_ret_default eq "good") {
2778 return 1;
2779 } elsif ($bisect_ret_default eq "bad") {
2780 return 0;
2781 } elsif ($bisect_ret_default eq "skip") {
2782 return -1;
2783 } elsif ($bisect_ret_default eq "abort") {
2784 return -2;
2785 } else {
2786 fail "unknown default action: $bisect_ret_default"
2787 and return -2;
2788 }
2789 }
2790 }
2791
2792 if ($bug || $child_exit) {
2793 return 0 if $in_bisect;
2794 fail "test failed" and return 0;
2795 }
2796 return 1;
2797}
2798
2799sub run_git_bisect {
2800 my ($command) = @_;
2801
2802 doprint "$command ... ";
2803
2804 my $output = `$command 2>&1`;
2805 my $ret = $?;
2806
2807 logit $output;
2808
2809 if ($ret) {
2810 doprint "FAILED\n";
2811 dodie "Failed to git bisect";
2812 }
2813
2814 doprint "SUCCESS\n";
2815 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
2816 doprint "$1 [$2]\n";
2817 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
2818 $bisect_bad_commit = $1;
2819 doprint "Found bad commit... $1\n";
2820 return 0;
2821 } else {
2822 # we already logged it, just print it now.
2823 print $output;
2824 }
2825
2826 return 1;
2827}
2828
2829sub bisect_reboot {
2830 doprint "Reboot and sleep $bisect_sleep_time seconds\n";
2831 reboot_to_good $bisect_sleep_time;
2832}
2833
2834# returns 1 on success, 0 on failure, -1 on skip
2835sub run_bisect_test {
2836 my ($type, $buildtype) = @_;
2837
2838 my $failed = 0;
2839 my $result;
2840 my $output;
2841 my $ret;
2842
2843 $in_bisect = 1;
2844
2845 build $buildtype or $failed = 1;
2846
2847 if ($type ne "build") {
2848 if ($failed && $bisect_skip) {
2849 $in_bisect = 0;
2850 return -1;
2851 }
2852 dodie "Failed on build" if $failed;
2853
2854 # Now boot the box
2855 start_monitor_and_install or $failed = 1;
2856
2857 if ($type ne "boot") {
2858 if ($failed && $bisect_skip) {
2859 end_monitor;
2860 bisect_reboot;
2861 $in_bisect = 0;
2862 return -1;
2863 }
2864 dodie "Failed on boot" if $failed;
2865
2866 do_run_test or $failed = 1;
2867 }
2868 end_monitor;
2869 }
2870
2871 if ($failed) {
2872 $result = 0;
2873 } else {
2874 $result = 1;
2875 }
2876
2877 # reboot the box to a kernel we can ssh to
2878 if ($type ne "build") {
2879 bisect_reboot;
2880 }
2881 $in_bisect = 0;
2882
2883 return $result;
2884}
2885
2886sub run_bisect {
2887 my ($type) = @_;
2888 my $buildtype = "oldconfig";
2889
2890 # We should have a minconfig to use?
2891 if (defined($minconfig)) {
2892 $buildtype = "useconfig:$minconfig";
2893 }
2894
2895 # If the user sets bisect_tries to less than 1, then no tries
2896 # is a success.
2897 my $ret = 1;
2898
2899 # Still let the user manually decide that though.
2900 if ($bisect_tries < 1 && $bisect_manual) {
2901 $ret = answer_bisect;
2902 }
2903
2904 for (my $i = 0; $i < $bisect_tries; $i++) {
2905 if ($bisect_tries > 1) {
2906 my $t = $i + 1;
2907 doprint("Running bisect trial $t of $bisect_tries:\n");
2908 }
2909 $ret = run_bisect_test $type, $buildtype;
2910
2911 if ($bisect_manual) {
2912 $ret = answer_bisect;
2913 }
2914
2915 last if (!$ret);
2916 }
2917
2918 # Are we looking for where it worked, not failed?
2919 if ($reverse_bisect && $ret >= 0) {
2920 $ret = !$ret;
2921 }
2922
2923 if ($ret > 0) {
2924 return "good";
2925 } elsif ($ret == 0) {
2926 return "bad";
2927 } elsif ($bisect_skip) {
2928 doprint "HIT A BAD COMMIT ... SKIPPING\n";
2929 return "skip";
2930 }
2931}
2932
2933sub update_bisect_replay {
2934 my $tmp_log = "$tmpdir/ktest_bisect_log";
2935 run_command "git bisect log > $tmp_log" or
2936 dodie "can't create bisect log";
2937 return $tmp_log;
2938}
2939
2940sub bisect {
2941 my ($i) = @_;
2942
2943 my $result;
2944
2945 dodie "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good));
2946 dodie "BISECT_BAD[$i] not defined\n" if (!defined($bisect_bad));
2947 dodie "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type));
2948
2949 my $good = $bisect_good;
2950 my $bad = $bisect_bad;
2951 my $type = $bisect_type;
2952 my $start = $bisect_start;
2953 my $replay = $bisect_replay;
2954 my $start_files = $bisect_files;
2955
2956 if (defined($start_files)) {
2957 $start_files = " -- " . $start_files;
2958 } else {
2959 $start_files = "";
2960 }
2961
2962 # convert to true sha1's
2963 $good = get_sha1($good);
2964 $bad = get_sha1($bad);
2965
2966 if (defined($bisect_reverse) && $bisect_reverse == 1) {
2967 doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
2968 $reverse_bisect = 1;
2969 } else {
2970 $reverse_bisect = 0;
2971 }
2972
2973 # Can't have a test without having a test to run
2974 if ($type eq "test" && !defined($run_test)) {
2975 $type = "boot";
2976 }
2977
2978 # Check if a bisect was running
2979 my $bisect_start_file = "$builddir/.git/BISECT_START";
2980
2981 my $check = $bisect_check;
2982 my $do_check = defined($check) && $check ne "0";
2983
2984 if ( -f $bisect_start_file ) {
2985 print "Bisect in progress found\n";
2986 if ($do_check) {
2987 print " If you say yes, then no checks of good or bad will be done\n";
2988 }
2989 if (defined($replay)) {
2990 print "** BISECT_REPLAY is defined in config file **";
2991 print " Ignore config option and perform new git bisect log?\n";
2992 if (read_ync " (yes, no, or cancel) ") {
2993 $replay = update_bisect_replay;
2994 $do_check = 0;
2995 }
2996 } elsif (read_yn "read git log and continue?") {
2997 $replay = update_bisect_replay;
2998 $do_check = 0;
2999 }
3000 }
3001
3002 if ($do_check) {
3003
3004 # get current HEAD
3005 my $head = get_sha1("HEAD");
3006
3007 if ($check ne "good") {
3008 doprint "TESTING BISECT BAD [$bad]\n";
3009 run_command "git checkout $bad" or
3010 dodie "Failed to checkout $bad";
3011
3012 $result = run_bisect $type;
3013
3014 if ($result ne "bad") {
3015 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
3016 }
3017 }
3018
3019 if ($check ne "bad") {
3020 doprint "TESTING BISECT GOOD [$good]\n";
3021 run_command "git checkout $good" or
3022 dodie "Failed to checkout $good";
3023
3024 $result = run_bisect $type;
3025
3026 if ($result ne "good") {
3027 fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
3028 }
3029 }
3030
3031 # checkout where we started
3032 run_command "git checkout $head" or
3033 dodie "Failed to checkout $head";
3034 }
3035
3036 run_command "git bisect start$start_files" or
3037 dodie "could not start bisect";
3038
3039 if (defined($replay)) {
3040 run_command "git bisect replay $replay" or
3041 dodie "failed to run replay";
3042 } else {
3043
3044 run_command "git bisect good $good" or
3045 dodie "could not set bisect good to $good";
3046
3047 run_git_bisect "git bisect bad $bad" or
3048 dodie "could not set bisect bad to $bad";
3049
3050 }
3051
3052 if (defined($start)) {
3053 run_command "git checkout $start" or
3054 dodie "failed to checkout $start";
3055 }
3056
3057 my $test;
3058 do {
3059 $result = run_bisect $type;
3060 $test = run_git_bisect "git bisect $result";
3061 print_times;
3062 } while ($test);
3063
3064 run_command "git bisect log" or
3065 dodie "could not capture git bisect log";
3066
3067 run_command "git bisect reset" or
3068 dodie "could not reset git bisect";
3069
3070 doprint "Bad commit was [$bisect_bad_commit]\n";
3071
3072 success $i;
3073}
3074
3075# config_ignore holds the configs that were set (or unset) for
3076# a good config and we will ignore these configs for the rest
3077# of a config bisect. These configs stay as they were.
3078my %config_ignore;
3079
3080# config_set holds what all configs were set as.
3081my %config_set;
3082
3083# config_off holds the set of configs that the bad config had disabled.
3084# We need to record them and set them in the .config when running
3085# olddefconfig, because olddefconfig keeps the defaults.
3086my %config_off;
3087
3088# config_off_tmp holds a set of configs to turn off for now
3089my @config_off_tmp;
3090
3091# config_list is the set of configs that are being tested
3092my %config_list;
3093my %null_config;
3094
3095my %dependency;
3096
3097sub assign_configs {
3098 my ($hash, $config) = @_;
3099
3100 doprint "Reading configs from $config\n";
3101
3102 open (IN, $config)
3103 or dodie "Failed to read $config";
3104
3105 while (<IN>) {
3106 chomp;
3107 if (/^((CONFIG\S*)=.*)/) {
3108 ${$hash}{$2} = $1;
3109 } elsif (/^(# (CONFIG\S*) is not set)/) {
3110 ${$hash}{$2} = $1;
3111 }
3112 }
3113
3114 close(IN);
3115}
3116
3117sub process_config_ignore {
3118 my ($config) = @_;
3119
3120 assign_configs \%config_ignore, $config;
3121}
3122
3123sub get_dependencies {
3124 my ($config) = @_;
3125
3126 my $arr = $dependency{$config};
3127 if (!defined($arr)) {
3128 return ();
3129 }
3130
3131 my @deps = @{$arr};
3132
3133 foreach my $dep (@{$arr}) {
3134 print "ADD DEP $dep\n";
3135 @deps = (@deps, get_dependencies $dep);
3136 }
3137
3138 return @deps;
3139}
3140
3141sub save_config {
3142 my ($pc, $file) = @_;
3143
3144 my %configs = %{$pc};
3145
3146 doprint "Saving configs into $file\n";
3147
3148 open(OUT, ">$file") or dodie "Can not write to $file";
3149
3150 foreach my $config (keys %configs) {
3151 print OUT "$configs{$config}\n";
3152 }
3153 close(OUT);
3154}
3155
3156sub create_config {
3157 my ($name, $pc) = @_;
3158
3159 doprint "Creating old config from $name configs\n";
3160
3161 save_config $pc, $output_config;
3162
3163 make_oldconfig;
3164}
3165
3166sub run_config_bisect_test {
3167 my ($type) = @_;
3168
3169 my $ret = run_bisect_test $type, "oldconfig";
3170
3171 if ($bisect_manual) {
3172 $ret = answer_bisect;
3173 }
3174
3175 return $ret;
3176}
3177
3178sub config_bisect_end {
3179 my ($good, $bad) = @_;
3180 my $diffexec = "diff -u";
3181
3182 if (-f "$builddir/scripts/diffconfig") {
3183 $diffexec = "$builddir/scripts/diffconfig";
3184 }
3185 doprint "\n\n***************************************\n";
3186 doprint "No more config bisecting possible.\n";
3187 run_command "$diffexec $good $bad", 1;
3188 doprint "***************************************\n\n";
3189}
3190
3191sub run_config_bisect {
3192 my ($good, $bad, $last_result) = @_;
3193 my $reset = "";
3194 my $cmd;
3195 my $ret;
3196
3197 if (!length($last_result)) {
3198 $reset = "-r";
3199 }
3200 run_command "$config_bisect_exec $reset -b $outputdir $good $bad $last_result", 1;
3201
3202 # config-bisect returns:
3203 # 0 if there is more to bisect
3204 # 1 for finding a good config
3205 # 2 if it can not find any more configs
3206 # -1 (255) on error
3207 if ($run_command_status) {
3208 return $run_command_status;
3209 }
3210
3211 $ret = run_config_bisect_test $config_bisect_type;
3212 if ($ret) {
3213 doprint "NEW GOOD CONFIG\n";
3214 # Return 3 for good config
3215 return 3;
3216 } else {
3217 doprint "NEW BAD CONFIG\n";
3218 # Return 4 for bad config
3219 return 4;
3220 }
3221}
3222
3223sub config_bisect {
3224 my ($i) = @_;
3225
3226 my $good_config;
3227 my $bad_config;
3228
3229 my $type = $config_bisect_type;
3230 my $ret;
3231
3232 $bad_config = $config_bisect;
3233
3234 if (defined($config_bisect_good)) {
3235 $good_config = $config_bisect_good;
3236 } elsif (defined($minconfig)) {
3237 $good_config = $minconfig;
3238 } else {
3239 doprint "No config specified, checking if defconfig works";
3240 $ret = run_bisect_test $type, "defconfig";
3241 if (!$ret) {
3242 fail "Have no good config to compare with, please set CONFIG_BISECT_GOOD";
3243 return 1;
3244 }
3245 $good_config = $output_config;
3246 }
3247
3248 if (!defined($config_bisect_exec)) {
3249 # First check the location that ktest.pl ran
3250 my @locations = ( "$pwd/config-bisect.pl",
3251 "$dirname/config-bisect.pl",
3252 "$builddir/tools/testing/ktest/config-bisect.pl",
3253 undef );
3254 foreach my $loc (@locations) {
3255 doprint "loc = $loc\n";
3256 $config_bisect_exec = $loc;
3257 last if (defined($config_bisect_exec && -x $config_bisect_exec));
3258 }
3259 if (!defined($config_bisect_exec)) {
3260 fail "Could not find an executable config-bisect.pl\n",
3261 " Set CONFIG_BISECT_EXEC to point to config-bisect.pl";
3262 return 1;
3263 }
3264 }
3265
3266 # we don't want min configs to cause issues here.
3267 doprint "Disabling 'MIN_CONFIG' for this test\n";
3268 undef $minconfig;
3269
3270 my %good_configs;
3271 my %bad_configs;
3272 my %tmp_configs;
3273
3274 if (-f "$tmpdir/good_config.tmp" || -f "$tmpdir/bad_config.tmp") {
3275 if (read_yn "Interrupted config-bisect. Continue (n - will start new)?") {
3276 if (-f "$tmpdir/good_config.tmp") {
3277 $good_config = "$tmpdir/good_config.tmp";
3278 } else {
3279 $good_config = "$tmpdir/good_config";
3280 }
3281 if (-f "$tmpdir/bad_config.tmp") {
3282 $bad_config = "$tmpdir/bad_config.tmp";
3283 } else {
3284 $bad_config = "$tmpdir/bad_config";
3285 }
3286 }
3287 }
3288 doprint "Run good configs through make oldconfig\n";
3289 assign_configs \%tmp_configs, $good_config;
3290 create_config "$good_config", \%tmp_configs;
3291 $good_config = "$tmpdir/good_config";
3292 system("cp $output_config $good_config") == 0 or dodie "cp good config";
3293
3294 doprint "Run bad configs through make oldconfig\n";
3295 assign_configs \%tmp_configs, $bad_config;
3296 create_config "$bad_config", \%tmp_configs;
3297 $bad_config = "$tmpdir/bad_config";
3298 system("cp $output_config $bad_config") == 0 or dodie "cp bad config";
3299
3300 if (defined($config_bisect_check) && $config_bisect_check ne "0") {
3301 if ($config_bisect_check ne "good") {
3302 doprint "Testing bad config\n";
3303
3304 $ret = run_bisect_test $type, "useconfig:$bad_config";
3305 if ($ret) {
3306 fail "Bad config succeeded when expected to fail!";
3307 return 0;
3308 }
3309 }
3310 if ($config_bisect_check ne "bad") {
3311 doprint "Testing good config\n";
3312
3313 $ret = run_bisect_test $type, "useconfig:$good_config";
3314 if (!$ret) {
3315 fail "Good config failed when expected to succeed!";
3316 return 0;
3317 }
3318 }
3319 }
3320
3321 my $last_run = "";
3322
3323 do {
3324 $ret = run_config_bisect $good_config, $bad_config, $last_run;
3325 if ($ret == 3) {
3326 $last_run = "good";
3327 } elsif ($ret == 4) {
3328 $last_run = "bad";
3329 }
3330 print_times;
3331 } while ($ret == 3 || $ret == 4);
3332
3333 if ($ret == 2) {
3334 config_bisect_end "$good_config.tmp", "$bad_config.tmp";
3335 }
3336
3337 return $ret if ($ret < 0);
3338
3339 success $i;
3340}
3341
3342sub patchcheck_reboot {
3343 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
3344 reboot_to_good $patchcheck_sleep_time;
3345}
3346
3347sub patchcheck {
3348 my ($i) = @_;
3349
3350 dodie "PATCHCHECK_START[$i] not defined\n"
3351 if (!defined($patchcheck_start));
3352 dodie "PATCHCHECK_TYPE[$i] not defined\n"
3353 if (!defined($patchcheck_type));
3354
3355 my $start = $patchcheck_start;
3356
3357 my $cherry = $patchcheck_cherry;
3358 if (!defined($cherry)) {
3359 $cherry = 0;
3360 }
3361
3362 my $end = "HEAD";
3363 if (defined($patchcheck_end)) {
3364 $end = $patchcheck_end;
3365 } elsif ($cherry) {
3366 dodie "PATCHCHECK_END must be defined with PATCHCHECK_CHERRY\n";
3367 }
3368
3369 # Get the true sha1's since we can use things like HEAD~3
3370 $start = get_sha1($start);
3371 $end = get_sha1($end);
3372
3373 my $type = $patchcheck_type;
3374
3375 # Can't have a test without having a test to run
3376 if ($type eq "test" && !defined($run_test)) {
3377 $type = "boot";
3378 }
3379
3380 if ($cherry) {
3381 open (IN, "git cherry -v $start $end|") or
3382 dodie "could not get git list";
3383 } else {
3384 open (IN, "git log --pretty=oneline $end|") or
3385 dodie "could not get git list";
3386 }
3387
3388 my @list;
3389
3390 while (<IN>) {
3391 chomp;
3392 # git cherry adds a '+' we want to remove
3393 s/^\+ //;
3394 $list[$#list+1] = $_;
3395 last if (/^$start/);
3396 }
3397 close(IN);
3398
3399 if (!$cherry) {
3400 if ($list[$#list] !~ /^$start/) {
3401 fail "SHA1 $start not found";
3402 }
3403
3404 # go backwards in the list
3405 @list = reverse @list;
3406 }
3407
3408 doprint("Going to test the following commits:\n");
3409 foreach my $l (@list) {
3410 doprint "$l\n";
3411 }
3412
3413 my $save_clean = $noclean;
3414 my %ignored_warnings;
3415
3416 if (defined($ignore_warnings)) {
3417 foreach my $sha1 (split /\s+/, $ignore_warnings) {
3418 $ignored_warnings{$sha1} = 1;
3419 }
3420 }
3421
3422 $in_patchcheck = 1;
3423 foreach my $item (@list) {
3424 my $sha1 = $item;
3425 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
3426
3427 doprint "\nProcessing commit \"$item\"\n\n";
3428
3429 run_command "git checkout $sha1" or
3430 dodie "Failed to checkout $sha1";
3431
3432 # only clean on the first and last patch
3433 if ($item eq $list[0] ||
3434 $item eq $list[$#list]) {
3435 $noclean = $save_clean;
3436 } else {
3437 $noclean = 1;
3438 }
3439
3440 if (defined($minconfig)) {
3441 build "useconfig:$minconfig" or return 0;
3442 } else {
3443 # ?? no config to use?
3444 build "oldconfig" or return 0;
3445 }
3446
3447 # No need to do per patch checking if warnings file exists
3448 if (!defined($warnings_file) && !defined($ignored_warnings{$sha1})) {
3449 check_patch_buildlog $sha1 or return 0;
3450 }
3451
3452 check_buildlog or return 0;
3453
3454 next if ($type eq "build");
3455
3456 my $failed = 0;
3457
3458 start_monitor_and_install or $failed = 1;
3459
3460 if (!$failed && $type ne "boot"){
3461 do_run_test or $failed = 1;
3462 }
3463 end_monitor;
3464 if ($failed) {
3465 print_times;
3466 return 0;
3467 }
3468 patchcheck_reboot;
3469 print_times;
3470 }
3471 $in_patchcheck = 0;
3472 success $i;
3473
3474 return 1;
3475}
3476
3477my %depends;
3478my %depcount;
3479my $iflevel = 0;
3480my @ifdeps;
3481
3482# prevent recursion
3483my %read_kconfigs;
3484
3485sub add_dep {
3486 # $config depends on $dep
3487 my ($config, $dep) = @_;
3488
3489 if (defined($depends{$config})) {
3490 $depends{$config} .= " " . $dep;
3491 } else {
3492 $depends{$config} = $dep;
3493 }
3494
3495 # record the number of configs depending on $dep
3496 if (defined $depcount{$dep}) {
3497 $depcount{$dep}++;
3498 } else {
3499 $depcount{$dep} = 1;
3500 }
3501}
3502
3503# taken from streamline_config.pl
3504sub read_kconfig {
3505 my ($kconfig) = @_;
3506
3507 my $state = "NONE";
3508 my $config;
3509 my @kconfigs;
3510
3511 my $cont = 0;
3512 my $line;
3513
3514
3515 if (! -f $kconfig) {
3516 doprint "file $kconfig does not exist, skipping\n";
3517 return;
3518 }
3519
3520 open(KIN, "$kconfig")
3521 or dodie "Can't open $kconfig";
3522 while (<KIN>) {
3523 chomp;
3524
3525 # Make sure that lines ending with \ continue
3526 if ($cont) {
3527 $_ = $line . " " . $_;
3528 }
3529
3530 if (s/\\$//) {
3531 $cont = 1;
3532 $line = $_;
3533 next;
3534 }
3535
3536 $cont = 0;
3537
3538 # collect any Kconfig sources
3539 if (/^source\s*"(.*)"/) {
3540 $kconfigs[$#kconfigs+1] = $1;
3541 }
3542
3543 # configs found
3544 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
3545 $state = "NEW";
3546 $config = $2;
3547
3548 for (my $i = 0; $i < $iflevel; $i++) {
3549 add_dep $config, $ifdeps[$i];
3550 }
3551
3552 # collect the depends for the config
3553 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
3554
3555 add_dep $config, $1;
3556
3557 # Get the configs that select this config
3558 } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {
3559
3560 # selected by depends on config
3561 add_dep $1, $config;
3562
3563 # Check for if statements
3564 } elsif (/^if\s+(.*\S)\s*$/) {
3565 my $deps = $1;
3566 # remove beginning and ending non text
3567 $deps =~ s/^[^a-zA-Z0-9_]*//;
3568 $deps =~ s/[^a-zA-Z0-9_]*$//;
3569
3570 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
3571
3572 $ifdeps[$iflevel++] = join ':', @deps;
3573
3574 } elsif (/^endif/) {
3575
3576 $iflevel-- if ($iflevel);
3577
3578 # stop on "help"
3579 } elsif (/^\s*help\s*$/) {
3580 $state = "NONE";
3581 }
3582 }
3583 close(KIN);
3584
3585 # read in any configs that were found.
3586 foreach $kconfig (@kconfigs) {
3587 if (!defined($read_kconfigs{$kconfig})) {
3588 $read_kconfigs{$kconfig} = 1;
3589 read_kconfig("$builddir/$kconfig");
3590 }
3591 }
3592}
3593
3594sub read_depends {
3595 # find out which arch this is by the kconfig file
3596 open (IN, $output_config)
3597 or dodie "Failed to read $output_config";
3598 my $arch;
3599 while (<IN>) {
3600 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
3601 $arch = $1;
3602 last;
3603 }
3604 }
3605 close IN;
3606
3607 if (!defined($arch)) {
3608 doprint "Could not find arch from config file\n";
3609 doprint "no dependencies used\n";
3610 return;
3611 }
3612
3613 # arch is really the subarch, we need to know
3614 # what directory to look at.
3615 if ($arch eq "i386" || $arch eq "x86_64") {
3616 $arch = "x86";
3617 }
3618
3619 my $kconfig = "$builddir/arch/$arch/Kconfig";
3620
3621 if (! -f $kconfig && $arch =~ /\d$/) {
3622 my $orig = $arch;
3623 # some subarchs have numbers, truncate them
3624 $arch =~ s/\d*$//;
3625 $kconfig = "$builddir/arch/$arch/Kconfig";
3626 if (! -f $kconfig) {
3627 doprint "No idea what arch dir $orig is for\n";
3628 doprint "no dependencies used\n";
3629 return;
3630 }
3631 }
3632
3633 read_kconfig($kconfig);
3634}
3635
3636sub make_new_config {
3637 my @configs = @_;
3638
3639 open (OUT, ">$output_config")
3640 or dodie "Failed to write $output_config";
3641
3642 foreach my $config (@configs) {
3643 print OUT "$config\n";
3644 }
3645 close OUT;
3646}
3647
3648sub chomp_config {
3649 my ($config) = @_;
3650
3651 $config =~ s/CONFIG_//;
3652
3653 return $config;
3654}
3655
3656sub get_depends {
3657 my ($dep) = @_;
3658
3659 my $kconfig = chomp_config $dep;
3660
3661 $dep = $depends{"$kconfig"};
3662
3663 # the dep string we have saves the dependencies as they
3664 # were found, including expressions like ! && ||. We
3665 # want to split this out into just an array of configs.
3666
3667 my $valid = "A-Za-z_0-9";
3668
3669 my @configs;
3670
3671 while ($dep =~ /[$valid]/) {
3672
3673 if ($dep =~ /^[^$valid]*([$valid]+)/) {
3674 my $conf = "CONFIG_" . $1;
3675
3676 $configs[$#configs + 1] = $conf;
3677
3678 $dep =~ s/^[^$valid]*[$valid]+//;
3679 } else {
3680 dodie "this should never happen";
3681 }
3682 }
3683
3684 return @configs;
3685}
3686
3687my %min_configs;
3688my %keep_configs;
3689my %save_configs;
3690my %processed_configs;
3691my %nochange_config;
3692
3693sub test_this_config {
3694 my ($config) = @_;
3695
3696 my $found;
3697
3698 # if we already processed this config, skip it
3699 if (defined($processed_configs{$config})) {
3700 return undef;
3701 }
3702 $processed_configs{$config} = 1;
3703
3704 # if this config failed during this round, skip it
3705 if (defined($nochange_config{$config})) {
3706 return undef;
3707 }
3708
3709 my $kconfig = chomp_config $config;
3710
3711 # Test dependencies first
3712 if (defined($depends{"$kconfig"})) {
3713 my @parents = get_depends $config;
3714 foreach my $parent (@parents) {
3715 # if the parent is in the min config, check it first
3716 next if (!defined($min_configs{$parent}));
3717 $found = test_this_config($parent);
3718 if (defined($found)) {
3719 return $found;
3720 }
3721 }
3722 }
3723
3724 # Remove this config from the list of configs
3725 # do a make olddefconfig and then read the resulting
3726 # .config to make sure it is missing the config that
3727 # we had before
3728 my %configs = %min_configs;
3729 delete $configs{$config};
3730 make_new_config ((values %configs), (values %keep_configs));
3731 make_oldconfig;
3732 undef %configs;
3733 assign_configs \%configs, $output_config;
3734
3735 if (!defined($configs{$config}) || $configs{$config} =~ /^#/) {
3736 return $config;
3737 }
3738
3739 doprint "disabling config $config did not change .config\n";
3740
3741 $nochange_config{$config} = 1;
3742
3743 return undef;
3744}
3745
3746sub make_min_config {
3747 my ($i) = @_;
3748
3749 my $type = $minconfig_type;
3750 if ($type ne "boot" && $type ne "test") {
3751 fail "Invalid MIN_CONFIG_TYPE '$minconfig_type'\n" .
3752 " make_min_config works only with 'boot' and 'test'\n" and return;
3753 }
3754
3755 if (!defined($output_minconfig)) {
3756 fail "OUTPUT_MIN_CONFIG not defined" and return;
3757 }
3758
3759 # If output_minconfig exists, and the start_minconfig
3760 # came from min_config, than ask if we should use
3761 # that instead.
3762 if (-f $output_minconfig && !$start_minconfig_defined) {
3763 print "$output_minconfig exists\n";
3764 if (!defined($use_output_minconfig)) {
3765 if (read_yn " Use it as minconfig?") {
3766 $start_minconfig = $output_minconfig;
3767 }
3768 } elsif ($use_output_minconfig > 0) {
3769 doprint "Using $output_minconfig as MIN_CONFIG\n";
3770 $start_minconfig = $output_minconfig;
3771 } else {
3772 doprint "Set to still use MIN_CONFIG as starting point\n";
3773 }
3774 }
3775
3776 if (!defined($start_minconfig)) {
3777 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
3778 }
3779
3780 my $temp_config = "$tmpdir/temp_config";
3781
3782 # First things first. We build an allnoconfig to find
3783 # out what the defaults are that we can't touch.
3784 # Some are selections, but we really can't handle selections.
3785
3786 my $save_minconfig = $minconfig;
3787 undef $minconfig;
3788
3789 run_command "$make allnoconfig" or return 0;
3790
3791 read_depends;
3792
3793 process_config_ignore $output_config;
3794
3795 undef %save_configs;
3796 undef %min_configs;
3797
3798 if (defined($ignore_config)) {
3799 # make sure the file exists
3800 `touch $ignore_config`;
3801 assign_configs \%save_configs, $ignore_config;
3802 }
3803
3804 %keep_configs = %save_configs;
3805
3806 doprint "Load initial configs from $start_minconfig\n";
3807
3808 # Look at the current min configs, and save off all the
3809 # ones that were set via the allnoconfig
3810 assign_configs \%min_configs, $start_minconfig;
3811
3812 my @config_keys = keys %min_configs;
3813
3814 # All configs need a depcount
3815 foreach my $config (@config_keys) {
3816 my $kconfig = chomp_config $config;
3817 if (!defined $depcount{$kconfig}) {
3818 $depcount{$kconfig} = 0;
3819 }
3820 }
3821
3822 # Remove anything that was set by the make allnoconfig
3823 # we shouldn't need them as they get set for us anyway.
3824 foreach my $config (@config_keys) {
3825 # Remove anything in the ignore_config
3826 if (defined($keep_configs{$config})) {
3827 my $file = $ignore_config;
3828 $file =~ s,.*/(.*?)$,$1,;
3829 doprint "$config set by $file ... ignored\n";
3830 delete $min_configs{$config};
3831 next;
3832 }
3833 # But make sure the settings are the same. If a min config
3834 # sets a selection, we do not want to get rid of it if
3835 # it is not the same as what we have. Just move it into
3836 # the keep configs.
3837 if (defined($config_ignore{$config})) {
3838 if ($config_ignore{$config} ne $min_configs{$config}) {
3839 doprint "$config is in allnoconfig as '$config_ignore{$config}'";
3840 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
3841 $keep_configs{$config} = $min_configs{$config};
3842 } else {
3843 doprint "$config set by allnoconfig ... ignored\n";
3844 }
3845 delete $min_configs{$config};
3846 }
3847 }
3848
3849 my $done = 0;
3850 my $take_two = 0;
3851
3852 while (!$done) {
3853
3854 my $config;
3855 my $found;
3856
3857 # Now disable each config one by one and do a make oldconfig
3858 # till we find a config that changes our list.
3859
3860 my @test_configs = keys %min_configs;
3861
3862 # Sort keys by who is most dependent on
3863 @test_configs = sort { $depcount{chomp_config($b)} <=> $depcount{chomp_config($a)} }
3864 @test_configs ;
3865
3866 # Put configs that did not modify the config at the end.
3867 my $reset = 1;
3868 for (my $i = 0; $i < $#test_configs; $i++) {
3869 if (!defined($nochange_config{$test_configs[0]})) {
3870 $reset = 0;
3871 last;
3872 }
3873 # This config didn't change the .config last time.
3874 # Place it at the end
3875 my $config = shift @test_configs;
3876 push @test_configs, $config;
3877 }
3878
3879 # if every test config has failed to modify the .config file
3880 # in the past, then reset and start over.
3881 if ($reset) {
3882 undef %nochange_config;
3883 }
3884
3885 undef %processed_configs;
3886
3887 foreach my $config (@test_configs) {
3888
3889 $found = test_this_config $config;
3890
3891 last if (defined($found));
3892
3893 # oh well, try another config
3894 }
3895
3896 if (!defined($found)) {
3897 # we could have failed due to the nochange_config hash
3898 # reset and try again
3899 if (!$take_two) {
3900 undef %nochange_config;
3901 $take_two = 1;
3902 next;
3903 }
3904 doprint "No more configs found that we can disable\n";
3905 $done = 1;
3906 last;
3907 }
3908 $take_two = 0;
3909
3910 $config = $found;
3911
3912 doprint "Test with $config disabled\n";
3913
3914 # set in_bisect to keep build and monitor from dieing
3915 $in_bisect = 1;
3916
3917 my $failed = 0;
3918 build "oldconfig" or $failed = 1;
3919 if (!$failed) {
3920 start_monitor_and_install or $failed = 1;
3921
3922 if ($type eq "test" && !$failed) {
3923 do_run_test or $failed = 1;
3924 }
3925
3926 end_monitor;
3927 }
3928
3929 $in_bisect = 0;
3930
3931 if ($failed) {
3932 doprint "$min_configs{$config} is needed to boot the box... keeping\n";
3933 # this config is needed, add it to the ignore list.
3934 $keep_configs{$config} = $min_configs{$config};
3935 $save_configs{$config} = $min_configs{$config};
3936 delete $min_configs{$config};
3937
3938 # update new ignore configs
3939 if (defined($ignore_config)) {
3940 open (OUT, ">$temp_config")
3941 or dodie "Can't write to $temp_config";
3942 foreach my $config (keys %save_configs) {
3943 print OUT "$save_configs{$config}\n";
3944 }
3945 close OUT;
3946 run_command "mv $temp_config $ignore_config" or
3947 dodie "failed to copy update to $ignore_config";
3948 }
3949
3950 } else {
3951 # We booted without this config, remove it from the minconfigs.
3952 doprint "$config is not needed, disabling\n";
3953
3954 delete $min_configs{$config};
3955
3956 # Also disable anything that is not enabled in this config
3957 my %configs;
3958 assign_configs \%configs, $output_config;
3959 my @config_keys = keys %min_configs;
3960 foreach my $config (@config_keys) {
3961 if (!defined($configs{$config})) {
3962 doprint "$config is not set, disabling\n";
3963 delete $min_configs{$config};
3964 }
3965 }
3966
3967 # Save off all the current mandatory configs
3968 open (OUT, ">$temp_config")
3969 or dodie "Can't write to $temp_config";
3970 foreach my $config (keys %keep_configs) {
3971 print OUT "$keep_configs{$config}\n";
3972 }
3973 foreach my $config (keys %min_configs) {
3974 print OUT "$min_configs{$config}\n";
3975 }
3976 close OUT;
3977
3978 run_command "mv $temp_config $output_minconfig" or
3979 dodie "failed to copy update to $output_minconfig";
3980 }
3981
3982 doprint "Reboot and wait $sleep_time seconds\n";
3983 reboot_to_good $sleep_time;
3984 }
3985
3986 success $i;
3987 return 1;
3988}
3989
3990sub make_warnings_file {
3991 my ($i) = @_;
3992
3993 if (!defined($warnings_file)) {
3994 dodie "Must define WARNINGS_FILE for make_warnings_file test";
3995 }
3996
3997 if ($build_type eq "nobuild") {
3998 dodie "BUILD_TYPE can not be 'nobuild' for make_warnings_file test";
3999 }
4000
4001 build $build_type or dodie "Failed to build";
4002
4003 open(OUT, ">$warnings_file") or dodie "Can't create $warnings_file";
4004
4005 open(IN, $buildlog) or dodie "Can't open $buildlog";
4006 while (<IN>) {
4007
4008 # Some compilers use UTF-8 extended for quotes
4009 # for distcc heterogeneous systems, this causes issues
4010 s/$utf8_quote/'/g;
4011
4012 if (/$check_build_re/) {
4013 print OUT;
4014 }
4015 }
4016 close(IN);
4017
4018 close(OUT);
4019
4020 success $i;
4021}
4022
4023$#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl [config-file]\n";
4024
4025if ($#ARGV == 0) {
4026 $ktest_config = $ARGV[0];
4027 if (! -f $ktest_config) {
4028 print "$ktest_config does not exist.\n";
4029 if (!read_yn "Create it?") {
4030 exit 0;
4031 }
4032 }
4033}
4034
4035if (! -f $ktest_config) {
4036 $newconfig = 1;
4037 get_test_case;
4038 open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
4039 print OUT << "EOF"
4040# Generated by ktest.pl
4041#
4042
4043# PWD is a ktest.pl variable that will result in the process working
4044# directory that ktest.pl is executed in.
4045
4046# THIS_DIR is automatically assigned the PWD of the path that generated
4047# the config file. It is best to use this variable when assigning other
4048# directory paths within this directory. This allows you to easily
4049# move the test cases to other locations or to other machines.
4050#
4051THIS_DIR := $variable{"PWD"}
4052
4053# Define each test with TEST_START
4054# The config options below it will override the defaults
4055TEST_START
4056TEST_TYPE = $default{"TEST_TYPE"}
4057
4058DEFAULTS
4059EOF
4060;
4061 close(OUT);
4062}
4063read_config $ktest_config;
4064
4065if (defined($opt{"LOG_FILE"})) {
4066 $opt{"LOG_FILE"} = eval_option("LOG_FILE", $opt{"LOG_FILE"}, -1);
4067}
4068
4069# Append any configs entered in manually to the config file.
4070my @new_configs = keys %entered_configs;
4071if ($#new_configs >= 0) {
4072 print "\nAppending entered in configs to $ktest_config\n";
4073 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
4074 foreach my $config (@new_configs) {
4075 print OUT "$config = $entered_configs{$config}\n";
4076 $opt{$config} = process_variables($entered_configs{$config});
4077 }
4078}
4079
4080if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
4081 unlink $opt{"LOG_FILE"};
4082}
4083
4084doprint "\n\nSTARTING AUTOMATED TESTS\n\n";
4085
4086for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
4087
4088 if (!$i) {
4089 doprint "DEFAULT OPTIONS:\n";
4090 } else {
4091 doprint "\nTEST $i OPTIONS";
4092 if (defined($repeat_tests{$i})) {
4093 $repeat = $repeat_tests{$i};
4094 doprint " ITERATE $repeat";
4095 }
4096 doprint "\n";
4097 }
4098
4099 foreach my $option (sort keys %opt) {
4100
4101 if ($option =~ /\[(\d+)\]$/) {
4102 next if ($i != $1);
4103 } else {
4104 next if ($i);
4105 }
4106
4107 doprint "$option = $opt{$option}\n";
4108 }
4109}
4110
4111sub option_defined {
4112 my ($option) = @_;
4113
4114 if (defined($opt{$option}) && $opt{$option} !~ /^\s*$/) {
4115 return 1;
4116 }
4117
4118 return 0;
4119}
4120
4121sub __set_test_option {
4122 my ($name, $i) = @_;
4123
4124 my $option = "$name\[$i\]";
4125
4126 if (option_defined($option)) {
4127 return $opt{$option};
4128 }
4129
4130 foreach my $test (keys %repeat_tests) {
4131 if ($i >= $test &&
4132 $i < $test + $repeat_tests{$test}) {
4133 $option = "$name\[$test\]";
4134 if (option_defined($option)) {
4135 return $opt{$option};
4136 }
4137 }
4138 }
4139
4140 if (option_defined($name)) {
4141 return $opt{$name};
4142 }
4143
4144 return undef;
4145}
4146
4147sub set_test_option {
4148 my ($name, $i) = @_;
4149
4150 my $option = __set_test_option($name, $i);
4151 return $option if (!defined($option));
4152
4153 return eval_option($name, $option, $i);
4154}
4155
4156sub find_mailer {
4157 my ($mailer) = @_;
4158
4159 my @paths = split /:/, $ENV{PATH};
4160
4161 # sendmail is usually in /usr/sbin
4162 $paths[$#paths + 1] = "/usr/sbin";
4163
4164 foreach my $path (@paths) {
4165 if (-x "$path/$mailer") {
4166 return $path;
4167 }
4168 }
4169
4170 return undef;
4171}
4172
4173sub do_send_mail {
4174 my ($subject, $message) = @_;
4175
4176 if (!defined($mail_path)) {
4177 # find the mailer
4178 $mail_path = find_mailer $mailer;
4179 if (!defined($mail_path)) {
4180 die "\nCan not find $mailer in PATH\n";
4181 }
4182 }
4183
4184 if (!defined($mail_command)) {
4185 if ($mailer eq "mail" || $mailer eq "mailx") {
4186 $mail_command = "\$MAIL_PATH/\$MAILER -s \'\$SUBJECT\' \$MAILTO <<< \'\$MESSAGE\'";
4187 } elsif ($mailer eq "sendmail" ) {
4188 $mail_command = "echo \'Subject: \$SUBJECT\n\n\$MESSAGE\' | \$MAIL_PATH/\$MAILER -t \$MAILTO";
4189 } else {
4190 die "\nYour mailer: $mailer is not supported.\n";
4191 }
4192 }
4193
4194 $mail_command =~ s/\$MAILER/$mailer/g;
4195 $mail_command =~ s/\$MAIL_PATH/$mail_path/g;
4196 $mail_command =~ s/\$MAILTO/$mailto/g;
4197 $mail_command =~ s/\$SUBJECT/$subject/g;
4198 $mail_command =~ s/\$MESSAGE/$message/g;
4199
4200 run_command $mail_command;
4201}
4202
4203sub send_email {
4204
4205 if (defined($mailto)) {
4206 if (!defined($mailer)) {
4207 doprint "No email sent: email or mailer not specified in config.\n";
4208 return;
4209 }
4210 do_send_mail @_;
4211 }
4212}
4213
4214sub cancel_test {
4215 if ($email_when_canceled) {
4216 my $name = get_test_name;
4217 send_email("KTEST: Your [$name] test was cancelled",
4218 "Your test started at $script_start_time was cancelled: sig int");
4219 }
4220 die "\nCaught Sig Int, test interrupted: $!\n"
4221}
4222
4223$SIG{INT} = qw(cancel_test);
4224
4225# First we need to do is the builds
4226for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
4227
4228 # Do not reboot on failing test options
4229 $no_reboot = 1;
4230 $reboot_success = 0;
4231
4232 $have_version = 0;
4233
4234 $iteration = $i;
4235
4236 $build_time = 0;
4237 $install_time = 0;
4238 $reboot_time = 0;
4239 $test_time = 0;
4240
4241 undef %force_config;
4242
4243 my $makecmd = set_test_option("MAKE_CMD", $i);
4244
4245 $outputdir = set_test_option("OUTPUT_DIR", $i);
4246 $builddir = set_test_option("BUILD_DIR", $i);
4247
4248 chdir $builddir || dodie "can't change directory to $builddir";
4249
4250 if (!-d $outputdir) {
4251 mkpath($outputdir) or
4252 dodie "can't create $outputdir";
4253 }
4254
4255 $make = "$makecmd O=$outputdir";
4256
4257 # Load all the options into their mapped variable names
4258 foreach my $opt (keys %option_map) {
4259 ${$option_map{$opt}} = set_test_option($opt, $i);
4260 }
4261
4262 $start_minconfig_defined = 1;
4263
4264 # The first test may override the PRE_KTEST option
4265 if ($i == 1) {
4266 if (defined($pre_ktest)) {
4267 doprint "\n";
4268 run_command $pre_ktest;
4269 }
4270 if ($email_when_started) {
4271 my $name = get_test_name;
4272 send_email("KTEST: Your [$name] test was started",
4273 "Your test was started on $script_start_time");
4274 }
4275 }
4276
4277 # Any test can override the POST_KTEST option
4278 # The last test takes precedence.
4279 if (defined($post_ktest)) {
4280 $final_post_ktest = $post_ktest;
4281 }
4282
4283 if (!defined($start_minconfig)) {
4284 $start_minconfig_defined = 0;
4285 $start_minconfig = $minconfig;
4286 }
4287
4288 if (!-d $tmpdir) {
4289 mkpath($tmpdir) or
4290 dodie "can't create $tmpdir";
4291 }
4292
4293 $ENV{"SSH_USER"} = $ssh_user;
4294 $ENV{"MACHINE"} = $machine;
4295
4296 $buildlog = "$tmpdir/buildlog-$machine";
4297 $testlog = "$tmpdir/testlog-$machine";
4298 $dmesg = "$tmpdir/dmesg-$machine";
4299 $output_config = "$outputdir/.config";
4300
4301 if (!$buildonly) {
4302 $target = "$ssh_user\@$machine";
4303 if (($reboot_type eq "grub") or ($reboot_type eq "grub2bls")) {
4304 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
4305 } elsif ($reboot_type eq "grub2") {
4306 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
4307 dodie "GRUB_FILE not defined" if (!defined($grub_file));
4308 } elsif ($reboot_type eq "syslinux") {
4309 dodie "SYSLINUX_LABEL not defined" if (!defined($syslinux_label));
4310 }
4311 }
4312
4313 my $run_type = $build_type;
4314 if ($test_type eq "patchcheck") {
4315 $run_type = $patchcheck_type;
4316 } elsif ($test_type eq "bisect") {
4317 $run_type = $bisect_type;
4318 } elsif ($test_type eq "config_bisect") {
4319 $run_type = $config_bisect_type;
4320 } elsif ($test_type eq "make_min_config") {
4321 $run_type = "";
4322 } elsif ($test_type eq "make_warnings_file") {
4323 $run_type = "";
4324 }
4325
4326 # mistake in config file?
4327 if (!defined($run_type)) {
4328 $run_type = "ERROR";
4329 }
4330
4331 my $installme = "";
4332 $installme = " no_install" if ($no_install);
4333
4334 my $name = "";
4335
4336 if (defined($test_name)) {
4337 $name = " ($test_name)";
4338 }
4339
4340 doprint "\n\n";
4341 doprint "RUNNING TEST $i of $opt{NUM_TESTS}$name with option $test_type $run_type$installme\n\n";
4342
4343 if (defined($pre_test)) {
4344 run_command $pre_test;
4345 }
4346
4347 unlink $dmesg;
4348 unlink $buildlog;
4349 unlink $testlog;
4350
4351 if (defined($addconfig)) {
4352 my $min = $minconfig;
4353 if (!defined($minconfig)) {
4354 $min = "";
4355 }
4356 run_command "cat $addconfig $min > $tmpdir/add_config" or
4357 dodie "Failed to create temp config";
4358 $minconfig = "$tmpdir/add_config";
4359 }
4360
4361 if (defined($checkout)) {
4362 run_command "git checkout $checkout" or
4363 dodie "failed to checkout $checkout";
4364 }
4365
4366 $no_reboot = 0;
4367
4368 # A test may opt to not reboot the box
4369 if ($reboot_on_success) {
4370 $reboot_success = 1;
4371 }
4372
4373 if ($test_type eq "bisect") {
4374 bisect $i;
4375 next;
4376 } elsif ($test_type eq "config_bisect") {
4377 config_bisect $i;
4378 next;
4379 } elsif ($test_type eq "patchcheck") {
4380 patchcheck $i;
4381 next;
4382 } elsif ($test_type eq "make_min_config") {
4383 make_min_config $i;
4384 next;
4385 } elsif ($test_type eq "make_warnings_file") {
4386 $no_reboot = 1;
4387 make_warnings_file $i;
4388 next;
4389 }
4390
4391 if ($build_type ne "nobuild") {
4392 build $build_type or next;
4393 check_buildlog or next;
4394 }
4395
4396 if ($test_type eq "install") {
4397 get_version;
4398 install;
4399 success $i;
4400 next;
4401 }
4402
4403 if ($test_type ne "build") {
4404 my $failed = 0;
4405 start_monitor_and_install or $failed = 1;
4406
4407 if (!$failed && $test_type ne "boot" && defined($run_test)) {
4408 do_run_test or $failed = 1;
4409 }
4410 end_monitor;
4411 if ($failed) {
4412 print_times;
4413 next;
4414 }
4415 }
4416
4417 print_times;
4418
4419 success $i;
4420}
4421
4422if (defined($final_post_ktest)) {
4423
4424 my $cp_final_post_ktest = eval_kernel_version $final_post_ktest;
4425 run_command $cp_final_post_ktest;
4426}
4427
4428if ($opt{"POWEROFF_ON_SUCCESS"}) {
4429 halt;
4430} elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot && $reboot_success) {
4431 reboot_to_good;
4432} elsif (defined($switch_to_good)) {
4433 # still need to get to the good kernel
4434 run_command $switch_to_good;
4435}
4436
4437
4438doprint "\n $successes of $opt{NUM_TESTS} tests were successful\n\n";
4439
4440if ($email_when_finished) {
4441 send_email("KTEST: Your test has finished!",
4442 "$successes of $opt{NUM_TESTS} tests started at $script_start_time were successful!");
4443}
4444exit 0;