projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ktest: Add warning when bugs are ignored
[deliverable/linux.git] / tools / testing / ktest / ktest.pl
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
7 use strict;
8 use IPC::Open2;
9 use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
10 use File::Path qw(mkpath);
11 use File::Copy qw(cp);
12 use FileHandle;
13
14 my $VERSION = "0.2";
15
16 $| = 1;
17
18 my %opt;
19 my %repeat_tests;
20 my %repeats;
21
22 #default opts
23 my %default = (
24 "NUM_TESTS" => 1,
25 "TEST_TYPE" => "build",
26 "BUILD_TYPE" => "randconfig",
27 "MAKE_CMD" => "make",
28 "TIMEOUT" => 120,
29 "TMP_DIR" => "/tmp/ktest/\${MACHINE}",
30 "SLEEP_TIME" => 60, # sleep time between tests
31 "BUILD_NOCLEAN" => 0,
32 "REBOOT_ON_ERROR" => 0,
33 "POWEROFF_ON_ERROR" => 0,
34 "REBOOT_ON_SUCCESS" => 1,
35 "POWEROFF_ON_SUCCESS" => 0,
36 "BUILD_OPTIONS" => "",
37 "BISECT_SLEEP_TIME" => 60, # sleep time between bisects
38 "PATCHCHECK_SLEEP_TIME" => 60, # sleep time between patch checks
39 "CLEAR_LOG" => 0,
40 "BISECT_MANUAL" => 0,
41 "BISECT_SKIP" => 1,
42 "SUCCESS_LINE" => "login:",
43 "DETECT_TRIPLE_FAULT" => 1,
44 "NO_INSTALL" => 0,
45 "BOOTED_TIMEOUT" => 1,
46 "DIE_ON_FAILURE" => 1,
47 "SSH_EXEC" => "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND",
48 "SCP_TO_TARGET" => "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE",
49 "REBOOT" => "ssh \$SSH_USER\@\$MACHINE reboot",
50 "STOP_AFTER_SUCCESS" => 10,
51 "STOP_AFTER_FAILURE" => 60,
52 "STOP_TEST_AFTER" => 600,
53
54 # required, and we will ask users if they don't have them but we keep the default
55 # value something that is common.
56 "REBOOT_TYPE" => "grub",
57 "LOCALVERSION" => "-test",
58 "SSH_USER" => "root",
59 "BUILD_TARGET" => "arch/x86/boot/bzImage",
60 "TARGET_IMAGE" => "/boot/vmlinuz-test",
61
62 "LOG_FILE" => undef,
63 "IGNORE_UNUSED" => 0,
64 );
65
66 my $ktest_config;
67 my $version;
68 my $machine;
69 my $ssh_user;
70 my $tmpdir;
71 my $builddir;
72 my $outputdir;
73 my $output_config;
74 my $test_type;
75 my $build_type;
76 my $build_options;
77 my $pre_build;
78 my $post_build;
79 my $pre_build_die;
80 my $post_build_die;
81 my $reboot_type;
82 my $reboot_script;
83 my $power_cycle;
84 my $reboot;
85 my $reboot_on_error;
86 my $switch_to_good;
87 my $switch_to_test;
88 my $poweroff_on_error;
89 my $die_on_failure;
90 my $powercycle_after_reboot;
91 my $poweroff_after_halt;
92 my $ssh_exec;
93 my $scp_to_target;
94 my $power_off;
95 my $grub_menu;
96 my $grub_number;
97 my $target;
98 my $make;
99 my $post_install;
100 my $no_install;
101 my $noclean;
102 my $minconfig;
103 my $start_minconfig;
104 my $start_minconfig_defined;
105 my $output_minconfig;
106 my $ignore_config;
107 my $ignore_errors;
108 my $addconfig;
109 my $in_bisect = 0;
110 my $bisect_bad_commit = "";
111 my $reverse_bisect;
112 my $bisect_manual;
113 my $bisect_skip;
114 my $config_bisect_good;
115 my $bisect_ret_good;
116 my $bisect_ret_bad;
117 my $bisect_ret_skip;
118 my $bisect_ret_abort;
119 my $bisect_ret_default;
120 my $in_patchcheck = 0;
121 my $run_test;
122 my $redirect;
123 my $buildlog;
124 my $testlog;
125 my $dmesg;
126 my $monitor_fp;
127 my $monitor_pid;
128 my $monitor_cnt = 0;
129 my $sleep_time;
130 my $bisect_sleep_time;
131 my $patchcheck_sleep_time;
132 my $ignore_warnings;
133 my $store_failures;
134 my $store_successes;
135 my $test_name;
136 my $timeout;
137 my $booted_timeout;
138 my $detect_triplefault;
139 my $console;
140 my $reboot_success_line;
141 my $success_line;
142 my $stop_after_success;
143 my $stop_after_failure;
144 my $stop_test_after;
145 my $build_target;
146 my $target_image;
147 my $checkout;
148 my $localversion;
149 my $iteration = 0;
150 my $successes = 0;
151
152 my $bisect_good;
153 my $bisect_bad;
154 my $bisect_type;
155 my $bisect_start;
156 my $bisect_replay;
157 my $bisect_files;
158 my $bisect_reverse;
159 my $bisect_check;
160
161 my $config_bisect;
162 my $config_bisect_type;
163
164 my $patchcheck_type;
165 my $patchcheck_start;
166 my $patchcheck_end;
167
168 # set when a test is something other that just building or install
169 # which would require more options.
170 my $buildonly = 1;
171
172 # set when creating a new config
173 my $newconfig = 0;
174
175 my %entered_configs;
176 my %config_help;
177 my %variable;
178 my %force_config;
179
180 # do not force reboots on config problems
181 my $no_reboot = 1;
182
183 my %option_map = (
184 "MACHINE" => \$machine,
185 "SSH_USER" => \$ssh_user,
186 "TMP_DIR" => \$tmpdir,
187 "OUTPUT_DIR" => \$outputdir,
188 "BUILD_DIR" => \$builddir,
189 "TEST_TYPE" => \$test_type,
190 "BUILD_TYPE" => \$build_type,
191 "BUILD_OPTIONS" => \$build_options,
192 "PRE_BUILD" => \$pre_build,
193 "POST_BUILD" => \$post_build,
194 "PRE_BUILD_DIE" => \$pre_build_die,
195 "POST_BUILD_DIE" => \$post_build_die,
196 "POWER_CYCLE" => \$power_cycle,
197 "REBOOT" => \$reboot,
198 "BUILD_NOCLEAN" => \$noclean,
199 "MIN_CONFIG" => \$minconfig,
200 "OUTPUT_MIN_CONFIG" => \$output_minconfig,
201 "START_MIN_CONFIG" => \$start_minconfig,
202 "IGNORE_CONFIG" => \$ignore_config,
203 "TEST" => \$run_test,
204 "ADD_CONFIG" => \$addconfig,
205 "REBOOT_TYPE" => \$reboot_type,
206 "GRUB_MENU" => \$grub_menu,
207 "POST_INSTALL" => \$post_install,
208 "NO_INSTALL" => \$no_install,
209 "REBOOT_SCRIPT" => \$reboot_script,
210 "REBOOT_ON_ERROR" => \$reboot_on_error,
211 "SWITCH_TO_GOOD" => \$switch_to_good,
212 "SWITCH_TO_TEST" => \$switch_to_test,
213 "POWEROFF_ON_ERROR" => \$poweroff_on_error,
214 "DIE_ON_FAILURE" => \$die_on_failure,
215 "POWER_OFF" => \$power_off,
216 "POWERCYCLE_AFTER_REBOOT" => \$powercycle_after_reboot,
217 "POWEROFF_AFTER_HALT" => \$poweroff_after_halt,
218 "SLEEP_TIME" => \$sleep_time,
219 "BISECT_SLEEP_TIME" => \$bisect_sleep_time,
220 "PATCHCHECK_SLEEP_TIME" => \$patchcheck_sleep_time,
221 "IGNORE_WARNINGS" => \$ignore_warnings,
222 "IGNORE_ERRORS" => \$ignore_errors,
223 "BISECT_MANUAL" => \$bisect_manual,
224 "BISECT_SKIP" => \$bisect_skip,
225 "CONFIG_BISECT_GOOD" => \$config_bisect_good,
226 "BISECT_RET_GOOD" => \$bisect_ret_good,
227 "BISECT_RET_BAD" => \$bisect_ret_bad,
228 "BISECT_RET_SKIP" => \$bisect_ret_skip,
229 "BISECT_RET_ABORT" => \$bisect_ret_abort,
230 "BISECT_RET_DEFAULT" => \$bisect_ret_default,
231 "STORE_FAILURES" => \$store_failures,
232 "STORE_SUCCESSES" => \$store_successes,
233 "TEST_NAME" => \$test_name,
234 "TIMEOUT" => \$timeout,
235 "BOOTED_TIMEOUT" => \$booted_timeout,
236 "CONSOLE" => \$console,
237 "DETECT_TRIPLE_FAULT" => \$detect_triplefault,
238 "SUCCESS_LINE" => \$success_line,
239 "REBOOT_SUCCESS_LINE" => \$reboot_success_line,
240 "STOP_AFTER_SUCCESS" => \$stop_after_success,
241 "STOP_AFTER_FAILURE" => \$stop_after_failure,
242 "STOP_TEST_AFTER" => \$stop_test_after,
243 "BUILD_TARGET" => \$build_target,
244 "SSH_EXEC" => \$ssh_exec,
245 "SCP_TO_TARGET" => \$scp_to_target,
246 "CHECKOUT" => \$checkout,
247 "TARGET_IMAGE" => \$target_image,
248 "LOCALVERSION" => \$localversion,
249
250 "BISECT_GOOD" => \$bisect_good,
251 "BISECT_BAD" => \$bisect_bad,
252 "BISECT_TYPE" => \$bisect_type,
253 "BISECT_START" => \$bisect_start,
254 "BISECT_REPLAY" => \$bisect_replay,
255 "BISECT_FILES" => \$bisect_files,
256 "BISECT_REVERSE" => \$bisect_reverse,
257 "BISECT_CHECK" => \$bisect_check,
258
259 "CONFIG_BISECT" => \$config_bisect,
260 "CONFIG_BISECT_TYPE" => \$config_bisect_type,
261
262 "PATCHCHECK_TYPE" => \$patchcheck_type,
263 "PATCHCHECK_START" => \$patchcheck_start,
264 "PATCHCHECK_END" => \$patchcheck_end,
265 );
266
267 # Options may be used by other options, record them.
268 my %used_options;
269
270 # default variables that can be used
271 chomp ($variable{"PWD"} = `pwd`);
272
273 $config_help{"MACHINE"} = << "EOF"
274 The machine hostname that you will test.
275 For build only tests, it is still needed to differentiate log files.
276 EOF
277 ;
278 $config_help{"SSH_USER"} = << "EOF"
279 The box is expected to have ssh on normal bootup, provide the user
280 (most likely root, since you need privileged operations)
281 EOF
282 ;
283 $config_help{"BUILD_DIR"} = << "EOF"
284 The directory that contains the Linux source code (full path).
285 You can use \${PWD} that will be the path where ktest.pl is run, or use
286 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
287 EOF
288 ;
289 $config_help{"OUTPUT_DIR"} = << "EOF"
290 The directory that the objects will be built (full path).
291 (can not be same as BUILD_DIR)
292 You can use \${PWD} that will be the path where ktest.pl is run, or use
293 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
294 EOF
295 ;
296 $config_help{"BUILD_TARGET"} = << "EOF"
297 The location of the compiled file to copy to the target.
298 (relative to OUTPUT_DIR)
299 EOF
300 ;
301 $config_help{"BUILD_OPTIONS"} = << "EOF"
302 Options to add to \"make\" when building.
303 i.e. -j20
304 EOF
305 ;
306 $config_help{"TARGET_IMAGE"} = << "EOF"
307 The place to put your image on the test machine.
308 EOF
309 ;
310 $config_help{"POWER_CYCLE"} = << "EOF"
311 A script or command to reboot the box.
312
313 Here is a digital loggers power switch example
314 POWER_CYCLE = wget --no-proxy -O /dev/null -q --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL'
315
316 Here is an example to reboot a virtual box on the current host
317 with the name "Guest".
318 POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest
319 EOF
320 ;
321 $config_help{"CONSOLE"} = << "EOF"
322 The script or command that reads the console
323
324 If you use ttywatch server, something like the following would work.
325 CONSOLE = nc -d localhost 3001
326
327 For a virtual machine with guest name "Guest".
328 CONSOLE = virsh console Guest
329 EOF
330 ;
331 $config_help{"LOCALVERSION"} = << "EOF"
332 Required version ending to differentiate the test
333 from other linux builds on the system.
334 EOF
335 ;
336 $config_help{"REBOOT_TYPE"} = << "EOF"
337 Way to reboot the box to the test kernel.
338 Only valid options so far are "grub" and "script".
339
340 If you specify grub, it will assume grub version 1
341 and will search in /boot/grub/menu.lst for the title \$GRUB_MENU
342 and select that target to reboot to the kernel. If this is not
343 your setup, then specify "script" and have a command or script
344 specified in REBOOT_SCRIPT to boot to the target.
345
346 The entry in /boot/grub/menu.lst must be entered in manually.
347 The test will not modify that file.
348 EOF
349 ;
350 $config_help{"GRUB_MENU"} = << "EOF"
351 The grub title name for the test kernel to boot
352 (Only mandatory if REBOOT_TYPE = grub)
353
354 Note, ktest.pl will not update the grub menu.lst, you need to
355 manually add an option for the test. ktest.pl will search
356 the grub menu.lst for this option to find what kernel to
357 reboot into.
358
359 For example, if in the /boot/grub/menu.lst the test kernel title has:
360 title Test Kernel
361 kernel vmlinuz-test
362 GRUB_MENU = Test Kernel
363 EOF
364 ;
365 $config_help{"REBOOT_SCRIPT"} = << "EOF"
366 A script to reboot the target into the test kernel
367 (Only mandatory if REBOOT_TYPE = script)
368 EOF
369 ;
370
371 sub read_prompt {
372 my ($cancel, $prompt) = @_;
373
374 my $ans;
375
376 for (;;) {
377 if ($cancel) {
378 print "$prompt [y/n/C] ";
379 } else {
380 print "$prompt [Y/n] ";
381 }
382 $ans = <STDIN>;
383 chomp $ans;
384 if ($ans =~ /^\s*$/) {
385 if ($cancel) {
386 $ans = "c";
387 } else {
388 $ans = "y";
389 }
390 }
391 last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
392 if ($cancel) {
393 last if ($ans =~ /^c$/i);
394 print "Please answer either 'y', 'n' or 'c'.\n";
395 } else {
396 print "Please answer either 'y' or 'n'.\n";
397 }
398 }
399 if ($ans =~ /^c/i) {
400 exit;
401 }
402 if ($ans !~ /^y$/i) {
403 return 0;
404 }
405 return 1;
406 }
407
408 sub read_yn {
409 my ($prompt) = @_;
410
411 return read_prompt 0, $prompt;
412 }
413
414 sub read_ync {
415 my ($prompt) = @_;
416
417 return read_prompt 1, $prompt;
418 }
419
420 sub get_ktest_config {
421 my ($config) = @_;
422 my $ans;
423
424 return if (defined($opt{$config}));
425
426 if (defined($config_help{$config})) {
427 print "\n";
428 print $config_help{$config};
429 }
430
431 for (;;) {
432 print "$config = ";
433 if (defined($default{$config}) && length($default{$config})) {
434 print "\[$default{$config}\] ";
435 }
436 $ans = <STDIN>;
437 $ans =~ s/^\s*(.*\S)\s*$/$1/;
438 if ($ans =~ /^\s*$/) {
439 if ($default{$config}) {
440 $ans = $default{$config};
441 } else {
442 print "Your answer can not be blank\n";
443 next;
444 }
445 }
446 $entered_configs{$config} = ${ans};
447 last;
448 }
449 }
450
451 sub get_ktest_configs {
452 get_ktest_config("MACHINE");
453 get_ktest_config("BUILD_DIR");
454 get_ktest_config("OUTPUT_DIR");
455
456 if ($newconfig) {
457 get_ktest_config("BUILD_OPTIONS");
458 }
459
460 # options required for other than just building a kernel
461 if (!$buildonly) {
462 get_ktest_config("POWER_CYCLE");
463 get_ktest_config("CONSOLE");
464 }
465
466 # options required for install and more
467 if ($buildonly != 1) {
468 get_ktest_config("SSH_USER");
469 get_ktest_config("BUILD_TARGET");
470 get_ktest_config("TARGET_IMAGE");
471 }
472
473 get_ktest_config("LOCALVERSION");
474
475 return if ($buildonly);
476
477 my $rtype = $opt{"REBOOT_TYPE"};
478
479 if (!defined($rtype)) {
480 if (!defined($opt{"GRUB_MENU"})) {
481 get_ktest_config("REBOOT_TYPE");
482 $rtype = $entered_configs{"REBOOT_TYPE"};
483 } else {
484 $rtype = "grub";
485 }
486 }
487
488 if ($rtype eq "grub") {
489 get_ktest_config("GRUB_MENU");
490 }
491 }
492
493 sub process_variables {
494 my ($value, $remove_undef) = @_;
495 my $retval = "";
496
497 # We want to check for '\', and it is just easier
498 # to check the previous characet of '$' and not need
499 # to worry if '$' is the first character. By adding
500 # a space to $value, we can just check [^\\]\$ and
501 # it will still work.
502 $value = " $value";
503
504 while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
505 my $begin = $1;
506 my $var = $2;
507 my $end = $3;
508 # append beginning of value to retval
509 $retval = "$retval$begin";
510 if (defined($variable{$var})) {
511 $retval = "$retval$variable{$var}";
512 } elsif (defined($remove_undef) && $remove_undef) {
513 # for if statements, any variable that is not defined,
514 # we simple convert to 0
515 $retval = "${retval}0";
516 } else {
517 # put back the origin piece.
518 $retval = "$retval\$\{$var\}";
519 # This could be an option that is used later, save
520 # it so we don't warn if this option is not one of
521 # ktests options.
522 $used_options{$var} = 1;
523 }
524 $value = $end;
525 }
526 $retval = "$retval$value";
527
528 # remove the space added in the beginning
529 $retval =~ s/ //;
530
531 return "$retval"
532 }
533
534 sub set_value {
535 my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
536
537 my $prvalue = process_variables($rvalue);
538
539 if ($buildonly && $lvalue =~ /^TEST_TYPE(\[.*\])?$/ && $prvalue ne "build") {
540 # Note if a test is something other than build, then we
541 # will need other manditory options.
542 if ($prvalue ne "install") {
543 $buildonly = 0;
544 } else {
545 # install still limits some manditory options.
546 $buildonly = 2;
547 }
548 }
549
550 if (defined($opt{$lvalue})) {
551 if (!$override || defined(${$overrides}{$lvalue})) {
552 my $extra = "";
553 if ($override) {
554 $extra = "In the same override section!\n";
555 }
556 die "$name: $.: Option $lvalue defined more than once!\n$extra";
557 }
558 ${$overrides}{$lvalue} = $prvalue;
559 }
560 if ($rvalue =~ /^\s*$/) {
561 delete $opt{$lvalue};
562 } else {
563 $opt{$lvalue} = $prvalue;
564 }
565 }
566
567 sub set_variable {
568 my ($lvalue, $rvalue) = @_;
569
570 if ($rvalue =~ /^\s*$/) {
571 delete $variable{$lvalue};
572 } else {
573 $rvalue = process_variables($rvalue);
574 $variable{$lvalue} = $rvalue;
575 }
576 }
577
578 sub process_compare {
579 my ($lval, $cmp, $rval) = @_;
580
581 # remove whitespace
582
583 $lval =~ s/^\s*//;
584 $lval =~ s/\s*$//;
585
586 $rval =~ s/^\s*//;
587 $rval =~ s/\s*$//;
588
589 if ($cmp eq "==") {
590 return $lval eq $rval;
591 } elsif ($cmp eq "!=") {
592 return $lval ne $rval;
593 }
594
595 my $statement = "$lval $cmp $rval";
596 my $ret = eval $statement;
597
598 # $@ stores error of eval
599 if ($@) {
600 return -1;
601 }
602
603 return $ret;
604 }
605
606 sub value_defined {
607 my ($val) = @_;
608
609 return defined($variable{$2}) ||
610 defined($opt{$2});
611 }
612
613 my $d = 0;
614 sub process_expression {
615 my ($name, $val) = @_;
616
617 my $c = $d++;
618
619 while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
620 my $express = $1;
621
622 if (process_expression($name, $express)) {
623 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
624 } else {
625 $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
626 }
627 }
628
629 $d--;
630 my $OR = "\\|\\|";
631 my $AND = "\\&\\&";
632
633 while ($val =~ s/^(.*?)($OR|$AND)//) {
634 my $express = $1;
635 my $op = $2;
636
637 if (process_expression($name, $express)) {
638 if ($op eq "||") {
639 return 1;
640 }
641 } else {
642 if ($op eq "&&") {
643 return 0;
644 }
645 }
646 }
647
648 if ($val =~ /(.*)(==|\!=|>=|<=|>|<)(.*)/) {
649 my $ret = process_compare($1, $2, $3);
650 if ($ret < 0) {
651 die "$name: $.: Unable to process comparison\n";
652 }
653 return $ret;
654 }
655
656 if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
657 if (defined $1) {
658 return !value_defined($2);
659 } else {
660 return value_defined($2);
661 }
662 }
663
664 if ($val =~ /^\s*0\s*$/) {
665 return 0;
666 } elsif ($val =~ /^\s*\d+\s*$/) {
667 return 1;
668 }
669
670 die ("$name: $.: Undefined content $val in if statement\n");
671 }
672
673 sub process_if {
674 my ($name, $value) = @_;
675
676 # Convert variables and replace undefined ones with 0
677 my $val = process_variables($value, 1);
678 my $ret = process_expression $name, $val;
679
680 return $ret;
681 }
682
683 sub __read_config {
684 my ($config, $current_test_num) = @_;
685
686 my $in;
687 open($in, $config) || die "can't read file $config";
688
689 my $name = $config;
690 $name =~ s,.*/(.*),$1,;
691
692 my $test_num = $$current_test_num;
693 my $default = 1;
694 my $repeat = 1;
695 my $num_tests_set = 0;
696 my $skip = 0;
697 my $rest;
698 my $line;
699 my $test_case = 0;
700 my $if = 0;
701 my $if_set = 0;
702 my $override = 0;
703
704 my %overrides;
705
706 while (<$in>) {
707
708 # ignore blank lines and comments
709 next if (/^\s*$/ || /\s*\#/);
710
711 if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
712
713 my $type = $1;
714 $rest = $2;
715 $line = $2;
716
717 my $old_test_num;
718 my $old_repeat;
719 $override = 0;
720
721 if ($type eq "TEST_START") {
722
723 if ($num_tests_set) {
724 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
725 }
726
727 $old_test_num = $test_num;
728 $old_repeat = $repeat;
729
730 $test_num += $repeat;
731 $default = 0;
732 $repeat = 1;
733 } else {
734 $default = 1;
735 }
736
737 # If SKIP is anywhere in the line, the command will be skipped
738 if ($rest =~ s/\s+SKIP\b//) {
739 $skip = 1;
740 } else {
741 $test_case = 1;
742 $skip = 0;
743 }
744
745 if ($rest =~ s/\sELSE\b//) {
746 if (!$if) {
747 die "$name: $.: ELSE found with out matching IF section\n$_";
748 }
749 $if = 0;
750
751 if ($if_set) {
752 $skip = 1;
753 } else {
754 $skip = 0;
755 }
756 }
757
758 if ($rest =~ s/\sIF\s+(.*)//) {
759 if (process_if($name, $1)) {
760 $if_set = 1;
761 } else {
762 $skip = 1;
763 }
764 $if = 1;
765 } else {
766 $if = 0;
767 $if_set = 0;
768 }
769
770 if (!$skip) {
771 if ($type eq "TEST_START") {
772 if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
773 $repeat = $1;
774 $repeat_tests{"$test_num"} = $repeat;
775 }
776 } elsif ($rest =~ s/\sOVERRIDE\b//) {
777 # DEFAULT only
778 $override = 1;
779 # Clear previous overrides
780 %overrides = ();
781 }
782 }
783
784 if (!$skip && $rest !~ /^\s*$/) {
785 die "$name: $.: Gargbage found after $type\n$_";
786 }
787
788 if ($skip && $type eq "TEST_START") {
789 $test_num = $old_test_num;
790 $repeat = $old_repeat;
791 }
792
793 } elsif (/^\s*ELSE\b(.*)$/) {
794 if (!$if) {
795 die "$name: $.: ELSE found with out matching IF section\n$_";
796 }
797 $rest = $1;
798 if ($if_set) {
799 $skip = 1;
800 $rest = "";
801 } else {
802 $skip = 0;
803
804 if ($rest =~ /\sIF\s+(.*)/) {
805 # May be a ELSE IF section.
806 if (!process_if($name, $1)) {
807 $skip = 1;
808 }
809 $rest = "";
810 } else {
811 $if = 0;
812 }
813 }
814
815 if ($rest !~ /^\s*$/) {
816 die "$name: $.: Gargbage found after DEFAULTS\n$_";
817 }
818
819 } elsif (/^\s*INCLUDE\s+(\S+)/) {
820
821 next if ($skip);
822
823 if (!$default) {
824 die "$name: $.: INCLUDE can only be done in default sections\n$_";
825 }
826
827 my $file = process_variables($1);
828
829 if ($file !~ m,^/,) {
830 # check the path of the config file first
831 if ($config =~ m,(.*)/,) {
832 if (-f "$1/$file") {
833 $file = "$1/$file";
834 }
835 }
836 }
837
838 if ( ! -r $file ) {
839 die "$name: $.: Can't read file $file\n$_";
840 }
841
842 if (__read_config($file, \$test_num)) {
843 $test_case = 1;
844 }
845
846 } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
847
848 next if ($skip);
849
850 my $lvalue = $1;
851 my $rvalue = $2;
852
853 if (!$default &&
854 ($lvalue eq "NUM_TESTS" ||
855 $lvalue eq "LOG_FILE" ||
856 $lvalue eq "CLEAR_LOG")) {
857 die "$name: $.: $lvalue must be set in DEFAULTS section\n";
858 }
859
860 if ($lvalue eq "NUM_TESTS") {
861 if ($test_num) {
862 die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
863 }
864 if (!$default) {
865 die "$name: $.: NUM_TESTS must be set in default section\n";
866 }
867 $num_tests_set = 1;
868 }
869
870 if ($default || $lvalue =~ /\[\d+\]$/) {
871 set_value($lvalue, $rvalue, $override, \%overrides, $name);
872 } else {
873 my $val = "$lvalue\[$test_num\]";
874 set_value($val, $rvalue, $override, \%overrides, $name);
875
876 if ($repeat > 1) {
877 $repeats{$val} = $repeat;
878 }
879 }
880 } elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
881 next if ($skip);
882
883 my $lvalue = $1;
884 my $rvalue = $2;
885
886 # process config variables.
887 # Config variables are only active while reading the
888 # config and can be defined anywhere. They also ignore
889 # TEST_START and DEFAULTS, but are skipped if they are in
890 # on of these sections that have SKIP defined.
891 # The save variable can be
892 # defined multiple times and the new one simply overrides
893 # the prevous one.
894 set_variable($lvalue, $rvalue);
895
896 } else {
897 die "$name: $.: Garbage found in config\n$_";
898 }
899 }
900
901 if ($test_num) {
902 $test_num += $repeat - 1;
903 $opt{"NUM_TESTS"} = $test_num;
904 }
905
906 close($in);
907
908 $$current_test_num = $test_num;
909
910 return $test_case;
911 }
912
913 sub get_test_case {
914 print "What test case would you like to run?\n";
915 print " (build, install or boot)\n";
916 print " Other tests are available but require editing the config file\n";
917 my $ans = <STDIN>;
918 chomp $ans;
919 $default{"TEST_TYPE"} = $ans;
920 }
921
922 sub read_config {
923 my ($config) = @_;
924
925 my $test_case;
926 my $test_num = 0;
927
928 $test_case = __read_config $config, \$test_num;
929
930 # make sure we have all mandatory configs
931 get_ktest_configs;
932
933 # was a test specified?
934 if (!$test_case) {
935 print "No test case specified.\n";
936 get_test_case;
937 }
938
939 # set any defaults
940
941 foreach my $default (keys %default) {
942 if (!defined($opt{$default})) {
943 $opt{$default} = $default{$default};
944 }
945 }
946
947 if ($opt{"IGNORE_UNUSED"} == 1) {
948 return;
949 }
950
951 my %not_used;
952
953 # check if there are any stragglers (typos?)
954 foreach my $option (keys %opt) {
955 my $op = $option;
956 # remove per test labels.
957 $op =~ s/\[.*\]//;
958 if (!exists($option_map{$op}) &&
959 !exists($default{$op}) &&
960 !exists($used_options{$op})) {
961 $not_used{$op} = 1;
962 }
963 }
964
965 if (%not_used) {
966 my $s = "s are";
967 $s = " is" if (keys %not_used == 1);
968 print "The following option$s not used; could be a typo:\n";
969 foreach my $option (keys %not_used) {
970 print "$option\n";
971 }
972 print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";
973 if (!read_yn "Do you want to continue?") {
974 exit -1;
975 }
976 }
977 }
978
979 sub __eval_option {
980 my ($option, $i) = @_;
981
982 # Add space to evaluate the character before $
983 $option = " $option";
984 my $retval = "";
985 my $repeated = 0;
986 my $parent = 0;
987
988 foreach my $test (keys %repeat_tests) {
989 if ($i >= $test &&
990 $i < $test + $repeat_tests{$test}) {
991
992 $repeated = 1;
993 $parent = $test;
994 last;
995 }
996 }
997
998 while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
999 my $start = $1;
1000 my $var = $2;
1001 my $end = $3;
1002
1003 # Append beginning of line
1004 $retval = "$retval$start";
1005
1006 # If the iteration option OPT[$i] exists, then use that.
1007 # otherwise see if the default OPT (without [$i]) exists.
1008
1009 my $o = "$var\[$i\]";
1010 my $parento = "$var\[$parent\]";
1011
1012 if (defined($opt{$o})) {
1013 $o = $opt{$o};
1014 $retval = "$retval$o";
1015 } elsif ($repeated && defined($opt{$parento})) {
1016 $o = $opt{$parento};
1017 $retval = "$retval$o";
1018 } elsif (defined($opt{$var})) {
1019 $o = $opt{$var};
1020 $retval = "$retval$o";
1021 } else {
1022 $retval = "$retval\$\{$var\}";
1023 }
1024
1025 $option = $end;
1026 }
1027
1028 $retval = "$retval$option";
1029
1030 $retval =~ s/^ //;
1031
1032 return $retval;
1033 }
1034
1035 sub eval_option {
1036 my ($option, $i) = @_;
1037
1038 my $prev = "";
1039
1040 # Since an option can evaluate to another option,
1041 # keep iterating until we do not evaluate any more
1042 # options.
1043 my $r = 0;
1044 while ($prev ne $option) {
1045 # Check for recursive evaluations.
1046 # 100 deep should be more than enough.
1047 if ($r++ > 100) {
1048 die "Over 100 evaluations accurred with $option\n" .
1049 "Check for recursive variables\n";
1050 }
1051 $prev = $option;
1052 $option = __eval_option($option, $i);
1053 }
1054
1055 return $option;
1056 }
1057
1058 sub _logit {
1059 if (defined($opt{"LOG_FILE"})) {
1060 open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
1061 print OUT @_;
1062 close(OUT);
1063 }
1064 }
1065
1066 sub logit {
1067 if (defined($opt{"LOG_FILE"})) {
1068 _logit @_;
1069 } else {
1070 print @_;
1071 }
1072 }
1073
1074 sub doprint {
1075 print @_;
1076 _logit @_;
1077 }
1078
1079 sub run_command;
1080 sub start_monitor;
1081 sub end_monitor;
1082 sub wait_for_monitor;
1083
1084 sub reboot {
1085 my ($time) = @_;
1086
1087 if (defined($time)) {
1088 start_monitor;
1089 # flush out current monitor
1090 # May contain the reboot success line
1091 wait_for_monitor 1;
1092 }
1093
1094 # try to reboot normally
1095 if (run_command $reboot) {
1096 if (defined($powercycle_after_reboot)) {
1097 sleep $powercycle_after_reboot;
1098 run_command "$power_cycle";
1099 }
1100 } else {
1101 # nope? power cycle it.
1102 run_command "$power_cycle";
1103 }
1104
1105 if (defined($time)) {
1106 wait_for_monitor($time, $reboot_success_line);
1107 end_monitor;
1108 }
1109 }
1110
1111 sub reboot_to_good {
1112 my ($time) = @_;
1113
1114 if (defined($switch_to_good)) {
1115 run_command $switch_to_good;
1116 return;
1117 }
1118
1119 reboot $time;
1120 }
1121
1122 sub do_not_reboot {
1123 my $i = $iteration;
1124
1125 return $test_type eq "build" || $no_reboot ||
1126 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
1127 ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
1128 }
1129
1130 sub dodie {
1131 doprint "CRITICAL FAILURE... ", @_, "\n";
1132
1133 my $i = $iteration;
1134
1135 if ($reboot_on_error && !do_not_reboot) {
1136
1137 doprint "REBOOTING\n";
1138 reboot_to_good;
1139
1140 } elsif ($poweroff_on_error && defined($power_off)) {
1141 doprint "POWERING OFF\n";
1142 `$power_off`;
1143 }
1144
1145 if (defined($opt{"LOG_FILE"})) {
1146 print " See $opt{LOG_FILE} for more info.\n";
1147 }
1148
1149 die @_, "\n";
1150 }
1151
1152 sub open_console {
1153 my ($fp) = @_;
1154
1155 my $flags;
1156
1157 my $pid = open($fp, "$console|") or
1158 dodie "Can't open console $console";
1159
1160 $flags = fcntl($fp, F_GETFL, 0) or
1161 dodie "Can't get flags for the socket: $!";
1162 $flags = fcntl($fp, F_SETFL, $flags | O_NONBLOCK) or
1163 dodie "Can't set flags for the socket: $!";
1164
1165 return $pid;
1166 }
1167
1168 sub close_console {
1169 my ($fp, $pid) = @_;
1170
1171 doprint "kill child process $pid\n";
1172 kill 2, $pid;
1173
1174 print "closing!\n";
1175 close($fp);
1176 }
1177
1178 sub start_monitor {
1179 if ($monitor_cnt++) {
1180 return;
1181 }
1182 $monitor_fp = \*MONFD;
1183 $monitor_pid = open_console $monitor_fp;
1184
1185 return;
1186
1187 open(MONFD, "Stop perl from warning about single use of MONFD");
1188 }
1189
1190 sub end_monitor {
1191 if (--$monitor_cnt) {
1192 return;
1193 }
1194 close_console($monitor_fp, $monitor_pid);
1195 }
1196
1197 sub wait_for_monitor {
1198 my ($time, $stop) = @_;
1199 my $full_line = "";
1200 my $line;
1201 my $booted = 0;
1202
1203 doprint "** Wait for monitor to settle down **\n";
1204
1205 # read the monitor and wait for the system to calm down
1206 while (!$booted) {
1207 $line = wait_for_input($monitor_fp, $time);
1208 last if (!defined($line));
1209 print "$line";
1210 $full_line .= $line;
1211
1212 if (defined($stop) && $full_line =~ /$stop/) {
1213 doprint "wait for monitor detected $stop\n";
1214 $booted = 1;
1215 }
1216
1217 if ($line =~ /\n/) {
1218 $full_line = "";
1219 }
1220 }
1221 print "** Monitor flushed **\n";
1222 }
1223
1224 sub save_logs {
1225 my ($result, $basedir) = @_;
1226 my @t = localtime;
1227 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
1228 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
1229
1230 my $type = $build_type;
1231 if ($type =~ /useconfig/) {
1232 $type = "useconfig";
1233 }
1234
1235 my $dir = "$machine-$test_type-$type-$result-$date";
1236
1237 $dir = "$basedir/$dir";
1238
1239 if (!-d $dir) {
1240 mkpath($dir) or
1241 die "can't create $dir";
1242 }
1243
1244 my %files = (
1245 "config" => $output_config,
1246 "buildlog" => $buildlog,
1247 "dmesg" => $dmesg,
1248 "testlog" => $testlog,
1249 );
1250
1251 while (my ($name, $source) = each(%files)) {
1252 if (-f "$source") {
1253 cp "$source", "$dir/$name" or
1254 die "failed to copy $source";
1255 }
1256 }
1257
1258 doprint "*** Saved info to $dir ***\n";
1259 }
1260
1261 sub fail {
1262
1263 if ($die_on_failure) {
1264 dodie @_;
1265 }
1266
1267 doprint "FAILED\n";
1268
1269 my $i = $iteration;
1270
1271 # no need to reboot for just building.
1272 if (!do_not_reboot) {
1273 doprint "REBOOTING\n";
1274 reboot_to_good $sleep_time;
1275 }
1276
1277 my $name = "";
1278
1279 if (defined($test_name)) {
1280 $name = " ($test_name)";
1281 }
1282
1283 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1284 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1285 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
1286 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1287 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1288
1289 if (defined($store_failures)) {
1290 save_logs "fail", $store_failures;
1291 }
1292
1293 return 1;
1294 }
1295
1296 sub run_command {
1297 my ($command) = @_;
1298 my $dolog = 0;
1299 my $dord = 0;
1300 my $pid;
1301
1302 $command =~ s/\$SSH_USER/$ssh_user/g;
1303 $command =~ s/\$MACHINE/$machine/g;
1304
1305 doprint("$command ... ");
1306
1307 $pid = open(CMD, "$command 2>&1 |") or
1308 (fail "unable to exec $command" and return 0);
1309
1310 if (defined($opt{"LOG_FILE"})) {
1311 open(LOG, ">>$opt{LOG_FILE}") or
1312 dodie "failed to write to log";
1313 $dolog = 1;
1314 }
1315
1316 if (defined($redirect)) {
1317 open (RD, ">$redirect") or
1318 dodie "failed to write to redirect $redirect";
1319 $dord = 1;
1320 }
1321
1322 while (<CMD>) {
1323 print LOG if ($dolog);
1324 print RD if ($dord);
1325 }
1326
1327 waitpid($pid, 0);
1328 my $failed = $?;
1329
1330 close(CMD);
1331 close(LOG) if ($dolog);
1332 close(RD) if ($dord);
1333
1334 if ($failed) {
1335 doprint "FAILED!\n";
1336 } else {
1337 doprint "SUCCESS\n";
1338 }
1339
1340 return !$failed;
1341 }
1342
1343 sub run_ssh {
1344 my ($cmd) = @_;
1345 my $cp_exec = $ssh_exec;
1346
1347 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
1348 return run_command "$cp_exec";
1349 }
1350
1351 sub run_scp {
1352 my ($src, $dst) = @_;
1353 my $cp_scp = $scp_to_target;
1354
1355 $cp_scp =~ s/\$SRC_FILE/$src/g;
1356 $cp_scp =~ s/\$DST_FILE/$dst/g;
1357
1358 return run_command "$cp_scp";
1359 }
1360
1361 sub get_grub_index {
1362
1363 if ($reboot_type ne "grub") {
1364 return;
1365 }
1366 return if (defined($grub_number));
1367
1368 doprint "Find grub menu ... ";
1369 $grub_number = -1;
1370
1371 my $ssh_grub = $ssh_exec;
1372 $ssh_grub =~ s,\$SSH_COMMAND,cat /boot/grub/menu.lst,g;
1373
1374 open(IN, "$ssh_grub |")
1375 or die "unable to get menu.lst";
1376
1377 my $found = 0;
1378
1379 while (<IN>) {
1380 if (/^\s*title\s+$grub_menu\s*$/) {
1381 $grub_number++;
1382 $found = 1;
1383 last;
1384 } elsif (/^\s*title\s/) {
1385 $grub_number++;
1386 }
1387 }
1388 close(IN);
1389
1390 die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
1391 if (!$found);
1392 doprint "$grub_number\n";
1393 }
1394
1395 sub wait_for_input
1396 {
1397 my ($fp, $time) = @_;
1398 my $rin;
1399 my $ready;
1400 my $line;
1401 my $ch;
1402
1403 if (!defined($time)) {
1404 $time = $timeout;
1405 }
1406
1407 $rin = '';
1408 vec($rin, fileno($fp), 1) = 1;
1409 $ready = select($rin, undef, undef, $time);
1410
1411 $line = "";
1412
1413 # try to read one char at a time
1414 while (sysread $fp, $ch, 1) {
1415 $line .= $ch;
1416 last if ($ch eq "\n");
1417 }
1418
1419 if (!length($line)) {
1420 return undef;
1421 }
1422
1423 return $line;
1424 }
1425
1426 sub reboot_to {
1427 if (defined($switch_to_test)) {
1428 run_command $switch_to_test;
1429 }
1430
1431 if ($reboot_type eq "grub") {
1432 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
1433 } elsif (defined $reboot_script) {
1434 run_command "$reboot_script";
1435 }
1436 reboot;
1437 }
1438
1439 sub get_sha1 {
1440 my ($commit) = @_;
1441
1442 doprint "git rev-list --max-count=1 $commit ... ";
1443 my $sha1 = `git rev-list --max-count=1 $commit`;
1444 my $ret = $?;
1445
1446 logit $sha1;
1447
1448 if ($ret) {
1449 doprint "FAILED\n";
1450 dodie "Failed to get git $commit";
1451 }
1452
1453 print "SUCCESS\n";
1454
1455 chomp $sha1;
1456
1457 return $sha1;
1458 }
1459
1460 sub monitor {
1461 my $booted = 0;
1462 my $bug = 0;
1463 my $bug_ignored = 0;
1464 my $skip_call_trace = 0;
1465 my $loops;
1466
1467 wait_for_monitor 5;
1468
1469 my $line;
1470 my $full_line = "";
1471
1472 open(DMESG, "> $dmesg") or
1473 die "unable to write to $dmesg";
1474
1475 reboot_to;
1476
1477 my $success_start;
1478 my $failure_start;
1479 my $monitor_start = time;
1480 my $done = 0;
1481 my $version_found = 0;
1482
1483 while (!$done) {
1484
1485 if ($bug && defined($stop_after_failure) &&
1486 $stop_after_failure >= 0) {
1487 my $time = $stop_after_failure - (time - $failure_start);
1488 $line = wait_for_input($monitor_fp, $time);
1489 if (!defined($line)) {
1490 doprint "bug timed out after $booted_timeout seconds\n";
1491 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1492 last;
1493 }
1494 } elsif ($booted) {
1495 $line = wait_for_input($monitor_fp, $booted_timeout);
1496 if (!defined($line)) {
1497 my $s = $booted_timeout == 1 ? "" : "s";
1498 doprint "Successful boot found: break after $booted_timeout second$s\n";
1499 last;
1500 }
1501 } else {
1502 $line = wait_for_input($monitor_fp);
1503 if (!defined($line)) {
1504 my $s = $timeout == 1 ? "" : "s";
1505 doprint "Timed out after $timeout second$s\n";
1506 last;
1507 }
1508 }
1509
1510 doprint $line;
1511 print DMESG $line;
1512
1513 # we are not guaranteed to get a full line
1514 $full_line .= $line;
1515
1516 if ($full_line =~ /$success_line/) {
1517 $booted = 1;
1518 $success_start = time;
1519 }
1520
1521 if ($booted && defined($stop_after_success) &&
1522 $stop_after_success >= 0) {
1523 my $now = time;
1524 if ($now - $success_start >= $stop_after_success) {
1525 doprint "Test forced to stop after $stop_after_success seconds after success\n";
1526 last;
1527 }
1528 }
1529
1530 if ($full_line =~ /\[ backtrace testing \]/) {
1531 $skip_call_trace = 1;
1532 }
1533
1534 if ($full_line =~ /call trace:/i) {
1535 if (!$bug && !$skip_call_trace) {
1536 if ($ignore_errors) {
1537 $bug_ignored = 1;
1538 } else {
1539 $bug = 1;
1540 $failure_start = time;
1541 }
1542 }
1543 }
1544
1545 if ($bug && defined($stop_after_failure) &&
1546 $stop_after_failure >= 0) {
1547 my $now = time;
1548 if ($now - $failure_start >= $stop_after_failure) {
1549 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
1550 last;
1551 }
1552 }
1553
1554 if ($full_line =~ /\[ end of backtrace testing \]/) {
1555 $skip_call_trace = 0;
1556 }
1557
1558 if ($full_line =~ /Kernel panic -/) {
1559 $failure_start = time;
1560 $bug = 1;
1561 }
1562
1563 # Detect triple faults by testing the banner
1564 if ($full_line =~ /\bLinux version (\S+).*\n/) {
1565 if ($1 eq $version) {
1566 $version_found = 1;
1567 } elsif ($version_found && $detect_triplefault) {
1568 # We already booted into the kernel we are testing,
1569 # but now we booted into another kernel?
1570 # Consider this a triple fault.
1571 doprint "Aleady booted in Linux kernel $version, but now\n";
1572 doprint "we booted into Linux kernel $1.\n";
1573 doprint "Assuming that this is a triple fault.\n";
1574 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
1575 last;
1576 }
1577 }
1578
1579 if ($line =~ /\n/) {
1580 $full_line = "";
1581 }
1582
1583 if ($stop_test_after > 0 && !$booted && !$bug) {
1584 if (time - $monitor_start > $stop_test_after) {
1585 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
1586 $done = 1;
1587 }
1588 }
1589 }
1590
1591 close(DMESG);
1592
1593 if ($bug) {
1594 return 0 if ($in_bisect);
1595 fail "failed - got a bug report" and return 0;
1596 }
1597
1598 if (!$booted) {
1599 return 0 if ($in_bisect);
1600 fail "failed - never got a boot prompt." and return 0;
1601 }
1602
1603 if ($bug_ignored) {
1604 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
1605 }
1606
1607 return 1;
1608 }
1609
1610 sub eval_kernel_version {
1611 my ($option) = @_;
1612
1613 $option =~ s/\$KERNEL_VERSION/$version/g;
1614
1615 return $option;
1616 }
1617
1618 sub do_post_install {
1619
1620 return if (!defined($post_install));
1621
1622 my $cp_post_install = eval_kernel_version $post_install;
1623 run_command "$cp_post_install" or
1624 dodie "Failed to run post install";
1625 }
1626
1627 sub install {
1628
1629 return if ($no_install);
1630
1631 my $cp_target = eval_kernel_version $target_image;
1632
1633 run_scp "$outputdir/$build_target", "$cp_target" or
1634 dodie "failed to copy image";
1635
1636 my $install_mods = 0;
1637
1638 # should we process modules?
1639 $install_mods = 0;
1640 open(IN, "$output_config") or dodie("Can't read config file");
1641 while (<IN>) {
1642 if (/CONFIG_MODULES(=y)?/) {
1643 $install_mods = 1 if (defined($1));
1644 last;
1645 }
1646 }
1647 close(IN);
1648
1649 if (!$install_mods) {
1650 do_post_install;
1651 doprint "No modules needed\n";
1652 return;
1653 }
1654
1655 run_command "$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or
1656 dodie "Failed to install modules";
1657
1658 my $modlib = "/lib/modules/$version";
1659 my $modtar = "ktest-mods.tar.bz2";
1660
1661 run_ssh "rm -rf $modlib" or
1662 dodie "failed to remove old mods: $modlib";
1663
1664 # would be nice if scp -r did not follow symbolic links
1665 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
1666 dodie "making tarball";
1667
1668 run_scp "$tmpdir/$modtar", "/tmp" or
1669 dodie "failed to copy modules";
1670
1671 unlink "$tmpdir/$modtar";
1672
1673 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
1674 dodie "failed to tar modules";
1675
1676 run_ssh "rm -f /tmp/$modtar";
1677
1678 do_post_install;
1679 }
1680
1681 sub get_version {
1682 # get the release name
1683 doprint "$make kernelrelease ... ";
1684 $version = `$make kernelrelease | tail -1`;
1685 chomp($version);
1686 doprint "$version\n";
1687 }
1688
1689 sub start_monitor_and_boot {
1690 # Make sure the stable kernel has finished booting
1691 start_monitor;
1692 wait_for_monitor 5;
1693 end_monitor;
1694
1695 get_grub_index;
1696 get_version;
1697 install;
1698
1699 start_monitor;
1700 return monitor;
1701 }
1702
1703 sub check_buildlog {
1704 my ($patch) = @_;
1705
1706 my @files = `git show $patch | diffstat -l`;
1707
1708 open(IN, "git show $patch |") or
1709 dodie "failed to show $patch";
1710 while (<IN>) {
1711 if (m,^--- a/(.*),) {
1712 chomp $1;
1713 $files[$#files] = $1;
1714 }
1715 }
1716 close(IN);
1717
1718 open(IN, $buildlog) or dodie "Can't open $buildlog";
1719 while (<IN>) {
1720 if (/^\s*(.*?):.*(warning|error)/) {
1721 my $err = $1;
1722 foreach my $file (@files) {
1723 my $fullpath = "$builddir/$file";
1724 if ($file eq $err || $fullpath eq $err) {
1725 fail "$file built with warnings" and return 0;
1726 }
1727 }
1728 }
1729 }
1730 close(IN);
1731
1732 return 1;
1733 }
1734
1735 sub apply_min_config {
1736 my $outconfig = "$output_config.new";
1737
1738 # Read the config file and remove anything that
1739 # is in the force_config hash (from minconfig and others)
1740 # then add the force config back.
1741
1742 doprint "Applying minimum configurations into $output_config.new\n";
1743
1744 open (OUT, ">$outconfig") or
1745 dodie "Can't create $outconfig";
1746
1747 if (-f $output_config) {
1748 open (IN, $output_config) or
1749 dodie "Failed to open $output_config";
1750 while (<IN>) {
1751 if (/^(# )?(CONFIG_[^\s=]*)/) {
1752 next if (defined($force_config{$2}));
1753 }
1754 print OUT;
1755 }
1756 close IN;
1757 }
1758 foreach my $config (keys %force_config) {
1759 print OUT "$force_config{$config}\n";
1760 }
1761 close OUT;
1762
1763 run_command "mv $outconfig $output_config";
1764 }
1765
1766 sub make_oldconfig {
1767
1768 my @force_list = keys %force_config;
1769
1770 if ($#force_list >= 0) {
1771 apply_min_config;
1772 }
1773
1774 if (!run_command "$make oldnoconfig") {
1775 # Perhaps oldnoconfig doesn't exist in this version of the kernel
1776 # try a yes '' | oldconfig
1777 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
1778 run_command "yes '' | $make oldconfig" or
1779 dodie "failed make config oldconfig";
1780 }
1781 }
1782
1783 # read a config file and use this to force new configs.
1784 sub load_force_config {
1785 my ($config) = @_;
1786
1787 open(IN, $config) or
1788 dodie "failed to read $config";
1789 while (<IN>) {
1790 chomp;
1791 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
1792 $force_config{$1} = $_;
1793 } elsif (/^# (CONFIG_\S*) is not set/) {
1794 $force_config{$1} = $_;
1795 }
1796 }
1797 close IN;
1798 }
1799
1800 sub build {
1801 my ($type) = @_;
1802
1803 unlink $buildlog;
1804
1805 # Failed builds should not reboot the target
1806 my $save_no_reboot = $no_reboot;
1807 $no_reboot = 1;
1808
1809 if (defined($pre_build)) {
1810 my $ret = run_command $pre_build;
1811 if (!$ret && defined($pre_build_die) &&
1812 $pre_build_die) {
1813 dodie "failed to pre_build\n";
1814 }
1815 }
1816
1817 if ($type =~ /^useconfig:(.*)/) {
1818 run_command "cp $1 $output_config" or
1819 dodie "could not copy $1 to .config";
1820
1821 $type = "oldconfig";
1822 }
1823
1824 # old config can ask questions
1825 if ($type eq "oldconfig") {
1826 $type = "oldnoconfig";
1827
1828 # allow for empty configs
1829 run_command "touch $output_config";
1830
1831 if (!$noclean) {
1832 run_command "mv $output_config $outputdir/config_temp" or
1833 dodie "moving .config";
1834
1835 run_command "$make mrproper" or dodie "make mrproper";
1836
1837 run_command "mv $outputdir/config_temp $output_config" or
1838 dodie "moving config_temp";
1839 }
1840
1841 } elsif (!$noclean) {
1842 unlink "$output_config";
1843 run_command "$make mrproper" or
1844 dodie "make mrproper";
1845 }
1846
1847 # add something to distinguish this build
1848 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
1849 print OUT "$localversion\n";
1850 close(OUT);
1851
1852 if (defined($minconfig)) {
1853 load_force_config($minconfig);
1854 }
1855
1856 if ($type ne "oldnoconfig") {
1857 run_command "$make $type" or
1858 dodie "failed make config";
1859 }
1860 # Run old config regardless, to enforce min configurations
1861 make_oldconfig;
1862
1863 $redirect = "$buildlog";
1864 my $build_ret = run_command "$make $build_options";
1865 undef $redirect;
1866
1867 if (defined($post_build)) {
1868 my $ret = run_command $post_build;
1869 if (!$ret && defined($post_build_die) &&
1870 $post_build_die) {
1871 dodie "failed to post_build\n";
1872 }
1873 }
1874
1875 if (!$build_ret) {
1876 # bisect may need this to pass
1877 if ($in_bisect) {
1878 $no_reboot = $save_no_reboot;
1879 return 0;
1880 }
1881 fail "failed build" and return 0;
1882 }
1883
1884 $no_reboot = $save_no_reboot;
1885
1886 return 1;
1887 }
1888
1889 sub halt {
1890 if (!run_ssh "halt" or defined($power_off)) {
1891 if (defined($poweroff_after_halt)) {
1892 sleep $poweroff_after_halt;
1893 run_command "$power_off";
1894 }
1895 } else {
1896 # nope? the zap it!
1897 run_command "$power_off";
1898 }
1899 }
1900
1901 sub success {
1902 my ($i) = @_;
1903
1904 $successes++;
1905
1906 my $name = "";
1907
1908 if (defined($test_name)) {
1909 $name = " ($test_name)";
1910 }
1911
1912 doprint "\n\n*******************************************\n";
1913 doprint "*******************************************\n";
1914 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
1915 doprint "*******************************************\n";
1916 doprint "*******************************************\n";
1917
1918 if (defined($store_successes)) {
1919 save_logs "success", $store_successes;
1920 }
1921
1922 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
1923 doprint "Reboot and wait $sleep_time seconds\n";
1924 reboot_to_good $sleep_time;
1925 }
1926 }
1927
1928 sub answer_bisect {
1929 for (;;) {
1930 doprint "Pass or fail? [p/f]";
1931 my $ans = <STDIN>;
1932 chomp $ans;
1933 if ($ans eq "p" || $ans eq "P") {
1934 return 1;
1935 } elsif ($ans eq "f" || $ans eq "F") {
1936 return 0;
1937 } else {
1938 print "Please answer 'P' or 'F'\n";
1939 }
1940 }
1941 }
1942
1943 sub child_run_test {
1944 my $failed = 0;
1945
1946 # child should have no power
1947 $reboot_on_error = 0;
1948 $poweroff_on_error = 0;
1949 $die_on_failure = 1;
1950
1951 $redirect = "$testlog";
1952 run_command $run_test or $failed = 1;
1953 undef $redirect;
1954
1955 exit $failed;
1956 }
1957
1958 my $child_done;
1959
1960 sub child_finished {
1961 $child_done = 1;
1962 }
1963
1964 sub do_run_test {
1965 my $child_pid;
1966 my $child_exit;
1967 my $line;
1968 my $full_line;
1969 my $bug = 0;
1970
1971 wait_for_monitor 1;
1972
1973 doprint "run test $run_test\n";
1974
1975 $child_done = 0;
1976
1977 $SIG{CHLD} = qw(child_finished);
1978
1979 $child_pid = fork;
1980
1981 child_run_test if (!$child_pid);
1982
1983 $full_line = "";
1984
1985 do {
1986 $line = wait_for_input($monitor_fp, 1);
1987 if (defined($line)) {
1988
1989 # we are not guaranteed to get a full line
1990 $full_line .= $line;
1991 doprint $line;
1992
1993 if ($full_line =~ /call trace:/i) {
1994 $bug = 1;
1995 }
1996
1997 if ($full_line =~ /Kernel panic -/) {
1998 $bug = 1;
1999 }
2000
2001 if ($line =~ /\n/) {
2002 $full_line = "";
2003 }
2004 }
2005 } while (!$child_done && !$bug);
2006
2007 if ($bug) {
2008 my $failure_start = time;
2009 my $now;
2010 do {
2011 $line = wait_for_input($monitor_fp, 1);
2012 if (defined($line)) {
2013 doprint $line;
2014 }
2015 $now = time;
2016 if ($now - $failure_start >= $stop_after_failure) {
2017 last;
2018 }
2019 } while (defined($line));
2020
2021 doprint "Detected kernel crash!\n";
2022 # kill the child with extreme prejudice
2023 kill 9, $child_pid;
2024 }
2025
2026 waitpid $child_pid, 0;
2027 $child_exit = $?;
2028
2029 if (!$bug && $in_bisect) {
2030 if (defined($bisect_ret_good)) {
2031 if ($child_exit == $bisect_ret_good) {
2032 return 1;
2033 }
2034 }
2035 if (defined($bisect_ret_skip)) {
2036 if ($child_exit == $bisect_ret_skip) {
2037 return -1;
2038 }
2039 }
2040 if (defined($bisect_ret_abort)) {
2041 if ($child_exit == $bisect_ret_abort) {
2042 fail "test abort" and return -2;
2043 }
2044 }
2045 if (defined($bisect_ret_bad)) {
2046 if ($child_exit == $bisect_ret_skip) {
2047 return 0;
2048 }
2049 }
2050 if (defined($bisect_ret_default)) {
2051 if ($bisect_ret_default eq "good") {
2052 return 1;
2053 } elsif ($bisect_ret_default eq "bad") {
2054 return 0;
2055 } elsif ($bisect_ret_default eq "skip") {
2056 return -1;
2057 } elsif ($bisect_ret_default eq "abort") {
2058 return -2;
2059 } else {
2060 fail "unknown default action: $bisect_ret_default"
2061 and return -2;
2062 }
2063 }
2064 }
2065
2066 if ($bug || $child_exit) {
2067 return 0 if $in_bisect;
2068 fail "test failed" and return 0;
2069 }
2070 return 1;
2071 }
2072
2073 sub run_git_bisect {
2074 my ($command) = @_;
2075
2076 doprint "$command ... ";
2077
2078 my $output = `$command 2>&1`;
2079 my $ret = $?;
2080
2081 logit $output;
2082
2083 if ($ret) {
2084 doprint "FAILED\n";
2085 dodie "Failed to git bisect";
2086 }
2087
2088 doprint "SUCCESS\n";
2089 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
2090 doprint "$1 [$2]\n";
2091 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
2092 $bisect_bad_commit = $1;
2093 doprint "Found bad commit... $1\n";
2094 return 0;
2095 } else {
2096 # we already logged it, just print it now.
2097 print $output;
2098 }
2099
2100 return 1;
2101 }
2102
2103 sub bisect_reboot {
2104 doprint "Reboot and sleep $bisect_sleep_time seconds\n";
2105 reboot_to_good $bisect_sleep_time;
2106 }
2107
2108 # returns 1 on success, 0 on failure, -1 on skip
2109 sub run_bisect_test {
2110 my ($type, $buildtype) = @_;
2111
2112 my $failed = 0;
2113 my $result;
2114 my $output;
2115 my $ret;
2116
2117 $in_bisect = 1;
2118
2119 build $buildtype or $failed = 1;
2120
2121 if ($type ne "build") {
2122 if ($failed && $bisect_skip) {
2123 $in_bisect = 0;
2124 return -1;
2125 }
2126 dodie "Failed on build" if $failed;
2127
2128 # Now boot the box
2129 start_monitor_and_boot or $failed = 1;
2130
2131 if ($type ne "boot") {
2132 if ($failed && $bisect_skip) {
2133 end_monitor;
2134 bisect_reboot;
2135 $in_bisect = 0;
2136 return -1;
2137 }
2138 dodie "Failed on boot" if $failed;
2139
2140 do_run_test or $failed = 1;
2141 }
2142 end_monitor;
2143 }
2144
2145 if ($failed) {
2146 $result = 0;
2147 } else {
2148 $result = 1;
2149 }
2150
2151 # reboot the box to a kernel we can ssh to
2152 if ($type ne "build") {
2153 bisect_reboot;
2154 }
2155 $in_bisect = 0;
2156
2157 return $result;
2158 }
2159
2160 sub run_bisect {
2161 my ($type) = @_;
2162 my $buildtype = "oldconfig";
2163
2164 # We should have a minconfig to use?
2165 if (defined($minconfig)) {
2166 $buildtype = "useconfig:$minconfig";
2167 }
2168
2169 my $ret = run_bisect_test $type, $buildtype;
2170
2171 if ($bisect_manual) {
2172 $ret = answer_bisect;
2173 }
2174
2175 # Are we looking for where it worked, not failed?
2176 if ($reverse_bisect) {
2177 $ret = !$ret;
2178 }
2179
2180 if ($ret > 0) {
2181 return "good";
2182 } elsif ($ret == 0) {
2183 return "bad";
2184 } elsif ($bisect_skip) {
2185 doprint "HIT A BAD COMMIT ... SKIPPING\n";
2186 return "skip";
2187 }
2188 }
2189
2190 sub update_bisect_replay {
2191 my $tmp_log = "$tmpdir/ktest_bisect_log";
2192 run_command "git bisect log > $tmp_log" or
2193 die "can't create bisect log";
2194 return $tmp_log;
2195 }
2196
2197 sub bisect {
2198 my ($i) = @_;
2199
2200 my $result;
2201
2202 die "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good));
2203 die "BISECT_BAD[$i] not defined\n" if (!defined($bisect_bad));
2204 die "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type));
2205
2206 my $good = $bisect_good;
2207 my $bad = $bisect_bad;
2208 my $type = $bisect_type;
2209 my $start = $bisect_start;
2210 my $replay = $bisect_replay;
2211 my $start_files = $bisect_files;
2212
2213 if (defined($start_files)) {
2214 $start_files = " -- " . $start_files;
2215 } else {
2216 $start_files = "";
2217 }
2218
2219 # convert to true sha1's
2220 $good = get_sha1($good);
2221 $bad = get_sha1($bad);
2222
2223 if (defined($bisect_reverse) && $bisect_reverse == 1) {
2224 doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
2225 $reverse_bisect = 1;
2226 } else {
2227 $reverse_bisect = 0;
2228 }
2229
2230 # Can't have a test without having a test to run
2231 if ($type eq "test" && !defined($run_test)) {
2232 $type = "boot";
2233 }
2234
2235 # Check if a bisect was running
2236 my $bisect_start_file = "$builddir/.git/BISECT_START";
2237
2238 my $check = $bisect_check;
2239 my $do_check = defined($check) && $check ne "0";
2240
2241 if ( -f $bisect_start_file ) {
2242 print "Bisect in progress found\n";
2243 if ($do_check) {
2244 print " If you say yes, then no checks of good or bad will be done\n";
2245 }
2246 if (defined($replay)) {
2247 print "** BISECT_REPLAY is defined in config file **";
2248 print " Ignore config option and perform new git bisect log?\n";
2249 if (read_ync " (yes, no, or cancel) ") {
2250 $replay = update_bisect_replay;
2251 $do_check = 0;
2252 }
2253 } elsif (read_yn "read git log and continue?") {
2254 $replay = update_bisect_replay;
2255 $do_check = 0;
2256 }
2257 }
2258
2259 if ($do_check) {
2260
2261 # get current HEAD
2262 my $head = get_sha1("HEAD");
2263
2264 if ($check ne "good") {
2265 doprint "TESTING BISECT BAD [$bad]\n";
2266 run_command "git checkout $bad" or
2267 die "Failed to checkout $bad";
2268
2269 $result = run_bisect $type;
2270
2271 if ($result ne "bad") {
2272 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
2273 }
2274 }
2275
2276 if ($check ne "bad") {
2277 doprint "TESTING BISECT GOOD [$good]\n";
2278 run_command "git checkout $good" or
2279 die "Failed to checkout $good";
2280
2281 $result = run_bisect $type;
2282
2283 if ($result ne "good") {
2284 fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
2285 }
2286 }
2287
2288 # checkout where we started
2289 run_command "git checkout $head" or
2290 die "Failed to checkout $head";
2291 }
2292
2293 run_command "git bisect start$start_files" or
2294 dodie "could not start bisect";
2295
2296 run_command "git bisect good $good" or
2297 dodie "could not set bisect good to $good";
2298
2299 run_git_bisect "git bisect bad $bad" or
2300 dodie "could not set bisect bad to $bad";
2301
2302 if (defined($replay)) {
2303 run_command "git bisect replay $replay" or
2304 dodie "failed to run replay";
2305 }
2306
2307 if (defined($start)) {
2308 run_command "git checkout $start" or
2309 dodie "failed to checkout $start";
2310 }
2311
2312 my $test;
2313 do {
2314 $result = run_bisect $type;
2315 $test = run_git_bisect "git bisect $result";
2316 } while ($test);
2317
2318 run_command "git bisect log" or
2319 dodie "could not capture git bisect log";
2320
2321 run_command "git bisect reset" or
2322 dodie "could not reset git bisect";
2323
2324 doprint "Bad commit was [$bisect_bad_commit]\n";
2325
2326 success $i;
2327 }
2328
2329 my %config_ignore;
2330 my %config_set;
2331
2332 my %config_list;
2333 my %null_config;
2334
2335 my %dependency;
2336
2337 sub assign_configs {
2338 my ($hash, $config) = @_;
2339
2340 open (IN, $config)
2341 or dodie "Failed to read $config";
2342
2343 while (<IN>) {
2344 if (/^((CONFIG\S*)=.*)/) {
2345 ${$hash}{$2} = $1;
2346 }
2347 }
2348
2349 close(IN);
2350 }
2351
2352 sub process_config_ignore {
2353 my ($config) = @_;
2354
2355 assign_configs \%config_ignore, $config;
2356 }
2357
2358 sub read_current_config {
2359 my ($config_ref) = @_;
2360
2361 %{$config_ref} = ();
2362 undef %{$config_ref};
2363
2364 my @key = keys %{$config_ref};
2365 if ($#key >= 0) {
2366 print "did not delete!\n";
2367 exit;
2368 }
2369 open (IN, "$output_config");
2370
2371 while (<IN>) {
2372 if (/^(CONFIG\S+)=(.*)/) {
2373 ${$config_ref}{$1} = $2;
2374 }
2375 }
2376 close(IN);
2377 }
2378
2379 sub get_dependencies {
2380 my ($config) = @_;
2381
2382 my $arr = $dependency{$config};
2383 if (!defined($arr)) {
2384 return ();
2385 }
2386
2387 my @deps = @{$arr};
2388
2389 foreach my $dep (@{$arr}) {
2390 print "ADD DEP $dep\n";
2391 @deps = (@deps, get_dependencies $dep);
2392 }
2393
2394 return @deps;
2395 }
2396
2397 sub create_config {
2398 my @configs = @_;
2399
2400 open(OUT, ">$output_config") or dodie "Can not write to $output_config";
2401
2402 foreach my $config (@configs) {
2403 print OUT "$config_set{$config}\n";
2404 my @deps = get_dependencies $config;
2405 foreach my $dep (@deps) {
2406 print OUT "$config_set{$dep}\n";
2407 }
2408 }
2409
2410 foreach my $config (keys %config_ignore) {
2411 print OUT "$config_ignore{$config}\n";
2412 }
2413 close(OUT);
2414
2415 # exit;
2416 make_oldconfig;
2417 }
2418
2419 sub compare_configs {
2420 my (%a, %b) = @_;
2421
2422 foreach my $item (keys %a) {
2423 if (!defined($b{$item})) {
2424 print "diff $item\n";
2425 return 1;
2426 }
2427 delete $b{$item};
2428 }
2429
2430 my @keys = keys %b;
2431 if ($#keys) {
2432 print "diff2 $keys[0]\n";
2433 }
2434 return -1 if ($#keys >= 0);
2435
2436 return 0;
2437 }
2438
2439 sub run_config_bisect_test {
2440 my ($type) = @_;
2441
2442 return run_bisect_test $type, "oldconfig";
2443 }
2444
2445 sub process_passed {
2446 my (%configs) = @_;
2447
2448 doprint "These configs had no failure: (Enabling them for further compiles)\n";
2449 # Passed! All these configs are part of a good compile.
2450 # Add them to the min options.
2451 foreach my $config (keys %configs) {
2452 if (defined($config_list{$config})) {
2453 doprint " removing $config\n";
2454 $config_ignore{$config} = $config_list{$config};
2455 delete $config_list{$config};
2456 }
2457 }
2458 doprint "config copied to $outputdir/config_good\n";
2459 run_command "cp -f $output_config $outputdir/config_good";
2460 }
2461
2462 sub process_failed {
2463 my ($config) = @_;
2464
2465 doprint "\n\n***************************************\n";
2466 doprint "Found bad config: $config\n";
2467 doprint "***************************************\n\n";
2468 }
2469
2470 sub run_config_bisect {
2471
2472 my @start_list = keys %config_list;
2473
2474 if ($#start_list < 0) {
2475 doprint "No more configs to test!!!\n";
2476 return -1;
2477 }
2478
2479 doprint "***** RUN TEST ***\n";
2480 my $type = $config_bisect_type;
2481 my $ret;
2482 my %current_config;
2483
2484 my $count = $#start_list + 1;
2485 doprint " $count configs to test\n";
2486
2487 my $half = int($#start_list / 2);
2488
2489 do {
2490 my @tophalf = @start_list[0 .. $half];
2491
2492 create_config @tophalf;
2493 read_current_config \%current_config;
2494
2495 $count = $#tophalf + 1;
2496 doprint "Testing $count configs\n";
2497 my $found = 0;
2498 # make sure we test something
2499 foreach my $config (@tophalf) {
2500 if (defined($current_config{$config})) {
2501 logit " $config\n";
2502 $found = 1;
2503 }
2504 }
2505 if (!$found) {
2506 # try the other half
2507 doprint "Top half produced no set configs, trying bottom half\n";
2508 @tophalf = @start_list[$half + 1 .. $#start_list];
2509 create_config @tophalf;
2510 read_current_config \%current_config;
2511 foreach my $config (@tophalf) {
2512 if (defined($current_config{$config})) {
2513 logit " $config\n";
2514 $found = 1;
2515 }
2516 }
2517 if (!$found) {
2518 doprint "Failed: Can't make new config with current configs\n";
2519 foreach my $config (@start_list) {
2520 doprint " CONFIG: $config\n";
2521 }
2522 return -1;
2523 }
2524 $count = $#tophalf + 1;
2525 doprint "Testing $count configs\n";
2526 }
2527
2528 $ret = run_config_bisect_test $type;
2529 if ($bisect_manual) {
2530 $ret = answer_bisect;
2531 }
2532 if ($ret) {
2533 process_passed %current_config;
2534 return 0;
2535 }
2536
2537 doprint "This config had a failure.\n";
2538 doprint "Removing these configs that were not set in this config:\n";
2539 doprint "config copied to $outputdir/config_bad\n";
2540 run_command "cp -f $output_config $outputdir/config_bad";
2541
2542 # A config exists in this group that was bad.
2543 foreach my $config (keys %config_list) {
2544 if (!defined($current_config{$config})) {
2545 doprint " removing $config\n";
2546 delete $config_list{$config};
2547 }
2548 }
2549
2550 @start_list = @tophalf;
2551
2552 if ($#start_list == 0) {
2553 process_failed $start_list[0];
2554 return 1;
2555 }
2556
2557 # remove half the configs we are looking at and see if
2558 # they are good.
2559 $half = int($#start_list / 2);
2560 } while ($#start_list > 0);
2561
2562 # we found a single config, try it again unless we are running manually
2563
2564 if ($bisect_manual) {
2565 process_failed $start_list[0];
2566 return 1;
2567 }
2568
2569 my @tophalf = @start_list[0 .. 0];
2570
2571 $ret = run_config_bisect_test $type;
2572 if ($ret) {
2573 process_passed %current_config;
2574 return 0;
2575 }
2576
2577 process_failed $start_list[0];
2578 return 1;
2579 }
2580
2581 sub config_bisect {
2582 my ($i) = @_;
2583
2584 my $start_config = $config_bisect;
2585
2586 my $tmpconfig = "$tmpdir/use_config";
2587
2588 if (defined($config_bisect_good)) {
2589 process_config_ignore $config_bisect_good;
2590 }
2591
2592 # Make the file with the bad config and the min config
2593 if (defined($minconfig)) {
2594 # read the min config for things to ignore
2595 run_command "cp $minconfig $tmpconfig" or
2596 dodie "failed to copy $minconfig to $tmpconfig";
2597 } else {
2598 unlink $tmpconfig;
2599 }
2600
2601 if (-f $tmpconfig) {
2602 load_force_config($tmpconfig);
2603 process_config_ignore $tmpconfig;
2604 }
2605
2606 # now process the start config
2607 run_command "cp $start_config $output_config" or
2608 dodie "failed to copy $start_config to $output_config";
2609
2610 # read directly what we want to check
2611 my %config_check;
2612 open (IN, $output_config)
2613 or dodie "faied to open $output_config";
2614
2615 while (<IN>) {
2616 if (/^((CONFIG\S*)=.*)/) {
2617 $config_check{$2} = $1;
2618 }
2619 }
2620 close(IN);
2621
2622 # Now run oldconfig with the minconfig
2623 make_oldconfig;
2624
2625 # check to see what we lost (or gained)
2626 open (IN, $output_config)
2627 or dodie "Failed to read $start_config";
2628
2629 my %removed_configs;
2630 my %added_configs;
2631
2632 while (<IN>) {
2633 if (/^((CONFIG\S*)=.*)/) {
2634 # save off all options
2635 $config_set{$2} = $1;
2636 if (defined($config_check{$2})) {
2637 if (defined($config_ignore{$2})) {
2638 $removed_configs{$2} = $1;
2639 } else {
2640 $config_list{$2} = $1;
2641 }
2642 } elsif (!defined($config_ignore{$2})) {
2643 $added_configs{$2} = $1;
2644 $config_list{$2} = $1;
2645 }
2646 }
2647 }
2648 close(IN);
2649
2650 my @confs = keys %removed_configs;
2651 if ($#confs >= 0) {
2652 doprint "Configs overridden by default configs and removed from check:\n";
2653 foreach my $config (@confs) {
2654 doprint " $config\n";
2655 }
2656 }
2657 @confs = keys %added_configs;
2658 if ($#confs >= 0) {
2659 doprint "Configs appearing in make oldconfig and added:\n";
2660 foreach my $config (@confs) {
2661 doprint " $config\n";
2662 }
2663 }
2664
2665 my %config_test;
2666 my $once = 0;
2667
2668 # Sometimes kconfig does weird things. We must make sure
2669 # that the config we autocreate has everything we need
2670 # to test, otherwise we may miss testing configs, or
2671 # may not be able to create a new config.
2672 # Here we create a config with everything set.
2673 create_config (keys %config_list);
2674 read_current_config \%config_test;
2675 foreach my $config (keys %config_list) {
2676 if (!defined($config_test{$config})) {
2677 if (!$once) {
2678 $once = 1;
2679 doprint "Configs not produced by kconfig (will not be checked):\n";
2680 }
2681 doprint " $config\n";
2682 delete $config_list{$config};
2683 }
2684 }
2685 my $ret;
2686 do {
2687 $ret = run_config_bisect;
2688 } while (!$ret);
2689
2690 return $ret if ($ret < 0);
2691
2692 success $i;
2693 }
2694
2695 sub patchcheck_reboot {
2696 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
2697 reboot_to_good $patchcheck_sleep_time;
2698 }
2699
2700 sub patchcheck {
2701 my ($i) = @_;
2702
2703 die "PATCHCHECK_START[$i] not defined\n"
2704 if (!defined($patchcheck_start));
2705 die "PATCHCHECK_TYPE[$i] not defined\n"
2706 if (!defined($patchcheck_type));
2707
2708 my $start = $patchcheck_start;
2709
2710 my $end = "HEAD";
2711 if (defined($patchcheck_end)) {
2712 $end = $patchcheck_end;
2713 }
2714
2715 # Get the true sha1's since we can use things like HEAD~3
2716 $start = get_sha1($start);
2717 $end = get_sha1($end);
2718
2719 my $type = $patchcheck_type;
2720
2721 # Can't have a test without having a test to run
2722 if ($type eq "test" && !defined($run_test)) {
2723 $type = "boot";
2724 }
2725
2726 open (IN, "git log --pretty=oneline $end|") or
2727 dodie "could not get git list";
2728
2729 my @list;
2730
2731 while (<IN>) {
2732 chomp;
2733 $list[$#list+1] = $_;
2734 last if (/^$start/);
2735 }
2736 close(IN);
2737
2738 if ($list[$#list] !~ /^$start/) {
2739 fail "SHA1 $start not found";
2740 }
2741
2742 # go backwards in the list
2743 @list = reverse @list;
2744
2745 my $save_clean = $noclean;
2746 my %ignored_warnings;
2747
2748 if (defined($ignore_warnings)) {
2749 foreach my $sha1 (split /\s+/, $ignore_warnings) {
2750 $ignored_warnings{$sha1} = 1;
2751 }
2752 }
2753
2754 $in_patchcheck = 1;
2755 foreach my $item (@list) {
2756 my $sha1 = $item;
2757 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
2758
2759 doprint "\nProcessing commit $item\n\n";
2760
2761 run_command "git checkout $sha1" or
2762 die "Failed to checkout $sha1";
2763
2764 # only clean on the first and last patch
2765 if ($item eq $list[0] ||
2766 $item eq $list[$#list]) {
2767 $noclean = $save_clean;
2768 } else {
2769 $noclean = 1;
2770 }
2771
2772 if (defined($minconfig)) {
2773 build "useconfig:$minconfig" or return 0;
2774 } else {
2775 # ?? no config to use?
2776 build "oldconfig" or return 0;
2777 }
2778
2779
2780 if (!defined($ignored_warnings{$sha1})) {
2781 check_buildlog $sha1 or return 0;
2782 }
2783
2784 next if ($type eq "build");
2785
2786 my $failed = 0;
2787
2788 start_monitor_and_boot or $failed = 1;
2789
2790 if (!$failed && $type ne "boot"){
2791 do_run_test or $failed = 1;
2792 }
2793 end_monitor;
2794 return 0 if ($failed);
2795
2796 patchcheck_reboot;
2797
2798 }
2799 $in_patchcheck = 0;
2800 success $i;
2801
2802 return 1;
2803 }
2804
2805 my %depends;
2806 my %depcount;
2807 my $iflevel = 0;
2808 my @ifdeps;
2809
2810 # prevent recursion
2811 my %read_kconfigs;
2812
2813 sub add_dep {
2814 # $config depends on $dep
2815 my ($config, $dep) = @_;
2816
2817 if (defined($depends{$config})) {
2818 $depends{$config} .= " " . $dep;
2819 } else {
2820 $depends{$config} = $dep;
2821 }
2822
2823 # record the number of configs depending on $dep
2824 if (defined $depcount{$dep}) {
2825 $depcount{$dep}++;
2826 } else {
2827 $depcount{$dep} = 1;
2828 }
2829 }
2830
2831 # taken from streamline_config.pl
2832 sub read_kconfig {
2833 my ($kconfig) = @_;
2834
2835 my $state = "NONE";
2836 my $config;
2837 my @kconfigs;
2838
2839 my $cont = 0;
2840 my $line;
2841
2842
2843 if (! -f $kconfig) {
2844 doprint "file $kconfig does not exist, skipping\n";
2845 return;
2846 }
2847
2848 open(KIN, "$kconfig")
2849 or die "Can't open $kconfig";
2850 while (<KIN>) {
2851 chomp;
2852
2853 # Make sure that lines ending with \ continue
2854 if ($cont) {
2855 $_ = $line . " " . $_;
2856 }
2857
2858 if (s/\\$//) {
2859 $cont = 1;
2860 $line = $_;
2861 next;
2862 }
2863
2864 $cont = 0;
2865
2866 # collect any Kconfig sources
2867 if (/^source\s*"(.*)"/) {
2868 $kconfigs[$#kconfigs+1] = $1;
2869 }
2870
2871 # configs found
2872 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
2873 $state = "NEW";
2874 $config = $2;
2875
2876 for (my $i = 0; $i < $iflevel; $i++) {
2877 add_dep $config, $ifdeps[$i];
2878 }
2879
2880 # collect the depends for the config
2881 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
2882
2883 add_dep $config, $1;
2884
2885 # Get the configs that select this config
2886 } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {
2887
2888 # selected by depends on config
2889 add_dep $1, $config;
2890
2891 # Check for if statements
2892 } elsif (/^if\s+(.*\S)\s*$/) {
2893 my $deps = $1;
2894 # remove beginning and ending non text
2895 $deps =~ s/^[^a-zA-Z0-9_]*//;
2896 $deps =~ s/[^a-zA-Z0-9_]*$//;
2897
2898 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
2899
2900 $ifdeps[$iflevel++] = join ':', @deps;
2901
2902 } elsif (/^endif/) {
2903
2904 $iflevel-- if ($iflevel);
2905
2906 # stop on "help"
2907 } elsif (/^\s*help\s*$/) {
2908 $state = "NONE";
2909 }
2910 }
2911 close(KIN);
2912
2913 # read in any configs that were found.
2914 foreach $kconfig (@kconfigs) {
2915 if (!defined($read_kconfigs{$kconfig})) {
2916 $read_kconfigs{$kconfig} = 1;
2917 read_kconfig("$builddir/$kconfig");
2918 }
2919 }
2920 }
2921
2922 sub read_depends {
2923 # find out which arch this is by the kconfig file
2924 open (IN, $output_config)
2925 or dodie "Failed to read $output_config";
2926 my $arch;
2927 while (<IN>) {
2928 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
2929 $arch = $1;
2930 last;
2931 }
2932 }
2933 close IN;
2934
2935 if (!defined($arch)) {
2936 doprint "Could not find arch from config file\n";
2937 doprint "no dependencies used\n";
2938 return;
2939 }
2940
2941 # arch is really the subarch, we need to know
2942 # what directory to look at.
2943 if ($arch eq "i386" || $arch eq "x86_64") {
2944 $arch = "x86";
2945 } elsif ($arch =~ /^tile/) {
2946 $arch = "tile";
2947 }
2948
2949 my $kconfig = "$builddir/arch/$arch/Kconfig";
2950
2951 if (! -f $kconfig && $arch =~ /\d$/) {
2952 my $orig = $arch;
2953 # some subarchs have numbers, truncate them
2954 $arch =~ s/\d*$//;
2955 $kconfig = "$builddir/arch/$arch/Kconfig";
2956 if (! -f $kconfig) {
2957 doprint "No idea what arch dir $orig is for\n";
2958 doprint "no dependencies used\n";
2959 return;
2960 }
2961 }
2962
2963 read_kconfig($kconfig);
2964 }
2965
2966 sub read_config_list {
2967 my ($config) = @_;
2968
2969 open (IN, $config)
2970 or dodie "Failed to read $config";
2971
2972 while (<IN>) {
2973 if (/^((CONFIG\S*)=.*)/) {
2974 if (!defined($config_ignore{$2})) {
2975 $config_list{$2} = $1;
2976 }
2977 }
2978 }
2979
2980 close(IN);
2981 }
2982
2983 sub read_output_config {
2984 my ($config) = @_;
2985
2986 assign_configs \%config_ignore, $config;
2987 }
2988
2989 sub make_new_config {
2990 my @configs = @_;
2991
2992 open (OUT, ">$output_config")
2993 or dodie "Failed to write $output_config";
2994
2995 foreach my $config (@configs) {
2996 print OUT "$config\n";
2997 }
2998 close OUT;
2999 }
3000
3001 sub chomp_config {
3002 my ($config) = @_;
3003
3004 $config =~ s/CONFIG_//;
3005
3006 return $config;
3007 }
3008
3009 sub get_depends {
3010 my ($dep) = @_;
3011
3012 my $kconfig = chomp_config $dep;
3013
3014 $dep = $depends{"$kconfig"};
3015
3016 # the dep string we have saves the dependencies as they
3017 # were found, including expressions like ! && ||. We
3018 # want to split this out into just an array of configs.
3019
3020 my $valid = "A-Za-z_0-9";
3021
3022 my @configs;
3023
3024 while ($dep =~ /[$valid]/) {
3025
3026 if ($dep =~ /^[^$valid]*([$valid]+)/) {
3027 my $conf = "CONFIG_" . $1;
3028
3029 $configs[$#configs + 1] = $conf;
3030
3031 $dep =~ s/^[^$valid]*[$valid]+//;
3032 } else {
3033 die "this should never happen";
3034 }
3035 }
3036
3037 return @configs;
3038 }
3039
3040 my %min_configs;
3041 my %keep_configs;
3042 my %save_configs;
3043 my %processed_configs;
3044 my %nochange_config;
3045
3046 sub test_this_config {
3047 my ($config) = @_;
3048
3049 my $found;
3050
3051 # if we already processed this config, skip it
3052 if (defined($processed_configs{$config})) {
3053 return undef;
3054 }
3055 $processed_configs{$config} = 1;
3056
3057 # if this config failed during this round, skip it
3058 if (defined($nochange_config{$config})) {
3059 return undef;
3060 }
3061
3062 my $kconfig = chomp_config $config;
3063
3064 # Test dependencies first
3065 if (defined($depends{"$kconfig"})) {
3066 my @parents = get_depends $config;
3067 foreach my $parent (@parents) {
3068 # if the parent is in the min config, check it first
3069 next if (!defined($min_configs{$parent}));
3070 $found = test_this_config($parent);
3071 if (defined($found)) {
3072 return $found;
3073 }
3074 }
3075 }
3076
3077 # Remove this config from the list of configs
3078 # do a make oldnoconfig and then read the resulting
3079 # .config to make sure it is missing the config that
3080 # we had before
3081 my %configs = %min_configs;
3082 delete $configs{$config};
3083 make_new_config ((values %configs), (values %keep_configs));
3084 make_oldconfig;
3085 undef %configs;
3086 assign_configs \%configs, $output_config;
3087
3088 return $config if (!defined($configs{$config}));
3089
3090 doprint "disabling config $config did not change .config\n";
3091
3092 $nochange_config{$config} = 1;
3093
3094 return undef;
3095 }
3096
3097 sub make_min_config {
3098 my ($i) = @_;
3099
3100 if (!defined($output_minconfig)) {
3101 fail "OUTPUT_MIN_CONFIG not defined" and return;
3102 }
3103
3104 # If output_minconfig exists, and the start_minconfig
3105 # came from min_config, than ask if we should use
3106 # that instead.
3107 if (-f $output_minconfig && !$start_minconfig_defined) {
3108 print "$output_minconfig exists\n";
3109 if (read_yn " Use it as minconfig?") {
3110 $start_minconfig = $output_minconfig;
3111 }
3112 }
3113
3114 if (!defined($start_minconfig)) {
3115 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
3116 }
3117
3118 my $temp_config = "$tmpdir/temp_config";
3119
3120 # First things first. We build an allnoconfig to find
3121 # out what the defaults are that we can't touch.
3122 # Some are selections, but we really can't handle selections.
3123
3124 my $save_minconfig = $minconfig;
3125 undef $minconfig;
3126
3127 run_command "$make allnoconfig" or return 0;
3128
3129 read_depends;
3130
3131 process_config_ignore $output_config;
3132
3133 undef %save_configs;
3134 undef %min_configs;
3135
3136 if (defined($ignore_config)) {
3137 # make sure the file exists
3138 `touch $ignore_config`;
3139 assign_configs \%save_configs, $ignore_config;
3140 }
3141
3142 %keep_configs = %save_configs;
3143
3144 doprint "Load initial configs from $start_minconfig\n";
3145
3146 # Look at the current min configs, and save off all the
3147 # ones that were set via the allnoconfig
3148 assign_configs \%min_configs, $start_minconfig;
3149
3150 my @config_keys = keys %min_configs;
3151
3152 # All configs need a depcount
3153 foreach my $config (@config_keys) {
3154 my $kconfig = chomp_config $config;
3155 if (!defined $depcount{$kconfig}) {
3156 $depcount{$kconfig} = 0;
3157 }
3158 }
3159
3160 # Remove anything that was set by the make allnoconfig
3161 # we shouldn't need them as they get set for us anyway.
3162 foreach my $config (@config_keys) {
3163 # Remove anything in the ignore_config
3164 if (defined($keep_configs{$config})) {
3165 my $file = $ignore_config;
3166 $file =~ s,.*/(.*?)$,$1,;
3167 doprint "$config set by $file ... ignored\n";
3168 delete $min_configs{$config};
3169 next;
3170 }
3171 # But make sure the settings are the same. If a min config
3172 # sets a selection, we do not want to get rid of it if
3173 # it is not the same as what we have. Just move it into
3174 # the keep configs.
3175 if (defined($config_ignore{$config})) {
3176 if ($config_ignore{$config} ne $min_configs{$config}) {
3177 doprint "$config is in allnoconfig as '$config_ignore{$config}'";
3178 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
3179 $keep_configs{$config} = $min_configs{$config};
3180 } else {
3181 doprint "$config set by allnoconfig ... ignored\n";
3182 }
3183 delete $min_configs{$config};
3184 }
3185 }
3186
3187 my $done = 0;
3188 my $take_two = 0;
3189
3190 while (!$done) {
3191
3192 my $config;
3193 my $found;
3194
3195 # Now disable each config one by one and do a make oldconfig
3196 # till we find a config that changes our list.
3197
3198 my @test_configs = keys %min_configs;
3199
3200 # Sort keys by who is most dependent on
3201 @test_configs = sort { $depcount{chomp_config($b)} <=> $depcount{chomp_config($a)} }
3202 @test_configs ;
3203
3204 # Put configs that did not modify the config at the end.
3205 my $reset = 1;
3206 for (my $i = 0; $i < $#test_configs; $i++) {
3207 if (!defined($nochange_config{$test_configs[0]})) {
3208 $reset = 0;
3209 last;
3210 }
3211 # This config didn't change the .config last time.
3212 # Place it at the end
3213 my $config = shift @test_configs;
3214 push @test_configs, $config;
3215 }
3216
3217 # if every test config has failed to modify the .config file
3218 # in the past, then reset and start over.
3219 if ($reset) {
3220 undef %nochange_config;
3221 }
3222
3223 undef %processed_configs;
3224
3225 foreach my $config (@test_configs) {
3226
3227 $found = test_this_config $config;
3228
3229 last if (defined($found));
3230
3231 # oh well, try another config
3232 }
3233
3234 if (!defined($found)) {
3235 # we could have failed due to the nochange_config hash
3236 # reset and try again
3237 if (!$take_two) {
3238 undef %nochange_config;
3239 $take_two = 1;
3240 next;
3241 }
3242 doprint "No more configs found that we can disable\n";
3243 $done = 1;
3244 last;
3245 }
3246 $take_two = 0;
3247
3248 $config = $found;
3249
3250 doprint "Test with $config disabled\n";
3251
3252 # set in_bisect to keep build and monitor from dieing
3253 $in_bisect = 1;
3254
3255 my $failed = 0;
3256 build "oldconfig" or $failed = 1;
3257 if (!$failed) {
3258 start_monitor_and_boot or $failed = 1;
3259 end_monitor;
3260 }
3261
3262 $in_bisect = 0;
3263
3264 if ($failed) {
3265 doprint "$min_configs{$config} is needed to boot the box... keeping\n";
3266 # this config is needed, add it to the ignore list.
3267 $keep_configs{$config} = $min_configs{$config};
3268 $save_configs{$config} = $min_configs{$config};
3269 delete $min_configs{$config};
3270
3271 # update new ignore configs
3272 if (defined($ignore_config)) {
3273 open (OUT, ">$temp_config")
3274 or die "Can't write to $temp_config";
3275 foreach my $config (keys %save_configs) {
3276 print OUT "$save_configs{$config}\n";
3277 }
3278 close OUT;
3279 run_command "mv $temp_config $ignore_config" or
3280 dodie "failed to copy update to $ignore_config";
3281 }
3282
3283 } else {
3284 # We booted without this config, remove it from the minconfigs.
3285 doprint "$config is not needed, disabling\n";
3286
3287 delete $min_configs{$config};
3288
3289 # Also disable anything that is not enabled in this config
3290 my %configs;
3291 assign_configs \%configs, $output_config;
3292 my @config_keys = keys %min_configs;
3293 foreach my $config (@config_keys) {
3294 if (!defined($configs{$config})) {
3295 doprint "$config is not set, disabling\n";
3296 delete $min_configs{$config};
3297 }
3298 }
3299
3300 # Save off all the current mandidory configs
3301 open (OUT, ">$temp_config")
3302 or die "Can't write to $temp_config";
3303 foreach my $config (keys %keep_configs) {
3304 print OUT "$keep_configs{$config}\n";
3305 }
3306 foreach my $config (keys %min_configs) {
3307 print OUT "$min_configs{$config}\n";
3308 }
3309 close OUT;
3310
3311 run_command "mv $temp_config $output_minconfig" or
3312 dodie "failed to copy update to $output_minconfig";
3313 }
3314
3315 doprint "Reboot and wait $sleep_time seconds\n";
3316 reboot_to_good $sleep_time;
3317 }
3318
3319 success $i;
3320 return 1;
3321 }
3322
3323 $#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl config-file\n";
3324
3325 if ($#ARGV == 0) {
3326 $ktest_config = $ARGV[0];
3327 if (! -f $ktest_config) {
3328 print "$ktest_config does not exist.\n";
3329 if (!read_yn "Create it?") {
3330 exit 0;
3331 }
3332 }
3333 } else {
3334 $ktest_config = "ktest.conf";
3335 }
3336
3337 if (! -f $ktest_config) {
3338 $newconfig = 1;
3339 get_test_case;
3340 open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
3341 print OUT << "EOF"
3342 # Generated by ktest.pl
3343 #
3344
3345 # PWD is a ktest.pl variable that will result in the process working
3346 # directory that ktest.pl is executed in.
3347
3348 # THIS_DIR is automatically assigned the PWD of the path that generated
3349 # the config file. It is best to use this variable when assigning other
3350 # directory paths within this directory. This allows you to easily
3351 # move the test cases to other locations or to other machines.
3352 #
3353 THIS_DIR := $variable{"PWD"}
3354
3355 # Define each test with TEST_START
3356 # The config options below it will override the defaults
3357 TEST_START
3358 TEST_TYPE = $default{"TEST_TYPE"}
3359
3360 DEFAULTS
3361 EOF
3362 ;
3363 close(OUT);
3364 }
3365 read_config $ktest_config;
3366
3367 if (defined($opt{"LOG_FILE"})) {
3368 $opt{"LOG_FILE"} = eval_option($opt{"LOG_FILE"}, -1);
3369 }
3370
3371 # Append any configs entered in manually to the config file.
3372 my @new_configs = keys %entered_configs;
3373 if ($#new_configs >= 0) {
3374 print "\nAppending entered in configs to $ktest_config\n";
3375 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
3376 foreach my $config (@new_configs) {
3377 print OUT "$config = $entered_configs{$config}\n";
3378 $opt{$config} = process_variables($entered_configs{$config});
3379 }
3380 }
3381
3382 if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
3383 unlink $opt{"LOG_FILE"};
3384 }
3385
3386 doprint "\n\nSTARTING AUTOMATED TESTS\n\n";
3387
3388 for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
3389
3390 if (!$i) {
3391 doprint "DEFAULT OPTIONS:\n";
3392 } else {
3393 doprint "\nTEST $i OPTIONS";
3394 if (defined($repeat_tests{$i})) {
3395 $repeat = $repeat_tests{$i};
3396 doprint " ITERATE $repeat";
3397 }
3398 doprint "\n";
3399 }
3400
3401 foreach my $option (sort keys %opt) {
3402
3403 if ($option =~ /\[(\d+)\]$/) {
3404 next if ($i != $1);
3405 } else {
3406 next if ($i);
3407 }
3408
3409 doprint "$option = $opt{$option}\n";
3410 }
3411 }
3412
3413 sub __set_test_option {
3414 my ($name, $i) = @_;
3415
3416 my $option = "$name\[$i\]";
3417
3418 if (defined($opt{$option})) {
3419 return $opt{$option};
3420 }
3421
3422 foreach my $test (keys %repeat_tests) {
3423 if ($i >= $test &&
3424 $i < $test + $repeat_tests{$test}) {
3425 $option = "$name\[$test\]";
3426 if (defined($opt{$option})) {
3427 return $opt{$option};
3428 }
3429 }
3430 }
3431
3432 if (defined($opt{$name})) {
3433 return $opt{$name};
3434 }
3435
3436 return undef;
3437 }
3438
3439 sub set_test_option {
3440 my ($name, $i) = @_;
3441
3442 my $option = __set_test_option($name, $i);
3443 return $option if (!defined($option));
3444
3445 return eval_option($option, $i);
3446 }
3447
3448 # First we need to do is the builds
3449 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
3450
3451 # Do not reboot on failing test options
3452 $no_reboot = 1;
3453
3454 $iteration = $i;
3455
3456 my $makecmd = set_test_option("MAKE_CMD", $i);
3457
3458 # Load all the options into their mapped variable names
3459 foreach my $opt (keys %option_map) {
3460 ${$option_map{$opt}} = set_test_option($opt, $i);
3461 }
3462
3463 $start_minconfig_defined = 1;
3464
3465 if (!defined($start_minconfig)) {
3466 $start_minconfig_defined = 0;
3467 $start_minconfig = $minconfig;
3468 }
3469
3470 chdir $builddir || die "can't change directory to $builddir";
3471
3472 foreach my $dir ($tmpdir, $outputdir) {
3473 if (!-d $dir) {
3474 mkpath($dir) or
3475 die "can't create $dir";
3476 }
3477 }
3478
3479 $ENV{"SSH_USER"} = $ssh_user;
3480 $ENV{"MACHINE"} = $machine;
3481
3482 $buildlog = "$tmpdir/buildlog-$machine";
3483 $testlog = "$tmpdir/testlog-$machine";
3484 $dmesg = "$tmpdir/dmesg-$machine";
3485 $make = "$makecmd O=$outputdir";
3486 $output_config = "$outputdir/.config";
3487
3488 if (!$buildonly) {
3489 $target = "$ssh_user\@$machine";
3490 if ($reboot_type eq "grub") {
3491 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
3492 }
3493 }
3494
3495 my $run_type = $build_type;
3496 if ($test_type eq "patchcheck") {
3497 $run_type = $patchcheck_type;
3498 } elsif ($test_type eq "bisect") {
3499 $run_type = $bisect_type;
3500 } elsif ($test_type eq "config_bisect") {
3501 $run_type = $config_bisect_type;
3502 }
3503
3504 if ($test_type eq "make_min_config") {
3505 $run_type = "";
3506 }
3507
3508 # mistake in config file?
3509 if (!defined($run_type)) {
3510 $run_type = "ERROR";
3511 }
3512
3513 my $installme = "";
3514 $installme = " no_install" if ($no_install);
3515
3516 doprint "\n\n";
3517 doprint "RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type$installme\n\n";
3518
3519 unlink $dmesg;
3520 unlink $buildlog;
3521 unlink $testlog;
3522
3523 if (defined($addconfig)) {
3524 my $min = $minconfig;
3525 if (!defined($minconfig)) {
3526 $min = "";
3527 }
3528 run_command "cat $addconfig $min > $tmpdir/add_config" or
3529 dodie "Failed to create temp config";
3530 $minconfig = "$tmpdir/add_config";
3531 }
3532
3533 if (defined($checkout)) {
3534 run_command "git checkout $checkout" or
3535 die "failed to checkout $checkout";
3536 }
3537
3538 $no_reboot = 0;
3539
3540
3541 if ($test_type eq "bisect") {
3542 bisect $i;
3543 next;
3544 } elsif ($test_type eq "config_bisect") {
3545 config_bisect $i;
3546 next;
3547 } elsif ($test_type eq "patchcheck") {
3548 patchcheck $i;
3549 next;
3550 } elsif ($test_type eq "make_min_config") {
3551 make_min_config $i;
3552 next;
3553 }
3554
3555 if ($build_type ne "nobuild") {
3556 build $build_type or next;
3557 }
3558
3559 if ($test_type eq "install") {
3560 get_version;
3561 install;
3562 success $i;
3563 next;
3564 }
3565
3566 if ($test_type ne "build") {
3567 my $failed = 0;
3568 start_monitor_and_boot or $failed = 1;
3569
3570 if (!$failed && $test_type ne "boot" && defined($run_test)) {
3571 do_run_test or $failed = 1;
3572 }
3573 end_monitor;
3574 next if ($failed);
3575 }
3576
3577 success $i;
3578 }
3579
3580 if ($opt{"POWEROFF_ON_SUCCESS"}) {
3581 halt;
3582 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot) {
3583 reboot_to_good;
3584 }
3585
3586 doprint "\n $successes of $opt{NUM_TESTS} tests were successful\n\n";
3587
3588 exit 0;
Linux kernel - Deliverables
This page took 0.147259 seconds and 5 git commands to generate.