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