ktest.pl 77.4 KB
Newer Older
S
Steven Rostedt 已提交
1
#!/usr/bin/perl -w
2
#
3
# Copyright 2010 - Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
4 5
# Licensed under the terms of the GNU GPL License version 2
#
S
Steven Rostedt 已提交
6 7 8 9

use strict;
use IPC::Open2;
use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
10 11
use File::Path qw(mkpath);
use File::Copy qw(cp);
S
Steven Rostedt 已提交
12 13
use FileHandle;

14 15
my $VERSION = "0.2";

S
Steven Rostedt 已提交
16 17 18
$| = 1;

my %opt;
19 20
my %repeat_tests;
my %repeats;
S
Steven Rostedt 已提交
21 22

#default opts
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
my %default = (
    "NUM_TESTS"			=> 1,
    "TEST_TYPE"			=> "build",
    "BUILD_TYPE"		=> "randconfig",
    "MAKE_CMD"			=> "make",
    "TIMEOUT"			=> 120,
    "TMP_DIR"			=> "/tmp/ktest/\${MACHINE}",
    "SLEEP_TIME"		=> 60,	# sleep time between tests
    "BUILD_NOCLEAN"		=> 0,
    "REBOOT_ON_ERROR"		=> 0,
    "POWEROFF_ON_ERROR"		=> 0,
    "REBOOT_ON_SUCCESS"		=> 1,
    "POWEROFF_ON_SUCCESS"	=> 0,
    "BUILD_OPTIONS"		=> "",
    "BISECT_SLEEP_TIME"		=> 60,   # sleep time between bisects
    "PATCHCHECK_SLEEP_TIME"	=> 60, # sleep time between patch checks
    "CLEAR_LOG"			=> 0,
    "BISECT_MANUAL"		=> 0,
    "BISECT_SKIP"		=> 1,
    "SUCCESS_LINE"		=> "login:",
    "DETECT_TRIPLE_FAULT"	=> 1,
    "NO_INSTALL"		=> 0,
    "BOOTED_TIMEOUT"		=> 1,
    "DIE_ON_FAILURE"		=> 1,
    "SSH_EXEC"			=> "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND",
    "SCP_TO_TARGET"		=> "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE",
49
    "SCP_TO_TARGET_INSTALL"	=> "\${SCP_TO_TARGET}",
50 51 52 53
    "REBOOT"			=> "ssh \$SSH_USER\@\$MACHINE reboot",
    "STOP_AFTER_SUCCESS"	=> 10,
    "STOP_AFTER_FAILURE"	=> 60,
    "STOP_TEST_AFTER"		=> 600,
54 55 56

# required, and we will ask users if they don't have them but we keep the default
# value something that is common.
57 58 59 60 61
    "REBOOT_TYPE"		=> "grub",
    "LOCALVERSION"		=> "-test",
    "SSH_USER"			=> "root",
    "BUILD_TARGET"	 	=> "arch/x86/boot/bzImage",
    "TARGET_IMAGE"		=> "/boot/vmlinuz-test",
62 63 64

    "LOG_FILE"			=> undef,
    "IGNORE_UNUSED"		=> 0,
65
);
S
Steven Rostedt 已提交
66

67
my $ktest_config;
S
Steven Rostedt 已提交
68
my $version;
69
my $machine;
70
my $ssh_user;
71 72 73
my $tmpdir;
my $builddir;
my $outputdir;
74
my $output_config;
75
my $test_type;
76
my $build_type;
77
my $build_options;
78 79 80 81
my $pre_build;
my $post_build;
my $pre_build_die;
my $post_build_die;
82 83 84
my $reboot_type;
my $reboot_script;
my $power_cycle;
85
my $reboot;
86
my $reboot_on_error;
87 88
my $switch_to_good;
my $switch_to_test;
89
my $poweroff_on_error;
90
my $reboot_on_success;
91
my $die_on_failure;
92 93
my $powercycle_after_reboot;
my $poweroff_after_halt;
94 95
my $ssh_exec;
my $scp_to_target;
96
my $scp_to_target_install;
97 98
my $power_off;
my $grub_menu;
S
Steven Rostedt 已提交
99 100 101
my $grub_number;
my $target;
my $make;
102
my $post_install;
103
my $no_install;
104
my $noclean;
105
my $minconfig;
106
my $start_minconfig;
107
my $start_minconfig_defined;
108 109
my $output_minconfig;
my $ignore_config;
110
my $ignore_errors;
111
my $addconfig;
112
my $in_bisect = 0;
113
my $bisect_bad_commit = "";
114
my $reverse_bisect;
S
Steven Rostedt 已提交
115
my $bisect_manual;
S
Steven Rostedt 已提交
116
my $bisect_skip;
117
my $config_bisect_good;
118 119 120 121 122
my $bisect_ret_good;
my $bisect_ret_bad;
my $bisect_ret_skip;
my $bisect_ret_abort;
my $bisect_ret_default;
S
Steven Rostedt 已提交
123
my $in_patchcheck = 0;
124
my $run_test;
S
Steven Rostedt 已提交
125
my $redirect;
126
my $buildlog;
R
Rabin Vincent 已提交
127
my $testlog;
128 129 130 131
my $dmesg;
my $monitor_fp;
my $monitor_pid;
my $monitor_cnt = 0;
132 133
my $sleep_time;
my $bisect_sleep_time;
134
my $patchcheck_sleep_time;
135
my $ignore_warnings;
136
my $store_failures;
137
my $store_successes;
S
Steven Rostedt 已提交
138
my $test_name;
139 140
my $timeout;
my $booted_timeout;
141
my $detect_triplefault;
142
my $console;
143
my $reboot_success_line;
144
my $success_line;
145 146
my $stop_after_success;
my $stop_after_failure;
147
my $stop_test_after;
148 149
my $build_target;
my $target_image;
150
my $checkout;
151
my $localversion;
152
my $iteration = 0;
153
my $successes = 0;
S
Steven Rostedt 已提交
154

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
my $bisect_good;
my $bisect_bad;
my $bisect_type;
my $bisect_start;
my $bisect_replay;
my $bisect_files;
my $bisect_reverse;
my $bisect_check;

my $config_bisect;
my $config_bisect_type;

my $patchcheck_type;
my $patchcheck_start;
my $patchcheck_end;

171
# set when a test is something other that just building or install
172 173 174
# which would require more options.
my $buildonly = 1;

175 176 177
# set when creating a new config
my $newconfig = 0;

178 179
my %entered_configs;
my %config_help;
180
my %variable;
181
my %force_config;
182

183 184 185
# do not force reboots on config problems
my $no_reboot = 1;

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
my %option_map = (
    "MACHINE"			=> \$machine,
    "SSH_USER"			=> \$ssh_user,
    "TMP_DIR"			=> \$tmpdir,
    "OUTPUT_DIR"		=> \$outputdir,
    "BUILD_DIR"			=> \$builddir,
    "TEST_TYPE"			=> \$test_type,
    "BUILD_TYPE"		=> \$build_type,
    "BUILD_OPTIONS"		=> \$build_options,
    "PRE_BUILD"			=> \$pre_build,
    "POST_BUILD"		=> \$post_build,
    "PRE_BUILD_DIE"		=> \$pre_build_die,
    "POST_BUILD_DIE"		=> \$post_build_die,
    "POWER_CYCLE"		=> \$power_cycle,
    "REBOOT"			=> \$reboot,
    "BUILD_NOCLEAN"		=> \$noclean,
    "MIN_CONFIG"		=> \$minconfig,
    "OUTPUT_MIN_CONFIG"		=> \$output_minconfig,
    "START_MIN_CONFIG"		=> \$start_minconfig,
    "IGNORE_CONFIG"		=> \$ignore_config,
    "TEST"			=> \$run_test,
    "ADD_CONFIG"		=> \$addconfig,
    "REBOOT_TYPE"		=> \$reboot_type,
    "GRUB_MENU"			=> \$grub_menu,
    "POST_INSTALL"		=> \$post_install,
    "NO_INSTALL"		=> \$no_install,
    "REBOOT_SCRIPT"		=> \$reboot_script,
    "REBOOT_ON_ERROR"		=> \$reboot_on_error,
    "SWITCH_TO_GOOD"		=> \$switch_to_good,
    "SWITCH_TO_TEST"		=> \$switch_to_test,
    "POWEROFF_ON_ERROR"		=> \$poweroff_on_error,
217
    "REBOOT_ON_SUCCESS"		=> \$reboot_on_success,
218 219 220 221 222 223 224 225
    "DIE_ON_FAILURE"		=> \$die_on_failure,
    "POWER_OFF"			=> \$power_off,
    "POWERCYCLE_AFTER_REBOOT"	=> \$powercycle_after_reboot,
    "POWEROFF_AFTER_HALT"	=> \$poweroff_after_halt,
    "SLEEP_TIME"		=> \$sleep_time,
    "BISECT_SLEEP_TIME"		=> \$bisect_sleep_time,
    "PATCHCHECK_SLEEP_TIME"	=> \$patchcheck_sleep_time,
    "IGNORE_WARNINGS"		=> \$ignore_warnings,
226
    "IGNORE_ERRORS"		=> \$ignore_errors,
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
    "BISECT_MANUAL"		=> \$bisect_manual,
    "BISECT_SKIP"		=> \$bisect_skip,
    "CONFIG_BISECT_GOOD"	=> \$config_bisect_good,
    "BISECT_RET_GOOD"		=> \$bisect_ret_good,
    "BISECT_RET_BAD"		=> \$bisect_ret_bad,
    "BISECT_RET_SKIP"		=> \$bisect_ret_skip,
    "BISECT_RET_ABORT"		=> \$bisect_ret_abort,
    "BISECT_RET_DEFAULT"	=> \$bisect_ret_default,
    "STORE_FAILURES"		=> \$store_failures,
    "STORE_SUCCESSES"		=> \$store_successes,
    "TEST_NAME"			=> \$test_name,
    "TIMEOUT"			=> \$timeout,
    "BOOTED_TIMEOUT"		=> \$booted_timeout,
    "CONSOLE"			=> \$console,
    "DETECT_TRIPLE_FAULT"	=> \$detect_triplefault,
    "SUCCESS_LINE"		=> \$success_line,
    "REBOOT_SUCCESS_LINE"	=> \$reboot_success_line,
    "STOP_AFTER_SUCCESS"	=> \$stop_after_success,
    "STOP_AFTER_FAILURE"	=> \$stop_after_failure,
    "STOP_TEST_AFTER"		=> \$stop_test_after,
    "BUILD_TARGET"		=> \$build_target,
    "SSH_EXEC"			=> \$ssh_exec,
    "SCP_TO_TARGET"		=> \$scp_to_target,
250
    "SCP_TO_TARGET_INSTALL"	=> \$scp_to_target_install,
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
    "CHECKOUT"			=> \$checkout,
    "TARGET_IMAGE"		=> \$target_image,
    "LOCALVERSION"		=> \$localversion,

    "BISECT_GOOD"		=> \$bisect_good,
    "BISECT_BAD"		=> \$bisect_bad,
    "BISECT_TYPE"		=> \$bisect_type,
    "BISECT_START"		=> \$bisect_start,
    "BISECT_REPLAY"		=> \$bisect_replay,
    "BISECT_FILES"		=> \$bisect_files,
    "BISECT_REVERSE"		=> \$bisect_reverse,
    "BISECT_CHECK"		=> \$bisect_check,

    "CONFIG_BISECT"		=> \$config_bisect,
    "CONFIG_BISECT_TYPE"	=> \$config_bisect_type,

    "PATCHCHECK_TYPE"		=> \$patchcheck_type,
    "PATCHCHECK_START"		=> \$patchcheck_start,
    "PATCHCHECK_END"		=> \$patchcheck_end,
);

# Options may be used by other options, record them.
my %used_options;

S
Steven Rostedt 已提交
275 276 277
# default variables that can be used
chomp ($variable{"PWD"} = `pwd`);

278 279
$config_help{"MACHINE"} = << "EOF"
 The machine hostname that you will test.
280
 For build only tests, it is still needed to differentiate log files.
281 282 283 284 285 286 287 288 289
EOF
    ;
$config_help{"SSH_USER"} = << "EOF"
 The box is expected to have ssh on normal bootup, provide the user
  (most likely root, since you need privileged operations)
EOF
    ;
$config_help{"BUILD_DIR"} = << "EOF"
 The directory that contains the Linux source code (full path).
290 291
 You can use \${PWD} that will be the path where ktest.pl is run, or use
 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
292 293 294 295 296
EOF
    ;
$config_help{"OUTPUT_DIR"} = << "EOF"
 The directory that the objects will be built (full path).
 (can not be same as BUILD_DIR)
297 298
 You can use \${PWD} that will be the path where ktest.pl is run, or use
 \${THIS_DIR} which is assigned \${PWD} but may be changed later.
299 300 301 302 303 304 305
EOF
    ;
$config_help{"BUILD_TARGET"} = << "EOF"
 The location of the compiled file to copy to the target.
 (relative to OUTPUT_DIR)
EOF
    ;
306 307 308 309 310
$config_help{"BUILD_OPTIONS"} = << "EOF"
 Options to add to \"make\" when building.
 i.e.  -j20
EOF
    ;
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
$config_help{"TARGET_IMAGE"} = << "EOF"
 The place to put your image on the test machine.
EOF
    ;
