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