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