$config_help{"POWER_CYCLE"} = << "EOF"
 A script or command to reboot the box.

 Here is a digital loggers power switch example
 POWER_CYCLE = wget --no-proxy -O /dev/null -q  --auth-no-challenge 'http://admin:admin\@power/outlet?5=CCL'

 Here is an example to reboot a virtual box on the current host
 with the name "Guest".
 POWER_CYCLE = virsh destroy Guest; sleep 5; virsh start Guest
EOF
    ;
$config_help{"CONSOLE"} = << "EOF"
 The script or command that reads the console

  If you use ttywatch server, something like the following would work.
CONSOLE = nc -d localhost 3001

 For a virtual machine with guest name "Guest".
CONSOLE =  virsh console Guest
EOF
    ;
$config_help{"LOCALVERSION"} = << "EOF"
 Required version ending to differentiate the test
 from other linux builds on the system.
EOF
    ;
$config_help{"REBOOT_TYPE"} = << "EOF"
 Way to reboot the box to the test kernel.
 Only valid options so far are "grub" and "script".

 If you specify grub, it will assume grub version 1
 and will search in /boot/grub/menu.lst for the title \$GRUB_MENU
 and select that target to reboot to the kernel. If this is not
 your setup, then specify "script" and have a command or script
 specified in REBOOT_SCRIPT to boot to the target.

 The entry in /boot/grub/menu.lst must be entered in manually.
 The test will not modify that file.
EOF
    ;
$config_help{"GRUB_MENU"} = << "EOF"
 The grub title name for the test kernel to boot
 (Only mandatory if REBOOT_TYPE = grub)

 Note, ktest.pl will not update the grub menu.lst, you need to
 manually add an option for the test. ktest.pl will search
 the grub menu.lst for this option to find what kernel to
 reboot into.

 For example, if in the /boot/grub/menu.lst the test kernel title has:
 title Test Kernel
 kernel vmlinuz-test
 GRUB_MENU = Test Kernel
EOF
    ;
$config_help{"REBOOT_SCRIPT"} = << "EOF"
 A script to reboot the target into the test kernel
 (Only mandatory if REBOOT_TYPE = script)
EOF
    ;

376 377
sub read_prompt {
    my ($cancel, $prompt) = @_;
378 379 380 381

    my $ans;

    for (;;) {
382 383 384 385 386
	if ($cancel) {
	    print "$prompt [y/n/C] ";
	} else {
	    print "$prompt [Y/n] ";
	}
387 388 389
	$ans = <STDIN>;
	chomp $ans;
	if ($ans =~ /^\s*$/) {
390 391 392 393 394
	    if ($cancel) {
		$ans = "c";
	    } else {
		$ans = "y";
	    }
395 396
	}
	last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
397 398 399 400 401 402 403 404 405
	if ($cancel) {
	    last if ($ans =~ /^c$/i);
	    print "Please answer either 'y', 'n' or 'c'.\n";
	} else {
	    print "Please answer either 'y' or 'n'.\n";
	}
    }
    if ($ans =~ /^c/i) {
	exit;
406 407 408 409 410 411
    }
    if ($ans !~ /^y$/i) {
	return 0;
    }
    return 1;
}
412

413 414 415 416 417 418 419 420 421 422 423 424
sub read_yn {
    my ($prompt) = @_;

    return read_prompt 0, $prompt;
}

sub read_ync {
    my ($prompt) = @_;

    return read_prompt 1, $prompt;
}

425 426
sub get_ktest_config {
    my ($config) = @_;
427
    my $ans;
428 429 430 431 432 433 434 435 436 437

    return if (defined($opt{$config}));

    if (defined($config_help{$config})) {
	print "\n";
	print $config_help{$config};
    }

    for (;;) {
	print "$config = ";
438
	if (defined($default{$config}) && length($default{$config})) {
439 440
	    print "\[$default{$config}\] ";
	}
441 442 443
	$ans = <STDIN>;
	$ans =~ s/^\s*(.*\S)\s*$/$1/;
	if ($ans =~ /^\s*$/) {
444
	    if ($default{$config}) {
445
		$ans = $default{$config};
446 447 448 449 450
	    } else {
		print "Your answer can not be blank\n";
		next;
	    }
	}
451
	$entered_configs{$config} = ${ans};
452 453 454 455 456 457 458 459
	last;
    }
}

sub get_ktest_configs {
    get_ktest_config("MACHINE");
    get_ktest_config("BUILD_DIR");
    get_ktest_config("OUTPUT_DIR");
460

461 462 463 464
    if ($newconfig) {
	get_ktest_config("BUILD_OPTIONS");
    }

465 466
    # options required for other than just building a kernel
    if (!$buildonly) {
467 468 469 470 471 472
	get_ktest_config("POWER_CYCLE");
	get_ktest_config("CONSOLE");
    }

    # options required for install and more
    if ($buildonly != 1) {
473 474 475 476 477
	get_ktest_config("SSH_USER");
	get_ktest_config("BUILD_TARGET");
	get_ktest_config("TARGET_IMAGE");
    }

478 479
    get_ktest_config("LOCALVERSION");

480 481
    return if ($buildonly);

482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
    my $rtype = $opt{"REBOOT_TYPE"};

    if (!defined($rtype)) {
	if (!defined($opt{"GRUB_MENU"})) {
	    get_ktest_config("REBOOT_TYPE");
	    $rtype = $entered_configs{"REBOOT_TYPE"};
	} else {
	    $rtype = "grub";
	}
    }

    if ($rtype eq "grub") {
	get_ktest_config("GRUB_MENU");
    }
}

498
sub process_variables {
499
    my ($value, $remove_undef) = @_;
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
    my $retval = "";

    # We want to check for '\', and it is just easier
    # to check the previous characet of '$' and not need
    # to worry if '$' is the first character. By adding
    # a space to $value, we can just check [^\\]\$ and
    # it will still work.
    $value = " $value";

    while ($value =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
	my $begin = $1;
	my $var = $2;
	my $end = $3;
	# append beginning of value to retval
	$retval = "$retval$begin";
	if (defined($variable{$var})) {
	    $retval = "$retval$variable{$var}";
517 518 519 520
	} elsif (defined($remove_undef) && $remove_undef) {
	    # for if statements, any variable that is not defined,
	    # we simple convert to 0
	    $retval = "${retval}0";
521 522 523
	} else {
	    # put back the origin piece.
	    $retval = "$retval\$\{$var\}";
524 525 526 527
	    # This could be an option that is used later, save
	    # it so we don't warn if this option is not one of
	    # ktests options.
	    $used_options{$var} = 1;
528 529 530 531 532 533 534 535 536 537 538
	}
	$value = $end;
    }
    $retval = "$retval$value";

    # remove the space added in the beginning
    $retval =~ s/ //;

    return "$retval"
}

539
sub set_value {
540
    my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
541

542 543 544
    my $prvalue = process_variables($rvalue);

    if ($buildonly && $lvalue =~ /^TEST_TYPE(\[.*\])?$/ && $prvalue ne "build") {
545 546
	# Note if a test is something other than build, then we
	# will need other manditory options.
547
	if ($prvalue ne "install") {
548 549 550 551 552
	    $buildonly = 0;
	} else {
	    # install still limits some manditory options.
	    $buildonly = 2;
	}
553 554
    }

555
    if (defined($opt{$lvalue})) {
556 557 558 559 560 561 562
	if (!$override || defined(${$overrides}{$lvalue})) {
	    my $extra = "";
	    if ($override) {
		$extra = "In the same override section!\n";
	    }
	    die "$name: $.: Option $lvalue defined more than once!\n$extra";
	}
563
	${$overrides}{$lvalue} = $prvalue;
564
    }
565 566 567
    if ($rvalue =~ /^\s*$/) {
	delete $opt{$lvalue};
    } else {
568
	$opt{$lvalue} = $prvalue;
569
    }
570 571
}

572 573 574 575 576 577 578 579 580 581 582
sub set_variable {
    my ($lvalue, $rvalue) = @_;

    if ($rvalue =~ /^\s*$/) {
	delete $variable{$lvalue};
    } else {
	$rvalue = process_variables($rvalue);
	$variable{$lvalue} = $rvalue;
    }
}

583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
sub process_compare {
    my ($lval, $cmp, $rval) = @_;

    # remove whitespace

    $lval =~ s/^\s*//;
    $lval =~ s/\s*$//;

    $rval =~ s/^\s*//;
    $rval =~ s/\s*$//;

    if ($cmp eq "==") {
	return $lval eq $rval;
    } elsif ($cmp eq "!=") {
	return $lval ne $rval;
    }

    my $statement = "$lval $cmp $rval";
    my $ret = eval $statement;

    # $@ stores error of eval
    if ($@) {
	return -1;
    }

    return $ret;
}

611 612 613 614 615 616 617
sub value_defined {
    my ($val) = @_;

    return defined($variable{$2}) ||
	defined($opt{$2});
}

618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
my $d = 0;
sub process_expression {
    my ($name, $val) = @_;

    my $c = $d++;

    while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
	my $express = $1;

	if (process_expression($name, $express)) {
	    $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
	} else {
	    $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
	}
    }

    $d--;
    my $OR = "\\|\\|";
    my $AND = "\\&\\&";
637

638 639 640 641 642 643 644 645 646 647 648 649 650 651
    while ($val =~ s/^(.*?)($OR|$AND)//) {
	my $express = $1;
	my $op = $2;

	if (process_expression($name, $express)) {
	    if ($op eq "||") {
		return 1;
	    }
	} else {
	    if ($op eq "&&") {
		return 0;
	    }
	}
    }
652

653 654 655 656 657 658 659 660
    if ($val =~ /(.*)(==|\!=|>=|<=|>|<)(.*)/) {
	my $ret = process_compare($1, $2, $3);
	if ($ret < 0) {
	    die "$name: $.: Unable to process comparison\n";
	}
	return $ret;
    }

661 662 663 664 665 666 667 668
    if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
	if (defined $1) {
	    return !value_defined($2);
	} else {
	    return value_defined($2);
	}
    }

669 670 671 672 673 674
    if ($val =~ /^\s*0\s*$/) {
	return 0;
    } elsif ($val =~ /^\s*\d+\s*$/) {
	return 1;
    }

675
    die ("$name: $.: Undefined content $val in if statement\n");
676 677 678 679 680 681 682 683 684 685
}

sub process_if {
    my ($name, $value) = @_;

    # Convert variables and replace undefined ones with 0
    my $val = process_variables($value, 1);
    my $ret = process_expression $name, $val;

    return $ret;
686 687
}

