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