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