688 689
sub __read_config {
    my ($config, $current_test_num) = @_;
S
Steven Rostedt 已提交
690

691 692
    my $in;
    open($in, $config) || die "can't read file $config";
S
Steven Rostedt 已提交
693

694 695 696
    my $name = $config;
    $name =~ s,.*/(.*),$1,;

697
    my $test_num = $$current_test_num;
698 699 700 701 702
    my $default = 1;
    my $repeat = 1;
    my $num_tests_set = 0;
    my $skip = 0;
    my $rest;
703
    my $line;
704
    my $test_case = 0;
705 706
    my $if = 0;
    my $if_set = 0;
707 708 709
    my $override = 0;

    my %overrides;
710

711
    while (<$in>) {
S
Steven Rostedt 已提交
712 713 714 715

	# ignore blank lines and comments
	next if (/^\s*$/ || /\s*\#/);

716
	if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
717

718 719
	    my $type = $1;
	    $rest = $2;
720
	    $line = $2;
721

722 723
	    my $old_test_num;
	    my $old_repeat;
724
	    $override = 0;
725 726 727 728 729 730

	    if ($type eq "TEST_START") {

		if ($num_tests_set) {
		    die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
		}
731

732 733
		$old_test_num = $test_num;
		$old_repeat = $repeat;
734

735 736 737 738 739 740
		$test_num += $repeat;
		$default = 0;
		$repeat = 1;
	    } else {
		$default = 1;
	    }
741

742 743
	    # If SKIP is anywhere in the line, the command will be skipped
	    if ($rest =~ s/\s+SKIP\b//) {
744 745
		$skip = 1;
	    } else {
746
		$test_case = 1;
747 748 749
		$skip = 0;
	    }

750 751 752 753 754 755 756 757 758 759
	    if ($rest =~ s/\sELSE\b//) {
		if (!$if) {
		    die "$name: $.: ELSE found with out matching IF section\n$_";
		}
		$if = 0;

		if ($if_set) {
		    $skip = 1;
		} else {
		    $skip = 0;
760
		}
761 762
	    }

763
	    if ($rest =~ s/\sIF\s+(.*)//) {
764 765 766 767 768 769 770 771
		if (process_if($name, $1)) {
		    $if_set = 1;
		} else {
		    $skip = 1;
		}
		$if = 1;
	    } else {
		$if = 0;
772 773 774 775 776 777 778 779 780 781 782 783 784 785 786
		$if_set = 0;
	    }

	    if (!$skip) {
		if ($type eq "TEST_START") {
		    if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
			$repeat = $1;
			$repeat_tests{"$test_num"} = $repeat;
		    }
		} elsif ($rest =~ s/\sOVERRIDE\b//) {
		    # DEFAULT only
		    $override = 1;
		    # Clear previous overrides
		    %overrides = ();
		}
787 788
	    }

789
	    if (!$skip && $rest !~ /^\s*$/) {
790
		die "$name: $.: Gargbage found after $type\n$_";
791 792
	    }

793
	    if ($skip && $type eq "TEST_START") {
794
		$test_num = $old_test_num;
795
		$repeat = $old_repeat;
796 797
	    }

798
	} elsif (/^\s*ELSE\b(.*)$/) {
799 800 801 802 803 804
	    if (!$if) {
		die "$name: $.: ELSE found with out matching IF section\n$_";
	    }
	    $rest = $1;
	    if ($if_set) {
		$skip = 1;
805
		$rest = "";
806 807 808
	    } else {
		$skip = 0;

809
		if ($rest =~ /\sIF\s+(.*)/) {
810 811 812 813
		    # May be a ELSE IF section.
		    if (!process_if($name, $1)) {
			$skip = 1;
		    }
814
		    $rest = "";
815 816 817 818 819
		} else {
		    $if = 0;
		}
	    }

820 821 822 823
	    if ($rest !~ /^\s*$/) {
		die "$name: $.: Gargbage found after DEFAULTS\n$_";
	    }

824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
	} elsif (/^\s*INCLUDE\s+(\S+)/) {

	    next if ($skip);

	    if (!$default) {
		die "$name: $.: INCLUDE can only be done in default sections\n$_";
	    }

	    my $file = process_variables($1);

	    if ($file !~ m,^/,) {
		# check the path of the config file first
		if ($config =~ m,(.*)/,) {
		    if (-f "$1/$file") {
			$file = "$1/$file";
		    }
		}
	    }
		
	    if ( ! -r $file ) {
		die "$name: $.: Can't read file $file\n$_";
	    }

	    if (__read_config($file, \$test_num)) {
		$test_case = 1;
	    }

851 852 853 854
	} elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {

	    next if ($skip);

S
Steven Rostedt 已提交
855 856 857
	    my $lvalue = $1;
	    my $rvalue = $2;

858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
	    if (!$default &&
		($lvalue eq "NUM_TESTS" ||
		 $lvalue eq "LOG_FILE" ||
		 $lvalue eq "CLEAR_LOG")) {
		die "$name: $.: $lvalue must be set in DEFAULTS section\n";
	    }

	    if ($lvalue eq "NUM_TESTS") {
		if ($test_num) {
		    die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
		}
		if (!$default) {
		    die "$name: $.: NUM_TESTS must be set in default section\n";
		}
		$num_tests_set = 1;
	    }

	    if ($default || $lvalue =~ /\[\d+\]$/) {
876
		set_value($lvalue, $rvalue, $override, \%overrides, $name);
877 878
	    } else {
		my $val = "$lvalue\[$test_num\]";
879
		set_value($val, $rvalue, $override, \%overrides, $name);
880 881 882 883

		if ($repeat > 1) {
		    $repeats{$val} = $repeat;
		}
884
	    }
885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
	} elsif (/^\s*([A-Z_\[\]\d]+)\s*:=\s*(.*?)\s*$/) {
	    next if ($skip);

	    my $lvalue = $1;
	    my $rvalue = $2;

	    # process config variables.
	    # Config variables are only active while reading the
	    # config and can be defined anywhere. They also ignore
	    # TEST_START and DEFAULTS, but are skipped if they are in
	    # on of these sections that have SKIP defined.
	    # The save variable can be
	    # defined multiple times and the new one simply overrides
	    # the prevous one.
	    set_variable($lvalue, $rvalue);

901 902
	} else {
	    die "$name: $.: Garbage found in config\n$_";
S
Steven Rostedt 已提交
903 904 905
	}
    }

906 907 908 909 910
    if ($test_num) {
	$test_num += $repeat - 1;
	$opt{"NUM_TESTS"} = $test_num;
    }

911 912 913 914 915 916 917
    close($in);

    $$current_test_num = $test_num;

    return $test_case;
}

918 919 920 921 922 923 924 925 926
sub get_test_case {
	print "What test case would you like to run?\n";
	print " (build, install or boot)\n";
	print " Other tests are available but require editing the config file\n";
	my $ans = <STDIN>;
	chomp $ans;
	$default{"TEST_TYPE"} = $ans;
}

927 928 929 930 931 932 933 934
sub read_config {
    my ($config) = @_;

    my $test_case;
    my $test_num = 0;

    $test_case = __read_config $config, \$test_num;

935 936 937
    # make sure we have all mandatory configs
    get_ktest_configs;

938 939 940
    # was a test specified?
    if (!$test_case) {
	print "No test case specified.\n";
941
	get_test_case;
942 943
    }

944 945 946 947 948 949 950
    # set any defaults

    foreach my $default (keys %default) {
	if (!defined($opt{$default})) {
	    $opt{$default} = $default{$default};
	}
    }
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981

    if ($opt{"IGNORE_UNUSED"} == 1) {
	return;
    }

    my %not_used;

    # check if there are any stragglers (typos?)
    foreach my $option (keys %opt) {
	my $op = $option;
	# remove per test labels.
	$op =~ s/\[.*\]//;
	if (!exists($option_map{$op}) &&
	    !exists($default{$op}) &&
	    !exists($used_options{$op})) {
	    $not_used{$op} = 1;
	}
    }

    if (%not_used) {
	my $s = "s are";
	$s = " is" if (keys %not_used == 1);
	print "The following option$s not used; could be a typo:\n";
	foreach my $option (keys %not_used) {
	    print "$option\n";
	}
	print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";
	if (!read_yn "Do you want to continue?") {
	    exit -1;
	}
    }
S
Steven Rostedt 已提交
982 983
}

984 985 986 987 988 989
sub __eval_option {
    my ($option, $i) = @_;

    # Add space to evaluate the character before $
    $option = " $option";
    my $retval = "";
990 991 992 993 994 995 996 997 998 999 1000 1001
    my $repeated = 0;
    my $parent = 0;

    foreach my $test (keys %repeat_tests) {
	if ($i >= $test &&
	    $i < $test + $repeat_tests{$test}) {

	    $repeated = 1;
	    $parent = $test;
	    last;
	}
    }
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014

    while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
	my $start = $1;
	my $var = $2;
	my $end = $3;

	# Append beginning of line
	$retval = "$retval$start";

	# If the iteration option OPT[$i] exists, then use that.
	# otherwise see if the default OPT (without [$i]) exists.

	my $o = "$var\[$i\]";
1015
	my $parento = "$var\[$parent\]";
1016 1017 1018 1019

	if (defined($opt{$o})) {
	    $o = $opt{$o};
	    $retval = "$retval$o";
1020 1021 1022
	} elsif ($repeated && defined($opt{$parento})) {
	    $o = $opt{$parento};
	    $retval = "$retval$o";
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
	} elsif (defined($opt{$var})) {
	    $o = $opt{$var};
	    $retval = "$retval$o";
	} else {
	    $retval = "$retval\$\{$var\}";
	}

	$option = $end;
    }

    $retval = "$retval$option";

    $retval =~ s/^ //;

    return $retval;
}

sub eval_option {
    my ($option, $i) = @_;

    my $prev = "";

    # Since an option can evaluate to another option,
    # keep iterating until we do not evaluate any more
    # options.
    my $r = 0;
    while ($prev ne $option) {
	# Check for recursive evaluations.
	# 100 deep should be more than enough.
	if ($r++ > 100) {
	    die "Over 100 evaluations accurred with $option\n" .
		"Check for recursive variables\n";
	}
	$prev = $option;
	$option = __eval_option($option, $i);
    }

    return $option;
}

1063
sub _logit {
S
Steven Rostedt 已提交
1064 1065 1066 1067 1068 1069 1070
    if (defined($opt{"LOG_FILE"})) {
	open(OUT, ">> $opt{LOG_FILE}") or die "Can't write to $opt{LOG_FILE}";
	print OUT @_;
	close(OUT);
    }
}

1071 1072 1073 1074 1075 1076 1077 1078
sub logit {
    if (defined($opt{"LOG_FILE"})) {
	_logit @_;
    } else {
	print @_;
    }
}

1079 1080
sub doprint {
    print @_;
1081
    _logit @_;
1082 1083
}

1084
sub run_command;
1085 1086 1087
sub start_monitor;
sub end_monitor;
sub wait_for_monitor;
1088 1089

sub reboot {
1090 1091
    my ($time) = @_;

1092 1093 1094 1095 1096 1097 1098
    if (defined($time)) {
	start_monitor;
	# flush out current monitor
	# May contain the reboot success line
	wait_for_monitor 1;
    }

1099
    # try to reboot normally
1100
    if (run_command $reboot) {
1101 1102 1103 1104 1105
	if (defined($powercycle_after_reboot)) {
	    sleep $powercycle_after_reboot;
	    run_command "$power_cycle";
	}
    } else {
1106
	# nope? power cycle it.
1107
	run_command "$power_cycle";
1108
    }
1109 1110

    if (defined($time)) {
1111
	wait_for_monitor($time, $reboot_success_line);
1112 1113
	end_monitor;
    }
1114 1115
}

1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
sub reboot_to_good {
    my ($time) = @_;

    if (defined($switch_to_good)) {
	run_command $switch_to_good;
    }

    reboot $time;
}

