source: src/linux/universal/linux-4.4/tools/testing/ktest/ktest.pl @ 31662

Last change on this file since 31662 was 31662, checked in by brainslayer, 3 months ago

use new squashfs in all kernels

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