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