1126 1127 1128
sub do_not_reboot {
    my $i = $iteration;

1129
    return $test_type eq "build" || $no_reboot ||
1130 1131 1132 1133
	($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
	($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
}

1134
sub dodie {
1135
    doprint "CRITICAL FAILURE... ", @_, "\n";
1136

1137 1138 1139 1140
    my $i = $iteration;

    if ($reboot_on_error && !do_not_reboot) {

1141
	doprint "REBOOTING\n";
1142
	reboot_to_good;
1143

1144
    } elsif ($poweroff_on_error && defined($power_off)) {
1145
	doprint "POWERING OFF\n";
1146
	`$power_off`;
1147
    }
1148

1149 1150 1151 1152
    if (defined($opt{"LOG_FILE"})) {
	print " See $opt{LOG_FILE} for more info.\n";
    }

1153
    die @_, "\n";
1154 1155
}

1156 1157 1158 1159 1160
sub open_console {
    my ($fp) = @_;

    my $flags;

1161 1162
    my $pid = open($fp, "$console|") or
	dodie "Can't open console $console";
1163 1164

    $flags = fcntl($fp, F_GETFL, 0) or
1165
	dodie "Can't get flags for the socket: $!";
1166
    $flags = fcntl($fp, F_SETFL, $flags | O_NONBLOCK) or
1167
	dodie "Can't set flags for the socket: $!";
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187

    return $pid;
}

sub close_console {
    my ($fp, $pid) = @_;

    doprint "kill child process $pid\n";
    kill 2, $pid;

    print "closing!\n";
    close($fp);
}

sub start_monitor {
    if ($monitor_cnt++) {
	return;
    }
    $monitor_fp = \*MONFD;
    $monitor_pid = open_console $monitor_fp;
1188 1189 1190 1191

    return;

    open(MONFD, "Stop perl from warning about single use of MONFD");
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
}

sub end_monitor {
    if (--$monitor_cnt) {
	return;
    }
    close_console($monitor_fp, $monitor_pid);
}

sub wait_for_monitor {
1202 1203
    my ($time, $stop) = @_;
    my $full_line = "";
1204
    my $line;
1205
    my $booted = 0;
1206

1207
    doprint "** Wait for monitor to settle down **\n";
1208 1209

    # read the monitor and wait for the system to calm down
1210
    while (!$booted) {
1211
	$line = wait_for_input($monitor_fp, $time);
1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
	last if (!defined($line));
	print "$line";
	$full_line .= $line;

	if (defined($stop) && $full_line =~ /$stop/) {
	    doprint "wait for monitor detected $stop\n";
	    $booted = 1;
	}

	if ($line =~ /\n/) {
	    $full_line = "";
	}
    }
1225
    print "** Monitor flushed **\n";
1226 1227
}

1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
sub save_logs {
	my ($result, $basedir) = @_;
	my @t = localtime;
	my $date = sprintf "%04d%02d%02d%02d%02d%02d",
		1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];

	my $type = $build_type;
	if ($type =~ /useconfig/) {
	    $type = "useconfig";
	}

	my $dir = "$machine-$test_type-$type-$result-$date";

	$dir = "$basedir/$dir";

	if (!-d $dir) {
	    mkpath($dir) or
		die "can't create $dir";
	}

	my %files = (
		"config" => $output_config,
		"buildlog" => $buildlog,
		"dmesg" => $dmesg,
		"testlog" => $testlog,
	);

	while (my ($name, $source) = each(%files)) {
		if (-f "$source") {
			cp "$source", "$dir/$name" or
				die "failed to copy $source";
		}
	}

	doprint "*** Saved info to $dir ***\n";
}

1265 1266
sub fail {

1267
	if ($die_on_failure) {
1268 1269 1270
		dodie @_;
	}

1271
	doprint "FAILED\n";
1272

1273 1274
	my $i = $iteration;

1275
	# no need to reboot for just building.
1276
	if (!do_not_reboot) {
1277
	    doprint "REBOOTING\n";
1278
	    reboot_to_good $sleep_time;
1279
	}
1280

S
Steven Rostedt 已提交
1281 1282 1283 1284 1285 1286
	my $name = "";

	if (defined($test_name)) {
	    $name = " ($test_name)";
	}

1287 1288
	doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
	doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
S
Steven Rostedt 已提交
1289
	doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
1290 1291
	doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
	doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1292

1293 1294 1295
	if (defined($store_failures)) {
	    save_logs "fail", $store_failures;
        }
1296

1297 1298 1299
	return 1;
}

S
Steven Rostedt 已提交
1300 1301
sub run_command {
    my ($command) = @_;
1302 1303 1304 1305
    my $dolog = 0;
    my $dord = 0;
    my $pid;

1306 1307 1308
    $command =~ s/\$SSH_USER/$ssh_user/g;
    $command =~ s/\$MACHINE/$machine/g;

1309 1310 1311
    doprint("$command ... ");

    $pid = open(CMD, "$command 2>&1 |") or
1312
	(fail "unable to exec $command" and return 0);
S
Steven Rostedt 已提交
1313 1314

    if (defined($opt{"LOG_FILE"})) {
1315 1316 1317
	open(LOG, ">>$opt{LOG_FILE}") or
	    dodie "failed to write to log";
	$dolog = 1;
S
Steven Rostedt 已提交
1318 1319 1320
    }

    if (defined($redirect)) {
1321 1322 1323
	open (RD, ">$redirect") or
	    dodie "failed to write to redirect $redirect";
	$dord = 1;
S
Steven Rostedt 已提交
1324 1325
    }

1326 1327 1328 1329
    while (<CMD>) {
	print LOG if ($dolog);
	print RD  if ($dord);
    }
S
Steven Rostedt 已提交
1330

1331
    waitpid($pid, 0);
S
Steven Rostedt 已提交
1332 1333
    my $failed = $?;

1334 1335 1336 1337
    close(CMD);
    close(LOG) if ($dolog);
    close(RD)  if ($dord);

S
Steven Rostedt 已提交
1338 1339 1340 1341 1342 1343
    if ($failed) {
	doprint "FAILED!\n";
    } else {
	doprint "SUCCESS\n";
    }

1344 1345 1346
    return !$failed;
}

1347 1348 1349 1350 1351 1352 1353 1354 1355
sub run_ssh {
    my ($cmd) = @_;
    my $cp_exec = $ssh_exec;

    $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
    return run_command "$cp_exec";
}

sub run_scp {
1356
    my ($src, $dst, $cp_scp) = @_;
1357 1358 1359 1360 1361 1362 1363

    $cp_scp =~ s/\$SRC_FILE/$src/g;
    $cp_scp =~ s/\$DST_FILE/$dst/g;

    return run_command "$cp_scp";
}

1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
sub run_scp_install {
    my ($src, $dst) = @_;

    my $cp_scp = $scp_to_target_install;

    return run_scp($src, $dst, $cp_scp);
}

sub run_scp_mod {
    my ($src, $dst) = @_;

    my $cp_scp = $scp_to_target;

    return run_scp($src, $dst, $cp_scp);
}

1380 1381
sub get_grub_index {

1382 1383 1384
    if ($reboot_type ne "grub") {
	return;
    }
1385
    return if (defined($grub_number));
1386 1387 1388

    doprint "Find grub menu ... ";
    $grub_number = -1;
1389 1390 1391 1392 1393

    my $ssh_grub = $ssh_exec;
    $ssh_grub =~ s,\$SSH_COMMAND,cat /boot/grub/menu.lst,g;

    open(IN, "$ssh_grub |")
1394
	or die "unable to get menu.lst";
1395

1396 1397
    my $found = 0;

1398
    while (<IN>) {
1399
	if (/^\s*title\s+$grub_menu\s*$/) {
1400
	    $grub_number++;
1401
	    $found = 1;
1402 1403 1404 1405 1406 1407 1408
	    last;
	} elsif (/^\s*title\s/) {
	    $grub_number++;
	}
    }
    close(IN);

1409
    die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
1410
	if (!$found);
1411
    doprint "$grub_number\n";
S
Steven Rostedt 已提交
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
}

sub wait_for_input
{
    my ($fp, $time) = @_;
    my $rin;
    my $ready;
    my $line;
    my $ch;

    if (!defined($time)) {
	$time = $timeout;
    }

    $rin = '';
    vec($rin, fileno($fp), 1) = 1;
    $ready = select($rin, undef, undef, $time);

    $line = "";

    # try to read one char at a time
    while (sysread $fp, $ch, 1) {
	$line .= $ch;
	last if ($ch eq "\n");
    }

    if (!length($line)) {
	return undef;
    }

    return $line;
}

1445
sub reboot_to {
1446 1447 1448 1449
    if (defined($switch_to_test)) {
	run_command $switch_to_test;
    }

1450
    if ($reboot_type eq "grub") {
1451
	run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
1452 1453
    } elsif (defined $reboot_script) {
	run_command "$reboot_script";
1454
    }
1455
    reboot;
S
Steven Rostedt 已提交
1456 1457
}

1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
sub get_sha1 {
    my ($commit) = @_;

    doprint "git rev-list --max-count=1 $commit ... ";
    my $sha1 = `git rev-list --max-count=1 $commit`;
    my $ret = $?;

    logit $sha1;

    if ($ret) {
	doprint "FAILED\n";
	dodie "Failed to get git $commit";
    }

    print "SUCCESS\n";

    chomp $sha1;

    return $sha1;
}

1479
sub monitor {
S
Steven Rostedt 已提交
1480 1481
    my $booted = 0;
    my $bug = 0;
1482
    my $bug_ignored = 0;
1483
    my $skip_call_trace = 0;
1484
    my $loops;
S
Steven Rostedt 已提交
1485

1486
    wait_for_monitor 5;
S
Steven Rostedt 已提交
1487 1488 1489 1490

    my $line;
    my $full_line = "";

1491 1492
    open(DMESG, "> $dmesg") or
	die "unable to write to $dmesg";
S
Steven Rostedt 已提交
1493

1494
    reboot_to;
S
Steven Rostedt 已提交
1495

1496 1497
    my $success_start;
    my $failure_start;
1498 1499
    my $monitor_start = time;
    my $done = 0;
1500
    my $version_found = 0;
1501

1502
    while (!$done) {
S
Steven Rostedt 已提交
1503

1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
	if ($bug && defined($stop_after_failure) &&
	    $stop_after_failure >= 0) {
	    my $time = $stop_after_failure - (time - $failure_start);
	    $line = wait_for_input($monitor_fp, $time);
	    if (!defined($line)) {
		doprint "bug timed out after $booted_timeout seconds\n";
		doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
		last;
	    }
	} elsif ($booted) {
1514
	    $line = wait_for_input($monitor_fp, $booted_timeout);
1515 1516 1517 1518 1519
	    if (!defined($line)) {
		my $s = $booted_timeout == 1 ? "" : "s";
		doprint "Successful boot found: break after $booted_timeout second$s\n";
		last;
	    }
1520
	} else {
1521
	    $line = wait_for_input($monitor_fp);
1522 1523 1524 1525 1526
	    if (!defined($line)) {
		my $s = $timeout == 1 ? "" : "s";
		doprint "Timed out after $timeout second$s\n";
		last;
	    }
1527
	}
S
Steven Rostedt 已提交
1528 1529

	doprint $line;
1530
	print DMESG $line;
S
Steven Rostedt 已提交
1531 1532 1533 1534

	# we are not guaranteed to get a full line
	$full_line .= $line;

1535
	if ($full_line =~ /$success_line/) {
S
Steven Rostedt 已提交
1536
	    $booted = 1;
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
	    $success_start = time;
	}

	if ($booted && defined($stop_after_success) &&
	    $stop_after_success >= 0) {
	    my $now = time;
	    if ($now - $success_start >= $stop_after_success) {
		doprint "Test forced to stop after $stop_after_success seconds after success\n";
		last;
	    }
S
Steven Rostedt 已提交
1547 1548
	}

1549 1550 1551 1552
	if ($full_line =~ /\[ backtrace testing \]/) {
	    $skip_call_trace = 1;
	}

S
Steven Rostedt 已提交
1553
	if ($full_line =~ /call trace:/i) {
1554 1555 1556 1557 1558 1559 1560
	    if (!$bug && !$skip_call_trace) {
		if ($ignore_errors) {
		    $bug_ignored = 1;
		} else {
		    $bug = 1;
		    $failure_start = time;
		}
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
	    }
	}

	if ($bug && defined($stop_after_failure) &&
	    $stop_after_failure >= 0) {
	    my $now = time;
	    if ($now - $failure_start >= $stop_after_failure) {
		doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
		last;
	    }
1571 1572 1573 1574 1575 1576 1577
	}

	if ($full_line =~ /\[ end of backtrace testing \]/) {
	    $skip_call_trace = 0;
	}

	if ($full_line =~ /Kernel panic -/) {
1578
	    $failure_start = time;
S
Steven Rostedt 已提交
1579 1580 1581
	    $bug = 1;
	}

1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
	# Detect triple faults by testing the banner
	if ($full_line =~ /\bLinux version (\S+).*\n/) {
	    if ($1 eq $version) {
		$version_found = 1;
	    } elsif ($version_found && $detect_triplefault) {
		# We already booted into the kernel we are testing,
		# but now we booted into another kernel?
		# Consider this a triple fault.
		doprint "Aleady booted in Linux kernel $version, but now\n";
		doprint "we booted into Linux kernel $1.\n";
		doprint "Assuming that this is a triple fault.\n";
		doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
		last;
	    }
	}

S
Steven Rostedt 已提交
1598 1599 1600
	if ($line =~ /\n/) {
	    $full_line = "";
	}
1601 1602 1603

	if ($stop_test_after > 0 && !$booted && !$bug) {
	    if (time - $monitor_start > $stop_test_after) {
1604
		doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
1605 1606 1607
		$done = 1;
	    }
	}
S
Steven Rostedt 已提交
1608 1609
    }

1610
    close(DMESG);
S
Steven Rostedt 已提交
1611

1612
    if ($bug) {
1613
	return 0 if ($in_bisect);
1614
	fail "failed - got a bug report" and return 0;
S
Steven Rostedt 已提交
1615 1616
    }

1617
    if (!$booted) {
1618
	return 0 if ($in_bisect);
1619
	fail "failed - never got a boot prompt." and return 0;
S
Steven Rostedt 已提交
1620
    }
1621

1622 1623 1624 1625
    if ($bug_ignored) {
	doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
    }

1626
    return 1;
S
Steven Rostedt 已提交
1627 1628
}

1629 1630 1631 1632 1633 1634 1635 1636
sub eval_kernel_version {
    my ($option) = @_;

    $option =~ s/\$KERNEL_VERSION/$version/g;

    return $option;
}

1637 1638 1639 1640
sub do_post_install {

    return if (!defined($post_install));

1641
    my $cp_post_install = eval_kernel_version $post_install;
1642 1643 1644 1645
    run_command "$cp_post_install" or
	dodie "Failed to run post install";
}

S
Steven Rostedt 已提交
1646 1647
sub install {

1648 1649
    return if ($no_install);

1650 1651
    my $cp_target = eval_kernel_version $target_image;

1652
    run_scp_install "$outputdir/$build_target", "$cp_target" or
1653
	dodie "failed to copy image";
S
Steven Rostedt 已提交
1654

1655
    my $install_mods = 0;
S
Steven Rostedt 已提交
1656

1657 1658
    # should we process modules?
    $install_mods = 0;
1659
    open(IN, "$output_config") or dodie("Can't read config file");
1660 1661 1662 1663
    while (<IN>) {
	if (/CONFIG_MODULES(=y)?/) {
	    $install_mods = 1 if (defined($1));
	    last;
1664
	}
1665 1666
    }
    close(IN);
1667

1668
    if (!$install_mods) {
1669
	do_post_install;
1670 1671 1672
	doprint "No modules needed\n";
	return;
    }
S
Steven Rostedt 已提交
1673

1674
    run_command "$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or
1675
	dodie "Failed to install modules";
1676

1677
    my $modlib = "/lib/modules/$version";
1678
    my $modtar = "ktest-mods.tar.bz2";
1679

1680
    run_ssh "rm -rf $modlib" or
1681
	dodie "failed to remove old mods: $modlib";
1682

1683
    # would be nice if scp -r did not follow symbolic links
1684
    run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
1685 1686
	dodie "making tarball";

1687
    run_scp_mod "$tmpdir/$modtar", "/tmp" or
1688 1689
	dodie "failed to copy modules";

1690
    unlink "$tmpdir/$modtar";
1691

1692
    run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
1693
	dodie "failed to tar modules";
S
Steven Rostedt 已提交
1694

1695
    run_ssh "rm -f /tmp/$modtar";
1696

1697
    do_post_install;
S
Steven Rostedt 已提交
1698 1699
}

1700 1701 1702 1703 1704 1705 1706 1707 1708
sub get_version {
    # get the release name
    doprint "$make kernelrelease ... ";
    $version = `$make kernelrelease | tail -1`;
    chomp($version);
    doprint "$version\n";
}

sub start_monitor_and_boot {
1709 1710 1711 1712 1713
    # Make sure the stable kernel has finished booting
    start_monitor;
    wait_for_monitor 5;
    end_monitor;

1714 1715 1716 1717 1718 1719 1720 1721
    get_grub_index;
    get_version;
    install;

    start_monitor;
    return monitor;
}

S
Steven Rostedt 已提交
1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741
sub check_buildlog {
    my ($patch) = @_;

    my @files = `git show $patch | diffstat -l`;

    open(IN, "git show $patch |") or
	dodie "failed to show $patch";
    while (<IN>) {
	if (m,^--- a/(.*),) {
	    chomp $1;
	    $files[$#files] = $1;
	}
    }
    close(IN);

    open(IN, $buildlog) or dodie "Can't open $buildlog";
    while (<IN>) {
	if (/^\s*(.*?):.*(warning|error)/) {
	    my $err = $1;
	    foreach my $file (@files) {
1742
		my $fullpath = "$builddir/$file";
S
Steven Rostedt 已提交
1743
		if ($file eq $err || $fullpath eq $err) {
1744
		    fail "$file built with warnings" and return 0;
S
Steven Rostedt 已提交
1745 1746 1747 1748 1749
		}
	    }
	}
    }
    close(IN);
1750 1751

    return 1;
S
Steven Rostedt 已提交
1752 1753
}

1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784
sub apply_min_config {
    my $outconfig = "$output_config.new";

    # Read the config file and remove anything that
    # is in the force_config hash (from minconfig and others)
    # then add the force config back.

    doprint "Applying minimum configurations into $output_config.new\n";

    open (OUT, ">$outconfig") or
	dodie "Can't create $outconfig";

    if (-f $output_config) {
	open (IN, $output_config) or
	    dodie "Failed to open $output_config";
	while (<IN>) {
	    if (/^(# )?(CONFIG_[^\s=]*)/) {
		next if (defined($force_config{$2}));
	    }
	    print OUT;
	}
	close IN;
    }
    foreach my $config (keys %force_config) {
	print OUT "$force_config{$config}\n";
    }
    close OUT;

    run_command "mv $outconfig $output_config";
}

1785 1786
sub make_oldconfig {

1787 1788 1789 1790 1791
    my @force_list = keys %force_config;

    if ($#force_list >= 0) {
	apply_min_config;
    }
1792 1793

    if (!run_command "$make oldnoconfig") {
1794 1795 1796
	# Perhaps oldnoconfig doesn't exist in this version of the kernel
	# try a yes '' | oldconfig
	doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
1797
	run_command "yes '' | $make oldconfig" or
1798 1799 1800 1801
	    dodie "failed make config oldconfig";
    }
}

1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
# read a config file and use this to force new configs.
sub load_force_config {
    my ($config) = @_;

    open(IN, $config) or
	dodie "failed to read $config";
    while (<IN>) {
	chomp;
	if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
	    $force_config{$1} = $_;
	} elsif (/^# (CONFIG_\S*) is not set/) {
	    $force_config{$1} = $_;
	}
    }
    close IN;
}

S
Steven Rostedt 已提交
1819 1820
sub build {
    my ($type) = @_;
1821

1822 1823
    unlink $buildlog;

1824 1825 1826 1827
    # Failed builds should not reboot the target
    my $save_no_reboot = $no_reboot;
    $no_reboot = 1;

1828 1829 1830 1831 1832 1833 1834 1835
    if (defined($pre_build)) {
	my $ret = run_command $pre_build;
	if (!$ret && defined($pre_build_die) &&
	    $pre_build_die) {
	    dodie "failed to pre_build\n";
	}
    }

1836
    if ($type =~ /^useconfig:(.*)/) {
1837
	run_command "cp $1 $output_config" or
1838
	    dodie "could not copy $1 to .config";
1839

1840 1841 1842
	$type = "oldconfig";
    }

1843 1844
    # old config can ask questions
    if ($type eq "oldconfig") {
1845
	$type = "oldnoconfig";
1846 1847

	# allow for empty configs
1848
	run_command "touch $output_config";
1849

1850 1851 1852
	if (!$noclean) {
	    run_command "mv $output_config $outputdir/config_temp" or
		dodie "moving .config";
S
Steven Rostedt 已提交
1853

1854
	    run_command "$make mrproper" or dodie "make mrproper";
S
Steven Rostedt 已提交
1855

1856 1857 1858
	    run_command "mv $outputdir/config_temp $output_config" or
		dodie "moving config_temp";
	}
1859 1860

    } elsif (!$noclean) {
1861
	unlink "$output_config";
1862
	run_command "$make mrproper" or
1863 1864
	    dodie "make mrproper";
    }
S
Steven Rostedt 已提交
1865 1866

    # add something to distinguish this build
1867 1868
    open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
    print OUT "$localversion\n";
S
Steven Rostedt 已提交
1869 1870
    close(OUT);

1871
    if (defined($minconfig)) {
1872
	load_force_config($minconfig);
S
Steven Rostedt 已提交
1873 1874
    }

1875 1876
    if ($type ne "oldnoconfig") {
	run_command "$make $type" or
1877 1878
	    dodie "failed make config";
    }
1879 1880
    # Run old config regardless, to enforce min configurations
    make_oldconfig;
S
Steven Rostedt 已提交
1881

1882
    $redirect = "$buildlog";
1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894
    my $build_ret = run_command "$make $build_options";
    undef $redirect;

    if (defined($post_build)) {
	my $ret = run_command $post_build;
	if (!$ret && defined($post_build_die) &&
	    $post_build_die) {
	    dodie "failed to post_build\n";
	}
    }

    if (!$build_ret) {
1895
	# bisect may need this to pass
1896 1897 1898 1899
	if ($in_bisect) {
	    $no_reboot = $save_no_reboot;
	    return 0;
	}
1900
	fail "failed build" and return 0;
S
Steven Rostedt 已提交
1901
    }
1902

1903 1904
    $no_reboot = $save_no_reboot;

1905
    return 1;
S
Steven Rostedt 已提交
1906 1907
}

1908
sub halt {
1909
    if (!run_ssh "halt" or defined($power_off)) {
1910 1911 1912 1913 1914
	if (defined($poweroff_after_halt)) {
	    sleep $poweroff_after_halt;
	    run_command "$power_off";
	}
    } else {
1915
	# nope? the zap it!
1916
	run_command "$power_off";
1917 1918 1919
    }
}

1920 1921 1922
sub success {
    my ($i) = @_;

1923 1924
    $successes++;

S
Steven Rostedt 已提交
1925 1926 1927 1928 1929 1930
    my $name = "";

    if (defined($test_name)) {
	$name = " ($test_name)";
    }

1931 1932
    doprint "\n\n*******************************************\n";
    doprint     "*******************************************\n";
S
Steven Rostedt 已提交
1933
    doprint     "KTEST RESULT: TEST $i$name SUCCESS!!!!         **\n";
1934 1935 1936
    doprint     "*******************************************\n";
    doprint     "*******************************************\n";

1937 1938 1939 1940
    if (defined($store_successes)) {
        save_logs "success", $store_successes;
    }

1941
    if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
1942
	doprint "Reboot and wait $sleep_time seconds\n";
1943
	reboot_to_good $sleep_time;
1944 1945 1946
    }
}

S
Steven Rostedt 已提交
1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961
sub answer_bisect {
    for (;;) {
	doprint "Pass or fail? [p/f]";
	my $ans = <STDIN>;
	chomp $ans;
	if ($ans eq "p" || $ans eq "P") {
	    return 1;
	} elsif ($ans eq "f" || $ans eq "F") {
	    return 0;
	} else {
	    print "Please answer 'P' or 'F'\n";
	}
    }
}

1962
sub child_run_test {
1963
    my $failed = 0;
1964

1965
    # child should have no power
1966 1967 1968
    $reboot_on_error = 0;
    $poweroff_on_error = 0;
    $die_on_failure = 1;
1969

R
Rabin Vincent 已提交
1970
    $redirect = "$testlog";
1971
    run_command $run_test or $failed = 1;
R
Rabin Vincent 已提交
1972 1973
    undef $redirect;

1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989
    exit $failed;
}

my $child_done;

sub child_finished {
    $child_done = 1;
}

sub do_run_test {
    my $child_pid;
    my $child_exit;
    my $line;
    my $full_line;
    my $bug = 0;

1990
    wait_for_monitor 1;
1991

1992
    doprint "run test $run_test\n";
1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004

    $child_done = 0;

    $SIG{CHLD} = qw(child_finished);

    $child_pid = fork;

    child_run_test if (!$child_pid);

    $full_line = "";

    do {
2005
	$line = wait_for_input($monitor_fp, 1);
2006 2007 2008 2009
	if (defined($line)) {

	    # we are not guaranteed to get a full line
	    $full_line .= $line;
2010
	    doprint $line;
2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026

	    if ($full_line =~ /call trace:/i) {
		$bug = 1;
	    }

	    if ($full_line =~ /Kernel panic -/) {
		$bug = 1;
	    }

	    if ($line =~ /\n/) {
		$full_line = "";
	    }
	}
    } while (!$child_done && !$bug);

    if ($bug) {
2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
	my $failure_start = time;
	my $now;
	do {
	    $line = wait_for_input($monitor_fp, 1);
	    if (defined($line)) {
		doprint $line;
	    }
	    $now = time;
	    if ($now - $failure_start >= $stop_after_failure) {
		last;
	    }
	} while (defined($line));

2040 2041 2042 2043 2044 2045 2046 2047
	doprint "Detected kernel crash!\n";
	# kill the child with extreme prejudice
	kill 9, $child_pid;
    }

    waitpid $child_pid, 0;
    $child_exit = $?;

2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084
    if (!$bug && $in_bisect) {
	if (defined($bisect_ret_good)) {
	    if ($child_exit == $bisect_ret_good) {
		return 1;
	    }
	}
	if (defined($bisect_ret_skip)) {
	    if ($child_exit == $bisect_ret_skip) {
		return -1;
	    }
	}
	if (defined($bisect_ret_abort)) {
	    if ($child_exit == $bisect_ret_abort) {
		fail "test abort" and return -2;
	    }
	}
	if (defined($bisect_ret_bad)) {
	    if ($child_exit == $bisect_ret_skip) {
		return 0;
	    }
	}
	if (defined($bisect_ret_default)) {
	    if ($bisect_ret_default eq "good") {
		return 1;
	    } elsif ($bisect_ret_default eq "bad") {
		return 0;
	    } elsif ($bisect_ret_default eq "skip") {
		return -1;
	    } elsif ($bisect_ret_default eq "abort") {
		return -2;
	    } else {
		fail "unknown default action: $bisect_ret_default"
		    and return -2;
	    }
	}
    }

2085
    if ($bug || $child_exit) {
2086 2087
	return 0 if $in_bisect;
	fail "test failed" and return 0;
2088
    }
2089
    return 1;
2090 2091
}

2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110
sub run_git_bisect {
    my ($command) = @_;

    doprint "$command ... ";

    my $output = `$command 2>&1`;
    my $ret = $?;

    logit $output;

    if ($ret) {
	doprint "FAILED\n";
	dodie "Failed to git bisect";
    }

    doprint "SUCCESS\n";
    if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
	doprint "$1 [$2]\n";
    } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
2111
	$bisect_bad_commit = $1;
2112 2113 2114 2115 2116 2117 2118 2119 2120 2121
	doprint "Found bad commit... $1\n";
	return 0;
    } else {
	# we already logged it, just print it now.
	print $output;
    }

    return 1;
}

