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