#!/usr/bin/perl -w
# SPDX-License-Identifier: GPL-2.0-only
#
# Copyright 2010 - Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
#
use strict;
use IPC::Open2;
use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
use File::Path qw(mkpath);
use File::
Copy qw(
cp);
use FileHandle;
use FindBin;
use IO::Handle;
my $VERSION =
"0.2";
$| = 1;
my %opt;
my %repeat_tests;
my %repeats;
my %evals;
my @command_vars;
my %command_tmp_vars;
#default opts
my %default = (
"MAILER" =>
"sendmail",
# default mailer
"EMAIL_ON_ERROR" => 1,
"EMAIL_WHEN_FINISHED" => 1,
"EMAIL_WHEN_CANCELED" => 0,
"EMAIL_WHEN_STARTED" => 0,
"NUM_TESTS" => 1,
"TEST_TYPE" =>
"build",
"BUILD_TYPE" =>
"oldconfig",
"MAKE_CMD" =>
"make",
"CLOSE_CONSOLE_SIGNAL" =>
"INT",
"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,
"BISECT_TRIES" => 1,
"MIN_CONFIG_TYPE" =>
"boot",
"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",
"SCP_TO_TARGET_INSTALL" =>
"\${SCP_TO_TARGET}",
"REBOOT" =>
"ssh \$SSH_USER\@\$MACHINE reboot",
"REBOOT_RETURN_CODE" => 255,
"STOP_AFTER_SUCCESS" => 10,
"STOP_AFTER_FAILURE" => 60,
"STOP_TEST_AFTER" => 600,
"MAX_MONITOR_WAIT" => 1800,
"GRUB_REBOOT" =>
"grub2-reboot",
"GRUB_BLS_GET" =>
"grubby --info=ALL",
"SYSLINUX" =>
"extlinux",
"SYSLINUX_PATH" =>
"/boot/extlinux",
"CONNECT_TIMEOUT" => 25,
# required, and we will ask users if they don't have them but we keep the default
# value something that is common.
"REBOOT_TYPE" =>
"grub",
"LOCALVERSION" =>
"-test",
"SSH_USER" =>
"root",
"BUILD_TARGET" =>
"arch/x86/boot/bzImage",
"TARGET_IMAGE" =>
"/boot/vmlinuz-test",
"LOG_FILE" => undef,
"IGNORE_UNUSED" => 0,
);
my $test_log_start = 0;
my $ktest_config =
"ktest.conf";
my $version;
my $have_version = 0;
my $machine;
my $last_machine;
my $ssh_user;
my $tmpdir;
my $builddir;
my $outputdir;
my $output_config;
my $test_type;
my $build_type;
my $build_options;
my $final_post_ktest;
my $pre_ktest;
my $post_ktest;
my $pre_test;
my $pre_test_die;
my $post_test;
my $pre_build;
my $post_build;
my $pre_build_die;
my $post_build_die;
my $reboot_type;
my $reboot_script;
my $power_cycle;
my $reboot;
my $reboot_return_code;
my $reboot_on_error;
my $switch_to_good;
my $switch_to_test;
my $poweroff_on_error;
my $reboot_on_success;
my $die_on_failure;
my $powercycle_after_reboot;
my $poweroff_after_halt;
my $max_monitor_wait;
my $ssh_exec;
my $scp_to_target;
my $scp_to_target_install;
my $power_off;
my $grub_menu;
my $last_grub_menu;
my $grub_file;
my $grub_number;
my $grub_reboot;
my $grub_bls_get;
my $syslinux;
my $syslinux_path;
my $syslinux_label;
my $target;
my $
make;
my $pre_install;
my $post_install;
my $no_install;
my $noclean;
my $minconfig;
my $start_minconfig;
my $start_minconfig_defined;
my $output_minconfig;
my $minconfig_type;
my $use_output_minconfig;
my $warnings_file;
my $ignore_config;
my $ignore_errors;
my $addconfig;
my $in_bisect = 0;
my $bisect_bad_commit =
"";
my $reverse_bisect;
my $bisect_manual;
my $bisect_skip;
my $bisect_tries;
my $config_bisect_good;
my $bisect_ret_good;
my $bisect_ret_bad;
my $bisect_ret_skip;
my $bisect_ret_abort;
my $bisect_ret_default;
my $in_patchcheck = 0;
my $run_test;
my $buildlog;
my $testlog;
my $dmesg;
my $monitor_fp;
my $monitor_pid;
my $monitor_cnt = 0;
my $sleep_time;
my $bisect_sleep_time;
my $patchcheck_sleep_time;
my $ignore_warnings;
my $store_failures;
my $store_successes;
my $test_name;
my $timeout;
my $run_timeout;
my $connect_timeout;
my $config_bisect_exec;
my $booted_timeout;
my $detect_triplefault;
my $console;
my $close_console_signal;
my $reboot_success_line;
my $success_line;
my $stop_after_success;
my $stop_after_failure;
my $stop_test_after;
my $build_target;
my $target_image;
my $checkout;
my $localversion;
my $iteration = 0;
my $successes = 0;
my $stty_orig;
my $run_command_status = 0;
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 $config_bisect_check;
my $patchcheck_type;
my $patchcheck_start;
my $patchcheck_cherry;
my $patchcheck_end;
my $patchcheck_skip;
my $build_time;
my $install_time;
my $reboot_time;
my $test_time;
my $warning_found = 0;
my $pwd;
my $dirname = $FindBin::Bin;
my $mailto;
my $mailer;
my $mail_path;
my $mail_max_size;
my $mail_command;
my $email_on_error;
my $email_when_finished;
my $email_when_started;
my $email_when_canceled;
my $script_start_time = localtime();
# set when a test is something other that just building or install
# which would require more options.
my $buildonly = 1;
# tell build not to worry about warnings, even when WARNINGS_FILE is set
my $warnings_ok = 0;
# set when creating a new config
my $newconfig = 0;
my %entered_configs;
my %config_help;
my %variable;
# force_config is the list of configs that we force enabled (or disabled)
# in a .config file. The MIN_CONFIG and ADD_CONFIG configs.
my %force_config;
# do not force reboots on config problems
my $no_reboot = 1;
# reboot on success
my $reboot_success = 0;
my %option_map = (
"MAILTO" => \$mailto,
"MAILER" => \$mailer,
"MAIL_PATH" => \$mail_path,
"MAIL_MAX_SIZE" => \$mail_max_size,
"MAIL_COMMAND" => \$mail_command,
"EMAIL_ON_ERROR" => \$email_on_error,
"EMAIL_WHEN_FINISHED" => \$email_when_finished,
"EMAIL_WHEN_STARTED" => \$email_when_started,
"EMAIL_WHEN_CANCELED" => \$email_when_canceled,
"MACHINE" => \$machine,
"SSH_USER" => \$ssh_user,
"TMP_DIR" => \$tmpdir,
"OUTPUT_DIR" => \$outputdir,
"BUILD_DIR" => \$builddir,
"TEST_TYPE" => \$test_type,
"PRE_KTEST" => \$pre_ktest,
"POST_KTEST" => \$post_ktest,
"PRE_TEST" => \$pre_test,
"PRE_TEST_DIE" => \$pre_test_die,
"POST_TEST" => \$post_test,
"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,
"REBOOT_RETURN_CODE" => \$reboot_return_code,
"BUILD_NOCLEAN" => \$noclean,
"MIN_CONFIG" => \$minconfig,
"OUTPUT_MIN_CONFIG" => \$output_minconfig,
"START_MIN_CONFIG" => \$start_minconfig,
"MIN_CONFIG_TYPE" => \$minconfig_type,
"USE_OUTPUT_MIN_CONFIG" => \$use_output_minconfig,
"WARNINGS_FILE" => \$warnings_file,
"IGNORE_CONFIG" => \$ignore_config,
"TEST" => \$run_test,
"ADD_CONFIG" => \$addconfig,
"REBOOT_TYPE" => \$reboot_type,
"GRUB_MENU" => \$grub_menu,
"GRUB_FILE" => \$grub_file,
"GRUB_REBOOT" => \$grub_reboot,
"GRUB_BLS_GET" => \$grub_bls_get,
"SYSLINUX" => \$syslinux,
"SYSLINUX_PATH" => \$syslinux_path,
"SYSLINUX_LABEL" => \$syslinux_label,
"PRE_INSTALL" => \$pre_install,
"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,
"REBOOT_ON_SUCCESS" => \$reboot_on_success,
"DIE_ON_FAILURE" => \$die_on_failure,
"POWER_OFF" => \$power_off,
"POWERCYCLE_AFTER_REBOOT" => \$powercycle_after_reboot,
"POWEROFF_AFTER_HALT" => \$poweroff_after_halt,
"MAX_MONITOR_WAIT" => \$max_monitor_wait,
"SLEEP_TIME" => \$sleep_time,
"BISECT_SLEEP_TIME" => \$bisect_sleep_time,
"PATCHCHECK_SLEEP_TIME" => \$patchcheck_sleep_time,
"IGNORE_WARNINGS" => \$ignore_warnings,
"IGNORE_ERRORS" => \$ignore_errors,
"BISECT_MANUAL" => \$bisect_manual,
"BISECT_SKIP" => \$bisect_skip,
"BISECT_TRIES" => \$bisect_tries,
"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,
"RUN_TIMEOUT" => \$run_timeout,
"CONNECT_TIMEOUT" => \$connect_timeout,
"CONFIG_BISECT_EXEC" => \$config_bisect_exec,
"BOOTED_TIMEOUT" => \$booted_timeout,
"CONSOLE" => \$console,
"CLOSE_CONSOLE_SIGNAL" => \$close_console_signal,
"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,
"SCP_TO_TARGET_INSTALL" => \$scp_to_target_install,
"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,
"CONFIG_BISECT_CHECK" => \$config_bisect_check,
"PATCHCHECK_TYPE" => \$patchcheck_type,
"PATCHCHECK_START" => \$patchcheck_start,
"PATCHCHECK_CHERRY" => \$patchcheck_cherry,
"PATCHCHECK_END" => \$patchcheck_end,
"PATCHCHECK_SKIP" => \$patchcheck_skip,
);
# Options may be used by other options, record them.
my %used_options;
# default variables that can be used
chomp ($variable{
"PWD"} = `pwd`);
$pwd = $variable{
"PWD"};
$config_help{
"MACHINE"} = <<
"EOF"
The machine hostname that you will test.
For build only tests, it is still needed to differentiate log files.
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).
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.
EOF
;
$config_help{
"OUTPUT_DIR"} = <<
"EOF"
The directory that the objects will be built (full path).
(can not be same as BUILD_DIR)
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.
EOF
;
$config_help{
"BUILD_TARGET"} = <<
"EOF"
The location of the compiled file to
copy to the target.
(relative to OUTPUT_DIR)
EOF
;
$config_help{
"BUILD_OPTIONS"} = <<
"EOF"
Options to add to \
"make\" when building.
i.e. -j20
EOF
;
$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",
"grub2",
"grub2bls",
"syslinux", 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.
If you specify grub2,
then you also need to specify both \$GRUB_MENU
and \$GRUB_FILE.
If you specify grub2bls,
then you also need to specify \$GRUB_MENU.
If you specify syslinux,
then you may use SYSLINUX to
define the syslinux
command (defaults to extlinux), and SYSLINUX_PATH to specify the path to
the syslinux install (defaults to /boot/extlinux). But you have to specify
SYSLINUX_LABEL to
define the label to boot to
for the test kernel.
EOF
;
$config_help{
"GRUB_MENU"} = <<
"EOF"
The grub title name
for the test kernel to boot
(Only mandatory
if REBOOT_TYPE = grub or grub2)
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
For grub2, a search of \$GRUB_FILE is performed
for the lines
that
begin with
"menuentry". It will not detect submenus. The
menu must be a non-nested menu. Add the quotes used in the menu
to guarantee your selection, as the first menuentry with the content
of \$GRUB_MENU that is found will be used.
For grub2bls, \$GRUB_MENU is searched on the result of \$GRUB_BLS_GET
command
for the lines that
begin with
"title".
EOF
;
$config_help{
"GRUB_FILE"} = <<
"EOF"
If grub2 is used, the full path
for the grub.cfg file is placed
here. Use something like /boot/grub2/grub.cfg to search.
EOF
;
$config_help{
"SYSLINUX_LABEL"} = <<
"EOF"
If syslinux is used, the label that boots the target kernel must
be specified with SYSLINUX_LABEL.
EOF
;
$config_help{
"REBOOT_SCRIPT"} = <<
"EOF"
A script to reboot the target into the test kernel
(Only mandatory
if REBOOT_TYPE = script)
EOF
;
# used with process_expression()
my $d = 0;
# defined before get_test_name()
my $in_die = 0;
# defined before process_warning_line()
my $check_build_re =
".*:.*(warning|error|Error):.*";
my $utf8_quote =
"\\x{e2}\\x{80}(\\x{98}|\\x{99})";
# defined before child_finished()
my $child_done;
# config_ignore holds the configs that were set (or unset) for
# a good config and we will ignore these configs for the rest
# of a config bisect. These configs stay as they were.
my %config_ignore;
# config_set holds what all configs were set as.
my %config_set;
# config_off holds the set of configs that the bad config had disabled.
# We need to record them and set them in the .config when running
# olddefconfig, because olddefconfig keeps the defaults.
my %config_off;
# config_off_tmp holds a set of configs to turn off for now
my @config_off_tmp;
# config_list is the set of configs that are being tested
my %config_list;
my %null_config;
my %dependency;
# found above run_config_bisect()
my $pass = 1;
# found above add_dep()
my %depends;
my %depcount;
my $iflevel = 0;
my @ifdeps;
# prevent recursion
my %read_kconfigs;
# found above test_this_config()
my %min_configs;
my %keep_configs;
my %save_configs;
my %processed_configs;
my %nochange_config;
#
# These are first defined here, main function later on
#
sub run_command;
sub start_monitor;
sub end_monitor;
sub wait_for_monitor;
sub _logit {
if (defined($opt{
"LOG_FILE"})) {
print LOG @_;
}
}
sub logit {
if (defined($opt{
"LOG_FILE"})) {
_logit @_;
}
else {
print @_;
}
}
sub doprint {
print @_;
_logit @_;
}
sub read_prompt {
my ($cancel, $prompt) = @_;
my $ans;
for (;;) {
if ($cancel) {
print
"$prompt [y/n/C] ";
}
else {
print
"$prompt [Y/n] ";
}
$ans = <STDIN>;
chomp $ans;
if ($ans =~ /^\s*$/) {
if ($cancel) {
$ans =
"c";
}
else {
$ans =
"y";
}
}
last
if ($ans =~ /^y$/i || $ans =~ /^n$/i);
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;
}
if ($ans !~ /^y$/i) {
return 0;
}
return 1;
}
sub read_yn {
my ($prompt) = @_;
return read_prompt 0, $prompt;
}
sub read_ync {
my ($prompt) = @_;
return read_prompt 1, $prompt;
}
sub get_mandatory_config {
my ($config) = @_;
my $ans;
return
if (defined($opt{$config}));
if (defined($config_help{$config})) {
print
"\n";
print $config_help{$config};
}
for (;;) {
print
"$config = ";
if (defined($default{$config}) && length($default{$config})) {
print
"\[$default{$config}\] ";
}
$ans = <STDIN>;
$ans =~ s/^\s*(.*\S)\s*$/$1/;
if ($ans =~ /^\s*$/) {
if ($default{$config}) {
$ans = $default{$config};
}
else {
print
"Your answer can not be blank\n";
next;
}
}
$entered_configs{$config} = ${ans};
last;
}
}
sub show_time {
my ($time) = @_;
my $hours = 0;
my $minutes = 0;
if ($time > 3600) {
$hours = int($time / 3600);
$time -= $hours * 3600;
}
if ($time > 60) {
$minutes = int($time / 60);
$time -= $minutes * 60;
}
if ($hours > 0) {
doprint
"$hours hour";
doprint
"s" if ($hours > 1);
doprint
" ";
}
if ($minutes > 0) {
doprint
"$minutes minute";
doprint
"s" if ($minutes > 1);
doprint
" ";
}
doprint
"$time second";
doprint
"s" if ($time != 1);
}
sub print_times {
doprint
"\n";
if ($build_time) {
doprint
"Build time: ";
show_time($build_time);
doprint
"\n";
}
if ($install_time) {
doprint
"Install time: ";
show_time($install_time);
doprint
"\n";
}
if ($reboot_time) {
doprint
"Reboot time: ";
show_time($reboot_time);
doprint
"\n";
}
if ($test_time) {
doprint
"Test time: ";
show_time($test_time);
doprint
"\n";
}
if ($warning_found) {
doprint
"\n*** WARNING";
doprint
"S" if ($warning_found > 1);
doprint
" found in build: $warning_found ***\n\n";
}
# reset for iterations like bisect
$build_time = 0;
$install_time = 0;
$reboot_time = 0;
$test_time = 0;
$warning_found = 0;
}
sub get_mandatory_configs {
get_mandatory_config(
"MACHINE");
get_mandatory_config(
"BUILD_DIR");
get_mandatory_config(
"OUTPUT_DIR");
if ($newconfig) {
get_mandatory_config(
"BUILD_OPTIONS");
}
# options required for other than just building a kernel
if (!$buildonly) {
get_mandatory_config(
"POWER_CYCLE");
get_mandatory_config(
"CONSOLE");
}
# options required for install and more
if ($buildonly != 1) {
get_mandatory_config(
"SSH_USER");
get_mandatory_config(
"BUILD_TARGET");
get_mandatory_config(
"TARGET_IMAGE");
}
get_mandatory_config(
"LOCALVERSION");
return
if ($buildonly);
my $rtype = $opt{
"REBOOT_TYPE"};
if (!defined($rtype)) {
if (!defined($opt{
"GRUB_MENU"})) {
get_mandatory_config(
"REBOOT_TYPE");
$rtype = $entered_configs{
"REBOOT_TYPE"};
}
else {
$rtype =
"grub";
}
}
if (($rtype eq
"grub") or ($rtype eq
"grub2bls")) {
get_mandatory_config(
"GRUB_MENU");
}
if ($rtype eq
"grub2") {
get_mandatory_config(
"GRUB_MENU");
get_mandatory_config(
"GRUB_FILE");
}
if ($rtype eq
"syslinux") {
get_mandatory_config(
"SYSLINUX_LABEL");
}
}
sub process_variables {
my ($value, $remove_undef) = @_;
my $retval =
"";
# We want to check for '\', and it is just easier
# to check the previous character 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 ($var =~ s/^shell\s+//) {
$retval = `$var`;
if ($?) {
doprint
"WARNING: $var returned an error\n";
}
else {
chomp $retval;
}
} elsif (defined($variable{$var})) {
$retval =
"$retval$variable{$var}";
} elsif (defined($remove_undef) && $remove_undef) {
# for if statements, any variable that is not defined,
# we simple convert to 0
$retval =
"${retval}0";
}
else {
# put back the origin piece, but with $#### to not reprocess it
$retval =
"$retval\$####\{$var\}";
# 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;
}
$value =
"$retval$end";
$retval =
"";
}
$retval = $value;
# Convert the saved variables with $####{var} back to ${var}
$retval =~ s/\$
####/\$/g;
# remove the space added in the beginning
$retval =~ s/ //;
return
"$retval";
}
sub set_value {
my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
my $prvalue = process_variables($rvalue);
if ($lvalue =~ /^(TEST|BISECT|CONFIG_BISECT)_TYPE(\[.*\])?$/ &&
$prvalue !~ /^(config_|)bisect$/ &&
$prvalue !~ /^build$/ &&
$prvalue !~ /^make_warnings_file$/ &&
$buildonly) {
# Note if a test is something other than build, then we
# will need other mandatory options.
if ($prvalue ne
"install") {
$buildonly = 0;
}
else {
# install still limits some mandatory options.
$buildonly = 2;
}
}
if (defined($opt{$lvalue})) {
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";
}
${$overrides}{$lvalue} = $prvalue;
}
$opt{$lvalue} = $prvalue;
}
sub set_eval {
my ($lvalue, $rvalue, $name) = @_;
my $prvalue = process_variables($rvalue);
my $arr;
if (defined($evals{$lvalue})) {
$arr = $evals{$lvalue};
}
else {
$arr = [];
$evals{$lvalue} = $arr;
}
push @{$arr}, $rvalue;
}
sub set_variable {
my ($lvalue, $rvalue, $command) = @_;
# Command line variables override all others
if (defined($command_tmp_vars{$lvalue})) {
return;
}
if ($rvalue =~ /^\s*$/) {
delete $variable{$lvalue};
}
else {
$rvalue = process_variables($rvalue);
$variable{$lvalue} = $rvalue;
}
if (defined($command)) {
$command_tmp_vars{$lvalue} = 1;
}
}
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;
} elsif ($cmp eq
"=~") {
return $lval =~ m/$rval/;
} elsif ($cmp eq
"!~") {
return $lval !~ m/$rval/;
}
my $statement =
"$lval $cmp $rval";
my $ret =
eval $statement;
# $@ stores error of eval
if ($@) {
return -1;
}
return $ret;
}
sub value_defined {
my ($val) = @_;
return defined($variable{$2}) ||
defined($opt{$2});
}
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 =
"\\&\\&";
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;
}
}
}
if ($val =~ /(.*)(==|\!=|>=|<=|>|<|=~|\!~)(.*)/) {
my $ret = process_compare($1, $2, $3);
if ($ret < 0) {
die
"$name: $.: Unable to process comparison\n";
}
return $ret;
}
if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
if (defined $1) {
return !value_defined($2);
}
else {
return value_defined($2);
}
}
if ($val =~ s/^\s*NOT\s+(.*)//) {
my $express = $1;
my $ret = process_expression($name, $express);
return !$ret;
}
if ($val =~ /^\s*0\s*$/) {
return 0;
} elsif ($val =~ /^\s*\d+\s*$/) {
return 1;
}
die (
"$name: $.: Undefined content $val in if statement\n");
}
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;
}
sub __read_config {
my ($config, $current_test_num) = @_;
my $in;
open($in, $config) || die
"can't read file $config";
my $name = $config;
$name =~ s,.*/(.*),$1,;
my $test_num = $$current_test_num;
my $default = 1;
my $repeat = 1;
my $num_tests_set = 0;
my $skip = 0;
my $rest;
my $line;
my $test_case = 0;
my $
if = 0;
my $if_set = 0;
my $override = 0;
my %overrides;
while (<$in>) {
# ignore blank lines and comments
next
if (/^\s*$/ || /\s*\
#/);
if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
my $type = $1;
$rest = $2;
$line = $2;
my $old_test_num;
my $old_repeat;
$override = 0;
if ($type eq
"TEST_START") {
if ($num_tests_set) {
die
"$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
}
$old_test_num = $test_num;
$old_repeat = $repeat;
$test_num += $repeat;
$default = 0;
$repeat = 1;
}
else {
$default = 1;
}
# If SKIP is anywhere in the line, the command will be skipped
if ($rest =~ s/\s+SKIP\b//) {
$skip = 1;
}
else {
$test_case = 1;
$skip = 0;
}
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;
}
}
if ($rest =~ s/\sIF\s+(.*)//) {
if (process_if($name, $1)) {
$if_set = 1;
}
else {
$skip = 1;
}
$
if = 1;
}
else {
$
if = 0;
$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 = ();
}
}
if (!$skip && $rest !~ /^\s*$/) {
die
"$name: $.: Garbage found after $type\n$_";
}
if ($skip && $type eq
"TEST_START") {
$test_num = $old_test_num;
$repeat = $old_repeat;
}
} elsif (/^\s*
ELSE\b(.*)$/) {
if (!$
if) {
die
"$name: $.: ELSE found with out matching IF section\n$_";
}
$rest = $1;
if ($if_set) {
$skip = 1;
$rest =
"";
}
else {
$skip = 0;
if ($rest =~ /\sIF\s+(.*)/) {
# May be a ELSE IF section.
if (process_if($name, $1)) {
$if_set = 1;
}
else {
$skip = 1;
}
$rest =
"";
}
else {
$
if = 0;
}
}
if ($rest !~ /^\s*$/) {
die
"$name: $.: Garbage found after DEFAULTS\n$_";
}
} 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;
}
} elsif (/^\s*([A-Z_\[\]\d]+)\s*=~\s*(.*?)\s*$/) {
next
if ($skip);
my $lvalue = $1;
my $rvalue = $2;
if ($default || $lvalue =~ /\[\d+\]$/) {
set_eval($lvalue, $rvalue, $name);
}
else {
my $val =
"$lvalue\[$test_num\]";
set_eval($val, $rvalue, $name);
}
} elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
next
if ($skip);
my $lvalue = $1;
my $rvalue = $2;
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+\]$/) {
set_value($lvalue, $rvalue, $override, \%overrides, $name);
}
else {
my $val =
"$lvalue\[$test_num\]";
set_value($val, $rvalue, $override, \%overrides, $name);
if ($repeat > 1) {
$repeats{$val} = $repeat;
}
}
} 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
# one of these sections that have SKIP defined.
# The save variable can be
# defined multiple times and the new one simply overrides
# the previous one.
set_variable($lvalue, $rvalue);
}
else {
die
"$name: $.: Garbage found in config\n$_";
}
}
if ($test_num) {
$test_num += $repeat - 1;
$opt{
"NUM_TESTS"} = $test_num;
}
close($in);
$$current_test_num = $test_num;
return $test_case;
}
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 ktest.conf\n";
print
" (see tools/testing/ktest/sample.conf)\n";
my $ans = <STDIN>;
chomp $ans;
$default{
"TEST_TYPE"} = $ans;
}
sub read_config {
my ($config) = @_;
my $test_case;
my $test_num = 0;
$test_case = __read_config $config, \$test_num;
foreach my $val (@command_vars) {
chomp $val;
my %command_overrides;
if ($val =~ m/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
my $lvalue = $1;
my $rvalue = $2;
set_value($lvalue, $rvalue, 1, \%command_overrides,
"COMMAND LINE");
}
else {
die
"Invalid option definition '$val'\n";
}
}
# make sure we have all mandatory configs
get_mandatory_configs;
# was a test specified?
if (!$test_case) {
print
"No test case specified.\n";
get_test_case;
}
# set any defaults
foreach my $default (keys %default) {
if (!defined($opt{$default})) {
$opt{$default} = $default{$default};
}
}
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 IGNORE_UNUSED = 1 to have ktest ignore unused variables\n";
if (!read_yn
"Do you want to continue?") {
exit -1;
}
}
}
sub __eval_option {
my ($name, $option, $i) = @_;
# Add space to evaluate the character before $
$option =
" $option";
my $retval =
"";
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;
}
}
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\]";
my $parento =
"$var\[$parent\]";
# If a variable contains itself, use the default var
if (($var eq $name) && defined($opt{$var})) {
$o = $opt{$var};
# Only append if the default doesn't contain itself
if ($o !~ m/\$\{$var\}/) {
$retval =
"$retval$o";
}
} elsif (defined($opt{$o})) {
$o = $opt{$o};
$retval =
"$retval$o";
} elsif ($repeated && defined($opt{$parento})) {
$o = $opt{$parento};
$retval =
"$retval$o";
} elsif (defined($opt{$var})) {
$o = $opt{$var};
$retval =
"$retval$o";
} elsif ($var eq
"KERNEL_VERSION" && defined($
make)) {
# special option KERNEL_VERSION uses kernel version
get_version();
$retval =
"$retval$version";
}
else {
$retval =
"$retval\$\{$var\}";
}
$option = $
end;
}
$retval =
"$retval$option";
$retval =~ s/^ //;
return $retval;
}
sub process_evals {
my ($name, $option, $i) = @_;
my $option_name =
"$name\[$i\]";
my $ev;
my $old_option = $option;
if (defined($evals{$option_name})) {
$ev = $evals{$option_name};
} elsif (defined($evals{$name})) {
$ev = $evals{$name};
}
else {
return $option;
}
for my $e (@{$ev}) {
eval "\$option =~ $e";
}
if ($option ne $old_option) {
doprint(
"$name changed from '$old_option' to '$option'\n");
}
return $option;
}
sub eval_option {
my ($name, $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 occurred with $option\n" .
"Check for recursive variables\n";
}
$prev = $option;
$option = __eval_option($name, $option, $i);
}
$option = process_evals($name, $option, $i);
return $option;
}
sub reboot {
my ($time) = @_;
my $powercycle = 0;
# test if the machine can be connected to within a few seconds
my $stat = run_ssh(
"echo check machine status", $connect_timeout);
if (!$stat) {
doprint(
"power cycle\n");
$powercycle = 1;
}
if ($powercycle) {
run_command
"$power_cycle";
start_monitor;
# flush out current monitor
# May contain the reboot success line
wait_for_monitor 1;
}
else {
# Make sure everything has been written to disk
run_ssh(
"sync", 10);
if (defined($time)) {
start_monitor;
# flush out current monitor
# May contain the reboot success line
wait_for_monitor 1;
}
# try to reboot normally
if (run_command $reboot) {
if (defined($powercycle_after_reboot)) {
sleep $powercycle_after_reboot;
run_command
"$power_cycle";
}
}
else {
# nope? power cycle it.
run_command
"$power_cycle";
}
}
if (defined($time)) {
# We only want to get to the new kernel, don't fail
# if we stumble over a call trace.
my $save_ignore_errors = $ignore_errors;
$ignore_errors = 1;
# Look for the good kernel to boot
if (wait_for_monitor($time,
"Linux version")) {
# reboot got stuck?
doprint
"Reboot did not finish. Forcing power cycle\n";
run_command
"$power_cycle";
}
$ignore_errors = $save_ignore_errors;
# Still need to wait for the reboot to finish
wait_for_monitor($time, $reboot_success_line);
}
if ($powercycle || $time) {
end_monitor;
}
}
sub reboot_to_good {
my ($time) = @_;
if (defined($switch_to_good)) {
run_command $switch_to_good;
}
reboot $time;
}
sub do_not_reboot {
my $i = $iteration;
return $test_type eq
"build" || $no_reboot ||
($test_type eq
"patchcheck" && $opt{
"PATCHCHECK_TYPE[$i]"} eq
"build") ||
($test_type eq
"bisect" && $opt{
"BISECT_TYPE[$i]"} eq
"build") ||
($test_type eq
"config_bisect" && $opt{
"CONFIG_BISECT_TYPE[$i]"} eq
"build");
}
sub get_test_name() {
my $name;
if (defined($test_name)) {
$name =
"$test_name:$test_type";
}
else {
$name = $test_type;
}
return $name;
}
sub dodie {
# avoid recursion
return
if ($in_die);
$in_die = 1;
if ($monitor_cnt) {
# restore terminal settings
system(
"stty $stty_orig");
}
my $i = $iteration;
doprint
"CRITICAL FAILURE... [TEST $i] ", @_,
"\n";
if ($reboot_on_error && !do_not_reboot) {
doprint
"REBOOTING\n";
reboot_to_good;
} elsif ($poweroff_on_error && defined($power_off)) {
doprint
"POWERING OFF\n";
`$power_off`;
}
if (defined($opt{
"LOG_FILE"})) {
print
" See $opt{LOG_FILE} for more info.\n";
}
if ($email_on_error) {
my $name = get_test_name;
my $log_file;
if (defined($opt{
"LOG_FILE"})) {
my $whence = 2;
# End of file
my $log_size = tell LOG;
my $size = $log_size - $test_log_start;
if (defined($mail_max_size)) {
if ($size > $mail_max_size) {
$size = $mail_max_size;
}
}
my $pos = - $size;
$log_file =
"$tmpdir/log";
open (L,
"$opt{LOG_FILE}") or die
"Can't open $opt{LOG_FILE} to read)";
open (O,
"> $tmpdir/log") or die
"Can't open $tmpdir/log\n";
seek(L, $pos, $whence);
while (<L>) {
print O;
}
close O;
close L;
}
send_email(
"KTEST: critical failure for test $i [$name]",
"Your test started at $script_start_time has failed with:\n@_\n", $log_file);
}
if (defined($post_test)) {
run_command $post_test;
}
die @_,
"\n";
}
sub create_pty {
my ($ptm, $pts) = @_;
my $tmp;
my $TIOCSPTLCK = 0x40045431;
my $TIOCGPTN = 0x80045430;
sysopen($ptm,
"/dev/ptmx", O_RDWR | O_NONBLOCK) or
dodie
"Can't open /dev/ptmx";
# unlockpt()
$tmp = pack(
"i", 0);
ioctl($ptm, $TIOCSPTLCK, $tmp) or
dodie
"ioctl TIOCSPTLCK for /dev/ptmx failed";
# ptsname()
ioctl($ptm, $TIOCGPTN, $tmp) or
dodie
"ioctl TIOCGPTN for /dev/ptmx failed";
$tmp = unpack(
"i", $tmp);
sysopen($pts,
"/dev/pts/$tmp", O_RDWR | O_NONBLOCK) or
dodie
"Can't open /dev/pts/$tmp";
}
sub exec_console {
my ($ptm, $pts) = @_;
close($ptm);
close(\*STDIN);
close(\*STDOUT);
close(\*STDERR);
open(\*STDIN,
'<&', $pts);
open(\*STDOUT,
'>&', $pts);
open(\*STDERR,
'>&', $pts);
close($pts);
exec $console or
dodie
"Can't open console $console";
}
sub open_console {
my ($ptm) = @_;
my $pts = \*PTSFD;
my $pid;
# save terminal settings
$stty_orig = `stty -g`;
# place terminal in cbreak mode so that stdin can be read one character at
# a time without having to wait for a newline
system(
"stty -icanon -echo -icrnl");
create_pty($ptm, $pts);
$pid = fork;
if (!$pid) {
# child
exec_console($ptm, $pts)
}
# parent
close($pts);
return $pid;
open(PTSFD,
"Stop perl from warning about single use of PTSFD");
}
sub close_console {
my ($fp, $pid) = @_;
doprint
"kill child process $pid\n";
kill $close_console_signal, $pid;
doprint
"wait for child process $pid to exit\n";
waitpid($pid, 0);
print
"closing!\n";
close($fp);
# restore terminal settings
system(
"stty $stty_orig");
}
sub start_monitor {
if ($monitor_cnt++) {
return;
}
$monitor_fp = \*MONFD;
$monitor_pid = open_console $monitor_fp;
return;
open(MONFD,
"Stop perl from warning about single use of MONFD");
}
sub end_monitor {
return
if (!defined $console);
if (--$monitor_cnt) {
return;
}
close_console($monitor_fp, $monitor_pid);
}
sub wait_for_monitor {
my ($time, $stop) = @_;
my $full_line =
"";
my $line;
my $booted = 0;
my $start_time = time;
my $skip_call_trace = 0;
my $bug = 0;
my $bug_ignored = 0;
my $now;
doprint
"** Wait for monitor to settle down **\n";
# read the monitor and wait for the system to calm down
while (!$booted) {
$line = wait_for_input($monitor_fp, $time);
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 ($full_line =~ /\[ backtrace testing \]/) {
$skip_call_trace = 1;
}
if ($full_line =~ /
call trace:/i) {
if (!$bug && !$skip_call_trace) {
if ($ignore_errors) {
$bug_ignored = 1;
}
else {
$bug = 1;
}
}
}
if ($full_line =~ /\[
end of backtrace testing \]/) {
$skip_call_trace = 0;
}
if ($full_line =~ /Kernel panic -/) {
$bug = 1;
}
if ($line =~ /\n/) {
$full_line =
"";
}
$now = time;
if ($now - $start_time >= $max_monitor_wait) {
doprint
"Exiting monitor flush due to hitting MAX_MONITOR_WAIT\n";
return 1;
}
}
print
"** Monitor flushed **\n";
# if stop is defined but wasn't hit, return error
# used by reboot (which wants to see a reboot)
if (defined($stop) && !$booted) {
$bug = 1;
}
return $bug;
}
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
dodie
"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
dodie
"failed to copy $source";
}
}
doprint
"*** Saved info to $dir ***\n";
}
sub fail {
if ($die_on_failure) {
dodie @_;
}
doprint
"FAILED\n";
my $i = $iteration;
# no need to reboot for just building.
if (!do_not_reboot) {
doprint
"REBOOTING\n";
reboot_to_good $sleep_time;
}
my $name =
"";
if (defined($test_name)) {
$name =
" ($test_name)";
}
print_times;
doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
doprint
"KTEST RESULT: TEST $i$name Failed: ", @_,
"\n";
doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
doprint
"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
if (defined($store_failures)) {
save_logs
"fail", $store_failures;
}
if (defined($post_test)) {
run_command $post_test;
}
return 1;
}
sub run_command {
my ($command, $redirect, $timeout) = @_;
my $start_time;
my $end_time;
my $dolog = 0;
my $dord = 0;
my $dostdout = 0;
my $pid;
my $command_orig = $command;
$command =~ s/\$SSH_USER/$ssh_user/g;
$command =~ s/\$MACHINE/$machine/g;
if (!defined($timeout)) {
$timeout = $run_timeout;
}
if (!defined($timeout)) {
$timeout = -1;
# tell wait_for_input to wait indefinitely
}
doprint(
"$command ... ");
$start_time = time;
$pid = open(CMD,
"$command 2>&1 |") or
(fail
"unable to exec $command" and return 0);
if (defined($opt{
"LOG_FILE"})) {
$dolog = 1;
}
if (defined($redirect)) {
if ($redirect eq 1) {
$dostdout = 1;
# Have the output of the command on its own line
doprint
"\n";
}
else {
open (RD,
">$redirect") or
dodie
"failed to write to redirect $redirect";
$dord = 1;
}
}
my $hit_timeout = 0;
while (1) {
my $fp = \*CMD;
my $line = wait_for_input($fp, $timeout);
if (!defined($line)) {
my $now = time;
if ($timeout >= 0 && (($now - $start_time) >= $timeout)) {
doprint
"Hit timeout of $timeout, killing process\n";
$hit_timeout = 1;
kill 9, $pid;
}
last;
}
print LOG $line
if ($dolog);
print RD $line
if ($dord);
print $line
if ($dostdout);
}
waitpid($pid, 0);
# shift 8 for real exit status
$run_command_status = $? >> 8;
if ($command_orig eq $default{REBOOT} &&
$run_command_status == $reboot_return_code) {
$run_command_status = 0;
}
close(CMD);
close(RD)
if ($dord);
$end_time = time;
my $delta = $end_time - $start_time;
if ($delta == 1) {
doprint
"[1 second] ";
}
else {
doprint
"[$delta seconds] ";
}
if ($hit_timeout) {
$run_command_status = 1;
}
if ($run_command_status) {
doprint
"FAILED!\n";
}
else {
doprint
"SUCCESS\n";
}
return !$run_command_status;
}
sub run_ssh {
my ($cmd, $timeout) = @_;
my $cp_exec = $ssh_exec;
$cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
return run_command
"$cp_exec", undef , $timeout;
}
sub run_scp {
my ($src, $dst, $cp_scp) = @_;
$cp_scp =~ s/\$SRC_FILE/$src/g;
$cp_scp =~ s/\$DST_FILE/$dst/g;
return run_command
"$cp_scp";
}
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);
}
sub _get_grub_index {
my ($command, $target, $skip, $submenu) = @_;
return
if (defined($grub_number) && defined($last_grub_menu) &&
$last_grub_menu eq $grub_menu && defined($last_machine) &&
$last_machine eq $machine);
doprint
"Find $reboot_type menu ... ";
$grub_number = -1;
my $ssh_grub = $ssh_exec;
$ssh_grub =~ s,\$SSH_COMMAND,$command,g;
open(IN,
"$ssh_grub |") or
dodie
"unable to execute $command";
my $found = 0;
my $submenu_number = 0;
while (<IN>) {
if (/$target/) {
$grub_number++;
$found = 1;
last;
} elsif (defined($submenu) && /$submenu/) {
$submenu_number++;
$grub_number = -1;
} elsif (/$skip/) {
$grub_number++;
}
}
close(IN);
dodie
"Could not find '$grub_menu' through $command on $machine"
if (!$found);
if ($submenu_number > 0) {
$grub_number =
"$submenu_number>$grub_number";
}
doprint
"$grub_number\n";
$last_grub_menu = $grub_menu;
$last_machine = $machine;
}
sub get_grub_index {
my $command;
my $target;
my $skip;
my $submenu;
my $grub_menu_qt;
if ($reboot_type !~ /^grub/) {
return;
}
$grub_menu_qt = quotemeta($grub_menu);
if ($reboot_type eq
"grub") {
$command =
"cat /boot/grub/menu.lst";
$target =
'^\s*title\s+' . $grub_menu_qt .
'\s*$';
$skip =
'^\s*title\s';
} elsif ($reboot_type eq
"grub2") {
$command =
"cat $grub_file";
$target =
'^\s*menuentry.*' . $grub_menu_qt;
$skip =
'^\s*menuentry\s';
$submenu =
'^\s*submenu\s';
} elsif ($reboot_type eq
"grub2bls") {
$command = $grub_bls_get;
$target =
'^title=.*' . $grub_menu_qt;
$skip =
'^title=';
}
else {
return;
}
_get_grub_index($command, $target, $skip, $submenu);
}
sub wait_for_input {
my ($fp, $time) = @_;
my $start_time;
my $rin;
my $rout;
my $nr;
my $buf;
my $line;
my $ch;
if (!defined($time)) {
$time = $timeout;
}
if ($time < 0) {
# Negative number means wait indefinitely
undef $time;
}
$rin =
'';
vec($rin, fileno($fp), 1) = 1;
vec($rin, fileno(\*STDIN), 1) = 1;
$start_time = time;
while (1) {
$nr = select($rout=$rin, undef, undef, $time);
last
if ($nr <= 0);
# copy data from stdin to the console
if (vec($rout, fileno(\*STDIN), 1) == 1) {
$nr = sysread(\*STDIN, $buf, 1000);
syswrite($fp, $buf, $nr)
if ($nr > 0);
}
# The timeout is based on time waiting for the fp data
if (vec($rout, fileno($fp), 1) != 1) {
last
if (defined($time) && (time - $start_time > $time));
next;
}
$line =
"";
# try to read one char at a time
while (sysread $fp, $ch, 1) {
$line .= $ch;
last
if ($ch eq
"\n");
}
last
if (!length($line));
return $line;
}
return undef;
}
sub reboot_to {
if (defined($switch_to_test)) {
run_command $switch_to_test;
}
if ($reboot_type eq
"grub") {
run_ssh
"'(echo \"savedefault --default=$grub_number --once\
" | grub --batch)'";
} elsif (($reboot_type eq
"grub2") or ($reboot_type eq
"grub2bls")) {
run_ssh
"$grub_reboot \"'$grub_number'\
"";
} elsif ($reboot_type eq
"syslinux") {
run_ssh
"$syslinux --once \\\"$syslinux_label\\\
" $syslinux_path";
} elsif (defined $reboot_script) {
run_command
"$reboot_script";
}
reboot;
}
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;
}
sub monitor {
my $booted = 0;
my $bug = 0;
my $bug_ignored = 0;
my $skip_call_trace = 0;
my $loops;
my $start_time = time;
wait_for_monitor 5;
my $line;
my $full_line =
"";
open(DMESG,
"> $dmesg") or
dodie
"unable to write to $dmesg";
reboot_to;
my $success_start;
my $failure_start;
my $monitor_start = time;
my $
done = 0;
my $version_found = 0;
while (!$
done) {
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) {
$line = wait_for_input($monitor_fp, $booted_timeout);
if (!defined($line)) {
my $s = $booted_timeout == 1 ?
"" :
"s";
doprint
"Successful boot found: break after $booted_timeout second$s\n";
last;
}
}
else {
$line = wait_for_input($monitor_fp);
if (!defined($line)) {
my $s = $timeout == 1 ?
"" :
"s";
doprint
"Timed out after $timeout second$s\n";
last;
}
}
doprint $line;
print DMESG $line;
# we are not guaranteed to get a full line
$full_line .= $line;
if ($full_line =~ /$success_line/) {
$booted = 1;
$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;
}
}
if ($full_line =~ /\[ backtrace testing \]/) {
$skip_call_trace = 1;
}
if ($full_line =~ /
call trace:/i) {
if (!$bug && !$skip_call_trace) {
if ($ignore_errors) {
$bug_ignored = 1;
}
else {
$bug = 1;
$failure_start = time;
}
}
}
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;
}
}
if ($full_line =~ /\[
end of backtrace testing \]/) {
$skip_call_trace = 0;
}
if ($full_line =~ /Kernel panic -/) {
$failure_start = time;
$bug = 1;
}
# 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
"Already 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;
}
}
if ($line =~ /\n/) {
$full_line =
"";
}
if ($stop_test_after > 0 && !$booted && !$bug) {
if (time - $monitor_start > $stop_test_after) {
doprint
"STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
$
done = 1;
}
}
}
my $end_time = time;
$reboot_time = $end_time - $start_time;
close(DMESG);
if ($bug) {
return 0
if ($in_bisect);
fail
"failed - got a bug report" and return 0;
}
if (!$booted) {
return 0
if ($in_bisect);
fail
"failed - never got a boot prompt." and return 0;
}
if ($bug_ignored) {
doprint
"WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
}
return 1;
}
sub eval_kernel_version {
my ($option) = @_;
$option =~ s/\$KERNEL_VERSION/$version/g;
return $option;
}
sub do_post_install {
return
if (!defined($post_install));
my $cp_post_install = eval_kernel_version $post_install;
run_command
"$cp_post_install" or
dodie
"Failed to run post install";
}
# Sometimes the reboot fails, and will hang. We try to ssh to the box
# and if we fail, we force another reboot, that should powercycle it.
sub test_booted {
if (!run_ssh
"echo testing connection") {
reboot $sleep_time;
}
}
sub install {
return
if ($no_install);
my $start_time = time;
if (defined($pre_install)) {
my $cp_pre_install = eval_kernel_version $pre_install;
run_command
"$cp_pre_install" or
dodie
"Failed to run pre install";
}
my $cp_target = eval_kernel_version $target_image;
test_booted;
run_scp_install
"$outputdir/$build_target",
"$cp_target" or
dodie
"failed to copy image";
my $install_mods = 0;
# should we process modules?
$install_mods = 0;
open(IN,
"$output_config") or dodie(
"Can't read config file");
while (<IN>) {
if (/CONFIG_MODULES(=y)?/) {
if (defined($1)) {
$install_mods = 1;
last;
}
}
}
close(IN);
if (!$install_mods) {
do_post_install;
doprint
"No modules needed\n";
my $end_time = time;
$install_time = $end_time - $start_time;
return;
}
run_command
"$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" o
r
dodie "Failed to install modules";
my $modlib = "/lib/modules/$version";
my $modtar = "ktest-mods.tar.bz2";
run_ssh "rm -rf $modlib" or
dodie "failed to remove old mods: $modlib";
# would be nice if scp -r did not follow symbolic links
run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
dodie "making tarball";
run_scp_mod "$tmpdir/$modtar", "/tmp" or
dodie "failed to copy modules";
unlink "$tmpdir/$modtar";
run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
dodie "failed to tar modules";
run_ssh "rm -f /tmp/$modtar";
do_post_install;
my $end_time = time;
$install_time = $end_time - $start_time;
}
sub get_version {
# get the release name
return if ($have_version);
doprint "$make kernelrelease ... ";
$version = `$make -s kernelrelease | tail -1`;
if (!length($version)) {
run_command "$make allnoconfig" or return 0;
doprint "$make kernelrelease ... ";
$version = `$make -s kernelrelease | tail -1`;
}
chomp($version);
doprint "$version\n";
$have_version = 1;
}
sub start_monitor_and_install {
# Make sure the stable kernel has finished booting
# Install bisects, don't need console
if (defined $console) {
start_monitor;
wait_for_monitor 5;
end_monitor;
}
get_grub_index;
get_version;
install;
start_monitor if (defined $console);
return monitor;
}
sub process_warning_line {
my ($line) = @_;
chomp $line;
# for distcc heterogeneous systems, some compilers
# do things differently causing warning lines
# to be slightly different. This makes an attempt
# to fixe those issues.
# chop off the index into the line
# using distcc, some compilers give different indexes
# depending on white space
$line =~ s/^(\s*\S+:\d+:)\d+/$1/;
# Some compilers use UTF-8 extended for quotes and some don't.
$line =~ s/$utf8_quote/'/g;
return $line;
}
# Read buildlog and check against warnings file for any
# new warnings.
#
# Returns 1 if OK
# 0 otherwise
sub check_buildlog {
my %warnings_list;
# Failed builds should not reboot the target
my $save_no_reboot = $no_reboot;
$no_reboot = 1;
if (-f $warnings_file) {
open(IN, $warnings_file) or
dodie "Error opening $warnings_file";
while (<IN>) {
if (/$check_build_re/) {
my $warning = process_warning_line $_;
$warnings_list{$warning} = 1;
}
}
close(IN);
}
open(IN, $buildlog) or dodie "Can't open $buildlog";
while (<IN>) {
if (/$check_build_re/) {
my $warning = process_warning_line $_;
if (!defined $warnings_list{$warning}) {
$warning_found++;
# If warnings file didn't exist, and WARNINGS_FILE exist,
# then we fail on any warning!
if (defined $warnings_file) {
fail "New warning found (not in $warnings_file)\n$_\n";
$no_reboot = $save_no_reboot;
return 0;
}
}
}
}
$no_reboot = $save_no_reboot;
close(IN);
}
sub check_patch_buildlog {
my ($patch) = @_;
my @files = `git show $patch | diffstat -l`;
foreach my $file (@files) {
chomp $file;
}
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) {
my $fullpath = "$builddir/$file";
if ($file eq $err || $fullpath eq $err) {
fail "$file built with warnings" and return 0;
}
}
}
}
close(IN);
return 1;
}
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";
}
sub make_oldconfig {
my @force_list = keys %force_config;
if ($#force_list >= 0) {
apply_min_config;
}
if (!run_command "$make olddefconfig") {
# Perhaps olddefconfig doesn't exist in this version of the kernel
# try oldnoconfig
doprint "olddefconfig failed, trying make oldnoconfig\n";
if (!run_command "$make oldnoconfig") {
doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
# try a yes '' | oldconfig
run_command "yes '' | $make oldconfig" or
dodie "failed make config oldconfig";
}
}
}
# read a config file and use this to force new configs.
sub load_force_config {
my ($config) = @_;
doprint "Loading force configs from $config\n";
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;
}
sub build {
my ($type) = @_;
unlink $buildlog;
my $start_time = time;
# Failed builds should not reboot the target
my $save_no_reboot = $no_reboot;
$no_reboot = 1;
# Calculate a new version from here.
$have_version = 0;
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";
}
}
if ($type =~ /^useconfig:(.*)/) {
run_command "cp $1 $output_config" or
dodie "could not copy $1 to .config";
$type = "oldconfig";
}
# old config can ask questions
if ($type eq "oldconfig") {
$type = "olddefconfig";
# allow for empty configs
run_command "touch $output_config";
if (!$noclean) {
run_command "mv $output_config $outputdir/config_temp" or
dodie "moving .config";
run_command "$make mrproper" or dodie "make mrproper";
run_command "mv $outputdir/config_temp $output_config" or
dodie "moving config_temp";
}
} elsif (!$noclean) {
unlink "$output_config";
run_command "$make mrproper" or
dodie "make mrproper";
}
# add something to distinguish this build
open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
print OUT "$localversion\n";
close(OUT);
if (defined($minconfig)) {
load_force_config($minconfig);
}
if ($type ne "olddefconfig") {
run_command "$make $type" or
dodie "failed make config";
}
# Run old config regardless, to enforce min configurations
make_oldconfig;
if (not defined($build_options)){
$build_options = "";
}
my $build_ret = run_command "$make $build_options", $buildlog;
if (defined($post_build)) {
# Because a post build may change the kernel version
# do it now.
get_version;
my $ret = run_command $post_build;
if (!$ret && defined($post_build_die) &&
$post_build_die) {
dodie "failed to post_build\n";
}
}
if (!$build_ret) {
# bisect may need this to pass
if ($in_bisect) {
$no_reboot = $save_no_reboot;
return 0;
}
fail "failed build" and return 0;
}
$no_reboot = $save_no_reboot;
my $end_time = time;
$build_time = $end_time - $start_time;
return 1;
}
sub halt {
if (!run_ssh "halt" or defined($power_off)) {
if (defined($poweroff_after_halt)) {
sleep $poweroff_after_halt;
run_command "$power_off";
}
} else {
# nope? the zap it!
run_command "$power_off";
}
}
sub success {
my ($i) = @_;
$successes++;
my $name = "";
if (defined($test_name)) {
$name = " ($test_name)";
}
print_times;
doprint "\n\n";
doprint "*******************************************\n";
doprint "*******************************************\n";
doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
doprint "*******************************************\n";
doprint "*******************************************\n";
if (defined($store_successes)) {
save_logs "success", $store_successes;
}
if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
doprint "Reboot and wait $sleep_time seconds\n";
reboot_to_good $sleep_time;
}
if (defined($post_test)) {
run_command $post_test;
}
}
sub answer_bisect {
for (;;) {
doprint "Pass, fail, or skip? [p/f/s]";
my $ans = <STDIN>;
chomp $ans;
if ($ans eq "p" || $ans eq "P") {
return 1;
} elsif ($ans eq "f" || $ans eq "F") {
return 0;
} elsif ($ans eq "s" || $ans eq "S") {
return -1;
} else {
print "Please answer 'p', 'f', or 's'\n";
}
}
}
sub child_run_test {
# child should have no power
$reboot_on_error = 0;
$poweroff_on_error = 0;
$die_on_failure = 1;
run_command $run_test, $testlog;
exit $run_command_status;
}
sub child_finished {
$child_done = 1;
}
sub do_run_test {
my $child_pid;
my $child_exit;
my $line;
my $full_line;
my $bug = 0;
my $bug_ignored = 0;
my $start_time = time;
wait_for_monitor 1;
doprint "run test $run_test\n";
$child_done = 0;
$SIG{CHLD} = qw(child_finished);
$child_pid = fork;
child_run_test if (!$child_pid);
$full_line = "";
do {
$line = wait_for_input($monitor_fp, 1);
if (defined($line)) {
# we are not guaranteed to get a full line
$full_line .= $line;
doprint $line;
if ($full_line =~ /call trace:/i) {
if ($ignore_errors) {
$bug_ignored = 1;
} else {
$bug = 1;
}
}
if ($full_line =~ /Kernel panic -/) {
$bug = 1;
}
if ($line =~ /\n/) {
$full_line = "";
}
}
} while (!$child_done && !$bug);
if (!$bug && $bug_ignored) {
doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
}
if ($bug) {
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));
doprint "Detected kernel crash!\n";
# kill the child with extreme prejudice
kill 9, $child_pid;
}
waitpid $child_pid, 0;
$child_exit = $? >> 8;
my $end_time = time;
$test_time = $end_time - $start_time;
if (!$bug && $in_bisect) {
--> --------------------
--> maximum size reached
--> --------------------