S
Steven Rostedt 已提交
2122 2123
sub bisect_reboot {
    doprint "Reboot and sleep $bisect_sleep_time seconds\n";
2124
    reboot_to_good $bisect_sleep_time;
S
Steven Rostedt 已提交
2125 2126 2127
}

# returns 1 on success, 0 on failure, -1 on skip
2128 2129
sub run_bisect_test {
    my ($type, $buildtype) = @_;
2130

2131
    my $failed = 0;
2132 2133 2134 2135
    my $result;
    my $output;
    my $ret;

2136 2137 2138
    $in_bisect = 1;

    build $buildtype or $failed = 1;
2139 2140

    if ($type ne "build") {
S
Steven Rostedt 已提交
2141 2142 2143 2144
	if ($failed && $bisect_skip) {
	    $in_bisect = 0;
	    return -1;
	}
2145
	dodie "Failed on build" if $failed;
2146 2147

	# Now boot the box
2148
	start_monitor_and_boot or $failed = 1;
2149 2150

	if ($type ne "boot") {
S
Steven Rostedt 已提交
2151 2152 2153 2154 2155 2156
	    if ($failed && $bisect_skip) {
		end_monitor;
		bisect_reboot;
		$in_bisect = 0;
		return -1;
	    }
2157
	    dodie "Failed on boot" if $failed;
2158

2159
	    do_run_test or $failed = 1;
2160
	}
2161
	end_monitor;
2162 2163 2164
    }

    if ($failed) {
2165
	$result = 0;
2166
    } else {
2167 2168
	$result = 1;
    }
2169 2170 2171 2172 2173

    # reboot the box to a kernel we can ssh to
    if ($type ne "build") {
	bisect_reboot;
    }
2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185
    $in_bisect = 0;

    return $result;
}

sub run_bisect {
    my ($type) = @_;
    my $buildtype = "oldconfig";

    # We should have a minconfig to use?
    if (defined($minconfig)) {
	$buildtype = "useconfig:$minconfig";
2186 2187
    }

2188 2189
    my $ret = run_bisect_test $type, $buildtype;

S
Steven Rostedt 已提交
2190 2191 2192
    if ($bisect_manual) {
	$ret = answer_bisect;
    }
2193

2194
    # Are we looking for where it worked, not failed?
2195
    if ($reverse_bisect && $ret >= 0) {
2196
	$ret = !$ret;
2197 2198
    }

S
Steven Rostedt 已提交
2199
    if ($ret > 0) {
2200
	return "good";
S
Steven Rostedt 已提交
2201
    } elsif ($ret == 0) {
2202
	return  "bad";
S
Steven Rostedt 已提交
2203 2204 2205
    } elsif ($bisect_skip) {
	doprint "HIT A BAD COMMIT ... SKIPPING\n";
	return "skip";
2206
    }
2207 2208
}

