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