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