2209 2210 2211 2212 2213 2214 2215
sub update_bisect_replay {
    my $tmp_log = "$tmpdir/ktest_bisect_log";
    run_command "git bisect log > $tmp_log" or
	die "can't create bisect log";
    return $tmp_log;
}

2216 2217 2218 2219 2220
sub bisect {
    my ($i) = @_;

    my $result;

2221 2222 2223
    die "BISECT_GOOD[$i] not defined\n"	if (!defined($bisect_good));
    die "BISECT_BAD[$i] not defined\n"	if (!defined($bisect_bad));
    die "BISECT_TYPE[$i] not defined\n"	if (!defined($bisect_type));
2224

2225 2226 2227 2228 2229 2230
    my $good = $bisect_good;
    my $bad = $bisect_bad;
    my $type = $bisect_type;
    my $start = $bisect_start;
    my $replay = $bisect_replay;
    my $start_files = $bisect_files;
2231 2232 2233 2234 2235 2236

    if (defined($start_files)) {
	$start_files = " -- " . $start_files;
    } else {
	$start_files = "";
    }
2237

2238 2239 2240 2241
    # convert to true sha1's
    $good = get_sha1($good);
    $bad = get_sha1($bad);

2242
    if (defined($bisect_reverse) && $bisect_reverse == 1) {
2243 2244 2245 2246 2247 2248
	doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
	$reverse_bisect = 1;
    } else {
	$reverse_bisect = 0;
    }

2249 2250 2251 2252 2253
    # Can't have a test without having a test to run
    if ($type eq "test" && !defined($run_test)) {
	$type = "boot";
    }

2254 2255 2256
    # Check if a bisect was running
    my $bisect_start_file = "$builddir/.git/BISECT_START";

2257
    my $check = $bisect_check;
2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278
    my $do_check = defined($check) && $check ne "0";

    if ( -f $bisect_start_file ) {
	print "Bisect in progress found\n";
	if ($do_check) {
	    print " If you say yes, then no checks of good or bad will be done\n";
	}
	if (defined($replay)) {
	    print "** BISECT_REPLAY is defined in config file **";
	    print " Ignore config option and perform new git bisect log?\n";
	    if (read_ync " (yes, no, or cancel) ") {
		$replay = update_bisect_replay;
		$do_check = 0;
	    }
	} elsif (read_yn "read git log and continue?") {
	    $replay = update_bisect_replay;
	    $do_check = 0;
	}
    }

    if ($do_check) {
2279 2280

	# get current HEAD
2281
	my $head = get_sha1("HEAD");
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311

	if ($check ne "good") {
	    doprint "TESTING BISECT BAD [$bad]\n";
	    run_command "git checkout $bad" or
		die "Failed to checkout $bad";

	    $result = run_bisect $type;

	    if ($result ne "bad") {
		fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
	    }
	}

	if ($check ne "bad") {
	    doprint "TESTING BISECT GOOD [$good]\n";
	    run_command "git checkout $good" or
		die "Failed to checkout $good";

	    $result = run_bisect $type;

	    if ($result ne "good") {
		fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
	    }
	}

	# checkout where we started
	run_command "git checkout $head" or
	    die "Failed to checkout $head";
    }

2312
    run_command "git bisect start$start_files" or
2313
	dodie "could not start bisect";
2314 2315

    run_command "git bisect good $good" or
2316
	dodie "could not set bisect good to $good";
2317

2318 2319
    run_git_bisect "git bisect bad $bad" or
	dodie "could not set bisect bad to $bad";
2320

2321 2322 2323
    if (defined($replay)) {
	run_command "git bisect replay $replay" or
	    dodie "failed to run replay";
2324 2325
    }

2326 2327 2328 2329 2330 2331
    if (defined($start)) {
	run_command "git checkout $start" or
	    dodie "failed to checkout $start";
    }

    my $test;
2332 2333
    do {
	$result = run_bisect $type;
2334 2335
	$test = run_git_bisect "git bisect $result";
    } while ($test);
2336 2337 2338 2339 2340 2341 2342

    run_command "git bisect log" or
	dodie "could not capture git bisect log";

    run_command "git bisect reset" or
	dodie "could not reset git bisect";

2343
    doprint "Bad commit was [$bisect_bad_commit]\n";
2344

2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355
    success $i;
}

my %config_ignore;
my %config_set;

my %config_list;
my %null_config;

my %dependency;

2356 2357
sub assign_configs {
    my ($hash, $config) = @_;
2358 2359 2360 2361 2362

    open (IN, $config)
	or dodie "Failed to read $config";

    while (<IN>) {
2363
	if (/^((CONFIG\S*)=.*)/) {
2364
	    ${$hash}{$2} = $1;
2365 2366 2367 2368 2369 2370
	}
    }

    close(IN);
}

2371 2372 2373 2374 2375 2376
sub process_config_ignore {
    my ($config) = @_;

    assign_configs \%config_ignore, $config;
}

2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434
sub read_current_config {
    my ($config_ref) = @_;

    %{$config_ref} = ();
    undef %{$config_ref};

    my @key = keys %{$config_ref};
    if ($#key >= 0) {
	print "did not delete!\n";
	exit;
    }
    open (IN, "$output_config");

    while (<IN>) {
	if (/^(CONFIG\S+)=(.*)/) {
	    ${$config_ref}{$1} = $2;
	}
    }
    close(IN);
}

sub get_dependencies {
    my ($config) = @_;

    my $arr = $dependency{$config};
    if (!defined($arr)) {
	return ();
    }

    my @deps = @{$arr};

    foreach my $dep (@{$arr}) {
	print "ADD DEP $dep\n";
	@deps = (@deps, get_dependencies $dep);
    }

    return @deps;
}

sub create_config {
    my @configs = @_;

    open(OUT, ">$output_config") or dodie "Can not write to $output_config";

    foreach my $config (@configs) {
	print OUT "$config_set{$config}\n";
	my @deps = get_dependencies $config;
	foreach my $dep (@deps) {
	    print OUT "$config_set{$dep}\n";
	}
    }

    foreach my $config (keys %config_ignore) {
	print OUT "$config_ignore{$config}\n";
    }
    close(OUT);

#    exit;
2435
    make_oldconfig;
2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476
}

