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