sub compare_configs {
    my (%a, %b) = @_;

    foreach my $item (keys %a) {
	if (!defined($b{$item})) {
	    print "diff $item\n";
	    return 1;
	}
	delete $b{$item};
    }

    my @keys = keys %b;
    if ($#keys) {
	print "diff2 $keys[0]\n";
    }
    return -1 if ($#keys >= 0);

    return 0;
}

sub run_config_bisect_test {
    my ($type) = @_;

    return run_bisect_test $type, "oldconfig";
}

sub process_passed {
    my (%configs) = @_;

    doprint "These configs had no failure: (Enabling them for further compiles)\n";
    # Passed! All these configs are part of a good compile.
    # Add them to the min options.
    foreach my $config (keys %configs) {
	if (defined($config_list{$config})) {
	    doprint " removing $config\n";
	    $config_ignore{$config} = $config_list{$config};
	    delete $config_list{$config};
	}
    }
2477 2478
    doprint "config copied to $outputdir/config_good\n";
    run_command "cp -f $output_config $outputdir/config_good";
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498
}

sub process_failed {
    my ($config) = @_;

    doprint "\n\n***************************************\n";
    doprint "Found bad config: $config\n";
    doprint "***************************************\n\n";
}

sub run_config_bisect {

    my @start_list = keys %config_list;

    if ($#start_list < 0) {
	doprint "No more configs to test!!!\n";
	return -1;
    }

    doprint "***** RUN TEST ***\n";
2499
    my $type = $config_bisect_type;
2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526
    my $ret;
    my %current_config;

    my $count = $#start_list + 1;
    doprint "  $count configs to test\n";

    my $half = int($#start_list / 2);

    do {
	my @tophalf = @start_list[0 .. $half];

	create_config @tophalf;
	read_current_config \%current_config;

	$count = $#tophalf + 1;
	doprint "Testing $count configs\n";
	my $found = 0;
	# make sure we test something
	foreach my $config (@tophalf) {
	    if (defined($current_config{$config})) {
		logit " $config\n";
		$found = 1;
	    }
	}
	if (!$found) {
	    # try the other half
	    doprint "Top half produced no set configs, trying bottom half\n";
2527
	    @tophalf = @start_list[$half + 1 .. $#start_list];
2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547
	    create_config @tophalf;
	    read_current_config \%current_config;
	    foreach my $config (@tophalf) {
		if (defined($current_config{$config})) {
		    logit " $config\n";
		    $found = 1;
		}
	    }
	    if (!$found) {
		doprint "Failed: Can't make new config with current configs\n";
		foreach my $config (@start_list) {
		    doprint "  CONFIG: $config\n";
		}
		return -1;
	    }
	    $count = $#tophalf + 1;
	    doprint "Testing $count configs\n";
	}

	$ret = run_config_bisect_test $type;
S
Steven Rostedt 已提交
2548 2549 2550
	if ($bisect_manual) {
	    $ret = answer_bisect;
	}
2551 2552 2553 2554 2555 2556 2557
	if ($ret) {
	    process_passed %current_config;
	    return 0;
	}

	doprint "This config had a failure.\n";
	doprint "Removing these configs that were not set in this config:\n";
2558 2559
	doprint "config copied to $outputdir/config_bad\n";
	run_command "cp -f $output_config $outputdir/config_bad";
2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578

	# A config exists in this group that was bad.
	foreach my $config (keys %config_list) {
	    if (!defined($current_config{$config})) {
		doprint " removing $config\n";
		delete $config_list{$config};
	    }
	}

	@start_list = @tophalf;

	if ($#start_list == 0) {
	    process_failed $start_list[0];
	    return 1;
	}

	# remove half the configs we are looking at and see if
	# they are good.
	$half = int($#start_list / 2);
2579
    } while ($#start_list > 0);
2580

S
Steven Rostedt 已提交
2581 2582 2583 2584 2585 2586 2587
    # we found a single config, try it again unless we are running manually

    if ($bisect_manual) {
	process_failed $start_list[0];
	return 1;
    }

2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602
    my @tophalf = @start_list[0 .. 0];

    $ret = run_config_bisect_test $type;
    if ($ret) {
	process_passed %current_config;
	return 0;
    }

    process_failed $start_list[0];
    return 1;
}

sub config_bisect {
    my ($i) = @_;

2603
    my $start_config = $config_bisect;
2604 2605 2606

    my $tmpconfig = "$tmpdir/use_config";

2607 2608 2609 2610
    if (defined($config_bisect_good)) {
	process_config_ignore $config_bisect_good;
    }

2611 2612 2613 2614 2615 2616 2617 2618 2619 2620
    # Make the file with the bad config and the min config
    if (defined($minconfig)) {
	# read the min config for things to ignore
	run_command "cp $minconfig $tmpconfig" or
	    dodie "failed to copy $minconfig to $tmpconfig";
    } else {
	unlink $tmpconfig;
    }

    if (-f $tmpconfig) {
2621
	load_force_config($tmpconfig);
2622 2623 2624 2625 2626 2627 2628 2629 2630 2631
	process_config_ignore $tmpconfig;
    }

    # now process the start config
    run_command "cp $start_config $output_config" or
	dodie "failed to copy $start_config to $output_config";

    # read directly what we want to check
    my %config_check;
    open (IN, $output_config)
M
Masanari Iida 已提交
2632
	or dodie "failed to open $output_config";
2633 2634 2635 2636 2637 2638 2639 2640

    while (<IN>) {
	if (/^((CONFIG\S*)=.*)/) {
	    $config_check{$2} = $1;
	}
    }
    close(IN);

2641
    # Now run oldconfig with the minconfig
2642
    make_oldconfig;
2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709

    # check to see what we lost (or gained)
    open (IN, $output_config)
	or dodie "Failed to read $start_config";

    my %removed_configs;
    my %added_configs;

    while (<IN>) {
	if (/^((CONFIG\S*)=.*)/) {
	    # save off all options
	    $config_set{$2} = $1;
	    if (defined($config_check{$2})) {
		if (defined($config_ignore{$2})) {
		    $removed_configs{$2} = $1;
		} else {
		    $config_list{$2} = $1;
		}
	    } elsif (!defined($config_ignore{$2})) {
		$added_configs{$2} = $1;
		$config_list{$2} = $1;
	    }
	}
    }
    close(IN);

    my @confs = keys %removed_configs;
    if ($#confs >= 0) {
	doprint "Configs overridden by default configs and removed from check:\n";
	foreach my $config (@confs) {
	    doprint " $config\n";
	}
    }
    @confs = keys %added_configs;
    if ($#confs >= 0) {
	doprint "Configs appearing in make oldconfig and added:\n";
	foreach my $config (@confs) {
	    doprint " $config\n";
	}
    }

    my %config_test;
    my $once = 0;

    # Sometimes kconfig does weird things. We must make sure
    # that the config we autocreate has everything we need
    # to test, otherwise we may miss testing configs, or
    # may not be able to create a new config.
    # Here we create a config with everything set.
    create_config (keys %config_list);
    read_current_config \%config_test;
    foreach my $config (keys %config_list) {
	if (!defined($config_test{$config})) {
	    if (!$once) {
		$once = 1;
		doprint "Configs not produced by kconfig (will not be checked):\n";
	    }
	    doprint "  $config\n";
	    delete $config_list{$config};
	}
    }
    my $ret;
    do {
	$ret = run_config_bisect;
    } while (!$ret);

    return $ret if ($ret < 0);
2710 2711 2712 2713

    success $i;
}

2714 2715
sub patchcheck_reboot {
    doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
2716
    reboot_to_good $patchcheck_sleep_time;
2717 2718
}

S
Steven Rostedt 已提交
2719 2720 2721 2722
sub patchcheck {
    my ($i) = @_;

    die "PATCHCHECK_START[$i] not defined\n"
2723
	if (!defined($patchcheck_start));
S
Steven Rostedt 已提交
2724
    die "PATCHCHECK_TYPE[$i] not defined\n"
2725
	if (!defined($patchcheck_type));
S
Steven Rostedt 已提交
2726

2727
    my $start = $patchcheck_start;
S
Steven Rostedt 已提交
2728 2729

    my $end = "HEAD";
2730 2731
    if (defined($patchcheck_end)) {
	$end = $patchcheck_end;
S
Steven Rostedt 已提交
2732 2733
    }

2734 2735 2736 2737
    # Get the true sha1's since we can use things like HEAD~3
    $start = get_sha1($start);
    $end = get_sha1($end);

2738
    my $type = $patchcheck_type;
S
Steven Rostedt 已提交
2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757

    # Can't have a test without having a test to run
    if ($type eq "test" && !defined($run_test)) {
	$type = "boot";
    }

    open (IN, "git log --pretty=oneline $end|") or
	dodie "could not get git list";

    my @list;

    while (<IN>) {
	chomp;
	$list[$#list+1] = $_;
	last if (/^$start/);
    }
    close(IN);

    if ($list[$#list] !~ /^$start/) {
2758
	fail "SHA1 $start not found";
S
Steven Rostedt 已提交
2759 2760 2761 2762 2763 2764
    }

    # go backwards in the list
    @list = reverse @list;

    my $save_clean = $noclean;
2765 2766 2767 2768 2769 2770 2771
    my %ignored_warnings;

    if (defined($ignore_warnings)) {
	foreach my $sha1 (split /\s+/, $ignore_warnings) {
	    $ignored_warnings{$sha1} = 1;
	}
    }
S
Steven Rostedt 已提交
2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791

    $in_patchcheck = 1;
    foreach my $item (@list) {
	my $sha1 = $item;
	$sha1 =~ s/^([[:xdigit:]]+).*/$1/;

	doprint "\nProcessing commit $item\n\n";

	run_command "git checkout $sha1" or
	    die "Failed to checkout $sha1";

	# only clean on the first and last patch
	if ($item eq $list[0] ||
	    $item eq $list[$#list]) {
	    $noclean = $save_clean;
	} else {
	    $noclean = 1;
	}

	if (defined($minconfig)) {
2792
	    build "useconfig:$minconfig" or return 0;
S
Steven Rostedt 已提交
2793 2794
	} else {
	    # ?? no config to use?
2795
	    build "oldconfig" or return 0;
S
Steven Rostedt 已提交
2796 2797
	}

2798 2799 2800 2801

	if (!defined($ignored_warnings{$sha1})) {
	    check_buildlog $sha1 or return 0;
	}
S
Steven Rostedt 已提交
2802 2803 2804

	next if ($type eq "build");

2805 2806
	my $failed = 0;

2807
	start_monitor_and_boot or $failed = 1;
2808 2809 2810 2811 2812 2813 2814

	if (!$failed && $type ne "boot"){
	    do_run_test or $failed = 1;
	}
	end_monitor;
	return 0 if ($failed);

2815 2816
	patchcheck_reboot;

S
Steven Rostedt 已提交
2817 2818 2819
    }
    $in_patchcheck = 0;
    success $i;
2820 2821

    return 1;
S
Steven Rostedt 已提交
2822 2823
}

2824
my %depends;
2825
my %depcount;
2826 2827 2828 2829 2830 2831
my $iflevel = 0;
my @ifdeps;

# prevent recursion
my %read_kconfigs;

2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849
sub add_dep {
    # $config depends on $dep
    my ($config, $dep) = @_;

    if (defined($depends{$config})) {
	$depends{$config} .= " " . $dep;
    } else {
	$depends{$config} = $dep;
    }

    # record the number of configs depending on $dep
    if (defined $depcount{$dep}) {
	$depcount{$dep}++;
    } else {
	$depcount{$dep} = 1;
    } 
}

2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895
# taken from streamline_config.pl
sub read_kconfig {
    my ($kconfig) = @_;

    my $state = "NONE";
    my $config;
    my @kconfigs;

    my $cont = 0;
    my $line;


    if (! -f $kconfig) {
	doprint "file $kconfig does not exist, skipping\n";
	return;
    }

    open(KIN, "$kconfig")
	or die "Can't open $kconfig";
    while (<KIN>) {
	chomp;

	# Make sure that lines ending with \ continue
	if ($cont) {
	    $_ = $line . " " . $_;
	}

	if (s/\\$//) {
	    $cont = 1;
	    $line = $_;
	    next;
	}

	$cont = 0;

	# collect any Kconfig sources
	if (/^source\s*"(.*)"/) {
	    $kconfigs[$#kconfigs+1] = $1;
	}

	# configs found
	if (/^\s*(menu)?config\s+(\S+)\s*$/) {
	    $state = "NEW";
	    $config = $2;

	    for (my $i = 0; $i < $iflevel; $i++) {
2896
		add_dep $config, $ifdeps[$i];
2897 2898 2899 2900 2901
	    }

	# collect the depends for the config
	} elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {

2902
	    add_dep $config, $1;
2903 2904

	# Get the configs that select this config
2905 2906 2907 2908
	} elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {

	    # selected by depends on config
	    add_dep $1, $config;
2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984

	# Check for if statements
	} elsif (/^if\s+(.*\S)\s*$/) {
	    my $deps = $1;
	    # remove beginning and ending non text
	    $deps =~ s/^[^a-zA-Z0-9_]*//;
	    $deps =~ s/[^a-zA-Z0-9_]*$//;

	    my @deps = split /[^a-zA-Z0-9_]+/, $deps;

	    $ifdeps[$iflevel++] = join ':', @deps;

	} elsif (/^endif/) {

	    $iflevel-- if ($iflevel);

	# stop on "help"
	} elsif (/^\s*help\s*$/) {
	    $state = "NONE";
	}
    }
    close(KIN);

    # read in any configs that were found.
    foreach $kconfig (@kconfigs) {
	if (!defined($read_kconfigs{$kconfig})) {
	    $read_kconfigs{$kconfig} = 1;
	    read_kconfig("$builddir/$kconfig");
	}
    }
}

sub read_depends {
    # find out which arch this is by the kconfig file
    open (IN, $output_config)
	or dodie "Failed to read $output_config";
    my $arch;
    while (<IN>) {
	if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
	    $arch = $1;
	    last;
	}
    }
    close IN;

    if (!defined($arch)) {
	doprint "Could not find arch from config file\n";
	doprint "no dependencies used\n";
	return;
    }

    # arch is really the subarch, we need to know
    # what directory to look at.
    if ($arch eq "i386" || $arch eq "x86_64") {
	$arch = "x86";
    } elsif ($arch =~ /^tile/) {
	$arch = "tile";
    }

    my $kconfig = "$builddir/arch/$arch/Kconfig";

    if (! -f $kconfig && $arch =~ /\d$/) {
	my $orig = $arch;
 	# some subarchs have numbers, truncate them
	$arch =~ s/\d*$//;
	$kconfig = "$builddir/arch/$arch/Kconfig";
	if (! -f $kconfig) {
	    doprint "No idea what arch dir $orig is for\n";
	    doprint "no dependencies used\n";
	    return;
	}
    }

    read_kconfig($kconfig);
}

2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019
sub read_config_list {
    my ($config) = @_;

    open (IN, $config)
	or dodie "Failed to read $config";

    while (<IN>) {
	if (/^((CONFIG\S*)=.*)/) {
	    if (!defined($config_ignore{$2})) {
		$config_list{$2} = $1;
	    }
	}
    }

    close(IN);
}

sub read_output_config {
    my ($config) = @_;

    assign_configs \%config_ignore, $config;
}

sub make_new_config {
    my @configs = @_;

    open (OUT, ">$output_config")
	or dodie "Failed to write $output_config";

    foreach my $config (@configs) {
	print OUT "$config\n";
    }
    close OUT;
}

3020 3021 3022 3023 3024 3025 3026 3027
sub chomp_config {
    my ($config) = @_;

    $config =~ s/CONFIG_//;

    return $config;
}

3028 3029 3030
sub get_depends {
    my ($dep) = @_;

3031
    my $kconfig = chomp_config $dep;
3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060

    $dep = $depends{"$kconfig"};

    # the dep string we have saves the dependencies as they
    # were found, including expressions like ! && ||. We
    # want to split this out into just an array of configs.

    my $valid = "A-Za-z_0-9";

    my @configs;

    while ($dep =~ /[$valid]/) {

	if ($dep =~ /^[^$valid]*([$valid]+)/) {
	    my $conf = "CONFIG_" . $1;

	    $configs[$#configs + 1] = $conf;

	    $dep =~ s/^[^$valid]*[$valid]+//;
	} else {
	    die "this should never happen";
	}
    }

    return @configs;
}

my %min_configs;
my %keep_configs;
3061
my %save_configs;
3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080
my %processed_configs;
my %nochange_config;

sub test_this_config {
    my ($config) = @_;

    my $found;

    # if we already processed this config, skip it
    if (defined($processed_configs{$config})) {
	return undef;
    }
    $processed_configs{$config} = 1;

    # if this config failed during this round, skip it
    if (defined($nochange_config{$config})) {
	return undef;
    }

3081
    my $kconfig = chomp_config $config;
3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115

    # Test dependencies first
    if (defined($depends{"$kconfig"})) {
	my @parents = get_depends $config;
	foreach my $parent (@parents) {
	    # if the parent is in the min config, check it first
	    next if (!defined($min_configs{$parent}));
	    $found = test_this_config($parent);
	    if (defined($found)) {
		return $found;
	    }
	}
    }

    # Remove this config from the list of configs
    # do a make oldnoconfig and then read the resulting
    # .config to make sure it is missing the config that
    # we had before
    my %configs = %min_configs;
    delete $configs{$config};
    make_new_config ((values %configs), (values %keep_configs));
    make_oldconfig;
    undef %configs;
    assign_configs \%configs, $output_config;

    return $config if (!defined($configs{$config}));

    doprint "disabling config $config did not change .config\n";

    $nochange_config{$config} = 1;

    return undef;
}

3116 3117 3118 3119 3120 3121
sub make_min_config {
    my ($i) = @_;

    if (!defined($output_minconfig)) {
	fail "OUTPUT_MIN_CONFIG not defined" and return;
    }
3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132

    # If output_minconfig exists, and the start_minconfig
    # came from min_config, than ask if we should use
    # that instead.
    if (-f $output_minconfig && !$start_minconfig_defined) {
	print "$output_minconfig exists\n";
	if (read_yn " Use it as minconfig?") {
	    $start_minconfig = $output_minconfig;
	}
    }

3133 3134 3135 3136
    if (!defined($start_minconfig)) {
	fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
    }

3137 3138
    my $temp_config = "$tmpdir/temp_config";

3139 3140 3141 3142 3143 3144 3145 3146 3147
    # First things first. We build an allnoconfig to find
    # out what the defaults are that we can't touch.
    # Some are selections, but we really can't handle selections.

    my $save_minconfig = $minconfig;
    undef $minconfig;

    run_command "$make allnoconfig" or return 0;

3148 3149
    read_depends;

3150
    process_config_ignore $output_config;
3151

3152
    undef %save_configs;
3153
    undef %min_configs;
3154 3155 3156 3157

    if (defined($ignore_config)) {
	# make sure the file exists
	`touch $ignore_config`;
3158
	assign_configs \%save_configs, $ignore_config;
3159 3160
    }

3161 3162
    %keep_configs = %save_configs;

3163 3164 3165 3166 3167 3168 3169 3170
    doprint "Load initial configs from $start_minconfig\n";

    # Look at the current min configs, and save off all the
    # ones that were set via the allnoconfig
    assign_configs \%min_configs, $start_minconfig;

    my @config_keys = keys %min_configs;

3171 3172 3173 3174 3175 3176 3177 3178
    # All configs need a depcount
    foreach my $config (@config_keys) {
	my $kconfig = chomp_config $config;
	if (!defined $depcount{$kconfig}) {
		$depcount{$kconfig} = 0;
	}
    }

3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206
    # Remove anything that was set by the make allnoconfig
    # we shouldn't need them as they get set for us anyway.
    foreach my $config (@config_keys) {
	# Remove anything in the ignore_config
	if (defined($keep_configs{$config})) {
	    my $file = $ignore_config;
	    $file =~ s,.*/(.*?)$,$1,;
	    doprint "$config set by $file ... ignored\n";
	    delete $min_configs{$config};
	    next;
	}
	# But make sure the settings are the same. If a min config
	# sets a selection, we do not want to get rid of it if
	# it is not the same as what we have. Just move it into
	# the keep configs.
	if (defined($config_ignore{$config})) {
	    if ($config_ignore{$config} ne $min_configs{$config}) {
		doprint "$config is in allnoconfig as '$config_ignore{$config}'";
		doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
		$keep_configs{$config} = $min_configs{$config};
	    } else {
		doprint "$config set by allnoconfig ... ignored\n";
	    }
	    delete $min_configs{$config};
	}
    }

    my $done = 0;
3207
    my $take_two = 0;
3208 3209 3210 3211 3212 3213 3214 3215 3216 3217

    while (!$done) {

	my $config;
	my $found;

	# Now disable each config one by one and do a make oldconfig
	# till we find a config that changes our list.

	my @test_configs = keys %min_configs;
3218 3219 3220 3221 3222 3223

	# Sort keys by who is most dependent on
	@test_configs = sort  { $depcount{chomp_config($b)} <=> $depcount{chomp_config($a)} }
			  @test_configs ;

	# Put configs that did not modify the config at the end.
3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241
	my $reset = 1;
	for (my $i = 0; $i < $#test_configs; $i++) {
	    if (!defined($nochange_config{$test_configs[0]})) {
		$reset = 0;
		last;
	    }
	    # This config didn't change the .config last time.
	    # Place it at the end
	    my $config = shift @test_configs;
	    push @test_configs, $config;
	}

	# if every test config has failed to modify the .config file
	# in the past, then reset and start over.
	if ($reset) {
	    undef %nochange_config;
	}

3242 3243
	undef %processed_configs;

3244 3245
	foreach my $config (@test_configs) {

3246
	    $found = test_this_config $config;
3247

3248
	    last if (defined($found));
3249 3250 3251 3252 3253

	    # oh well, try another config
	}

	if (!defined($found)) {
3254 3255 3256 3257 3258 3259 3260
	    # we could have failed due to the nochange_config hash
	    # reset and try again
	    if (!$take_two) {
		undef %nochange_config;
		$take_two = 1;
		next;
	    }
3261 3262 3263 3264
	    doprint "No more configs found that we can disable\n";
	    $done = 1;
	    last;
	}
3265
	$take_two = 0;
3266 3267 3268 3269 3270 3271 3272 3273 3274

	$config = $found;

	doprint "Test with $config disabled\n";

	# set in_bisect to keep build and monitor from dieing
	$in_bisect = 1;

	my $failed = 0;
3275 3276 3277 3278 3279
	build "oldconfig" or $failed = 1;
	if (!$failed) {
		start_monitor_and_boot or $failed = 1;
		end_monitor;
	}
3280 3281 3282 3283

	$in_bisect = 0;

	if ($failed) {
3284
	    doprint "$min_configs{$config} is needed to boot the box... keeping\n";
3285 3286
	    # this config is needed, add it to the ignore list.
	    $keep_configs{$config} = $min_configs{$config};
3287
	    $save_configs{$config} = $min_configs{$config};
3288
	    delete $min_configs{$config};
3289 3290 3291 3292 3293

	    # update new ignore configs
	    if (defined($ignore_config)) {
		open (OUT, ">$temp_config")
		    or die "Can't write to $temp_config";
3294 3295
		foreach my $config (keys %save_configs) {
		    print OUT "$save_configs{$config}\n";
3296 3297 3298 3299 3300 3301
		}
		close OUT;
		run_command "mv $temp_config $ignore_config" or
		    dodie "failed to copy update to $ignore_config";
	    }

3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319
	} else {
	    # We booted without this config, remove it from the minconfigs.
	    doprint "$config is not needed, disabling\n";

	    delete $min_configs{$config};

	    # Also disable anything that is not enabled in this config
	    my %configs;
	    assign_configs \%configs, $output_config;
	    my @config_keys = keys %min_configs;
	    foreach my $config (@config_keys) {
		if (!defined($configs{$config})) {
		    doprint "$config is not set, disabling\n";
		    delete $min_configs{$config};
		}
	    }

	    # Save off all the current mandidory configs
3320 3321
	    open (OUT, ">$temp_config")
		or die "Can't write to $temp_config";
3322 3323 3324 3325 3326 3327 3328
	    foreach my $config (keys %keep_configs) {
		print OUT "$keep_configs{$config}\n";
	    }
	    foreach my $config (keys %min_configs) {
		print OUT "$min_configs{$config}\n";
	    }
	    close OUT;
3329 3330 3331

	    run_command "mv $temp_config $output_minconfig" or
		dodie "failed to copy update to $output_minconfig";
3332 3333 3334
	}

	doprint "Reboot and wait $sleep_time seconds\n";
3335
	reboot_to_good $sleep_time;
3336 3337 3338 3339 3340 3341
    }

    success $i;
    return 1;
}

3342 3343 3344 3345 3346 3347
$#ARGV < 1 or die "ktest.pl version: $VERSION\n   usage: ktest.pl config-file\n";

if ($#ARGV == 0) {
    $ktest_config = $ARGV[0];
    if (! -f $ktest_config) {
	print "$ktest_config does not exist.\n";
3348
	if (!read_yn "Create it?") {
3349 3350 3351 3352 3353 3354 3355 3356
	    exit 0;
	}
    }
} else {
    $ktest_config = "ktest.conf";
}

if (! -f $ktest_config) {
3357
    $newconfig = 1;
3358
    get_test_case;
3359 3360 3361 3362
    open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
    print OUT << "EOF"
# Generated by ktest.pl
#
3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373

# PWD is a ktest.pl variable that will result in the process working
# directory that ktest.pl is executed in.

# THIS_DIR is automatically assigned the PWD of the path that generated
# the config file. It is best to use this variable when assigning other
# directory paths within this directory. This allows you to easily
# move the test cases to other locations or to other machines.
#
THIS_DIR := $variable{"PWD"}

3374 3375 3376
# Define each test with TEST_START
# The config options below it will override the defaults
TEST_START
3377
TEST_TYPE = $default{"TEST_TYPE"}
3378 3379 3380 3381 3382 3383 3384 3385

DEFAULTS
EOF
;
    close(OUT);
}
read_config $ktest_config;

3386 3387 3388 3389
if (defined($opt{"LOG_FILE"})) {
    $opt{"LOG_FILE"} = eval_option($opt{"LOG_FILE"}, -1);
}

3390 3391 3392 3393 3394 3395 3396
# Append any configs entered in manually to the config file.
my @new_configs = keys %entered_configs;
if ($#new_configs >= 0) {
    print "\nAppending entered in configs to $ktest_config\n";
    open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
    foreach my $config (@new_configs) {
	print OUT "$config = $entered_configs{$config}\n";
3397
	$opt{$config} = process_variables($entered_configs{$config});
3398 3399
    }
}
S
Steven Rostedt 已提交
3400

3401 3402 3403
if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
    unlink $opt{"LOG_FILE"};
}
S
Steven Rostedt 已提交
3404

3405 3406
doprint "\n\nSTARTING AUTOMATED TESTS\n\n";

3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429
for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {

    if (!$i) {
	doprint "DEFAULT OPTIONS:\n";
    } else {
	doprint "\nTEST $i OPTIONS";
	if (defined($repeat_tests{$i})) {
	    $repeat = $repeat_tests{$i};
	    doprint " ITERATE $repeat";
	}
	doprint "\n";
    }

    foreach my $option (sort keys %opt) {

	if ($option =~ /\[(\d+)\]$/) {
	    next if ($i != $1);
	} else {
	    next if ($i);
	}

	doprint "$option = $opt{$option}\n";
    }
3430
}
S
Steven Rostedt 已提交
3431

3432
sub __set_test_option {
3433
    my ($name, $i) = @_;
S
Steven Rostedt 已提交
3434

3435
    my $option = "$name\[$i\]";
3436

3437 3438
    if (defined($opt{$option})) {
	return $opt{$option};
3439 3440
    }

3441 3442 3443 3444 3445 3446 3447 3448 3449 3450
    foreach my $test (keys %repeat_tests) {
	if ($i >= $test &&
	    $i < $test + $repeat_tests{$test}) {
	    $option = "$name\[$test\]";
	    if (defined($opt{$option})) {
		return $opt{$option};
	    }
	}
    }

3451 3452
    if (defined($opt{$name})) {
	return $opt{$name};
S
Steven Rostedt 已提交
3453 3454
    }

3455 3456 3457
    return undef;
}

3458 3459 3460 3461 3462 3463
sub set_test_option {
    my ($name, $i) = @_;

    my $option = __set_test_option($name, $i);
    return $option if (!defined($option));

3464
    return eval_option($option, $i);
3465 3466
}

3467
# First we need to do is the builds
3468 3469
for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {

3470 3471 3472
    # Do not reboot on failing test options
    $no_reboot = 1;

3473 3474
    $iteration = $i;

3475 3476
    my $makecmd = set_test_option("MAKE_CMD", $i);

3477 3478 3479 3480
    # Load all the options into their mapped variable names
    foreach my $opt (keys %option_map) {
	${$option_map{$opt}} = set_test_option($opt, $i);
    }
3481

3482 3483
    $start_minconfig_defined = 1;

3484
    if (!defined($start_minconfig)) {
3485
	$start_minconfig_defined = 0;
3486 3487 3488
	$start_minconfig = $minconfig;
    }

3489 3490
    chdir $builddir || die "can't change directory to $builddir";

3491 3492 3493 3494 3495
    foreach my $dir ($tmpdir, $outputdir) {
	if (!-d $dir) {
	    mkpath($dir) or
		die "can't create $dir";
	}
3496
    }
S
Steven Rostedt 已提交
3497

3498 3499 3500
    $ENV{"SSH_USER"} = $ssh_user;
    $ENV{"MACHINE"} = $machine;

3501
    $buildlog = "$tmpdir/buildlog-$machine";
R
Rabin Vincent 已提交
3502
    $testlog = "$tmpdir/testlog-$machine";
3503 3504
    $dmesg = "$tmpdir/dmesg-$machine";
    $make = "$makecmd O=$outputdir";
3505
    $output_config = "$outputdir/.config";
3506

3507 3508 3509 3510 3511
    if (!$buildonly) {
	$target = "$ssh_user\@$machine";
	if ($reboot_type eq "grub") {
	    dodie "GRUB_MENU not defined" if (!defined($grub_menu));
	}
3512 3513 3514 3515
    }

    my $run_type = $build_type;
    if ($test_type eq "patchcheck") {
3516
	$run_type = $patchcheck_type;
3517
    } elsif ($test_type eq "bisect") {
3518
	$run_type = $bisect_type;
3519
    } elsif ($test_type eq "config_bisect") {
3520
	$run_type = $config_bisect_type;
3521 3522
    }

3523 3524 3525 3526
    if ($test_type eq "make_min_config") {
	$run_type = "";
    }

3527 3528 3529 3530
    # mistake in config file?
    if (!defined($run_type)) {
	$run_type = "ERROR";
    }
3531

3532 3533 3534
    my $installme = "";
    $installme = " no_install" if ($no_install);

S
Steven Rostedt 已提交
3535
    doprint "\n\n";
3536
    doprint "RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type$installme\n\n";
3537 3538 3539

    unlink $dmesg;
    unlink $buildlog;
R
Rabin Vincent 已提交
3540
    unlink $testlog;
S
Steven Rostedt 已提交
3541

3542 3543 3544 3545 3546 3547
    if (defined($addconfig)) {
	my $min = $minconfig;
	if (!defined($minconfig)) {
	    $min = "";
	}
	run_command "cat $addconfig $min > $tmpdir/add_config" or
3548
	    dodie "Failed to create temp config";
3549
	$minconfig = "$tmpdir/add_config";
3550 3551
    }

S
Steven Rostedt 已提交
3552 3553 3554 3555 3556
    if (defined($checkout)) {
	run_command "git checkout $checkout" or
	    die "failed to checkout $checkout";
    }

3557 3558 3559 3560
    # A test may opt to not reboot the box
    if ($reboot_on_success) {
	$no_reboot = 0;
    }
3561

3562
    if ($test_type eq "bisect") {
3563 3564
	bisect $i;
	next;
3565 3566 3567
    } elsif ($test_type eq "config_bisect") {
	config_bisect $i;
	next;
3568
    } elsif ($test_type eq "patchcheck") {
S
Steven Rostedt 已提交
3569 3570
	patchcheck $i;
	next;
3571 3572 3573
    } elsif ($test_type eq "make_min_config") {
	make_min_config $i;
	next;
S
Steven Rostedt 已提交
3574 3575
    }

3576 3577
    if ($build_type ne "nobuild") {
	build $build_type or next;
S
Steven Rostedt 已提交
3578 3579
    }

3580 3581 3582 3583 3584 3585 3586
    if ($test_type eq "install") {
	get_version;
	install;
	success $i;
	next;
    }

3587 3588
    if ($test_type ne "build") {
	my $failed = 0;
3589
	start_monitor_and_boot or $failed = 1;
3590 3591 3592 3593 3594 3595

	if (!$failed && $test_type ne "boot" && defined($run_test)) {
	    do_run_test or $failed = 1;
	}
	end_monitor;
	next if ($failed);
3596 3597
    }

3598
    success $i;
S
Steven Rostedt 已提交
3599 3600
}

3601
if ($opt{"POWEROFF_ON_SUCCESS"}) {
3602
    halt;
3603
} elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot) {
3604
    reboot_to_good;
3605 3606 3607
} elsif (defined($switch_to_good)) {
    # still need to get to the good kernel
    run_command $switch_to_good;
3608
}
3609

3610

3611 3612
doprint "\n    $successes of $opt{NUM_TESTS} tests were successful\n\n";

S
Steven Rostedt 已提交
3613
exit 0;