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", 10);
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) { 1388 if ($powercycle || $time) {
1516 end_monitor; 1389 end_monitor;
1517 } 1390 }
1518 } 1391 }
1519 1392
1520 sub reboot_to_good { 1393 sub reboot_to_good {
1521 my ($time) = @_; 1394 my ($time) = @_;
1522 1395
1523 if (defined($switch_to_good)) { 1396 if (defined($switch_to_good)) {
1524 run_command $switch_to_good; 1397 run_command $switch_to_good;
1525 } 1398 }
1526 1399
1527 reboot $time; 1400 reboot $time;
1528 } 1401 }
1529 1402
1530 sub do_not_reboot { 1403 sub do_not_reboot {
1531 my $i = $iteration; 1404 my $i = $iteration;
1532 1405
1533 return $test_type eq "build" || $no_reboo 1406 return $test_type eq "build" || $no_reboot ||
1534 ($test_type eq "patchcheck" && $opt{" 1407 ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
1535 ($test_type eq "bisect" && $opt{"BISE !! 1408 ($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 } 1409 }
1549 1410
1550 sub dodie { 1411 sub dodie {
1551 # avoid recursion !! 1412 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 1413
1560 my $i = $iteration; 1414 my $i = $iteration;
1561 1415
1562 doprint "CRITICAL FAILURE... [TEST $i] ", <<
1563 <<
1564 if ($reboot_on_error && !do_not_reboot) { 1416 if ($reboot_on_error && !do_not_reboot) {
>> 1417
1565 doprint "REBOOTING\n"; 1418 doprint "REBOOTING\n";
1566 reboot_to_good; 1419 reboot_to_good;
>> 1420
1567 } elsif ($poweroff_on_error && defined($p 1421 } elsif ($poweroff_on_error && defined($power_off)) {
1568 doprint "POWERING OFF\n"; 1422 doprint "POWERING OFF\n";
1569 `$power_off`; 1423 `$power_off`;
1570 } 1424 }
1571 1425
1572 if (defined($opt{"LOG_FILE"})) { 1426 if (defined($opt{"LOG_FILE"})) {
1573 print " See $opt{LOG_FILE} for more i 1427 print " See $opt{LOG_FILE} for more info.\n";
1574 } 1428 }
1575 1429
1576 if ($email_on_error) { !! 1430 if ($monitor_cnt) {
1577 my $name = get_test_name; !! 1431 # restore terminal settings
1578 my $log_file; !! 1432 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 } 1433 }
1605 1434
1606 if (defined($post_test)) { 1435 if (defined($post_test)) {
1607 run_command $post_test; 1436 run_command $post_test;
1608 } 1437 }
1609 1438
1610 die @_, "\n"; 1439 die @_, "\n";
1611 } 1440 }
1612 1441
1613 sub create_pty { 1442 sub create_pty {
1614 my ($ptm, $pts) = @_; 1443 my ($ptm, $pts) = @_;
1615 my $tmp; 1444 my $tmp;
1616 my $TIOCSPTLCK = 0x40045431; 1445 my $TIOCSPTLCK = 0x40045431;
1617 my $TIOCGPTN = 0x80045430; 1446 my $TIOCGPTN = 0x80045430;
1618 1447
1619 sysopen($ptm, "/dev/ptmx", O_RDWR | O_NON 1448 sysopen($ptm, "/dev/ptmx", O_RDWR | O_NONBLOCK) or
1620 dodie "Can't open /dev/ptmx"; !! 1449 dodie "Cant open /dev/ptmx";
1621 1450
1622 # unlockpt() 1451 # unlockpt()
1623 $tmp = pack("i", 0); 1452 $tmp = pack("i", 0);
1624 ioctl($ptm, $TIOCSPTLCK, $tmp) or 1453 ioctl($ptm, $TIOCSPTLCK, $tmp) or
1625 dodie "ioctl TIOCSPTLCK for /dev/ptmx 1454 dodie "ioctl TIOCSPTLCK for /dev/ptmx failed";
1626 1455
1627 # ptsname() 1456 # ptsname()
1628 ioctl($ptm, $TIOCGPTN, $tmp) or 1457 ioctl($ptm, $TIOCGPTN, $tmp) or
1629 dodie "ioctl TIOCGPTN for /dev/ptmx f 1458 dodie "ioctl TIOCGPTN for /dev/ptmx failed";
1630 $tmp = unpack("i", $tmp); 1459 $tmp = unpack("i", $tmp);
1631 1460
1632 sysopen($pts, "/dev/pts/$tmp", O_RDWR | O 1461 sysopen($pts, "/dev/pts/$tmp", O_RDWR | O_NONBLOCK) or
1633 dodie "Can't open /dev/pts/$tmp"; 1462 dodie "Can't open /dev/pts/$tmp";
1634 } 1463 }
1635 1464
1636 sub exec_console { 1465 sub exec_console {
1637 my ($ptm, $pts) = @_; 1466 my ($ptm, $pts) = @_;
1638 1467
1639 close($ptm); 1468 close($ptm);
1640 1469
1641 close(\*STDIN); 1470 close(\*STDIN);
1642 close(\*STDOUT); 1471 close(\*STDOUT);
1643 close(\*STDERR); 1472 close(\*STDERR);
1644 1473
1645 open(\*STDIN, '<&', $pts); 1474 open(\*STDIN, '<&', $pts);
1646 open(\*STDOUT, '>&', $pts); 1475 open(\*STDOUT, '>&', $pts);
1647 open(\*STDERR, '>&', $pts); 1476 open(\*STDERR, '>&', $pts);
1648 1477
1649 close($pts); 1478 close($pts);
1650 1479
1651 exec $console or 1480 exec $console or
1652 dodie "Can't open console $console"; !! 1481 die "Can't open console $console";
1653 } 1482 }
1654 1483
1655 sub open_console { 1484 sub open_console {
1656 my ($ptm) = @_; 1485 my ($ptm) = @_;
1657 my $pts = \*PTSFD; 1486 my $pts = \*PTSFD;
1658 my $pid; 1487 my $pid;
1659 1488
1660 # save terminal settings 1489 # save terminal settings
1661 $stty_orig = `stty -g`; 1490 $stty_orig = `stty -g`;
1662 1491
1663 # place terminal in cbreak mode so that s 1492 # place terminal in cbreak mode so that stdin can be read one character at
1664 # a time without having to wait for a new 1493 # a time without having to wait for a newline
1665 system("stty -icanon -echo -icrnl"); 1494 system("stty -icanon -echo -icrnl");
1666 1495
1667 create_pty($ptm, $pts); 1496 create_pty($ptm, $pts);
1668 1497
1669 $pid = fork; 1498 $pid = fork;
1670 1499
1671 if (!$pid) { 1500 if (!$pid) {
1672 # child 1501 # child
1673 exec_console($ptm, $pts) 1502 exec_console($ptm, $pts)
1674 } 1503 }
1675 1504
1676 # parent 1505 # parent
1677 close($pts); 1506 close($pts);
1678 1507
1679 return $pid; 1508 return $pid;
1680 1509
1681 open(PTSFD, "Stop perl from warning about 1510 open(PTSFD, "Stop perl from warning about single use of PTSFD");
1682 } 1511 }
1683 1512
1684 sub close_console { 1513 sub close_console {
1685 my ($fp, $pid) = @_; 1514 my ($fp, $pid) = @_;
1686 1515
1687 doprint "kill child process $pid\n"; 1516 doprint "kill child process $pid\n";
1688 kill $close_console_signal, $pid; 1517 kill $close_console_signal, $pid;
1689 1518
1690 doprint "wait for child process $pid to e <<
1691 waitpid($pid, 0); <<
1692 <<
1693 print "closing!\n"; 1519 print "closing!\n";
1694 close($fp); 1520 close($fp);
1695 1521
1696 # restore terminal settings 1522 # restore terminal settings
1697 system("stty $stty_orig"); 1523 system("stty $stty_orig");
1698 } 1524 }
1699 1525
1700 sub start_monitor { 1526 sub start_monitor {
1701 if ($monitor_cnt++) { 1527 if ($monitor_cnt++) {
1702 return; 1528 return;
1703 } 1529 }
1704 $monitor_fp = \*MONFD; 1530 $monitor_fp = \*MONFD;
1705 $monitor_pid = open_console $monitor_fp; 1531 $monitor_pid = open_console $monitor_fp;
1706 1532
1707 return; 1533 return;
1708 1534
1709 open(MONFD, "Stop perl from warning about 1535 open(MONFD, "Stop perl from warning about single use of MONFD");
1710 } 1536 }
1711 1537
1712 sub end_monitor { 1538 sub end_monitor {
1713 return if (!defined $console); 1539 return if (!defined $console);
1714 if (--$monitor_cnt) { 1540 if (--$monitor_cnt) {
1715 return; 1541 return;
1716 } 1542 }
1717 close_console($monitor_fp, $monitor_pid); 1543 close_console($monitor_fp, $monitor_pid);
1718 } 1544 }
1719 1545
1720 sub wait_for_monitor { 1546 sub wait_for_monitor {
1721 my ($time, $stop) = @_; 1547 my ($time, $stop) = @_;
1722 my $full_line = ""; 1548 my $full_line = "";
1723 my $line; 1549 my $line;
1724 my $booted = 0; 1550 my $booted = 0;
1725 my $start_time = time; 1551 my $start_time = time;
1726 my $skip_call_trace = 0; 1552 my $skip_call_trace = 0;
1727 my $bug = 0; 1553 my $bug = 0;
1728 my $bug_ignored = 0; 1554 my $bug_ignored = 0;
1729 my $now; 1555 my $now;
1730 1556
1731 doprint "** Wait for monitor to settle do 1557 doprint "** Wait for monitor to settle down **\n";
1732 1558
1733 # read the monitor and wait for the syste 1559 # read the monitor and wait for the system to calm down
1734 while (!$booted) { 1560 while (!$booted) {
1735 $line = wait_for_input($monitor_fp, $ 1561 $line = wait_for_input($monitor_fp, $time);
1736 last if (!defined($line)); 1562 last if (!defined($line));
1737 print "$line"; 1563 print "$line";
1738 $full_line .= $line; 1564 $full_line .= $line;
1739 1565
1740 if (defined($stop) && $full_line =~ / 1566 if (defined($stop) && $full_line =~ /$stop/) {
1741 doprint "wait for monitor detecte 1567 doprint "wait for monitor detected $stop\n";
1742 $booted = 1; 1568 $booted = 1;
1743 } 1569 }
1744 1570
1745 if ($full_line =~ /\[ backtrace testi 1571 if ($full_line =~ /\[ backtrace testing \]/) {
1746 $skip_call_trace = 1; 1572 $skip_call_trace = 1;
1747 } 1573 }
1748 1574
1749 if ($full_line =~ /call trace:/i) { 1575 if ($full_line =~ /call trace:/i) {
1750 if (!$bug && !$skip_call_trace) { 1576 if (!$bug && !$skip_call_trace) {
1751 if ($ignore_errors) { 1577 if ($ignore_errors) {
1752 $bug_ignored = 1; 1578 $bug_ignored = 1;
1753 } else { 1579 } else {
1754 $bug = 1; 1580 $bug = 1;
1755 } 1581 }
1756 } 1582 }
1757 } 1583 }
1758 1584
1759 if ($full_line =~ /\[ end of backtrac 1585 if ($full_line =~ /\[ end of backtrace testing \]/) {
1760 $skip_call_trace = 0; 1586 $skip_call_trace = 0;
1761 } 1587 }
1762 1588
1763 if ($full_line =~ /Kernel panic -/) { 1589 if ($full_line =~ /Kernel panic -/) {
1764 $bug = 1; 1590 $bug = 1;
1765 } 1591 }
1766 1592
1767 if ($line =~ /\n/) { 1593 if ($line =~ /\n/) {
1768 $full_line = ""; 1594 $full_line = "";
1769 } 1595 }
1770 $now = time; 1596 $now = time;
1771 if ($now - $start_time >= $max_monito 1597 if ($now - $start_time >= $max_monitor_wait) {
1772 doprint "Exiting monitor flush du 1598 doprint "Exiting monitor flush due to hitting MAX_MONITOR_WAIT\n";
1773 return 1; 1599 return 1;
1774 } 1600 }
1775 } 1601 }
1776 print "** Monitor flushed **\n"; 1602 print "** Monitor flushed **\n";
1777 1603
1778 # if stop is defined but wasn't hit, retu 1604 # if stop is defined but wasn't hit, return error
1779 # used by reboot (which wants to see a re 1605 # used by reboot (which wants to see a reboot)
1780 if (defined($stop) && !$booted) { 1606 if (defined($stop) && !$booted) {
1781 $bug = 1; 1607 $bug = 1;
1782 } 1608 }
1783 return $bug; 1609 return $bug;
1784 } 1610 }
1785 1611
1786 sub save_logs { 1612 sub save_logs {
1787 my ($result, $basedir) = @_; !! 1613 my ($result, $basedir) = @_;
1788 my @t = localtime; !! 1614 my @t = localtime;
1789 my $date = sprintf "%04d%02d%02d%02d%02d% !! 1615 my $date = sprintf "%04d%02d%02d%02d%02d%02d",
1790 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t !! 1616 1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
1791 1617
1792 my $type = $build_type; !! 1618 my $type = $build_type;
1793 if ($type =~ /useconfig/) { !! 1619 if ($type =~ /useconfig/) {
1794 $type = "useconfig"; !! 1620 $type = "useconfig";
1795 } !! 1621 }
1796 1622
1797 my $dir = "$machine-$test_type-$type-$res !! 1623 my $dir = "$machine-$test_type-$type-$result-$date";
1798 1624
1799 $dir = "$basedir/$dir"; !! 1625 $dir = "$basedir/$dir";
1800 1626
1801 if (!-d $dir) { !! 1627 if (!-d $dir) {
1802 mkpath($dir) or !! 1628 mkpath($dir) or
1803 dodie "can't create $dir"; !! 1629 die "can't create $dir";
1804 } !! 1630 }
1805 1631
1806 my %files = ( !! 1632 my %files = (
1807 "config" => $output_config, !! 1633 "config" => $output_config,
1808 "buildlog" => $buildlog, !! 1634 "buildlog" => $buildlog,
1809 "dmesg" => $dmesg, !! 1635 "dmesg" => $dmesg,
1810 "testlog" => $testlog, !! 1636 "testlog" => $testlog,
1811 ); !! 1637 );
1812 1638
1813 while (my ($name, $source) = each(%files) !! 1639 while (my ($name, $source) = each(%files)) {
1814 if (-f "$source") { !! 1640 if (-f "$source") {
1815 cp "$source", "$dir/$name" or !! 1641 cp "$source", "$dir/$name" or
1816 dodie "failed to copy $source !! 1642 die "failed to copy $source";
>> 1643 }
1817 } 1644 }
1818 } <<
1819 1645
1820 doprint "*** Saved info to $dir ***\n"; !! 1646 doprint "*** Saved info to $dir ***\n";
1821 } 1647 }
1822 1648
1823 sub fail { 1649 sub fail {
1824 1650
1825 if ($die_on_failure) { !! 1651 if ($die_on_failure) {
1826 dodie @_; !! 1652 dodie @_;
1827 } !! 1653 }
1828 <<
1829 doprint "FAILED\n"; <<
1830 1654
1831 my $i = $iteration; !! 1655 doprint "FAILED\n";
1832 1656
1833 # no need to reboot for just building. !! 1657 my $i = $iteration;
1834 if (!do_not_reboot) { <<
1835 doprint "REBOOTING\n"; <<
1836 reboot_to_good $sleep_time; <<
1837 } <<
1838 1658
1839 my $name = ""; !! 1659 # no need to reboot for just building.
>> 1660 if (!do_not_reboot) {
>> 1661 doprint "REBOOTING\n";
>> 1662 reboot_to_good $sleep_time;
>> 1663 }
1840 1664
1841 if (defined($test_name)) { !! 1665 my $name = "";
1842 $name = " ($test_name)"; <<
1843 } <<
1844 1666
1845 print_times; !! 1667 if (defined($test_name)) {
>> 1668 $name = " ($test_name)";
>> 1669 }
1846 1670
1847 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% !! 1671 print_times;
1848 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% <<
1849 doprint "KTEST RESULT: TEST $i$name Faile <<
1850 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% <<
1851 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% <<
1852 1672
1853 if (defined($store_failures)) { !! 1673 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1854 save_logs "fail", $store_failures; !! 1674 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
1855 } !! 1675 doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
>> 1676 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
>> 1677 doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
>> 1678
>> 1679 if (defined($store_failures)) {
>> 1680 save_logs "fail", $store_failures;
>> 1681 }
1856 1682
1857 if (defined($post_test)) { !! 1683 if (defined($post_test)) {
1858 run_command $post_test; !! 1684 run_command $post_test;
1859 } !! 1685 }
1860 1686
1861 return 1; !! 1687 return 1;
1862 } 1688 }
1863 1689
1864 sub run_command { 1690 sub run_command {
1865 my ($command, $redirect, $timeout) = @_; 1691 my ($command, $redirect, $timeout) = @_;
1866 my $start_time; 1692 my $start_time;
1867 my $end_time; 1693 my $end_time;
1868 my $dolog = 0; 1694 my $dolog = 0;
1869 my $dord = 0; 1695 my $dord = 0;
1870 my $dostdout = 0; <<
1871 my $pid; 1696 my $pid;
1872 my $command_orig = $command; <<
1873 1697
1874 $command =~ s/\$SSH_USER/$ssh_user/g; 1698 $command =~ s/\$SSH_USER/$ssh_user/g;
1875 $command =~ s/\$MACHINE/$machine/g; 1699 $command =~ s/\$MACHINE/$machine/g;
1876 1700
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 ... "); 1701 doprint("$command ... ");
1886 $start_time = time; 1702 $start_time = time;
1887 1703
1888 $pid = open(CMD, "$command 2>&1 |") or 1704 $pid = open(CMD, "$command 2>&1 |") or
1889 (fail "unable to exec $command" and r 1705 (fail "unable to exec $command" and return 0);
1890 1706
1891 if (defined($opt{"LOG_FILE"})) { 1707 if (defined($opt{"LOG_FILE"})) {
>> 1708 open(LOG, ">>$opt{LOG_FILE}") or
>> 1709 dodie "failed to write to log";
1892 $dolog = 1; 1710 $dolog = 1;
1893 } 1711 }
1894 1712
1895 if (defined($redirect)) { 1713 if (defined($redirect)) {
1896 if ($redirect eq 1) { !! 1714 open (RD, ">$redirect") or
1897 $dostdout = 1; !! 1715 dodie "failed to write to redirect $redirect";
1898 # Have the output of the command !! 1716 $dord = 1;
1899 doprint "\n"; <<
1900 } else { <<
1901 open (RD, ">$redirect") or <<
1902 dodie "failed to write to red <<
1903 $dord = 1; <<
1904 } <<
1905 } 1717 }
1906 1718
1907 my $hit_timeout = 0; 1719 my $hit_timeout = 0;
1908 1720
1909 while (1) { 1721 while (1) {
1910 my $fp = \*CMD; 1722 my $fp = \*CMD;
>> 1723 if (defined($timeout)) {
>> 1724 doprint "timeout = $timeout\n";
>> 1725 }
1911 my $line = wait_for_input($fp, $timeo 1726 my $line = wait_for_input($fp, $timeout);
1912 if (!defined($line)) { 1727 if (!defined($line)) {
1913 my $now = time; 1728 my $now = time;
1914 if ($timeout >= 0 && (($now - $st !! 1729 if (defined($timeout) && (($now - $start_time) >= $timeout)) {
1915 doprint "Hit timeout of $time 1730 doprint "Hit timeout of $timeout, killing process\n";
1916 $hit_timeout = 1; 1731 $hit_timeout = 1;
1917 kill 9, $pid; 1732 kill 9, $pid;
1918 } 1733 }
1919 last; 1734 last;
1920 } 1735 }
1921 print LOG $line if ($dolog); 1736 print LOG $line if ($dolog);
1922 print RD $line if ($dord); 1737 print RD $line if ($dord);
1923 print $line if ($dostdout); <<
1924 } 1738 }
1925 1739
1926 waitpid($pid, 0); 1740 waitpid($pid, 0);
1927 # shift 8 for real exit status 1741 # shift 8 for real exit status
1928 $run_command_status = $? >> 8; 1742 $run_command_status = $? >> 8;
1929 1743
1930 if ($command_orig eq $default{REBOOT} && <<
1931 $run_command_status == $reboot_return <<
1932 $run_command_status = 0; <<
1933 } <<
1934 <<
1935 close(CMD); 1744 close(CMD);
>> 1745 close(LOG) if ($dolog);
1936 close(RD) if ($dord); 1746 close(RD) if ($dord);
1937 1747
1938 $end_time = time; 1748 $end_time = time;
1939 my $delta = $end_time - $start_time; 1749 my $delta = $end_time - $start_time;
1940 1750
1941 if ($delta == 1) { 1751 if ($delta == 1) {
1942 doprint "[1 second] "; 1752 doprint "[1 second] ";
1943 } else { 1753 } else {
1944 doprint "[$delta seconds] "; 1754 doprint "[$delta seconds] ";
1945 } 1755 }
1946 1756
1947 if ($hit_timeout) { 1757 if ($hit_timeout) {
1948 $run_command_status = 1; 1758 $run_command_status = 1;
1949 } 1759 }
1950 1760
1951 if ($run_command_status) { 1761 if ($run_command_status) {
1952 doprint "FAILED!\n"; 1762 doprint "FAILED!\n";
1953 } else { 1763 } else {
1954 doprint "SUCCESS\n"; 1764 doprint "SUCCESS\n";
1955 } 1765 }
1956 1766
1957 return !$run_command_status; 1767 return !$run_command_status;
1958 } 1768 }
1959 1769
1960 sub run_ssh { 1770 sub run_ssh {
1961 my ($cmd, $timeout) = @_; 1771 my ($cmd, $timeout) = @_;
1962 my $cp_exec = $ssh_exec; 1772 my $cp_exec = $ssh_exec;
1963 1773
1964 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g; 1774 $cp_exec =~ s/\$SSH_COMMAND/$cmd/g;
1965 return run_command "$cp_exec", undef , $t 1775 return run_command "$cp_exec", undef , $timeout;
1966 } 1776 }
1967 1777
1968 sub run_scp { 1778 sub run_scp {
1969 my ($src, $dst, $cp_scp) = @_; 1779 my ($src, $dst, $cp_scp) = @_;
1970 1780
1971 $cp_scp =~ s/\$SRC_FILE/$src/g; 1781 $cp_scp =~ s/\$SRC_FILE/$src/g;
1972 $cp_scp =~ s/\$DST_FILE/$dst/g; 1782 $cp_scp =~ s/\$DST_FILE/$dst/g;
1973 1783
1974 return run_command "$cp_scp"; 1784 return run_command "$cp_scp";
1975 } 1785 }
1976 1786
1977 sub run_scp_install { 1787 sub run_scp_install {
1978 my ($src, $dst) = @_; 1788 my ($src, $dst) = @_;
1979 1789
1980 my $cp_scp = $scp_to_target_install; 1790 my $cp_scp = $scp_to_target_install;
1981 1791
1982 return run_scp($src, $dst, $cp_scp); 1792 return run_scp($src, $dst, $cp_scp);
1983 } 1793 }
1984 1794
1985 sub run_scp_mod { 1795 sub run_scp_mod {
1986 my ($src, $dst) = @_; 1796 my ($src, $dst) = @_;
1987 1797
1988 my $cp_scp = $scp_to_target; 1798 my $cp_scp = $scp_to_target;
1989 1799
1990 return run_scp($src, $dst, $cp_scp); 1800 return run_scp($src, $dst, $cp_scp);
1991 } 1801 }
1992 1802
1993 sub _get_grub_index { !! 1803 sub get_grub2_index {
1994 <<
1995 my ($command, $target, $skip, $submenu) = <<
1996 1804
1997 return if (defined($grub_number) && defin 1805 return if (defined($grub_number) && defined($last_grub_menu) &&
1998 $last_grub_menu eq $grub_menu && defi !! 1806 $last_grub_menu eq $grub_menu && defined($last_machine) &&
1999 $last_machine eq $machine); !! 1807 $last_machine eq $machine);
2000 1808
2001 doprint "Find $reboot_type menu ... "; !! 1809 doprint "Find grub2 menu ... ";
2002 $grub_number = -1; 1810 $grub_number = -1;
2003 1811
2004 my $ssh_grub = $ssh_exec; 1812 my $ssh_grub = $ssh_exec;
2005 $ssh_grub =~ s,\$SSH_COMMAND,$command,g; !! 1813 $ssh_grub =~ s,\$SSH_COMMAND,cat $grub_file,g;
2006 1814
2007 open(IN, "$ssh_grub |") or !! 1815 open(IN, "$ssh_grub |")
2008 dodie "unable to execute $command"; !! 1816 or die "unable to get $grub_file";
2009 1817
2010 my $found = 0; 1818 my $found = 0;
2011 1819
2012 my $submenu_number = 0; <<
2013 <<
2014 while (<IN>) { 1820 while (<IN>) {
2015 if (/$target/) { !! 1821 if (/^menuentry.*$grub_menu/) {
2016 $grub_number++; 1822 $grub_number++;
2017 $found = 1; 1823 $found = 1;
2018 last; 1824 last;
2019 } elsif (defined($submenu) && /$subme !! 1825 } elsif (/^menuentry\s/) {
2020 $submenu_number++; <<
2021 $grub_number = -1; <<
2022 } elsif (/$skip/) { <<
2023 $grub_number++; 1826 $grub_number++;
2024 } 1827 }
2025 } 1828 }
2026 close(IN); 1829 close(IN);
2027 1830
2028 dodie "Could not find '$grub_menu' throug !! 1831 die "Could not find '$grub_menu' in $grub_file on $machine"
2029 if (!$found); 1832 if (!$found);
2030 if ($submenu_number > 0) { <<
2031 $grub_number = "$submenu_number>$grub <<
2032 } <<
2033 doprint "$grub_number\n"; 1833 doprint "$grub_number\n";
2034 $last_grub_menu = $grub_menu; 1834 $last_grub_menu = $grub_menu;
2035 $last_machine = $machine; 1835 $last_machine = $machine;
2036 } 1836 }
2037 1837
2038 sub get_grub_index { 1838 sub get_grub_index {
2039 1839
2040 my $command; !! 1840 if ($reboot_type eq "grub2") {
2041 my $target; !! 1841 get_grub2_index;
2042 my $skip; !! 1842 return;
2043 my $submenu; !! 1843 }
2044 my $grub_menu_qt; <<
2045 1844
2046 if ($reboot_type !~ /^grub/) { !! 1845 if ($reboot_type ne "grub") {
2047 return; 1846 return;
2048 } 1847 }
>> 1848 return if (defined($grub_number) && defined($last_grub_menu) &&
>> 1849 $last_grub_menu eq $grub_menu && defined($last_machine) &&
>> 1850 $last_machine eq $machine);
2049 1851
2050 $grub_menu_qt = quotemeta($grub_menu); !! 1852 doprint "Find grub menu ... ";
>> 1853 $grub_number = -1;
2051 1854
2052 if ($reboot_type eq "grub") { !! 1855 my $ssh_grub = $ssh_exec;
2053 $command = "cat /boot/grub/menu.lst"; !! 1856 $ssh_grub =~ s,\$SSH_COMMAND,cat /boot/grub/menu.lst,g;
2054 $target = '^\s*title\s+' . $grub_menu !! 1857
2055 $skip = '^\s*title\s'; !! 1858 open(IN, "$ssh_grub |")
2056 } elsif ($reboot_type eq "grub2") { !! 1859 or die "unable to get menu.lst";
2057 $command = "cat $grub_file"; !! 1860
2058 $target = '^\s*menuentry.*' . $grub_m !! 1861 my $found = 0;
2059 $skip = '^\s*menuentry\s'; !! 1862
2060 $submenu = '^\s*submenu\s'; !! 1863 while (<IN>) {
2061 } elsif ($reboot_type eq "grub2bls") { !! 1864 if (/^\s*title\s+$grub_menu\s*$/) {
2062 $command = $grub_bls_get; !! 1865 $grub_number++;
2063 $target = '^title=.*' . $grub_menu_qt !! 1866 $found = 1;
2064 $skip = '^title='; !! 1867 last;
2065 } else { !! 1868 } elsif (/^\s*title\s/) {
2066 return; !! 1869 $grub_number++;
>> 1870 }
2067 } 1871 }
>> 1872 close(IN);
2068 1873
2069 _get_grub_index($command, $target, $skip, !! 1874 die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
>> 1875 if (!$found);
>> 1876 doprint "$grub_number\n";
>> 1877 $last_grub_menu = $grub_menu;
>> 1878 $last_machine = $machine;
2070 } 1879 }
2071 1880
2072 sub wait_for_input { !! 1881 sub wait_for_input
>> 1882 {
2073 my ($fp, $time) = @_; 1883 my ($fp, $time) = @_;
2074 my $start_time; 1884 my $start_time;
2075 my $rin; 1885 my $rin;
2076 my $rout; 1886 my $rout;
2077 my $nr; 1887 my $nr;
2078 my $buf; 1888 my $buf;
2079 my $line; 1889 my $line;
2080 my $ch; 1890 my $ch;
2081 1891
2082 if (!defined($time)) { 1892 if (!defined($time)) {
2083 $time = $timeout; 1893 $time = $timeout;
2084 } 1894 }
2085 1895
2086 if ($time < 0) { <<
2087 # Negative number means wait indefini <<
2088 undef $time; <<
2089 } <<
2090 <<
2091 $rin = ''; 1896 $rin = '';
2092 vec($rin, fileno($fp), 1) = 1; 1897 vec($rin, fileno($fp), 1) = 1;
2093 vec($rin, fileno(\*STDIN), 1) = 1; 1898 vec($rin, fileno(\*STDIN), 1) = 1;
2094 1899
2095 $start_time = time; 1900 $start_time = time;
2096 1901
2097 while (1) { 1902 while (1) {
2098 $nr = select($rout=$rin, undef, undef 1903 $nr = select($rout=$rin, undef, undef, $time);
2099 1904
2100 last if ($nr <= 0); 1905 last if ($nr <= 0);
2101 1906
2102 # copy data from stdin to the console 1907 # copy data from stdin to the console
2103 if (vec($rout, fileno(\*STDIN), 1) == 1908 if (vec($rout, fileno(\*STDIN), 1) == 1) {
2104 $nr = sysread(\*STDIN, $buf, 1000 1909 $nr = sysread(\*STDIN, $buf, 1000);
2105 syswrite($fp, $buf, $nr) if ($nr 1910 syswrite($fp, $buf, $nr) if ($nr > 0);
2106 } 1911 }
2107 1912
2108 # The timeout is based on time waitin 1913 # The timeout is based on time waiting for the fp data
2109 if (vec($rout, fileno($fp), 1) != 1) 1914 if (vec($rout, fileno($fp), 1) != 1) {
2110 last if (defined($time) && (time 1915 last if (defined($time) && (time - $start_time > $time));
2111 next; 1916 next;
2112 } 1917 }
2113 1918
2114 $line = ""; 1919 $line = "";
2115 1920
2116 # try to read one char at a time 1921 # try to read one char at a time
2117 while (sysread $fp, $ch, 1) { 1922 while (sysread $fp, $ch, 1) {
2118 $line .= $ch; 1923 $line .= $ch;
2119 last if ($ch eq "\n"); 1924 last if ($ch eq "\n");
2120 } 1925 }
2121 1926
2122 last if (!length($line)); 1927 last if (!length($line));
2123 1928
2124 return $line; 1929 return $line;
2125 } 1930 }
2126 return undef; 1931 return undef;
2127 } 1932 }
2128 1933
2129 sub reboot_to { 1934 sub reboot_to {
2130 if (defined($switch_to_test)) { 1935 if (defined($switch_to_test)) {
2131 run_command $switch_to_test; 1936 run_command $switch_to_test;
2132 } 1937 }
2133 1938
2134 if ($reboot_type eq "grub") { 1939 if ($reboot_type eq "grub") {
2135 run_ssh "'(echo \"savedefault --defau 1940 run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
2136 } elsif (($reboot_type eq "grub2") or ($r !! 1941 } elsif ($reboot_type eq "grub2") {
2137 run_ssh "$grub_reboot \"'$grub_number !! 1942 run_ssh "$grub_reboot $grub_number";
2138 } elsif ($reboot_type eq "syslinux") { 1943 } elsif ($reboot_type eq "syslinux") {
2139 run_ssh "$syslinux --once \\\"$syslin 1944 run_ssh "$syslinux --once \\\"$syslinux_label\\\" $syslinux_path";
2140 } elsif (defined $reboot_script) { 1945 } elsif (defined $reboot_script) {
2141 run_command "$reboot_script"; 1946 run_command "$reboot_script";
2142 } 1947 }
2143 reboot; 1948 reboot;
2144 } 1949 }
2145 1950
2146 sub get_sha1 { 1951 sub get_sha1 {
2147 my ($commit) = @_; 1952 my ($commit) = @_;
2148 1953
2149 doprint "git rev-list --max-count=1 $comm 1954 doprint "git rev-list --max-count=1 $commit ... ";
2150 my $sha1 = `git rev-list --max-count=1 $c 1955 my $sha1 = `git rev-list --max-count=1 $commit`;
2151 my $ret = $?; 1956 my $ret = $?;
2152 1957
2153 logit $sha1; 1958 logit $sha1;
2154 1959
2155 if ($ret) { 1960 if ($ret) {
2156 doprint "FAILED\n"; 1961 doprint "FAILED\n";
2157 dodie "Failed to get git $commit"; 1962 dodie "Failed to get git $commit";
2158 } 1963 }
2159 1964
2160 print "SUCCESS\n"; 1965 print "SUCCESS\n";
2161 1966
2162 chomp $sha1; 1967 chomp $sha1;
2163 1968
2164 return $sha1; 1969 return $sha1;
2165 } 1970 }
2166 1971
2167 sub monitor { 1972 sub monitor {
2168 my $booted = 0; 1973 my $booted = 0;
2169 my $bug = 0; 1974 my $bug = 0;
2170 my $bug_ignored = 0; 1975 my $bug_ignored = 0;
2171 my $skip_call_trace = 0; 1976 my $skip_call_trace = 0;
2172 my $loops; 1977 my $loops;
2173 1978
2174 my $start_time = time; 1979 my $start_time = time;
2175 1980
2176 wait_for_monitor 5; 1981 wait_for_monitor 5;
2177 1982
2178 my $line; 1983 my $line;
2179 my $full_line = ""; 1984 my $full_line = "";
2180 1985
2181 open(DMESG, "> $dmesg") or 1986 open(DMESG, "> $dmesg") or
2182 dodie "unable to write to $dmesg"; !! 1987 die "unable to write to $dmesg";
2183 1988
2184 reboot_to; 1989 reboot_to;
2185 1990
2186 my $success_start; 1991 my $success_start;
2187 my $failure_start; 1992 my $failure_start;
2188 my $monitor_start = time; 1993 my $monitor_start = time;
2189 my $done = 0; 1994 my $done = 0;
2190 my $version_found = 0; 1995 my $version_found = 0;
2191 1996
2192 while (!$done) { 1997 while (!$done) {
>> 1998
2193 if ($bug && defined($stop_after_failu 1999 if ($bug && defined($stop_after_failure) &&
2194 $stop_after_failure >= 0) { 2000 $stop_after_failure >= 0) {
2195 my $time = $stop_after_failure - 2001 my $time = $stop_after_failure - (time - $failure_start);
2196 $line = wait_for_input($monitor_f 2002 $line = wait_for_input($monitor_fp, $time);
2197 if (!defined($line)) { 2003 if (!defined($line)) {
2198 doprint "bug timed out after 2004 doprint "bug timed out after $booted_timeout seconds\n";
2199 doprint "Test forced to stop 2005 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
2200 last; 2006 last;
2201 } 2007 }
2202 } elsif ($booted) { 2008 } elsif ($booted) {
2203 $line = wait_for_input($monitor_f 2009 $line = wait_for_input($monitor_fp, $booted_timeout);
2204 if (!defined($line)) { 2010 if (!defined($line)) {
2205 my $s = $booted_timeout == 1 2011 my $s = $booted_timeout == 1 ? "" : "s";
2206 doprint "Successful boot foun 2012 doprint "Successful boot found: break after $booted_timeout second$s\n";
2207 last; 2013 last;
2208 } 2014 }
2209 } else { 2015 } else {
2210 $line = wait_for_input($monitor_f 2016 $line = wait_for_input($monitor_fp);
2211 if (!defined($line)) { 2017 if (!defined($line)) {
2212 my $s = $timeout == 1 ? "" : 2018 my $s = $timeout == 1 ? "" : "s";
2213 doprint "Timed out after $tim 2019 doprint "Timed out after $timeout second$s\n";
2214 last; 2020 last;
2215 } 2021 }
2216 } 2022 }
2217 2023
2218 doprint $line; 2024 doprint $line;
2219 print DMESG $line; 2025 print DMESG $line;
2220 2026
2221 # we are not guaranteed to get a full 2027 # we are not guaranteed to get a full line
2222 $full_line .= $line; 2028 $full_line .= $line;
2223 2029
2224 if ($full_line =~ /$success_line/) { 2030 if ($full_line =~ /$success_line/) {
2225 $booted = 1; 2031 $booted = 1;
2226 $success_start = time; 2032 $success_start = time;
2227 } 2033 }
2228 2034
2229 if ($booted && defined($stop_after_su 2035 if ($booted && defined($stop_after_success) &&
2230 $stop_after_success >= 0) { 2036 $stop_after_success >= 0) {
2231 my $now = time; 2037 my $now = time;
2232 if ($now - $success_start >= $sto 2038 if ($now - $success_start >= $stop_after_success) {
2233 doprint "Test forced to stop 2039 doprint "Test forced to stop after $stop_after_success seconds after success\n";
2234 last; 2040 last;
2235 } 2041 }
2236 } 2042 }
2237 2043
2238 if ($full_line =~ /\[ backtrace testi 2044 if ($full_line =~ /\[ backtrace testing \]/) {
2239 $skip_call_trace = 1; 2045 $skip_call_trace = 1;
2240 } 2046 }
2241 2047
2242 if ($full_line =~ /call trace:/i) { 2048 if ($full_line =~ /call trace:/i) {
2243 if (!$bug && !$skip_call_trace) { 2049 if (!$bug && !$skip_call_trace) {
2244 if ($ignore_errors) { 2050 if ($ignore_errors) {
2245 $bug_ignored = 1; 2051 $bug_ignored = 1;
2246 } else { 2052 } else {
2247 $bug = 1; 2053 $bug = 1;
2248 $failure_start = time; 2054 $failure_start = time;
2249 } 2055 }
2250 } 2056 }
2251 } 2057 }
2252 2058
2253 if ($bug && defined($stop_after_failu 2059 if ($bug && defined($stop_after_failure) &&
2254 $stop_after_failure >= 0) { 2060 $stop_after_failure >= 0) {
2255 my $now = time; 2061 my $now = time;
2256 if ($now - $failure_start >= $sto 2062 if ($now - $failure_start >= $stop_after_failure) {
2257 doprint "Test forced to stop 2063 doprint "Test forced to stop after $stop_after_failure seconds after failure\n";
2258 last; 2064 last;
2259 } 2065 }
2260 } 2066 }
2261 2067
2262 if ($full_line =~ /\[ end of backtrac 2068 if ($full_line =~ /\[ end of backtrace testing \]/) {
2263 $skip_call_trace = 0; 2069 $skip_call_trace = 0;
2264 } 2070 }
2265 2071
2266 if ($full_line =~ /Kernel panic -/) { 2072 if ($full_line =~ /Kernel panic -/) {
2267 $failure_start = time; 2073 $failure_start = time;
2268 $bug = 1; 2074 $bug = 1;
2269 } 2075 }
2270 2076
2271 # Detect triple faults by testing the 2077 # Detect triple faults by testing the banner
2272 if ($full_line =~ /\bLinux version (\ 2078 if ($full_line =~ /\bLinux version (\S+).*\n/) {
2273 if ($1 eq $version) { 2079 if ($1 eq $version) {
2274 $version_found = 1; 2080 $version_found = 1;
2275 } elsif ($version_found && $detec 2081 } elsif ($version_found && $detect_triplefault) {
2276 # We already booted into the 2082 # We already booted into the kernel we are testing,
2277 # but now we booted into anot 2083 # but now we booted into another kernel?
2278 # Consider this a triple faul 2084 # Consider this a triple fault.
2279 doprint "Already booted in Li 2085 doprint "Already booted in Linux kernel $version, but now\n";
2280 doprint "we booted into Linux 2086 doprint "we booted into Linux kernel $1.\n";
2281 doprint "Assuming that this i 2087 doprint "Assuming that this is a triple fault.\n";
2282 doprint "To disable this: set 2088 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
2283 last; 2089 last;
2284 } 2090 }
2285 } 2091 }
2286 2092
2287 if ($line =~ /\n/) { 2093 if ($line =~ /\n/) {
2288 $full_line = ""; 2094 $full_line = "";
2289 } 2095 }
2290 2096
2291 if ($stop_test_after > 0 && !$booted 2097 if ($stop_test_after > 0 && !$booted && !$bug) {
2292 if (time - $monitor_start > $stop 2098 if (time - $monitor_start > $stop_test_after) {
2293 doprint "STOP_TEST_AFTER ($st 2099 doprint "STOP_TEST_AFTER ($stop_test_after seconds) timed out\n";
2294 $done = 1; 2100 $done = 1;
2295 } 2101 }
2296 } 2102 }
2297 } 2103 }
2298 2104
2299 my $end_time = time; 2105 my $end_time = time;
2300 $reboot_time = $end_time - $start_time; 2106 $reboot_time = $end_time - $start_time;
2301 2107
2302 close(DMESG); 2108 close(DMESG);
2303 2109
2304 if ($bug) { 2110 if ($bug) {
2305 return 0 if ($in_bisect); 2111 return 0 if ($in_bisect);
2306 fail "failed - got a bug report" and 2112 fail "failed - got a bug report" and return 0;
2307 } 2113 }
2308 2114
2309 if (!$booted) { 2115 if (!$booted) {
2310 return 0 if ($in_bisect); 2116 return 0 if ($in_bisect);
2311 fail "failed - never got a boot promp 2117 fail "failed - never got a boot prompt." and return 0;
2312 } 2118 }
2313 2119
2314 if ($bug_ignored) { 2120 if ($bug_ignored) {
2315 doprint "WARNING: Call Trace detected 2121 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2316 } 2122 }
2317 2123
2318 return 1; 2124 return 1;
2319 } 2125 }
2320 2126
2321 sub eval_kernel_version { 2127 sub eval_kernel_version {
2322 my ($option) = @_; 2128 my ($option) = @_;
2323 2129
2324 $option =~ s/\$KERNEL_VERSION/$version/g; 2130 $option =~ s/\$KERNEL_VERSION/$version/g;
2325 2131
2326 return $option; 2132 return $option;
2327 } 2133 }
2328 2134
2329 sub do_post_install { 2135 sub do_post_install {
2330 2136
2331 return if (!defined($post_install)); 2137 return if (!defined($post_install));
2332 2138
2333 my $cp_post_install = eval_kernel_version 2139 my $cp_post_install = eval_kernel_version $post_install;
2334 run_command "$cp_post_install" or 2140 run_command "$cp_post_install" or
2335 dodie "Failed to run post install"; 2141 dodie "Failed to run post install";
2336 } 2142 }
2337 2143
2338 # Sometimes the reboot fails, and will hang. 2144 # Sometimes the reboot fails, and will hang. We try to ssh to the box
2339 # and if we fail, we force another reboot, th 2145 # and if we fail, we force another reboot, that should powercycle it.
2340 sub test_booted { 2146 sub test_booted {
2341 if (!run_ssh "echo testing connection") { 2147 if (!run_ssh "echo testing connection") {
2342 reboot $sleep_time; 2148 reboot $sleep_time;
2343 } 2149 }
2344 } 2150 }
2345 2151
2346 sub install { 2152 sub install {
2347 2153
2348 return if ($no_install); 2154 return if ($no_install);
2349 2155
2350 my $start_time = time; 2156 my $start_time = time;
2351 2157
2352 if (defined($pre_install)) { 2158 if (defined($pre_install)) {
2353 my $cp_pre_install = eval_kernel_vers 2159 my $cp_pre_install = eval_kernel_version $pre_install;
2354 run_command "$cp_pre_install" or 2160 run_command "$cp_pre_install" or
2355 dodie "Failed to run pre install" 2161 dodie "Failed to run pre install";
2356 } 2162 }
2357 2163
2358 my $cp_target = eval_kernel_version $targ 2164 my $cp_target = eval_kernel_version $target_image;
2359 2165
2360 test_booted; 2166 test_booted;
2361 2167
2362 run_scp_install "$outputdir/$build_target 2168 run_scp_install "$outputdir/$build_target", "$cp_target" or
2363 dodie "failed to copy image"; 2169 dodie "failed to copy image";
2364 2170
2365 my $install_mods = 0; 2171 my $install_mods = 0;
2366 2172
2367 # should we process modules? 2173 # should we process modules?
2368 $install_mods = 0; 2174 $install_mods = 0;
2369 open(IN, "$output_config") or dodie("Can' 2175 open(IN, "$output_config") or dodie("Can't read config file");
2370 while (<IN>) { 2176 while (<IN>) {
2371 if (/CONFIG_MODULES(=y)?/) { 2177 if (/CONFIG_MODULES(=y)?/) {
2372 if (defined($1)) { 2178 if (defined($1)) {
2373 $install_mods = 1; 2179 $install_mods = 1;
2374 last; 2180 last;
2375 } 2181 }
2376 } 2182 }
2377 } 2183 }
2378 close(IN); 2184 close(IN);
2379 2185
2380 if (!$install_mods) { 2186 if (!$install_mods) {
2381 do_post_install; 2187 do_post_install;
2382 doprint "No modules needed\n"; 2188 doprint "No modules needed\n";
2383 my $end_time = time; 2189 my $end_time = time;
2384 $install_time = $end_time - $start_ti 2190 $install_time = $end_time - $start_time;
2385 return; 2191 return;
2386 } 2192 }
2387 2193
2388 run_command "$make INSTALL_MOD_STRIP=1 IN 2194 run_command "$make INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=$tmpdir modules_install" or
2389 dodie "Failed to install modules"; 2195 dodie "Failed to install modules";
2390 2196
2391 my $modlib = "/lib/modules/$version"; 2197 my $modlib = "/lib/modules/$version";
2392 my $modtar = "ktest-mods.tar.bz2"; 2198 my $modtar = "ktest-mods.tar.bz2";
2393 2199
2394 run_ssh "rm -rf $modlib" or 2200 run_ssh "rm -rf $modlib" or
2395 dodie "failed to remove old mods: $mo 2201 dodie "failed to remove old mods: $modlib";
2396 2202
2397 # would be nice if scp -r did not follow 2203 # would be nice if scp -r did not follow symbolic links
2398 run_command "cd $tmpdir && tar -cjf $modt 2204 run_command "cd $tmpdir && tar -cjf $modtar lib/modules/$version" or
2399 dodie "making tarball"; 2205 dodie "making tarball";
2400 2206
2401 run_scp_mod "$tmpdir/$modtar", "/tmp" or 2207 run_scp_mod "$tmpdir/$modtar", "/tmp" or
2402 dodie "failed to copy modules"; 2208 dodie "failed to copy modules";
2403 2209
2404 unlink "$tmpdir/$modtar"; 2210 unlink "$tmpdir/$modtar";
2405 2211
2406 run_ssh "'(cd / && tar xjf /tmp/$modtar)' 2212 run_ssh "'(cd / && tar xjf /tmp/$modtar)'" or
2407 dodie "failed to tar modules"; 2213 dodie "failed to tar modules";
2408 2214
2409 run_ssh "rm -f /tmp/$modtar"; 2215 run_ssh "rm -f /tmp/$modtar";
2410 2216
2411 do_post_install; 2217 do_post_install;
2412 2218
2413 my $end_time = time; 2219 my $end_time = time;
2414 $install_time = $end_time - $start_time; 2220 $install_time = $end_time - $start_time;
2415 } 2221 }
2416 2222
2417 sub get_version { 2223 sub get_version {
2418 # get the release name 2224 # get the release name
2419 return if ($have_version); 2225 return if ($have_version);
2420 doprint "$make kernelrelease ... "; 2226 doprint "$make kernelrelease ... ";
2421 $version = `$make -s kernelrelease | tail 2227 $version = `$make -s kernelrelease | tail -1`;
2422 chomp($version); 2228 chomp($version);
2423 doprint "$version\n"; 2229 doprint "$version\n";
2424 $have_version = 1; 2230 $have_version = 1;
2425 } 2231 }
2426 2232
2427 sub start_monitor_and_install { 2233 sub start_monitor_and_install {
2428 # Make sure the stable kernel has finishe 2234 # Make sure the stable kernel has finished booting
2429 2235
2430 # Install bisects, don't need console 2236 # Install bisects, don't need console
2431 if (defined $console) { 2237 if (defined $console) {
2432 start_monitor; 2238 start_monitor;
2433 wait_for_monitor 5; 2239 wait_for_monitor 5;
2434 end_monitor; 2240 end_monitor;
2435 } 2241 }
2436 2242
2437 get_grub_index; 2243 get_grub_index;
2438 get_version; 2244 get_version;
2439 install; 2245 install;
2440 2246
2441 start_monitor if (defined $console); 2247 start_monitor if (defined $console);
2442 return monitor; 2248 return monitor;
2443 } 2249 }
2444 2250
>> 2251 my $check_build_re = ".*:.*(warning|error|Error):.*";
>> 2252 my $utf8_quote = "\\x{e2}\\x{80}(\\x{98}|\\x{99})";
>> 2253
2445 sub process_warning_line { 2254 sub process_warning_line {
2446 my ($line) = @_; 2255 my ($line) = @_;
2447 2256
2448 chomp $line; 2257 chomp $line;
2449 2258
2450 # for distcc heterogeneous systems, some 2259 # for distcc heterogeneous systems, some compilers
2451 # do things differently causing warning l 2260 # do things differently causing warning lines
2452 # to be slightly different. This makes an 2261 # to be slightly different. This makes an attempt
2453 # to fixe those issues. 2262 # to fixe those issues.
2454 2263
2455 # chop off the index into the line 2264 # chop off the index into the line
2456 # using distcc, some compilers give diffe 2265 # using distcc, some compilers give different indexes
2457 # depending on white space 2266 # depending on white space
2458 $line =~ s/^(\s*\S+:\d+:)\d+/$1/; 2267 $line =~ s/^(\s*\S+:\d+:)\d+/$1/;
2459 2268
2460 # Some compilers use UTF-8 extended for q 2269 # Some compilers use UTF-8 extended for quotes and some don't.
2461 $line =~ s/$utf8_quote/'/g; 2270 $line =~ s/$utf8_quote/'/g;
2462 2271
2463 return $line; 2272 return $line;
2464 } 2273 }
2465 2274
2466 # Read buildlog and check against warnings fi 2275 # Read buildlog and check against warnings file for any
2467 # new warnings. 2276 # new warnings.
2468 # 2277 #
2469 # Returns 1 if OK 2278 # Returns 1 if OK
2470 # 0 otherwise 2279 # 0 otherwise
2471 sub check_buildlog { 2280 sub check_buildlog {
>> 2281 return 1 if (!defined $warnings_file);
>> 2282
2472 my %warnings_list; 2283 my %warnings_list;
2473 2284
2474 # Failed builds should not reboot the tar 2285 # Failed builds should not reboot the target
2475 my $save_no_reboot = $no_reboot; 2286 my $save_no_reboot = $no_reboot;
2476 $no_reboot = 1; 2287 $no_reboot = 1;
2477 2288
2478 if (-f $warnings_file) { 2289 if (-f $warnings_file) {
2479 open(IN, $warnings_file) or 2290 open(IN, $warnings_file) or
2480 dodie "Error opening $warnings_fi 2291 dodie "Error opening $warnings_file";
2481 2292
2482 while (<IN>) { 2293 while (<IN>) {
2483 if (/$check_build_re/) { 2294 if (/$check_build_re/) {
2484 my $warning = process_warning 2295 my $warning = process_warning_line $_;
2485 !! 2296
2486 $warnings_list{$warning} = 1; 2297 $warnings_list{$warning} = 1;
2487 } 2298 }
2488 } 2299 }
2489 close(IN); 2300 close(IN);
2490 } 2301 }
2491 2302
>> 2303 # If warnings file didn't exist, and WARNINGS_FILE exist,
>> 2304 # then we fail on any warning!
>> 2305
2492 open(IN, $buildlog) or dodie "Can't open 2306 open(IN, $buildlog) or dodie "Can't open $buildlog";
2493 while (<IN>) { 2307 while (<IN>) {
2494 if (/$check_build_re/) { 2308 if (/$check_build_re/) {
2495 my $warning = process_warning_lin 2309 my $warning = process_warning_line $_;
2496 2310
2497 if (!defined $warnings_list{$warn 2311 if (!defined $warnings_list{$warning}) {
2498 $warning_found++; !! 2312 fail "New warning found (not in $warnings_file)\n$_\n";
2499 !! 2313 $no_reboot = $save_no_reboot;
2500 # If warnings file didn't exi !! 2314 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 } 2315 }
2508 } 2316 }
2509 } 2317 }
2510 $no_reboot = $save_no_reboot; 2318 $no_reboot = $save_no_reboot;
2511 close(IN); 2319 close(IN);
2512 } 2320 }
2513 2321
2514 sub check_patch_buildlog { 2322 sub check_patch_buildlog {
2515 my ($patch) = @_; 2323 my ($patch) = @_;
2516 2324
2517 my @files = `git show $patch | diffstat - 2325 my @files = `git show $patch | diffstat -l`;
2518 2326
2519 foreach my $file (@files) { 2327 foreach my $file (@files) {
2520 chomp $file; 2328 chomp $file;
2521 } 2329 }
2522 2330
2523 open(IN, "git show $patch |") or 2331 open(IN, "git show $patch |") or
2524 dodie "failed to show $patch"; 2332 dodie "failed to show $patch";
2525 while (<IN>) { 2333 while (<IN>) {
2526 if (m,^--- a/(.*),) { 2334 if (m,^--- a/(.*),) {
2527 chomp $1; 2335 chomp $1;
2528 $files[$#files] = $1; 2336 $files[$#files] = $1;
2529 } 2337 }
2530 } 2338 }
2531 close(IN); 2339 close(IN);
2532 2340
2533 open(IN, $buildlog) or dodie "Can't open 2341 open(IN, $buildlog) or dodie "Can't open $buildlog";
2534 while (<IN>) { 2342 while (<IN>) {
2535 if (/^\s*(.*?):.*(warning|error)/) { 2343 if (/^\s*(.*?):.*(warning|error)/) {
2536 my $err = $1; 2344 my $err = $1;
2537 foreach my $file (@files) { 2345 foreach my $file (@files) {
2538 my $fullpath = "$builddir/$fi 2346 my $fullpath = "$builddir/$file";
2539 if ($file eq $err || $fullpat 2347 if ($file eq $err || $fullpath eq $err) {
2540 fail "$file built with wa 2348 fail "$file built with warnings" and return 0;
2541 } 2349 }
2542 } 2350 }
2543 } 2351 }
2544 } 2352 }
2545 close(IN); 2353 close(IN);
2546 2354
2547 return 1; 2355 return 1;
2548 } 2356 }
2549 2357
2550 sub apply_min_config { 2358 sub apply_min_config {
2551 my $outconfig = "$output_config.new"; 2359 my $outconfig = "$output_config.new";
2552 2360
2553 # Read the config file and remove anythin 2361 # Read the config file and remove anything that
2554 # is in the force_config hash (from minco 2362 # is in the force_config hash (from minconfig and others)
2555 # then add the force config back. 2363 # then add the force config back.
2556 2364
2557 doprint "Applying minimum configurations 2365 doprint "Applying minimum configurations into $output_config.new\n";
2558 2366
2559 open (OUT, ">$outconfig") or 2367 open (OUT, ">$outconfig") or
2560 dodie "Can't create $outconfig"; 2368 dodie "Can't create $outconfig";
2561 2369
2562 if (-f $output_config) { 2370 if (-f $output_config) {
2563 open (IN, $output_config) or 2371 open (IN, $output_config) or
2564 dodie "Failed to open $output_con 2372 dodie "Failed to open $output_config";
2565 while (<IN>) { 2373 while (<IN>) {
2566 if (/^(# )?(CONFIG_[^\s=]*)/) { 2374 if (/^(# )?(CONFIG_[^\s=]*)/) {
2567 next if (defined($force_confi 2375 next if (defined($force_config{$2}));
2568 } 2376 }
2569 print OUT; 2377 print OUT;
2570 } 2378 }
2571 close IN; 2379 close IN;
2572 } 2380 }
2573 foreach my $config (keys %force_config) { 2381 foreach my $config (keys %force_config) {
2574 print OUT "$force_config{$config}\n"; 2382 print OUT "$force_config{$config}\n";
2575 } 2383 }
2576 close OUT; 2384 close OUT;
2577 2385
2578 run_command "mv $outconfig $output_config 2386 run_command "mv $outconfig $output_config";
2579 } 2387 }
2580 2388
2581 sub make_oldconfig { 2389 sub make_oldconfig {
2582 2390
2583 my @force_list = keys %force_config; 2391 my @force_list = keys %force_config;
2584 2392
2585 if ($#force_list >= 0) { 2393 if ($#force_list >= 0) {
2586 apply_min_config; 2394 apply_min_config;
2587 } 2395 }
2588 2396
2589 if (!run_command "$make olddefconfig") { 2397 if (!run_command "$make olddefconfig") {
2590 # Perhaps olddefconfig doesn't exist 2398 # Perhaps olddefconfig doesn't exist in this version of the kernel
2591 # try oldnoconfig 2399 # try oldnoconfig
2592 doprint "olddefconfig failed, trying 2400 doprint "olddefconfig failed, trying make oldnoconfig\n";
2593 if (!run_command "$make oldnoconfig") 2401 if (!run_command "$make oldnoconfig") {
2594 doprint "oldnoconfig failed, tryi 2402 doprint "oldnoconfig failed, trying yes '' | make oldconfig\n";
2595 # try a yes '' | oldconfig 2403 # try a yes '' | oldconfig
2596 run_command "yes '' | $make oldco 2404 run_command "yes '' | $make oldconfig" or
2597 dodie "failed make config old 2405 dodie "failed make config oldconfig";
2598 } 2406 }
2599 } 2407 }
2600 } 2408 }
2601 2409
2602 # read a config file and use this to force ne 2410 # read a config file and use this to force new configs.
2603 sub load_force_config { 2411 sub load_force_config {
2604 my ($config) = @_; 2412 my ($config) = @_;
2605 2413
2606 doprint "Loading force configs from $conf 2414 doprint "Loading force configs from $config\n";
2607 open(IN, $config) or 2415 open(IN, $config) or
2608 dodie "failed to read $config"; 2416 dodie "failed to read $config";
2609 while (<IN>) { 2417 while (<IN>) {
2610 chomp; 2418 chomp;
2611 if (/^(CONFIG[^\s=]*)(\s*=.*)/) { 2419 if (/^(CONFIG[^\s=]*)(\s*=.*)/) {
2612 $force_config{$1} = $_; 2420 $force_config{$1} = $_;
2613 } elsif (/^# (CONFIG_\S*) is not set/ 2421 } elsif (/^# (CONFIG_\S*) is not set/) {
2614 $force_config{$1} = $_; 2422 $force_config{$1} = $_;
2615 } 2423 }
2616 } 2424 }
2617 close IN; 2425 close IN;
2618 } 2426 }
2619 2427
2620 sub build { 2428 sub build {
2621 my ($type) = @_; 2429 my ($type) = @_;
2622 2430
2623 unlink $buildlog; 2431 unlink $buildlog;
2624 2432
2625 my $start_time = time; 2433 my $start_time = time;
2626 2434
2627 # Failed builds should not reboot the tar 2435 # Failed builds should not reboot the target
2628 my $save_no_reboot = $no_reboot; 2436 my $save_no_reboot = $no_reboot;
2629 $no_reboot = 1; 2437 $no_reboot = 1;
2630 2438
2631 # Calculate a new version from here. 2439 # Calculate a new version from here.
2632 $have_version = 0; 2440 $have_version = 0;
2633 2441
2634 if (defined($pre_build)) { 2442 if (defined($pre_build)) {
2635 my $ret = run_command $pre_build; 2443 my $ret = run_command $pre_build;
2636 if (!$ret && defined($pre_build_die) 2444 if (!$ret && defined($pre_build_die) &&
2637 $pre_build_die) { 2445 $pre_build_die) {
2638 dodie "failed to pre_build\n"; 2446 dodie "failed to pre_build\n";
2639 } 2447 }
2640 } 2448 }
2641 2449
2642 if ($type =~ /^useconfig:(.*)/) { 2450 if ($type =~ /^useconfig:(.*)/) {
2643 run_command "cp $1 $output_config" or 2451 run_command "cp $1 $output_config" or
2644 dodie "could not copy $1 to .conf 2452 dodie "could not copy $1 to .config";
2645 2453
2646 $type = "oldconfig"; 2454 $type = "oldconfig";
2647 } 2455 }
2648 2456
2649 # old config can ask questions 2457 # old config can ask questions
2650 if ($type eq "oldconfig") { 2458 if ($type eq "oldconfig") {
2651 $type = "olddefconfig"; 2459 $type = "olddefconfig";
2652 2460
2653 # allow for empty configs 2461 # allow for empty configs
2654 run_command "touch $output_config"; 2462 run_command "touch $output_config";
2655 2463
2656 if (!$noclean) { 2464 if (!$noclean) {
2657 run_command "mv $output_config $o 2465 run_command "mv $output_config $outputdir/config_temp" or
2658 dodie "moving .config"; 2466 dodie "moving .config";
2659 2467
2660 run_command "$make mrproper" or d 2468 run_command "$make mrproper" or dodie "make mrproper";
2661 2469
2662 run_command "mv $outputdir/config 2470 run_command "mv $outputdir/config_temp $output_config" or
2663 dodie "moving config_temp"; 2471 dodie "moving config_temp";
2664 } 2472 }
>> 2473
2665 } elsif (!$noclean) { 2474 } elsif (!$noclean) {
2666 unlink "$output_config"; 2475 unlink "$output_config";
2667 run_command "$make mrproper" or 2476 run_command "$make mrproper" or
2668 dodie "make mrproper"; 2477 dodie "make mrproper";
2669 } 2478 }
2670 2479
2671 # add something to distinguish this build 2480 # add something to distinguish this build
2672 open(OUT, "> $outputdir/localversion") or 2481 open(OUT, "> $outputdir/localversion") or dodie("Can't make localversion file");
2673 print OUT "$localversion\n"; 2482 print OUT "$localversion\n";
2674 close(OUT); 2483 close(OUT);
2675 2484
2676 if (defined($minconfig)) { 2485 if (defined($minconfig)) {
2677 load_force_config($minconfig); 2486 load_force_config($minconfig);
2678 } 2487 }
2679 2488
2680 if ($type ne "olddefconfig") { 2489 if ($type ne "olddefconfig") {
2681 run_command "$make $type" or 2490 run_command "$make $type" or
2682 dodie "failed make config"; 2491 dodie "failed make config";
2683 } 2492 }
2684 # Run old config regardless, to enforce m 2493 # Run old config regardless, to enforce min configurations
2685 make_oldconfig; 2494 make_oldconfig;
2686 2495
2687 if (not defined($build_options)){ <<
2688 $build_options = ""; <<
2689 } <<
2690 my $build_ret = run_command "$make $build 2496 my $build_ret = run_command "$make $build_options", $buildlog;
2691 2497
2692 if (defined($post_build)) { 2498 if (defined($post_build)) {
2693 # Because a post build may change the 2499 # Because a post build may change the kernel version
2694 # do it now. 2500 # do it now.
2695 get_version; 2501 get_version;
2696 my $ret = run_command $post_build; 2502 my $ret = run_command $post_build;
2697 if (!$ret && defined($post_build_die) 2503 if (!$ret && defined($post_build_die) &&
2698 $post_build_die) { 2504 $post_build_die) {
2699 dodie "failed to post_build\n"; 2505 dodie "failed to post_build\n";
2700 } 2506 }
2701 } 2507 }
2702 2508
2703 if (!$build_ret) { 2509 if (!$build_ret) {
2704 # bisect may need this to pass 2510 # bisect may need this to pass
2705 if ($in_bisect) { 2511 if ($in_bisect) {
2706 $no_reboot = $save_no_reboot; 2512 $no_reboot = $save_no_reboot;
2707 return 0; 2513 return 0;
2708 } 2514 }
2709 fail "failed build" and return 0; 2515 fail "failed build" and return 0;
2710 } 2516 }
2711 2517
2712 $no_reboot = $save_no_reboot; 2518 $no_reboot = $save_no_reboot;
2713 2519
2714 my $end_time = time; 2520 my $end_time = time;
2715 $build_time = $end_time - $start_time; 2521 $build_time = $end_time - $start_time;
2716 2522
2717 return 1; 2523 return 1;
2718 } 2524 }
2719 2525
2720 sub halt { 2526 sub halt {
2721 if (!run_ssh "halt" or defined($power_off 2527 if (!run_ssh "halt" or defined($power_off)) {
2722 if (defined($poweroff_after_halt)) { 2528 if (defined($poweroff_after_halt)) {
2723 sleep $poweroff_after_halt; 2529 sleep $poweroff_after_halt;
2724 run_command "$power_off"; 2530 run_command "$power_off";
2725 } 2531 }
2726 } else { 2532 } else {
2727 # nope? the zap it! 2533 # nope? the zap it!
2728 run_command "$power_off"; 2534 run_command "$power_off";
2729 } 2535 }
2730 } 2536 }
2731 2537
2732 sub success { 2538 sub success {
2733 my ($i) = @_; 2539 my ($i) = @_;
2734 2540
2735 $successes++; 2541 $successes++;
2736 2542
2737 my $name = ""; 2543 my $name = "";
2738 2544
2739 if (defined($test_name)) { 2545 if (defined($test_name)) {
2740 $name = " ($test_name)"; 2546 $name = " ($test_name)";
2741 } 2547 }
2742 2548
2743 print_times; 2549 print_times;
2744 2550
2745 doprint "\n\n"; !! 2551 doprint "\n\n*******************************************\n";
2746 doprint "******************************** !! 2552 doprint "*******************************************\n";
2747 doprint "******************************** !! 2553 doprint "KTEST RESULT: TEST $i$name SUCCESS!!!! **\n";
2748 doprint "KTEST RESULT: TEST $i$name SUCCE !! 2554 doprint "*******************************************\n";
2749 doprint "******************************** !! 2555 doprint "*******************************************\n";
2750 doprint "******************************** <<
2751 2556
2752 if (defined($store_successes)) { 2557 if (defined($store_successes)) {
2753 save_logs "success", $store_successes !! 2558 save_logs "success", $store_successes;
2754 } 2559 }
2755 2560
2756 if ($i != $opt{"NUM_TESTS"} && !do_not_re 2561 if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
2757 doprint "Reboot and wait $sleep_time 2562 doprint "Reboot and wait $sleep_time seconds\n";
2758 reboot_to_good $sleep_time; 2563 reboot_to_good $sleep_time;
2759 } 2564 }
2760 2565
2761 if (defined($post_test)) { 2566 if (defined($post_test)) {
2762 run_command $post_test; 2567 run_command $post_test;
2763 } 2568 }
2764 } 2569 }
2765 2570
2766 sub answer_bisect { 2571 sub answer_bisect {
2767 for (;;) { 2572 for (;;) {
2768 doprint "Pass, fail, or skip? [p/f/s] 2573 doprint "Pass, fail, or skip? [p/f/s]";
2769 my $ans = <STDIN>; 2574 my $ans = <STDIN>;
2770 chomp $ans; 2575 chomp $ans;
2771 if ($ans eq "p" || $ans eq "P") { 2576 if ($ans eq "p" || $ans eq "P") {
2772 return 1; 2577 return 1;
2773 } elsif ($ans eq "f" || $ans eq "F") 2578 } elsif ($ans eq "f" || $ans eq "F") {
2774 return 0; 2579 return 0;
2775 } elsif ($ans eq "s" || $ans eq "S") 2580 } elsif ($ans eq "s" || $ans eq "S") {
2776 return -1; 2581 return -1;
2777 } else { 2582 } else {
2778 print "Please answer 'p', 'f', or 2583 print "Please answer 'p', 'f', or 's'\n";
2779 } 2584 }
2780 } 2585 }
2781 } 2586 }
2782 2587
2783 sub child_run_test { 2588 sub child_run_test {
2784 2589
2785 # child should have no power 2590 # child should have no power
2786 $reboot_on_error = 0; 2591 $reboot_on_error = 0;
2787 $poweroff_on_error = 0; 2592 $poweroff_on_error = 0;
2788 $die_on_failure = 1; 2593 $die_on_failure = 1;
2789 2594
2790 run_command $run_test, $testlog; 2595 run_command $run_test, $testlog;
2791 2596
2792 exit $run_command_status; 2597 exit $run_command_status;
2793 } 2598 }
2794 2599
>> 2600 my $child_done;
>> 2601
2795 sub child_finished { 2602 sub child_finished {
2796 $child_done = 1; 2603 $child_done = 1;
2797 } 2604 }
2798 2605
2799 sub do_run_test { 2606 sub do_run_test {
2800 my $child_pid; 2607 my $child_pid;
2801 my $child_exit; 2608 my $child_exit;
2802 my $line; 2609 my $line;
2803 my $full_line; 2610 my $full_line;
2804 my $bug = 0; 2611 my $bug = 0;
2805 my $bug_ignored = 0; 2612 my $bug_ignored = 0;
2806 2613
2807 my $start_time = time; 2614 my $start_time = time;
2808 2615
2809 wait_for_monitor 1; 2616 wait_for_monitor 1;
2810 2617
2811 doprint "run test $run_test\n"; 2618 doprint "run test $run_test\n";
2812 2619
2813 $child_done = 0; 2620 $child_done = 0;
2814 2621
2815 $SIG{CHLD} = qw(child_finished); 2622 $SIG{CHLD} = qw(child_finished);
2816 2623
2817 $child_pid = fork; 2624 $child_pid = fork;
2818 2625
2819 child_run_test if (!$child_pid); 2626 child_run_test if (!$child_pid);
2820 2627
2821 $full_line = ""; 2628 $full_line = "";
2822 2629
2823 do { 2630 do {
2824 $line = wait_for_input($monitor_fp, 1 2631 $line = wait_for_input($monitor_fp, 1);
2825 if (defined($line)) { 2632 if (defined($line)) {
2826 2633
2827 # we are not guaranteed to get a 2634 # we are not guaranteed to get a full line
2828 $full_line .= $line; 2635 $full_line .= $line;
2829 doprint $line; 2636 doprint $line;
2830 2637
2831 if ($full_line =~ /call trace:/i) 2638 if ($full_line =~ /call trace:/i) {
2832 if ($ignore_errors) { 2639 if ($ignore_errors) {
2833 $bug_ignored = 1; 2640 $bug_ignored = 1;
2834 } else { 2641 } else {
2835 $bug = 1; 2642 $bug = 1;
2836 } 2643 }
2837 } 2644 }
2838 2645
2839 if ($full_line =~ /Kernel panic - 2646 if ($full_line =~ /Kernel panic -/) {
2840 $bug = 1; 2647 $bug = 1;
2841 } 2648 }
2842 2649
2843 if ($line =~ /\n/) { 2650 if ($line =~ /\n/) {
2844 $full_line = ""; 2651 $full_line = "";
2845 } 2652 }
2846 } 2653 }
2847 } while (!$child_done && !$bug); 2654 } while (!$child_done && !$bug);
2848 2655
2849 if (!$bug && $bug_ignored) { 2656 if (!$bug && $bug_ignored) {
2850 doprint "WARNING: Call Trace detected 2657 doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
2851 } 2658 }
2852 2659
2853 if ($bug) { 2660 if ($bug) {
2854 my $failure_start = time; 2661 my $failure_start = time;
2855 my $now; 2662 my $now;
2856 do { 2663 do {
2857 $line = wait_for_input($monitor_f 2664 $line = wait_for_input($monitor_fp, 1);
2858 if (defined($line)) { 2665 if (defined($line)) {
2859 doprint $line; 2666 doprint $line;
2860 } 2667 }
2861 $now = time; 2668 $now = time;
2862 if ($now - $failure_start >= $sto 2669 if ($now - $failure_start >= $stop_after_failure) {
2863 last; 2670 last;
2864 } 2671 }
2865 } while (defined($line)); 2672 } while (defined($line));
2866 2673
2867 doprint "Detected kernel crash!\n"; 2674 doprint "Detected kernel crash!\n";
2868 # kill the child with extreme prejudi 2675 # kill the child with extreme prejudice
2869 kill 9, $child_pid; 2676 kill 9, $child_pid;
2870 } 2677 }
2871 2678
2872 waitpid $child_pid, 0; 2679 waitpid $child_pid, 0;
2873 $child_exit = $? >> 8; 2680 $child_exit = $? >> 8;
2874 2681
2875 my $end_time = time; 2682 my $end_time = time;
2876 $test_time = $end_time - $start_time; 2683 $test_time = $end_time - $start_time;
2877 2684
2878 if (!$bug && $in_bisect) { 2685 if (!$bug && $in_bisect) {
2879 if (defined($bisect_ret_good)) { 2686 if (defined($bisect_ret_good)) {
2880 if ($child_exit == $bisect_ret_go 2687 if ($child_exit == $bisect_ret_good) {
2881 return 1; 2688 return 1;
2882 } 2689 }
2883 } 2690 }
2884 if (defined($bisect_ret_skip)) { 2691 if (defined($bisect_ret_skip)) {
2885 if ($child_exit == $bisect_ret_sk 2692 if ($child_exit == $bisect_ret_skip) {
2886 return -1; 2693 return -1;
2887 } 2694 }
2888 } 2695 }
2889 if (defined($bisect_ret_abort)) { 2696 if (defined($bisect_ret_abort)) {
2890 if ($child_exit == $bisect_ret_ab 2697 if ($child_exit == $bisect_ret_abort) {
2891 fail "test abort" and return 2698 fail "test abort" and return -2;
2892 } 2699 }
2893 } 2700 }
2894 if (defined($bisect_ret_bad)) { 2701 if (defined($bisect_ret_bad)) {
2895 if ($child_exit == $bisect_ret_sk 2702 if ($child_exit == $bisect_ret_skip) {
2896 return 0; 2703 return 0;
2897 } 2704 }
2898 } 2705 }
2899 if (defined($bisect_ret_default)) { 2706 if (defined($bisect_ret_default)) {
2900 if ($bisect_ret_default eq "good" 2707 if ($bisect_ret_default eq "good") {
2901 return 1; 2708 return 1;
2902 } elsif ($bisect_ret_default eq " 2709 } elsif ($bisect_ret_default eq "bad") {
2903 return 0; 2710 return 0;
2904 } elsif ($bisect_ret_default eq " 2711 } elsif ($bisect_ret_default eq "skip") {
2905 return -1; 2712 return -1;
2906 } elsif ($bisect_ret_default eq " 2713 } elsif ($bisect_ret_default eq "abort") {
2907 return -2; 2714 return -2;
2908 } else { 2715 } else {
2909 fail "unknown default action: 2716 fail "unknown default action: $bisect_ret_default"
2910 and return -2; 2717 and return -2;
2911 } 2718 }
2912 } 2719 }
2913 } 2720 }
2914 2721
2915 if ($bug || $child_exit) { 2722 if ($bug || $child_exit) {
2916 return 0 if $in_bisect; 2723 return 0 if $in_bisect;
2917 fail "test failed" and return 0; 2724 fail "test failed" and return 0;
2918 } 2725 }
2919 return 1; 2726 return 1;
2920 } 2727 }
2921 2728
2922 sub run_git_bisect { 2729 sub run_git_bisect {
2923 my ($command) = @_; 2730 my ($command) = @_;
2924 2731
2925 doprint "$command ... "; 2732 doprint "$command ... ";
2926 2733
2927 my $output = `$command 2>&1`; 2734 my $output = `$command 2>&1`;
2928 my $ret = $?; 2735 my $ret = $?;
2929 2736
2930 logit $output; 2737 logit $output;
2931 2738
2932 if ($ret) { 2739 if ($ret) {
2933 doprint "FAILED\n"; 2740 doprint "FAILED\n";
2934 dodie "Failed to git bisect"; 2741 dodie "Failed to git bisect";
2935 } 2742 }
2936 2743
2937 doprint "SUCCESS\n"; 2744 doprint "SUCCESS\n";
2938 if ($output =~ m/^(Bisecting: .*\(roughly 2745 if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
2939 doprint "$1 [$2]\n"; 2746 doprint "$1 [$2]\n";
2940 } elsif ($output =~ m/^([[:xdigit:]]+) is 2747 } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
2941 $bisect_bad_commit = $1; 2748 $bisect_bad_commit = $1;
2942 doprint "Found bad commit... $1\n"; 2749 doprint "Found bad commit... $1\n";
2943 return 0; 2750 return 0;
2944 } else { 2751 } else {
2945 # we already logged it, just print it 2752 # we already logged it, just print it now.
2946 print $output; 2753 print $output;
2947 } 2754 }
2948 2755
2949 return 1; 2756 return 1;
2950 } 2757 }
2951 2758
2952 sub bisect_reboot { 2759 sub bisect_reboot {
2953 doprint "Reboot and sleep $bisect_sleep_t 2760 doprint "Reboot and sleep $bisect_sleep_time seconds\n";
2954 reboot_to_good $bisect_sleep_time; 2761 reboot_to_good $bisect_sleep_time;
2955 } 2762 }
2956 2763
2957 # returns 1 on success, 0 on failure, -1 on s 2764 # returns 1 on success, 0 on failure, -1 on skip
2958 sub run_bisect_test { 2765 sub run_bisect_test {
2959 my ($type, $buildtype) = @_; 2766 my ($type, $buildtype) = @_;
2960 2767
2961 my $failed = 0; 2768 my $failed = 0;
2962 my $result; 2769 my $result;
2963 my $output; 2770 my $output;
2964 my $ret; 2771 my $ret;
2965 2772
2966 $in_bisect = 1; 2773 $in_bisect = 1;
2967 2774
2968 build $buildtype or $failed = 1; 2775 build $buildtype or $failed = 1;
2969 2776
2970 if ($type ne "build") { 2777 if ($type ne "build") {
2971 if ($failed && $bisect_skip) { 2778 if ($failed && $bisect_skip) {
2972 $in_bisect = 0; 2779 $in_bisect = 0;
2973 return -1; 2780 return -1;
2974 } 2781 }
2975 dodie "Failed on build" if $failed; 2782 dodie "Failed on build" if $failed;
2976 2783
2977 # Now boot the box 2784 # Now boot the box
2978 start_monitor_and_install or $failed 2785 start_monitor_and_install or $failed = 1;
2979 2786
2980 if ($type ne "boot") { 2787 if ($type ne "boot") {
2981 if ($failed && $bisect_skip) { 2788 if ($failed && $bisect_skip) {
2982 end_monitor; 2789 end_monitor;
2983 bisect_reboot; 2790 bisect_reboot;
2984 $in_bisect = 0; 2791 $in_bisect = 0;
2985 return -1; 2792 return -1;
2986 } 2793 }
2987 dodie "Failed on boot" if $failed 2794 dodie "Failed on boot" if $failed;
2988 2795
2989 do_run_test or $failed = 1; 2796 do_run_test or $failed = 1;
2990 } 2797 }
2991 end_monitor; 2798 end_monitor;
2992 } 2799 }
2993 2800
2994 if ($failed) { 2801 if ($failed) {
2995 $result = 0; 2802 $result = 0;
2996 } else { 2803 } else {
2997 $result = 1; 2804 $result = 1;
2998 } 2805 }
2999 2806
3000 # reboot the box to a kernel we can ssh t 2807 # reboot the box to a kernel we can ssh to
3001 if ($type ne "build") { 2808 if ($type ne "build") {
3002 bisect_reboot; 2809 bisect_reboot;
3003 } 2810 }
3004 $in_bisect = 0; 2811 $in_bisect = 0;
3005 2812
3006 return $result; 2813 return $result;
3007 } 2814 }
3008 2815
3009 sub run_bisect { 2816 sub run_bisect {
3010 my ($type) = @_; 2817 my ($type) = @_;
3011 my $buildtype = "oldconfig"; 2818 my $buildtype = "oldconfig";
3012 2819
3013 # We should have a minconfig to use? 2820 # We should have a minconfig to use?
3014 if (defined($minconfig)) { 2821 if (defined($minconfig)) {
3015 $buildtype = "useconfig:$minconfig"; 2822 $buildtype = "useconfig:$minconfig";
3016 } 2823 }
3017 2824
3018 # If the user sets bisect_tries to less t 2825 # If the user sets bisect_tries to less than 1, then no tries
3019 # is a success. 2826 # is a success.
3020 my $ret = 1; 2827 my $ret = 1;
3021 2828
3022 # Still let the user manually decide that 2829 # Still let the user manually decide that though.
3023 if ($bisect_tries < 1 && $bisect_manual) 2830 if ($bisect_tries < 1 && $bisect_manual) {
3024 $ret = answer_bisect; 2831 $ret = answer_bisect;
3025 } 2832 }
3026 2833
3027 for (my $i = 0; $i < $bisect_tries; $i++) 2834 for (my $i = 0; $i < $bisect_tries; $i++) {
3028 if ($bisect_tries > 1) { 2835 if ($bisect_tries > 1) {
3029 my $t = $i + 1; 2836 my $t = $i + 1;
3030 doprint("Running bisect trial $t 2837 doprint("Running bisect trial $t of $bisect_tries:\n");
3031 } 2838 }
3032 $ret = run_bisect_test $type, $buildt 2839 $ret = run_bisect_test $type, $buildtype;
3033 2840
3034 if ($bisect_manual) { 2841 if ($bisect_manual) {
3035 $ret = answer_bisect; 2842 $ret = answer_bisect;
3036 } 2843 }
3037 2844
3038 last if (!$ret); 2845 last if (!$ret);
3039 } 2846 }
3040 2847
3041 # Are we looking for where it worked, not 2848 # Are we looking for where it worked, not failed?
3042 if ($reverse_bisect && $ret >= 0) { 2849 if ($reverse_bisect && $ret >= 0) {
3043 $ret = !$ret; 2850 $ret = !$ret;
3044 } 2851 }
3045 2852
3046 if ($ret > 0) { 2853 if ($ret > 0) {
3047 return "good"; 2854 return "good";
3048 } elsif ($ret == 0) { 2855 } elsif ($ret == 0) {
3049 return "bad"; 2856 return "bad";
3050 } elsif ($bisect_skip) { 2857 } elsif ($bisect_skip) {
3051 doprint "HIT A BAD COMMIT ... SKIPPIN 2858 doprint "HIT A BAD COMMIT ... SKIPPING\n";
3052 return "skip"; 2859 return "skip";
3053 } 2860 }
3054 } 2861 }
3055 2862
3056 sub update_bisect_replay { 2863 sub update_bisect_replay {
3057 my $tmp_log = "$tmpdir/ktest_bisect_log"; 2864 my $tmp_log = "$tmpdir/ktest_bisect_log";
3058 run_command "git bisect log > $tmp_log" o 2865 run_command "git bisect log > $tmp_log" or
3059 dodie "can't create bisect log"; !! 2866 die "can't create bisect log";
3060 return $tmp_log; 2867 return $tmp_log;
3061 } 2868 }
3062 2869
3063 sub bisect { 2870 sub bisect {
3064 my ($i) = @_; 2871 my ($i) = @_;
3065 2872
3066 my $result; 2873 my $result;
3067 2874
3068 dodie "BISECT_GOOD[$i] not defined\n" !! 2875 die "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good));
3069 dodie "BISECT_BAD[$i] not defined\n" !! 2876 die "BISECT_BAD[$i] not defined\n" if (!defined($bisect_bad));
3070 dodie "BISECT_TYPE[$i] not defined\n" !! 2877 die "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type));
3071 2878
3072 my $good = $bisect_good; 2879 my $good = $bisect_good;
3073 my $bad = $bisect_bad; 2880 my $bad = $bisect_bad;
3074 my $type = $bisect_type; 2881 my $type = $bisect_type;
3075 my $start = $bisect_start; 2882 my $start = $bisect_start;
3076 my $replay = $bisect_replay; 2883 my $replay = $bisect_replay;
3077 my $start_files = $bisect_files; 2884 my $start_files = $bisect_files;
3078 2885
3079 if (defined($start_files)) { 2886 if (defined($start_files)) {
3080 $start_files = " -- " . $start_files; 2887 $start_files = " -- " . $start_files;
3081 } else { 2888 } else {
3082 $start_files = ""; 2889 $start_files = "";
3083 } 2890 }
3084 2891
3085 # convert to true sha1's 2892 # convert to true sha1's
3086 $good = get_sha1($good); 2893 $good = get_sha1($good);
3087 $bad = get_sha1($bad); 2894 $bad = get_sha1($bad);
3088 2895
3089 if (defined($bisect_reverse) && $bisect_r 2896 if (defined($bisect_reverse) && $bisect_reverse == 1) {
3090 doprint "Performing a reverse bisect 2897 doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
3091 $reverse_bisect = 1; 2898 $reverse_bisect = 1;
3092 } else { 2899 } else {
3093 $reverse_bisect = 0; 2900 $reverse_bisect = 0;
3094 } 2901 }
3095 2902
3096 # Can't have a test without having a test 2903 # Can't have a test without having a test to run
3097 if ($type eq "test" && !defined($run_test 2904 if ($type eq "test" && !defined($run_test)) {
3098 $type = "boot"; 2905 $type = "boot";
3099 } 2906 }
3100 2907
3101 # Check if a bisect was running 2908 # Check if a bisect was running
3102 my $bisect_start_file = "$builddir/.git/B 2909 my $bisect_start_file = "$builddir/.git/BISECT_START";
3103 2910
3104 my $check = $bisect_check; 2911 my $check = $bisect_check;
3105 my $do_check = defined($check) && $check 2912 my $do_check = defined($check) && $check ne "0";
3106 2913
3107 if ( -f $bisect_start_file ) { 2914 if ( -f $bisect_start_file ) {
3108 print "Bisect in progress found\n"; 2915 print "Bisect in progress found\n";
3109 if ($do_check) { 2916 if ($do_check) {
3110 print " If you say yes, then no c 2917 print " If you say yes, then no checks of good or bad will be done\n";
3111 } 2918 }
3112 if (defined($replay)) { 2919 if (defined($replay)) {
3113 print "** BISECT_REPLAY is define 2920 print "** BISECT_REPLAY is defined in config file **";
3114 print " Ignore config option and 2921 print " Ignore config option and perform new git bisect log?\n";
3115 if (read_ync " (yes, no, or cance 2922 if (read_ync " (yes, no, or cancel) ") {
3116 $replay = update_bisect_repla 2923 $replay = update_bisect_replay;
3117 $do_check = 0; 2924 $do_check = 0;
3118 } 2925 }
3119 } elsif (read_yn "read git log and co 2926 } elsif (read_yn "read git log and continue?") {
3120 $replay = update_bisect_replay; 2927 $replay = update_bisect_replay;
3121 $do_check = 0; 2928 $do_check = 0;
3122 } 2929 }
3123 } 2930 }
3124 2931
3125 if ($do_check) { 2932 if ($do_check) {
>> 2933
3126 # get current HEAD 2934 # get current HEAD
3127 my $head = get_sha1("HEAD"); 2935 my $head = get_sha1("HEAD");
3128 2936
3129 if ($check ne "good") { 2937 if ($check ne "good") {
3130 doprint "TESTING BISECT BAD [$bad 2938 doprint "TESTING BISECT BAD [$bad]\n";
3131 run_command "git checkout $bad" o 2939 run_command "git checkout $bad" or
3132 dodie "Failed to checkout $ba !! 2940 die "Failed to checkout $bad";
3133 2941
3134 $result = run_bisect $type; 2942 $result = run_bisect $type;
3135 2943
3136 if ($result ne "bad") { 2944 if ($result ne "bad") {
3137 fail "Tested BISECT_BAD [$bad 2945 fail "Tested BISECT_BAD [$bad] and it succeeded" and return 0;
3138 } 2946 }
3139 } 2947 }
3140 2948
3141 if ($check ne "bad") { 2949 if ($check ne "bad") {
3142 doprint "TESTING BISECT GOOD [$go 2950 doprint "TESTING BISECT GOOD [$good]\n";
3143 run_command "git checkout $good" 2951 run_command "git checkout $good" or
3144 dodie "Failed to checkout $go !! 2952 die "Failed to checkout $good";
3145 2953
3146 $result = run_bisect $type; 2954 $result = run_bisect $type;
3147 2955
3148 if ($result ne "good") { 2956 if ($result ne "good") {
3149 fail "Tested BISECT_GOOD [$go 2957 fail "Tested BISECT_GOOD [$good] and it failed" and return 0;
3150 } 2958 }
3151 } 2959 }
3152 2960
3153 # checkout where we started 2961 # checkout where we started
3154 run_command "git checkout $head" or 2962 run_command "git checkout $head" or
3155 dodie "Failed to checkout $head"; !! 2963 die "Failed to checkout $head";
3156 } 2964 }
3157 2965
3158 run_command "git bisect start$start_files 2966 run_command "git bisect start$start_files" or
3159 dodie "could not start bisect"; 2967 dodie "could not start bisect";
3160 2968
3161 if (defined($replay)) { 2969 if (defined($replay)) {
3162 run_command "git bisect replay $repla 2970 run_command "git bisect replay $replay" or
3163 dodie "failed to run replay"; 2971 dodie "failed to run replay";
3164 } else { 2972 } else {
>> 2973
3165 run_command "git bisect good $good" o 2974 run_command "git bisect good $good" or
3166 dodie "could not set bisect good 2975 dodie "could not set bisect good to $good";
3167 2976
3168 run_git_bisect "git bisect bad $bad" 2977 run_git_bisect "git bisect bad $bad" or
3169 dodie "could not set bisect bad t 2978 dodie "could not set bisect bad to $bad";
>> 2979
3170 } 2980 }
3171 2981
3172 if (defined($start)) { 2982 if (defined($start)) {
3173 run_command "git checkout $start" or 2983 run_command "git checkout $start" or
3174 dodie "failed to checkout $start" 2984 dodie "failed to checkout $start";
3175 } 2985 }
3176 2986
3177 my $test; 2987 my $test;
3178 do { 2988 do {
3179 $result = run_bisect $type; 2989 $result = run_bisect $type;
3180 $test = run_git_bisect "git bisect $r 2990 $test = run_git_bisect "git bisect $result";
3181 print_times; 2991 print_times;
3182 } while ($test); 2992 } while ($test);
3183 2993
3184 run_command "git bisect log" or 2994 run_command "git bisect log" or
3185 dodie "could not capture git bisect l 2995 dodie "could not capture git bisect log";
3186 2996
3187 run_command "git bisect reset" or 2997 run_command "git bisect reset" or
3188 dodie "could not reset git bisect"; 2998 dodie "could not reset git bisect";
3189 2999
3190 doprint "Bad commit was [$bisect_bad_comm 3000 doprint "Bad commit was [$bisect_bad_commit]\n";
3191 3001
3192 success $i; 3002 success $i;
3193 } 3003 }
3194 3004
>> 3005 # config_ignore holds the configs that were set (or unset) for
>> 3006 # a good config and we will ignore these configs for the rest
>> 3007 # of a config bisect. These configs stay as they were.
>> 3008 my %config_ignore;
>> 3009
>> 3010 # config_set holds what all configs were set as.
>> 3011 my %config_set;
>> 3012
>> 3013 # config_off holds the set of configs that the bad config had disabled.
>> 3014 # We need to record them and set them in the .config when running
>> 3015 # olddefconfig, because olddefconfig keeps the defaults.
>> 3016 my %config_off;
>> 3017
>> 3018 # config_off_tmp holds a set of configs to turn off for now
>> 3019 my @config_off_tmp;
>> 3020
>> 3021 # config_list is the set of configs that are being tested
>> 3022 my %config_list;
>> 3023 my %null_config;
>> 3024
>> 3025 my %dependency;
>> 3026
3195 sub assign_configs { 3027 sub assign_configs {
3196 my ($hash, $config) = @_; 3028 my ($hash, $config) = @_;
3197 3029
3198 doprint "Reading configs from $config\n"; 3030 doprint "Reading configs from $config\n";
3199 3031
3200 open (IN, $config) or !! 3032 open (IN, $config)
3201 dodie "Failed to read $config"; !! 3033 or dodie "Failed to read $config";
3202 3034
3203 while (<IN>) { 3035 while (<IN>) {
3204 chomp; 3036 chomp;
3205 if (/^((CONFIG\S*)=.*)/) { 3037 if (/^((CONFIG\S*)=.*)/) {
3206 ${$hash}{$2} = $1; 3038 ${$hash}{$2} = $1;
3207 } elsif (/^(# (CONFIG\S*) is not set) 3039 } elsif (/^(# (CONFIG\S*) is not set)/) {
3208 ${$hash}{$2} = $1; 3040 ${$hash}{$2} = $1;
3209 } 3041 }
3210 } 3042 }
3211 3043
3212 close(IN); 3044 close(IN);
3213 } 3045 }
3214 3046
3215 sub process_config_ignore { 3047 sub process_config_ignore {
3216 my ($config) = @_; 3048 my ($config) = @_;
3217 3049
3218 assign_configs \%config_ignore, $config; 3050 assign_configs \%config_ignore, $config;
3219 } 3051 }
3220 3052
3221 sub get_dependencies { 3053 sub get_dependencies {
3222 my ($config) = @_; 3054 my ($config) = @_;
3223 3055
3224 my $arr = $dependency{$config}; 3056 my $arr = $dependency{$config};
3225 if (!defined($arr)) { 3057 if (!defined($arr)) {
3226 return (); 3058 return ();
3227 } 3059 }
3228 3060
3229 my @deps = @{$arr}; 3061 my @deps = @{$arr};
3230 3062
3231 foreach my $dep (@{$arr}) { 3063 foreach my $dep (@{$arr}) {
3232 print "ADD DEP $dep\n"; 3064 print "ADD DEP $dep\n";
3233 @deps = (@deps, get_dependencies $dep 3065 @deps = (@deps, get_dependencies $dep);
3234 } 3066 }
3235 3067
3236 return @deps; 3068 return @deps;
3237 } 3069 }
3238 3070
3239 sub save_config { 3071 sub save_config {
3240 my ($pc, $file) = @_; 3072 my ($pc, $file) = @_;
3241 3073
3242 my %configs = %{$pc}; 3074 my %configs = %{$pc};
3243 3075
3244 doprint "Saving configs into $file\n"; 3076 doprint "Saving configs into $file\n";
3245 3077
3246 open(OUT, ">$file") or dodie "Can not wri 3078 open(OUT, ">$file") or dodie "Can not write to $file";
3247 3079
3248 foreach my $config (keys %configs) { 3080 foreach my $config (keys %configs) {
3249 print OUT "$configs{$config}\n"; 3081 print OUT "$configs{$config}\n";
3250 } 3082 }
3251 close(OUT); 3083 close(OUT);
3252 } 3084 }
3253 3085
3254 sub create_config { 3086 sub create_config {
3255 my ($name, $pc) = @_; 3087 my ($name, $pc) = @_;
3256 3088
3257 doprint "Creating old config from $name c 3089 doprint "Creating old config from $name configs\n";
3258 3090
3259 save_config $pc, $output_config; 3091 save_config $pc, $output_config;
3260 3092
3261 make_oldconfig; 3093 make_oldconfig;
3262 } 3094 }
3263 3095
>> 3096 # compare two config hashes, and return configs with different vals.
>> 3097 # It returns B's config values, but you can use A to see what A was.
>> 3098 sub diff_config_vals {
>> 3099 my ($pa, $pb) = @_;
>> 3100
>> 3101 # crappy Perl way to pass in hashes.
>> 3102 my %a = %{$pa};
>> 3103 my %b = %{$pb};
>> 3104
>> 3105 my %ret;
>> 3106
>> 3107 foreach my $item (keys %a) {
>> 3108 if (defined($b{$item}) && $b{$item} ne $a{$item}) {
>> 3109 $ret{$item} = $b{$item};
>> 3110 }
>> 3111 }
>> 3112
>> 3113 return %ret;
>> 3114 }
>> 3115
>> 3116 # compare two config hashes and return the configs in B but not A
>> 3117 sub diff_configs {
>> 3118 my ($pa, $pb) = @_;
>> 3119
>> 3120 my %ret;
>> 3121
>> 3122 # crappy Perl way to pass in hashes.
>> 3123 my %a = %{$pa};
>> 3124 my %b = %{$pb};
>> 3125
>> 3126 foreach my $item (keys %b) {
>> 3127 if (!defined($a{$item})) {
>> 3128 $ret{$item} = $b{$item};
>> 3129 }
>> 3130 }
>> 3131
>> 3132 return %ret;
>> 3133 }
>> 3134
>> 3135 # return if two configs are equal or not
>> 3136 # 0 is equal +1 b has something a does not
>> 3137 # +1 if a and b have a different item.
>> 3138 # -1 if a has something b does not
>> 3139 sub compare_configs {
>> 3140 my ($pa, $pb) = @_;
>> 3141
>> 3142 my %ret;
>> 3143
>> 3144 # crappy Perl way to pass in hashes.
>> 3145 my %a = %{$pa};
>> 3146 my %b = %{$pb};
>> 3147
>> 3148 foreach my $item (keys %b) {
>> 3149 if (!defined($a{$item})) {
>> 3150 return 1;
>> 3151 }
>> 3152 if ($a{$item} ne $b{$item}) {
>> 3153 return 1;
>> 3154 }
>> 3155 }
>> 3156
>> 3157 foreach my $item (keys %a) {
>> 3158 if (!defined($b{$item})) {
>> 3159 return -1;
>> 3160 }
>> 3161 }
>> 3162
>> 3163 return 0;
>> 3164 }
>> 3165
3264 sub run_config_bisect_test { 3166 sub run_config_bisect_test {
3265 my ($type) = @_; 3167 my ($type) = @_;
3266 3168
3267 my $ret = run_bisect_test $type, "oldconf 3169 my $ret = run_bisect_test $type, "oldconfig";
3268 3170
3269 if ($bisect_manual) { 3171 if ($bisect_manual) {
3270 $ret = answer_bisect; 3172 $ret = answer_bisect;
3271 } 3173 }
3272 3174
3273 return $ret; 3175 return $ret;
3274 } 3176 }
3275 3177
3276 sub config_bisect_end { !! 3178 sub process_failed {
3277 my ($good, $bad) = @_; !! 3179 my ($config) = @_;
3278 my $diffexec = "diff -u"; <<
3279 3180
3280 if (-f "$builddir/scripts/diffconfig") { <<
3281 $diffexec = "$builddir/scripts/diffco <<
3282 } <<
3283 doprint "\n\n**************************** 3181 doprint "\n\n***************************************\n";
3284 doprint "No more config bisecting possibl !! 3182 doprint "Found bad config: $config\n";
3285 run_command "$diffexec $good $bad", 1; <<
3286 doprint "******************************** 3183 doprint "***************************************\n\n";
3287 } 3184 }
3288 3185
>> 3186 # used for config bisecting
>> 3187 my $good_config;
>> 3188 my $bad_config;
>> 3189
>> 3190 sub process_new_config {
>> 3191 my ($tc, $nc, $gc, $bc) = @_;
>> 3192
>> 3193 my %tmp_config = %{$tc};
>> 3194 my %good_configs = %{$gc};
>> 3195 my %bad_configs = %{$bc};
>> 3196
>> 3197 my %new_configs;
>> 3198
>> 3199 my $runtest = 1;
>> 3200 my $ret;
>> 3201
>> 3202 create_config "tmp_configs", \%tmp_config;
>> 3203 assign_configs \%new_configs, $output_config;
>> 3204
>> 3205 $ret = compare_configs \%new_configs, \%bad_configs;
>> 3206 if (!$ret) {
>> 3207 doprint "New config equals bad config, try next test\n";
>> 3208 $runtest = 0;
>> 3209 }
>> 3210
>> 3211 if ($runtest) {
>> 3212 $ret = compare_configs \%new_configs, \%good_configs;
>> 3213 if (!$ret) {
>> 3214 doprint "New config equals good config, try next test\n";
>> 3215 $runtest = 0;
>> 3216 }
>> 3217 }
>> 3218
>> 3219 %{$nc} = %new_configs;
>> 3220
>> 3221 return $runtest;
>> 3222 }
>> 3223
3289 sub run_config_bisect { 3224 sub run_config_bisect {
3290 my ($good, $bad, $last_result) = @_; !! 3225 my ($pgood, $pbad) = @_;
3291 my $reset = ""; !! 3226
3292 my $cmd; !! 3227 my $type = $config_bisect_type;
>> 3228
>> 3229 my %good_configs = %{$pgood};
>> 3230 my %bad_configs = %{$pbad};
>> 3231
>> 3232 my %diff_configs = diff_config_vals \%good_configs, \%bad_configs;
>> 3233 my %b_configs = diff_configs \%good_configs, \%bad_configs;
>> 3234 my %g_configs = diff_configs \%bad_configs, \%good_configs;
>> 3235
>> 3236 my @diff_arr = keys %diff_configs;
>> 3237 my $len_diff = $#diff_arr + 1;
>> 3238
>> 3239 my @b_arr = keys %b_configs;
>> 3240 my $len_b = $#b_arr + 1;
>> 3241
>> 3242 my @g_arr = keys %g_configs;
>> 3243 my $len_g = $#g_arr + 1;
>> 3244
>> 3245 my $runtest = 1;
>> 3246 my %new_configs;
3293 my $ret; 3247 my $ret;
3294 3248
3295 if (!length($last_result)) { !! 3249 # First, lets get it down to a single subset.
3296 $reset = "-r"; !! 3250 # Is the problem with a difference in values?
>> 3251 # Is the problem with a missing config?
>> 3252 # Is the problem with a config that breaks things?
>> 3253
>> 3254 # Enable all of one set and see if we get a new bad
>> 3255 # or good config.
>> 3256
>> 3257 # first set the good config to the bad values.
>> 3258
>> 3259 doprint "d=$len_diff g=$len_g b=$len_b\n";
>> 3260
>> 3261 # first lets enable things in bad config that are enabled in good config
>> 3262
>> 3263 if ($len_diff > 0) {
>> 3264 if ($len_b > 0 || $len_g > 0) {
>> 3265 my %tmp_config = %bad_configs;
>> 3266
>> 3267 doprint "Set tmp config to be bad config with good config values\n";
>> 3268 foreach my $item (@diff_arr) {
>> 3269 $tmp_config{$item} = $good_configs{$item};
>> 3270 }
>> 3271
>> 3272 $runtest = process_new_config \%tmp_config, \%new_configs,
>> 3273 \%good_configs, \%bad_configs;
>> 3274 }
3297 } 3275 }
3298 run_command "$config_bisect_exec $reset - <<
3299 3276
3300 # config-bisect returns: !! 3277 if (!$runtest && $len_diff > 0) {
3301 # 0 if there is more to bisect !! 3278
3302 # 1 for finding a good config !! 3279 if ($len_diff == 1) {
3303 # 2 if it can not find any more configs !! 3280 process_failed $diff_arr[0];
3304 # -1 (255) on error !! 3281 return 1;
3305 if ($run_command_status) { !! 3282 }
3306 return $run_command_status; !! 3283 my %tmp_config = %bad_configs;
>> 3284
>> 3285 my $half = int($#diff_arr / 2);
>> 3286 my @tophalf = @diff_arr[0 .. $half];
>> 3287
>> 3288 doprint "Settings bisect with top half:\n";
>> 3289 doprint "Set tmp config to be bad config with some good config values\n";
>> 3290 foreach my $item (@tophalf) {
>> 3291 $tmp_config{$item} = $good_configs{$item};
>> 3292 }
>> 3293
>> 3294 $runtest = process_new_config \%tmp_config, \%new_configs,
>> 3295 \%good_configs, \%bad_configs;
>> 3296
>> 3297 if (!$runtest) {
>> 3298 my %tmp_config = %bad_configs;
>> 3299
>> 3300 doprint "Try bottom half\n";
>> 3301
>> 3302 my @bottomhalf = @diff_arr[$half+1 .. $#diff_arr];
>> 3303
>> 3304 foreach my $item (@bottomhalf) {
>> 3305 $tmp_config{$item} = $good_configs{$item};
>> 3306 }
>> 3307
>> 3308 $runtest = process_new_config \%tmp_config, \%new_configs,
>> 3309 \%good_configs, \%bad_configs;
>> 3310 }
3307 } 3311 }
3308 3312
3309 $ret = run_config_bisect_test $config_bis !! 3313 if ($runtest) {
3310 if ($ret) { !! 3314 $ret = run_config_bisect_test $type;
3311 doprint "NEW GOOD CONFIG ($pass)\n"; !! 3315 if ($ret) {
3312 system("cp $output_config $tmpdir/goo !! 3316 doprint "NEW GOOD CONFIG\n";
3313 $pass++; !! 3317 %good_configs = %new_configs;
3314 # Return 3 for good config !! 3318 run_command "mv $good_config ${good_config}.last";
3315 return 3; !! 3319 save_config \%good_configs, $good_config;
3316 } else { !! 3320 %{$pgood} = %good_configs;
3317 doprint "NEW BAD CONFIG ($pass)\n"; !! 3321 } else {
3318 system("cp $output_config $tmpdir/bad !! 3322 doprint "NEW BAD CONFIG\n";
3319 $pass++; !! 3323 %bad_configs = %new_configs;
3320 # Return 4 for bad config !! 3324 run_command "mv $bad_config ${bad_config}.last";
3321 return 4; !! 3325 save_config \%bad_configs, $bad_config;
>> 3326 %{$pbad} = %bad_configs;
>> 3327 }
>> 3328 return 0;
3322 } 3329 }
>> 3330
>> 3331 fail "Hmm, need to do a mix match?\n";
>> 3332 return -1;
3323 } 3333 }
3324 3334
3325 sub config_bisect { 3335 sub config_bisect {
3326 my ($i) = @_; 3336 my ($i) = @_;
3327 3337
3328 my $good_config; <<
3329 my $bad_config; <<
3330 <<
3331 my $type = $config_bisect_type; 3338 my $type = $config_bisect_type;
3332 my $ret; 3339 my $ret;
3333 3340
3334 $bad_config = $config_bisect; 3341 $bad_config = $config_bisect;
3335 3342
3336 if (defined($config_bisect_good)) { 3343 if (defined($config_bisect_good)) {
3337 $good_config = $config_bisect_good; 3344 $good_config = $config_bisect_good;
3338 } elsif (defined($minconfig)) { 3345 } elsif (defined($minconfig)) {
3339 $good_config = $minconfig; 3346 $good_config = $minconfig;
3340 } else { 3347 } else {
3341 doprint "No config specified, checkin 3348 doprint "No config specified, checking if defconfig works";
3342 $ret = run_bisect_test $type, "defcon 3349 $ret = run_bisect_test $type, "defconfig";
3343 if (!$ret) { 3350 if (!$ret) {
3344 fail "Have no good config to comp 3351 fail "Have no good config to compare with, please set CONFIG_BISECT_GOOD";
3345 return 1; 3352 return 1;
3346 } 3353 }
3347 $good_config = $output_config; 3354 $good_config = $output_config;
3348 } 3355 }
3349 3356
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 3357 # we don't want min configs to cause issues here.
3370 doprint "Disabling 'MIN_CONFIG' for this 3358 doprint "Disabling 'MIN_CONFIG' for this test\n";
3371 undef $minconfig; 3359 undef $minconfig;
3372 3360
3373 my %good_configs; 3361 my %good_configs;
3374 my %bad_configs; 3362 my %bad_configs;
3375 my %tmp_configs; 3363 my %tmp_configs;
3376 3364
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 3365 doprint "Run good configs through make oldconfig\n";
3392 assign_configs \%tmp_configs, $good_confi 3366 assign_configs \%tmp_configs, $good_config;
3393 create_config "$good_config", \%tmp_confi 3367 create_config "$good_config", \%tmp_configs;
3394 $good_config = "$tmpdir/good_config"; !! 3368 assign_configs \%good_configs, $output_config;
3395 system("cp $output_config $good_config") <<
3396 3369
3397 doprint "Run bad configs through make old 3370 doprint "Run bad configs through make oldconfig\n";
3398 assign_configs \%tmp_configs, $bad_config 3371 assign_configs \%tmp_configs, $bad_config;
3399 create_config "$bad_config", \%tmp_config 3372 create_config "$bad_config", \%tmp_configs;
>> 3373 assign_configs \%bad_configs, $output_config;
>> 3374
>> 3375 $good_config = "$tmpdir/good_config";
3400 $bad_config = "$tmpdir/bad_config"; 3376 $bad_config = "$tmpdir/bad_config";
3401 system("cp $output_config $bad_config") = !! 3377
>> 3378 save_config \%good_configs, $good_config;
>> 3379 save_config \%bad_configs, $bad_config;
3402 3380
3403 if (defined($config_bisect_check) && $con 3381 if (defined($config_bisect_check) && $config_bisect_check ne "0") {
3404 if ($config_bisect_check ne "good") { 3382 if ($config_bisect_check ne "good") {
3405 doprint "Testing bad config\n"; 3383 doprint "Testing bad config\n";
3406 3384
3407 $ret = run_bisect_test $type, "us 3385 $ret = run_bisect_test $type, "useconfig:$bad_config";
3408 if ($ret) { 3386 if ($ret) {
3409 fail "Bad config succeeded wh 3387 fail "Bad config succeeded when expected to fail!";
3410 return 0; 3388 return 0;
3411 } 3389 }
3412 } 3390 }
3413 if ($config_bisect_check ne "bad") { 3391 if ($config_bisect_check ne "bad") {
3414 doprint "Testing good config\n"; 3392 doprint "Testing good config\n";
3415 3393
3416 $ret = run_bisect_test $type, "us 3394 $ret = run_bisect_test $type, "useconfig:$good_config";
3417 if (!$ret) { 3395 if (!$ret) {
3418 fail "Good config failed when 3396 fail "Good config failed when expected to succeed!";
3419 return 0; 3397 return 0;
3420 } 3398 }
3421 } 3399 }
3422 } 3400 }
3423 3401
3424 my $last_run = ""; <<
3425 <<
3426 do { 3402 do {
3427 $ret = run_config_bisect $good_config !! 3403 $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; 3404 print_times;
3434 } while ($ret == 3 || $ret == 4); !! 3405 } while (!$ret);
3435 <<
3436 if ($ret == 2) { <<
3437 config_bisect_end "$good_config.tmp", <<
3438 } <<
3439 3406
3440 return $ret if ($ret < 0); 3407 return $ret if ($ret < 0);
3441 3408
3442 success $i; 3409 success $i;
3443 } 3410 }
3444 3411
3445 sub patchcheck_reboot { 3412 sub patchcheck_reboot {
3446 doprint "Reboot and sleep $patchcheck_sle 3413 doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
3447 reboot_to_good $patchcheck_sleep_time; 3414 reboot_to_good $patchcheck_sleep_time;
3448 } 3415 }
3449 3416
3450 sub patchcheck { 3417 sub patchcheck {
3451 my ($i) = @_; 3418 my ($i) = @_;
3452 3419
3453 dodie "PATCHCHECK_START[$i] not defined\n !! 3420 die "PATCHCHECK_START[$i] not defined\n"
3454 if (!defined($patchcheck_start)); 3421 if (!defined($patchcheck_start));
3455 dodie "PATCHCHECK_TYPE[$i] not defined\n" !! 3422 die "PATCHCHECK_TYPE[$i] not defined\n"
3456 if (!defined($patchcheck_type)); 3423 if (!defined($patchcheck_type));
3457 3424
3458 my $start = $patchcheck_start; 3425 my $start = $patchcheck_start;
3459 3426
3460 my $cherry = $patchcheck_cherry; 3427 my $cherry = $patchcheck_cherry;
3461 if (!defined($cherry)) { 3428 if (!defined($cherry)) {
3462 $cherry = 0; 3429 $cherry = 0;
3463 } 3430 }
3464 3431
3465 my $end = "HEAD"; 3432 my $end = "HEAD";
3466 if (defined($patchcheck_end)) { 3433 if (defined($patchcheck_end)) {
3467 $end = $patchcheck_end; 3434 $end = $patchcheck_end;
3468 } elsif ($cherry) { 3435 } elsif ($cherry) {
3469 dodie "PATCHCHECK_END must be defined !! 3436 die "PATCHCHECK_END must be defined with PATCHCHECK_CHERRY\n";
3470 } 3437 }
3471 3438
3472 # Get the true sha1's since we can use th 3439 # Get the true sha1's since we can use things like HEAD~3
3473 $start = get_sha1($start); 3440 $start = get_sha1($start);
3474 $end = get_sha1($end); 3441 $end = get_sha1($end);
3475 3442
3476 my $type = $patchcheck_type; 3443 my $type = $patchcheck_type;
3477 3444
3478 # Can't have a test without having a test 3445 # Can't have a test without having a test to run
3479 if ($type eq "test" && !defined($run_test 3446 if ($type eq "test" && !defined($run_test)) {
3480 $type = "boot"; 3447 $type = "boot";
3481 } 3448 }
3482 3449
3483 if ($cherry) { 3450 if ($cherry) {
3484 open (IN, "git cherry -v $start $end| 3451 open (IN, "git cherry -v $start $end|") or
3485 dodie "could not get git list"; 3452 dodie "could not get git list";
3486 } else { 3453 } else {
3487 open (IN, "git log --pretty=oneline $ 3454 open (IN, "git log --pretty=oneline $end|") or
3488 dodie "could not get git list"; 3455 dodie "could not get git list";
3489 } 3456 }
3490 3457
3491 my @list; 3458 my @list;
3492 3459
3493 while (<IN>) { 3460 while (<IN>) {
3494 chomp; 3461 chomp;
3495 # git cherry adds a '+' we want to re 3462 # git cherry adds a '+' we want to remove
3496 s/^\+ //; 3463 s/^\+ //;
3497 $list[$#list+1] = $_; 3464 $list[$#list+1] = $_;
3498 last if (/^$start/); 3465 last if (/^$start/);
3499 } 3466 }
3500 close(IN); 3467 close(IN);
3501 3468
3502 if (!$cherry) { 3469 if (!$cherry) {
3503 if ($list[$#list] !~ /^$start/) { 3470 if ($list[$#list] !~ /^$start/) {
3504 fail "SHA1 $start not found"; 3471 fail "SHA1 $start not found";
3505 } 3472 }
3506 3473
3507 # go backwards in the list 3474 # go backwards in the list
3508 @list = reverse @list; 3475 @list = reverse @list;
3509 } 3476 }
3510 3477
3511 doprint("Going to test the following comm 3478 doprint("Going to test the following commits:\n");
3512 foreach my $l (@list) { 3479 foreach my $l (@list) {
3513 doprint "$l\n"; 3480 doprint "$l\n";
3514 } 3481 }
3515 3482
3516 my $save_clean = $noclean; 3483 my $save_clean = $noclean;
3517 my %ignored_warnings; 3484 my %ignored_warnings;
3518 3485
3519 if (defined($ignore_warnings)) { 3486 if (defined($ignore_warnings)) {
3520 foreach my $sha1 (split /\s+/, $ignor 3487 foreach my $sha1 (split /\s+/, $ignore_warnings) {
3521 $ignored_warnings{$sha1} = 1; 3488 $ignored_warnings{$sha1} = 1;
3522 } 3489 }
3523 } 3490 }
3524 3491
3525 $in_patchcheck = 1; 3492 $in_patchcheck = 1;
3526 foreach my $item (@list) { 3493 foreach my $item (@list) {
3527 my $sha1 = $item; 3494 my $sha1 = $item;
3528 $sha1 =~ s/^([[:xdigit:]]+).*/$1/; 3495 $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
3529 3496
3530 doprint "\nProcessing commit \"$item\ 3497 doprint "\nProcessing commit \"$item\"\n\n";
3531 3498
3532 run_command "git checkout $sha1" or 3499 run_command "git checkout $sha1" or
3533 dodie "Failed to checkout $sha1"; !! 3500 die "Failed to checkout $sha1";
3534 3501
3535 # only clean on the first and last pa 3502 # only clean on the first and last patch
3536 if ($item eq $list[0] || 3503 if ($item eq $list[0] ||
3537 $item eq $list[$#list]) { 3504 $item eq $list[$#list]) {
3538 $noclean = $save_clean; 3505 $noclean = $save_clean;
3539 } else { 3506 } else {
3540 $noclean = 1; 3507 $noclean = 1;
3541 } 3508 }
3542 3509
3543 if (defined($minconfig)) { 3510 if (defined($minconfig)) {
3544 build "useconfig:$minconfig" or r 3511 build "useconfig:$minconfig" or return 0;
3545 } else { 3512 } else {
3546 # ?? no config to use? 3513 # ?? no config to use?
3547 build "oldconfig" or return 0; 3514 build "oldconfig" or return 0;
3548 } 3515 }
3549 3516
3550 # No need to do per patch checking if 3517 # No need to do per patch checking if warnings file exists
3551 if (!defined($warnings_file) && !defi 3518 if (!defined($warnings_file) && !defined($ignored_warnings{$sha1})) {
3552 check_patch_buildlog $sha1 or ret 3519 check_patch_buildlog $sha1 or return 0;
3553 } 3520 }
3554 3521
3555 check_buildlog or return 0; 3522 check_buildlog or return 0;
3556 3523
3557 next if ($type eq "build"); 3524 next if ($type eq "build");
3558 3525
3559 my $failed = 0; 3526 my $failed = 0;
3560 3527
3561 start_monitor_and_install or $failed 3528 start_monitor_and_install or $failed = 1;
3562 3529
3563 if (!$failed && $type ne "boot"){ 3530 if (!$failed && $type ne "boot"){
3564 do_run_test or $failed = 1; 3531 do_run_test or $failed = 1;
3565 } 3532 }
3566 end_monitor; 3533 end_monitor;
3567 if ($failed) { 3534 if ($failed) {
3568 print_times; 3535 print_times;
3569 return 0; 3536 return 0;
3570 } 3537 }
3571 patchcheck_reboot; 3538 patchcheck_reboot;
3572 print_times; 3539 print_times;
3573 } 3540 }
3574 $in_patchcheck = 0; 3541 $in_patchcheck = 0;
3575 success $i; 3542 success $i;
3576 3543
3577 return 1; 3544 return 1;
3578 } 3545 }
3579 3546
>> 3547 my %depends;
>> 3548 my %depcount;
>> 3549 my $iflevel = 0;
>> 3550 my @ifdeps;
>> 3551
>> 3552 # prevent recursion
>> 3553 my %read_kconfigs;
>> 3554
3580 sub add_dep { 3555 sub add_dep {
3581 # $config depends on $dep 3556 # $config depends on $dep
3582 my ($config, $dep) = @_; 3557 my ($config, $dep) = @_;
3583 3558
3584 if (defined($depends{$config})) { 3559 if (defined($depends{$config})) {
3585 $depends{$config} .= " " . $dep; 3560 $depends{$config} .= " " . $dep;
3586 } else { 3561 } else {
3587 $depends{$config} = $dep; 3562 $depends{$config} = $dep;
3588 } 3563 }
3589 3564
3590 # record the number of configs depending 3565 # record the number of configs depending on $dep
3591 if (defined $depcount{$dep}) { 3566 if (defined $depcount{$dep}) {
3592 $depcount{$dep}++; 3567 $depcount{$dep}++;
3593 } else { 3568 } else {
3594 $depcount{$dep} = 1; 3569 $depcount{$dep} = 1;
3595 } 3570 }
3596 } 3571 }
3597 3572
3598 # taken from streamline_config.pl 3573 # taken from streamline_config.pl
3599 sub read_kconfig { 3574 sub read_kconfig {
3600 my ($kconfig) = @_; 3575 my ($kconfig) = @_;
3601 3576
3602 my $state = "NONE"; 3577 my $state = "NONE";
3603 my $config; 3578 my $config;
3604 my @kconfigs; 3579 my @kconfigs;
3605 3580
3606 my $cont = 0; 3581 my $cont = 0;
3607 my $line; 3582 my $line;
3608 3583
>> 3584
3609 if (! -f $kconfig) { 3585 if (! -f $kconfig) {
3610 doprint "file $kconfig does not exist 3586 doprint "file $kconfig does not exist, skipping\n";
3611 return; 3587 return;
3612 } 3588 }
3613 3589
3614 open(KIN, "$kconfig") 3590 open(KIN, "$kconfig")
3615 or dodie "Can't open $kconfig"; !! 3591 or die "Can't open $kconfig";
3616 while (<KIN>) { 3592 while (<KIN>) {
3617 chomp; 3593 chomp;
3618 3594
3619 # Make sure that lines ending with \ 3595 # Make sure that lines ending with \ continue
3620 if ($cont) { 3596 if ($cont) {
3621 $_ = $line . " " . $_; 3597 $_ = $line . " " . $_;
3622 } 3598 }
3623 3599
3624 if (s/\\$//) { 3600 if (s/\\$//) {
3625 $cont = 1; 3601 $cont = 1;
3626 $line = $_; 3602 $line = $_;
3627 next; 3603 next;
3628 } 3604 }
3629 3605
3630 $cont = 0; 3606 $cont = 0;
3631 3607
3632 # collect any Kconfig sources 3608 # collect any Kconfig sources
3633 if (/^source\s*"(.*)"/) { 3609 if (/^source\s*"(.*)"/) {
3634 $kconfigs[$#kconfigs+1] = $1; 3610 $kconfigs[$#kconfigs+1] = $1;
3635 } 3611 }
3636 3612
3637 # configs found 3613 # configs found
3638 if (/^\s*(menu)?config\s+(\S+)\s*$/) 3614 if (/^\s*(menu)?config\s+(\S+)\s*$/) {
3639 $state = "NEW"; 3615 $state = "NEW";
3640 $config = $2; 3616 $config = $2;
3641 3617
3642 for (my $i = 0; $i < $iflevel; $i 3618 for (my $i = 0; $i < $iflevel; $i++) {
3643 add_dep $config, $ifdeps[$i]; 3619 add_dep $config, $ifdeps[$i];
3644 } 3620 }
3645 3621
3646 # collect the depends for the config 3622 # collect the depends for the config
3647 } elsif ($state eq "NEW" && /^\s*depe 3623 } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
3648 3624
3649 add_dep $config, $1; 3625 add_dep $config, $1;
3650 3626
3651 # Get the configs that select this co 3627 # Get the configs that select this config
3652 } elsif ($state eq "NEW" && /^\s*sele 3628 } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {
3653 3629
3654 # selected by depends on config 3630 # selected by depends on config
3655 add_dep $1, $config; 3631 add_dep $1, $config;
3656 3632
3657 # Check for if statements 3633 # Check for if statements
3658 } elsif (/^if\s+(.*\S)\s*$/) { 3634 } elsif (/^if\s+(.*\S)\s*$/) {
3659 my $deps = $1; 3635 my $deps = $1;
3660 # remove beginning and ending non 3636 # remove beginning and ending non text
3661 $deps =~ s/^[^a-zA-Z0-9_]*//; 3637 $deps =~ s/^[^a-zA-Z0-9_]*//;
3662 $deps =~ s/[^a-zA-Z0-9_]*$//; 3638 $deps =~ s/[^a-zA-Z0-9_]*$//;
3663 3639
3664 my @deps = split /[^a-zA-Z0-9_]+/ 3640 my @deps = split /[^a-zA-Z0-9_]+/, $deps;
3665 3641
3666 $ifdeps[$iflevel++] = join ':', @ 3642 $ifdeps[$iflevel++] = join ':', @deps;
3667 3643
3668 } elsif (/^endif/) { 3644 } elsif (/^endif/) {
3669 3645
3670 $iflevel-- if ($iflevel); 3646 $iflevel-- if ($iflevel);
3671 3647
3672 # stop on "help" 3648 # stop on "help"
3673 } elsif (/^\s*help\s*$/) { 3649 } elsif (/^\s*help\s*$/) {
3674 $state = "NONE"; 3650 $state = "NONE";
3675 } 3651 }
3676 } 3652 }
3677 close(KIN); 3653 close(KIN);
3678 3654
3679 # read in any configs that were found. 3655 # read in any configs that were found.
3680 foreach $kconfig (@kconfigs) { 3656 foreach $kconfig (@kconfigs) {
3681 if (!defined($read_kconfigs{$kconfig} 3657 if (!defined($read_kconfigs{$kconfig})) {
3682 $read_kconfigs{$kconfig} = 1; 3658 $read_kconfigs{$kconfig} = 1;
3683 read_kconfig("$builddir/$kconfig" 3659 read_kconfig("$builddir/$kconfig");
3684 } 3660 }
3685 } 3661 }
3686 } 3662 }
3687 3663
3688 sub read_depends { 3664 sub read_depends {
3689 # find out which arch this is by the kcon 3665 # find out which arch this is by the kconfig file
3690 open (IN, $output_config) or !! 3666 open (IN, $output_config)
3691 dodie "Failed to read $output_config" !! 3667 or dodie "Failed to read $output_config";
3692 my $arch; 3668 my $arch;
3693 while (<IN>) { 3669 while (<IN>) {
3694 if (m,Linux/(\S+)\s+\S+\s+Kernel Conf 3670 if (m,Linux/(\S+)\s+\S+\s+Kernel Configuration,) {
3695 $arch = $1; 3671 $arch = $1;
3696 last; 3672 last;
3697 } 3673 }
3698 } 3674 }
3699 close IN; 3675 close IN;
3700 3676
3701 if (!defined($arch)) { 3677 if (!defined($arch)) {
3702 doprint "Could not find arch from con 3678 doprint "Could not find arch from config file\n";
3703 doprint "no dependencies used\n"; 3679 doprint "no dependencies used\n";
3704 return; 3680 return;
3705 } 3681 }
3706 3682
3707 # arch is really the subarch, we need to 3683 # arch is really the subarch, we need to know
3708 # what directory to look at. 3684 # what directory to look at.
3709 if ($arch eq "i386" || $arch eq "x86_64") 3685 if ($arch eq "i386" || $arch eq "x86_64") {
3710 $arch = "x86"; 3686 $arch = "x86";
>> 3687 } elsif ($arch =~ /^tile/) {
>> 3688 $arch = "tile";
3711 } 3689 }
3712 3690
3713 my $kconfig = "$builddir/arch/$arch/Kconf 3691 my $kconfig = "$builddir/arch/$arch/Kconfig";
3714 3692
3715 if (! -f $kconfig && $arch =~ /\d$/) { 3693 if (! -f $kconfig && $arch =~ /\d$/) {
3716 my $orig = $arch; 3694 my $orig = $arch;
3717 # some subarchs have numbers, truncat !! 3695 # some subarchs have numbers, truncate them
3718 $arch =~ s/\d*$//; 3696 $arch =~ s/\d*$//;
3719 $kconfig = "$builddir/arch/$arch/Kcon 3697 $kconfig = "$builddir/arch/$arch/Kconfig";
3720 if (! -f $kconfig) { 3698 if (! -f $kconfig) {
3721 doprint "No idea what arch dir $o 3699 doprint "No idea what arch dir $orig is for\n";
3722 doprint "no dependencies used\n"; 3700 doprint "no dependencies used\n";
3723 return; 3701 return;
3724 } 3702 }
3725 } 3703 }
3726 3704
3727 read_kconfig($kconfig); 3705 read_kconfig($kconfig);
3728 } 3706 }
3729 3707
3730 sub make_new_config { 3708 sub make_new_config {
3731 my @configs = @_; 3709 my @configs = @_;
3732 3710
3733 open (OUT, ">$output_config") 3711 open (OUT, ">$output_config")
3734 or dodie "Failed to write $output_con 3712 or dodie "Failed to write $output_config";
3735 3713
3736 foreach my $config (@configs) { 3714 foreach my $config (@configs) {
3737 print OUT "$config\n"; 3715 print OUT "$config\n";
3738 } 3716 }
3739 close OUT; 3717 close OUT;
3740 } 3718 }
3741 3719
3742 sub chomp_config { 3720 sub chomp_config {
3743 my ($config) = @_; 3721 my ($config) = @_;
3744 3722
3745 $config =~ s/CONFIG_//; 3723 $config =~ s/CONFIG_//;
3746 3724
3747 return $config; 3725 return $config;
3748 } 3726 }
3749 3727
3750 sub get_depends { 3728 sub get_depends {
3751 my ($dep) = @_; 3729 my ($dep) = @_;
3752 3730
3753 my $kconfig = chomp_config $dep; 3731 my $kconfig = chomp_config $dep;
3754 3732
3755 $dep = $depends{"$kconfig"}; 3733 $dep = $depends{"$kconfig"};
3756 3734
3757 # the dep string we have saves the depend 3735 # the dep string we have saves the dependencies as they
3758 # were found, including expressions like 3736 # were found, including expressions like ! && ||. We
3759 # want to split this out into just an arr 3737 # want to split this out into just an array of configs.
3760 3738
3761 my $valid = "A-Za-z_0-9"; 3739 my $valid = "A-Za-z_0-9";
3762 3740
3763 my @configs; 3741 my @configs;
3764 3742
3765 while ($dep =~ /[$valid]/) { 3743 while ($dep =~ /[$valid]/) {
>> 3744
3766 if ($dep =~ /^[^$valid]*([$valid]+)/) 3745 if ($dep =~ /^[^$valid]*([$valid]+)/) {
3767 my $conf = "CONFIG_" . $1; 3746 my $conf = "CONFIG_" . $1;
3768 3747
3769 $configs[$#configs + 1] = $conf; 3748 $configs[$#configs + 1] = $conf;
3770 3749
3771 $dep =~ s/^[^$valid]*[$valid]+//; 3750 $dep =~ s/^[^$valid]*[$valid]+//;
3772 } else { 3751 } else {
3773 dodie "this should never happen"; !! 3752 die "this should never happen";
3774 } 3753 }
3775 } 3754 }
3776 3755
3777 return @configs; 3756 return @configs;
3778 } 3757 }
3779 3758
>> 3759 my %min_configs;
>> 3760 my %keep_configs;
>> 3761 my %save_configs;
>> 3762 my %processed_configs;
>> 3763 my %nochange_config;
>> 3764
3780 sub test_this_config { 3765 sub test_this_config {
3781 my ($config) = @_; 3766 my ($config) = @_;
3782 3767
3783 my $found; 3768 my $found;
3784 3769
3785 # if we already processed this config, sk 3770 # if we already processed this config, skip it
3786 if (defined($processed_configs{$config})) 3771 if (defined($processed_configs{$config})) {
3787 return undef; 3772 return undef;
3788 } 3773 }
3789 $processed_configs{$config} = 1; 3774 $processed_configs{$config} = 1;
3790 3775
3791 # if this config failed during this round 3776 # if this config failed during this round, skip it
3792 if (defined($nochange_config{$config})) { 3777 if (defined($nochange_config{$config})) {
3793 return undef; 3778 return undef;
3794 } 3779 }
3795 3780
3796 my $kconfig = chomp_config $config; 3781 my $kconfig = chomp_config $config;
3797 3782
3798 # Test dependencies first 3783 # Test dependencies first
3799 if (defined($depends{"$kconfig"})) { 3784 if (defined($depends{"$kconfig"})) {
3800 my @parents = get_depends $config; 3785 my @parents = get_depends $config;
3801 foreach my $parent (@parents) { 3786 foreach my $parent (@parents) {
3802 # if the parent is in the min con 3787 # if the parent is in the min config, check it first
3803 next if (!defined($min_configs{$p 3788 next if (!defined($min_configs{$parent}));
3804 $found = test_this_config($parent 3789 $found = test_this_config($parent);
3805 if (defined($found)) { 3790 if (defined($found)) {
3806 return $found; 3791 return $found;
3807 } 3792 }
3808 } 3793 }
3809 } 3794 }
3810 3795
3811 # Remove this config from the list of con 3796 # Remove this config from the list of configs
3812 # do a make olddefconfig and then read th 3797 # do a make olddefconfig and then read the resulting
3813 # .config to make sure it is missing the 3798 # .config to make sure it is missing the config that
3814 # we had before 3799 # we had before
3815 my %configs = %min_configs; 3800 my %configs = %min_configs;
3816 $configs{$config} = "# $config is not set 3801 $configs{$config} = "# $config is not set";
3817 make_new_config ((values %configs), (valu 3802 make_new_config ((values %configs), (values %keep_configs));
3818 make_oldconfig; 3803 make_oldconfig;
3819 delete $configs{$config}; 3804 delete $configs{$config};
3820 undef %configs; 3805 undef %configs;
3821 assign_configs \%configs, $output_config; 3806 assign_configs \%configs, $output_config;
3822 3807
3823 if (!defined($configs{$config}) || $confi 3808 if (!defined($configs{$config}) || $configs{$config} =~ /^#/) {
3824 return $config; 3809 return $config;
3825 } 3810 }
3826 3811
3827 doprint "disabling config $config did not 3812 doprint "disabling config $config did not change .config\n";
3828 3813
3829 $nochange_config{$config} = 1; 3814 $nochange_config{$config} = 1;
3830 3815
3831 return undef; 3816 return undef;
3832 } 3817 }
3833 3818
3834 sub make_min_config { 3819 sub make_min_config {
3835 my ($i) = @_; 3820 my ($i) = @_;
3836 3821
3837 my $type = $minconfig_type; 3822 my $type = $minconfig_type;
3838 if ($type ne "boot" && $type ne "test") { 3823 if ($type ne "boot" && $type ne "test") {
3839 fail "Invalid MIN_CONFIG_TYPE '$minco 3824 fail "Invalid MIN_CONFIG_TYPE '$minconfig_type'\n" .
3840 " make_min_config works only with 3825 " make_min_config works only with 'boot' and 'test'\n" and return;
3841 } 3826 }
3842 3827
3843 if (!defined($output_minconfig)) { 3828 if (!defined($output_minconfig)) {
3844 fail "OUTPUT_MIN_CONFIG not defined" 3829 fail "OUTPUT_MIN_CONFIG not defined" and return;
3845 } 3830 }
3846 3831
3847 # If output_minconfig exists, and the sta 3832 # If output_minconfig exists, and the start_minconfig
3848 # came from min_config, than ask if we sh 3833 # came from min_config, than ask if we should use
3849 # that instead. 3834 # that instead.
3850 if (-f $output_minconfig && !$start_minco 3835 if (-f $output_minconfig && !$start_minconfig_defined) {
3851 print "$output_minconfig exists\n"; 3836 print "$output_minconfig exists\n";
3852 if (!defined($use_output_minconfig)) 3837 if (!defined($use_output_minconfig)) {
3853 if (read_yn " Use it as minconfig 3838 if (read_yn " Use it as minconfig?") {
3854 $start_minconfig = $output_mi 3839 $start_minconfig = $output_minconfig;
3855 } 3840 }
3856 } elsif ($use_output_minconfig > 0) { 3841 } elsif ($use_output_minconfig > 0) {
3857 doprint "Using $output_minconfig 3842 doprint "Using $output_minconfig as MIN_CONFIG\n";
3858 $start_minconfig = $output_mincon 3843 $start_minconfig = $output_minconfig;
3859 } else { 3844 } else {
3860 doprint "Set to still use MIN_CON 3845 doprint "Set to still use MIN_CONFIG as starting point\n";
3861 } 3846 }
3862 } 3847 }
3863 3848
3864 if (!defined($start_minconfig)) { 3849 if (!defined($start_minconfig)) {
3865 fail "START_MIN_CONFIG or MIN_CONFIG 3850 fail "START_MIN_CONFIG or MIN_CONFIG not defined" and return;
3866 } 3851 }
3867 3852
3868 my $temp_config = "$tmpdir/temp_config"; 3853 my $temp_config = "$tmpdir/temp_config";
3869 3854
3870 # First things first. We build an allnoco 3855 # First things first. We build an allnoconfig to find
3871 # out what the defaults are that we can't 3856 # out what the defaults are that we can't touch.
3872 # Some are selections, but we really can' 3857 # Some are selections, but we really can't handle selections.
3873 3858
3874 my $save_minconfig = $minconfig; 3859 my $save_minconfig = $minconfig;
3875 undef $minconfig; 3860 undef $minconfig;
3876 3861
3877 run_command "$make allnoconfig" or return 3862 run_command "$make allnoconfig" or return 0;
3878 3863
3879 read_depends; 3864 read_depends;
3880 3865
3881 process_config_ignore $output_config; 3866 process_config_ignore $output_config;
3882 3867
3883 undef %save_configs; 3868 undef %save_configs;
3884 undef %min_configs; 3869 undef %min_configs;
3885 3870
3886 if (defined($ignore_config)) { 3871 if (defined($ignore_config)) {
3887 # make sure the file exists 3872 # make sure the file exists
3888 `touch $ignore_config`; 3873 `touch $ignore_config`;
3889 assign_configs \%save_configs, $ignor 3874 assign_configs \%save_configs, $ignore_config;
3890 } 3875 }
3891 3876
3892 %keep_configs = %save_configs; 3877 %keep_configs = %save_configs;
3893 3878
3894 doprint "Load initial configs from $start 3879 doprint "Load initial configs from $start_minconfig\n";
3895 3880
3896 # Look at the current min configs, and sa 3881 # Look at the current min configs, and save off all the
3897 # ones that were set via the allnoconfig 3882 # ones that were set via the allnoconfig
3898 assign_configs \%min_configs, $start_minc 3883 assign_configs \%min_configs, $start_minconfig;
3899 3884
3900 my @config_keys = keys %min_configs; 3885 my @config_keys = keys %min_configs;
3901 3886
3902 # All configs need a depcount 3887 # All configs need a depcount
3903 foreach my $config (@config_keys) { 3888 foreach my $config (@config_keys) {
3904 my $kconfig = chomp_config $config; 3889 my $kconfig = chomp_config $config;
3905 if (!defined $depcount{$kconfig}) { 3890 if (!defined $depcount{$kconfig}) {
3906 $depcount{$kconfig} = 0; !! 3891 $depcount{$kconfig} = 0;
3907 } 3892 }
3908 } 3893 }
3909 3894
3910 # Remove anything that was set by the mak 3895 # Remove anything that was set by the make allnoconfig
3911 # we shouldn't need them as they get set 3896 # we shouldn't need them as they get set for us anyway.
3912 foreach my $config (@config_keys) { 3897 foreach my $config (@config_keys) {
3913 # Remove anything in the ignore_confi 3898 # Remove anything in the ignore_config
3914 if (defined($keep_configs{$config})) 3899 if (defined($keep_configs{$config})) {
3915 my $file = $ignore_config; 3900 my $file = $ignore_config;
3916 $file =~ s,.*/(.*?)$,$1,; 3901 $file =~ s,.*/(.*?)$,$1,;
3917 doprint "$config set by $file ... 3902 doprint "$config set by $file ... ignored\n";
3918 delete $min_configs{$config}; 3903 delete $min_configs{$config};
3919 next; 3904 next;
3920 } 3905 }
3921 # But make sure the settings are the 3906 # But make sure the settings are the same. If a min config
3922 # sets a selection, we do not want to 3907 # sets a selection, we do not want to get rid of it if
3923 # it is not the same as what we have. 3908 # it is not the same as what we have. Just move it into
3924 # the keep configs. 3909 # the keep configs.
3925 if (defined($config_ignore{$config})) 3910 if (defined($config_ignore{$config})) {
3926 if ($config_ignore{$config} ne $m 3911 if ($config_ignore{$config} ne $min_configs{$config}) {
3927 doprint "$config is in allnoc 3912 doprint "$config is in allnoconfig as '$config_ignore{$config}'";
3928 doprint " but it is '$min_con 3913 doprint " but it is '$min_configs{$config}' in minconfig .. keeping\n";
3929 $keep_configs{$config} = $min 3914 $keep_configs{$config} = $min_configs{$config};
3930 } else { 3915 } else {
3931 doprint "$config set by allno 3916 doprint "$config set by allnoconfig ... ignored\n";
3932 } 3917 }
3933 delete $min_configs{$config}; 3918 delete $min_configs{$config};
3934 } 3919 }
3935 } 3920 }
3936 3921
3937 my $done = 0; 3922 my $done = 0;
3938 my $take_two = 0; 3923 my $take_two = 0;
3939 3924
3940 while (!$done) { 3925 while (!$done) {
>> 3926
3941 my $config; 3927 my $config;
3942 my $found; 3928 my $found;
3943 3929
3944 # Now disable each config one by one 3930 # Now disable each config one by one and do a make oldconfig
3945 # till we find a config that changes 3931 # till we find a config that changes our list.
3946 3932
3947 my @test_configs = keys %min_configs; 3933 my @test_configs = keys %min_configs;
3948 3934
3949 # Sort keys by who is most dependent 3935 # Sort keys by who is most dependent on
3950 @test_configs = sort { $depcount{cho 3936 @test_configs = sort { $depcount{chomp_config($b)} <=> $depcount{chomp_config($a)} }
3951 @test_configs ; !! 3937 @test_configs ;
3952 3938
3953 # Put configs that did not modify the 3939 # Put configs that did not modify the config at the end.
3954 my $reset = 1; 3940 my $reset = 1;
3955 for (my $i = 0; $i < $#test_configs; 3941 for (my $i = 0; $i < $#test_configs; $i++) {
3956 if (!defined($nochange_config{$te 3942 if (!defined($nochange_config{$test_configs[0]})) {
3957 $reset = 0; 3943 $reset = 0;
3958 last; 3944 last;
3959 } 3945 }
3960 # This config didn't change the . 3946 # This config didn't change the .config last time.
3961 # Place it at the end 3947 # Place it at the end
3962 my $config = shift @test_configs; 3948 my $config = shift @test_configs;
3963 push @test_configs, $config; 3949 push @test_configs, $config;
3964 } 3950 }
3965 3951
3966 # if every test config has failed to 3952 # if every test config has failed to modify the .config file
3967 # in the past, then reset and start o 3953 # in the past, then reset and start over.
3968 if ($reset) { 3954 if ($reset) {
3969 undef %nochange_config; 3955 undef %nochange_config;
3970 } 3956 }
3971 3957
3972 undef %processed_configs; 3958 undef %processed_configs;
3973 3959
3974 foreach my $config (@test_configs) { 3960 foreach my $config (@test_configs) {
3975 3961
3976 $found = test_this_config $config 3962 $found = test_this_config $config;
3977 3963
3978 last if (defined($found)); 3964 last if (defined($found));
3979 3965
3980 # oh well, try another config 3966 # oh well, try another config
3981 } 3967 }
3982 3968
3983 if (!defined($found)) { 3969 if (!defined($found)) {
3984 # we could have failed due to the 3970 # we could have failed due to the nochange_config hash
3985 # reset and try again 3971 # reset and try again
3986 if (!$take_two) { 3972 if (!$take_two) {
3987 undef %nochange_config; 3973 undef %nochange_config;
3988 $take_two = 1; 3974 $take_two = 1;
3989 next; 3975 next;
3990 } 3976 }
3991 doprint "No more configs found th 3977 doprint "No more configs found that we can disable\n";
3992 $done = 1; 3978 $done = 1;
3993 last; 3979 last;
3994 } 3980 }
3995 $take_two = 0; 3981 $take_two = 0;
3996 3982
3997 $config = $found; 3983 $config = $found;
3998 3984
3999 doprint "Test with $config disabled\n 3985 doprint "Test with $config disabled\n";
4000 3986
4001 # set in_bisect to keep build and mon 3987 # set in_bisect to keep build and monitor from dieing
4002 $in_bisect = 1; 3988 $in_bisect = 1;
4003 3989
4004 my $failed = 0; 3990 my $failed = 0;
4005 build "oldconfig" or $failed = 1; 3991 build "oldconfig" or $failed = 1;
4006 if (!$failed) { 3992 if (!$failed) {
4007 start_monitor_and_install or $fai !! 3993 start_monitor_and_install or $failed = 1;
4008 3994
4009 if ($type eq "test" && !$failed) !! 3995 if ($type eq "test" && !$failed) {
4010 do_run_test or $failed = 1; !! 3996 do_run_test or $failed = 1;
4011 } !! 3997 }
4012 3998
4013 end_monitor; !! 3999 end_monitor;
4014 } 4000 }
4015 4001
4016 $in_bisect = 0; 4002 $in_bisect = 0;
4017 4003
4018 if ($failed) { 4004 if ($failed) {
4019 doprint "$min_configs{$config} is 4005 doprint "$min_configs{$config} is needed to boot the box... keeping\n";
4020 # this config is needed, add it t 4006 # this config is needed, add it to the ignore list.
4021 $keep_configs{$config} = $min_con 4007 $keep_configs{$config} = $min_configs{$config};
4022 $save_configs{$config} = $min_con 4008 $save_configs{$config} = $min_configs{$config};
4023 delete $min_configs{$config}; 4009 delete $min_configs{$config};
4024 4010
4025 # update new ignore configs 4011 # update new ignore configs
4026 if (defined($ignore_config)) { 4012 if (defined($ignore_config)) {
4027 open (OUT, ">$temp_config") o !! 4013 open (OUT, ">$temp_config")
4028 dodie "Can't write to $te !! 4014 or die "Can't write to $temp_config";
4029 foreach my $config (keys %sav 4015 foreach my $config (keys %save_configs) {
4030 print OUT "$save_configs{ 4016 print OUT "$save_configs{$config}\n";
4031 } 4017 }
4032 close OUT; 4018 close OUT;
4033 run_command "mv $temp_config 4019 run_command "mv $temp_config $ignore_config" or
4034 dodie "failed to copy upd 4020 dodie "failed to copy update to $ignore_config";
4035 } 4021 }
4036 4022
4037 } else { 4023 } else {
4038 # We booted without this config, 4024 # We booted without this config, remove it from the minconfigs.
4039 doprint "$config is not needed, d 4025 doprint "$config is not needed, disabling\n";
4040 4026
4041 delete $min_configs{$config}; 4027 delete $min_configs{$config};
4042 4028
4043 # Also disable anything that is n 4029 # Also disable anything that is not enabled in this config
4044 my %configs; 4030 my %configs;
4045 assign_configs \%configs, $output 4031 assign_configs \%configs, $output_config;
4046 my @config_keys = keys %min_confi 4032 my @config_keys = keys %min_configs;
4047 foreach my $config (@config_keys) 4033 foreach my $config (@config_keys) {
4048 if (!defined($configs{$config 4034 if (!defined($configs{$config})) {
4049 doprint "$config is not s 4035 doprint "$config is not set, disabling\n";
4050 delete $min_configs{$conf 4036 delete $min_configs{$config};
4051 } 4037 }
4052 } 4038 }
4053 4039
4054 # Save off all the current mandat 4040 # Save off all the current mandatory configs
4055 open (OUT, ">$temp_config") or !! 4041 open (OUT, ">$temp_config")
4056 dodie "Can't write to $temp_c !! 4042 or die "Can't write to $temp_config";
4057 foreach my $config (keys %keep_co 4043 foreach my $config (keys %keep_configs) {
4058 print OUT "$keep_configs{$con 4044 print OUT "$keep_configs{$config}\n";
4059 } 4045 }
4060 foreach my $config (keys %min_con 4046 foreach my $config (keys %min_configs) {
4061 print OUT "$min_configs{$conf 4047 print OUT "$min_configs{$config}\n";
4062 } 4048 }
4063 close OUT; 4049 close OUT;
4064 4050
4065 run_command "mv $temp_config $out 4051 run_command "mv $temp_config $output_minconfig" or
4066 dodie "failed to copy update 4052 dodie "failed to copy update to $output_minconfig";
4067 } 4053 }
4068 4054
4069 doprint "Reboot and wait $sleep_time 4055 doprint "Reboot and wait $sleep_time seconds\n";
4070 reboot_to_good $sleep_time; 4056 reboot_to_good $sleep_time;
4071 } 4057 }
4072 4058
4073 success $i; 4059 success $i;
4074 return 1; 4060 return 1;
4075 } 4061 }
4076 4062
4077 sub make_warnings_file { 4063 sub make_warnings_file {
4078 my ($i) = @_; 4064 my ($i) = @_;
4079 4065
4080 if (!defined($warnings_file)) { 4066 if (!defined($warnings_file)) {
4081 dodie "Must define WARNINGS_FILE for 4067 dodie "Must define WARNINGS_FILE for make_warnings_file test";
4082 } 4068 }
4083 4069
4084 if ($build_type eq "nobuild") { 4070 if ($build_type eq "nobuild") {
4085 dodie "BUILD_TYPE can not be 'nobuild 4071 dodie "BUILD_TYPE can not be 'nobuild' for make_warnings_file test";
4086 } 4072 }
4087 4073
4088 build $build_type or dodie "Failed to bui 4074 build $build_type or dodie "Failed to build";
4089 4075
4090 open(OUT, ">$warnings_file") or dodie "Ca 4076 open(OUT, ">$warnings_file") or dodie "Can't create $warnings_file";
4091 4077
4092 open(IN, $buildlog) or dodie "Can't open 4078 open(IN, $buildlog) or dodie "Can't open $buildlog";
4093 while (<IN>) { 4079 while (<IN>) {
>> 4080
4094 # Some compilers use UTF-8 extended f 4081 # Some compilers use UTF-8 extended for quotes
4095 # for distcc heterogeneous systems, t 4082 # for distcc heterogeneous systems, this causes issues
4096 s/$utf8_quote/'/g; 4083 s/$utf8_quote/'/g;
4097 4084
4098 if (/$check_build_re/) { 4085 if (/$check_build_re/) {
4099 print OUT; 4086 print OUT;
4100 } 4087 }
4101 } 4088 }
4102 close(IN); 4089 close(IN);
4103 4090
4104 close(OUT); 4091 close(OUT);
4105 4092
4106 success $i; 4093 success $i;
4107 } 4094 }
4108 4095
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 4096 $#ARGV < 1 or die "ktest.pl version: $VERSION\n usage: ktest.pl [config-file]\n";
4243 4097
4244 if ($#ARGV == 0) { 4098 if ($#ARGV == 0) {
4245 $ktest_config = $ARGV[0]; 4099 $ktest_config = $ARGV[0];
4246 if (! -f $ktest_config) { 4100 if (! -f $ktest_config) {
4247 print "$ktest_config does not exist.\ 4101 print "$ktest_config does not exist.\n";
4248 if (!read_yn "Create it?") { 4102 if (!read_yn "Create it?") {
4249 exit 0; 4103 exit 0;
4250 } 4104 }
4251 } 4105 }
4252 } 4106 }
4253 4107
4254 if (! -f $ktest_config) { 4108 if (! -f $ktest_config) {
4255 $newconfig = 1; 4109 $newconfig = 1;
4256 get_test_case; 4110 get_test_case;
4257 open(OUT, ">$ktest_config") or die "Can n 4111 open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
4258 print OUT << "EOF" 4112 print OUT << "EOF"
4259 # Generated by ktest.pl 4113 # Generated by ktest.pl
4260 # 4114 #
4261 4115
4262 # PWD is a ktest.pl variable that will result 4116 # PWD is a ktest.pl variable that will result in the process working
4263 # directory that ktest.pl is executed in. 4117 # directory that ktest.pl is executed in.
4264 4118
4265 # THIS_DIR is automatically assigned the PWD 4119 # THIS_DIR is automatically assigned the PWD of the path that generated
4266 # the config file. It is best to use this var 4120 # the config file. It is best to use this variable when assigning other
4267 # directory paths within this directory. This 4121 # directory paths within this directory. This allows you to easily
4268 # move the test cases to other locations or t 4122 # move the test cases to other locations or to other machines.
4269 # 4123 #
4270 THIS_DIR := $variable{"PWD"} 4124 THIS_DIR := $variable{"PWD"}
4271 4125
4272 # Define each test with TEST_START 4126 # Define each test with TEST_START
4273 # The config options below it will override t 4127 # The config options below it will override the defaults
4274 TEST_START 4128 TEST_START
4275 TEST_TYPE = $default{"TEST_TYPE"} 4129 TEST_TYPE = $default{"TEST_TYPE"}
4276 4130
4277 DEFAULTS 4131 DEFAULTS
4278 EOF 4132 EOF
4279 ; 4133 ;
4280 close(OUT); 4134 close(OUT);
4281 } 4135 }
4282 read_config $ktest_config; 4136 read_config $ktest_config;
4283 4137
4284 if (defined($opt{"LOG_FILE"})) { 4138 if (defined($opt{"LOG_FILE"})) {
4285 $opt{"LOG_FILE"} = eval_option("LOG_FILE" 4139 $opt{"LOG_FILE"} = eval_option("LOG_FILE", $opt{"LOG_FILE"}, -1);
4286 } 4140 }
4287 4141
4288 # Append any configs entered in manually to t 4142 # Append any configs entered in manually to the config file.
4289 my @new_configs = keys %entered_configs; 4143 my @new_configs = keys %entered_configs;
4290 if ($#new_configs >= 0) { 4144 if ($#new_configs >= 0) {
4291 print "\nAppending entered in configs to 4145 print "\nAppending entered in configs to $ktest_config\n";
4292 open(OUT, ">>$ktest_config") or die "Can 4146 open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
4293 foreach my $config (@new_configs) { 4147 foreach my $config (@new_configs) {
4294 print OUT "$config = $entered_configs 4148 print OUT "$config = $entered_configs{$config}\n";
4295 $opt{$config} = process_variables($en 4149 $opt{$config} = process_variables($entered_configs{$config});
4296 } 4150 }
4297 } 4151 }
4298 4152
4299 if (defined($opt{"LOG_FILE"})) { !! 4153 if ($opt{"CLEAR_LOG"} && defined($opt{"LOG_FILE"})) {
4300 if ($opt{"CLEAR_LOG"}) { !! 4154 unlink $opt{"LOG_FILE"};
4301 unlink $opt{"LOG_FILE"}; <<
4302 } <<
4303 open(LOG, ">> $opt{LOG_FILE}") or die "Ca <<
4304 LOG->autoflush(1); <<
4305 } 4155 }
4306 4156
4307 doprint "\n\nSTARTING AUTOMATED TESTS\n\n"; 4157 doprint "\n\nSTARTING AUTOMATED TESTS\n\n";
4308 4158
4309 for (my $i = 0, my $repeat = 1; $i <= $opt{"N 4159 for (my $i = 0, my $repeat = 1; $i <= $opt{"NUM_TESTS"}; $i += $repeat) {
4310 4160
4311 if (!$i) { 4161 if (!$i) {
4312 doprint "DEFAULT OPTIONS:\n"; 4162 doprint "DEFAULT OPTIONS:\n";
4313 } else { 4163 } else {
4314 doprint "\nTEST $i OPTIONS"; 4164 doprint "\nTEST $i OPTIONS";
4315 if (defined($repeat_tests{$i})) { 4165 if (defined($repeat_tests{$i})) {
4316 $repeat = $repeat_tests{$i}; 4166 $repeat = $repeat_tests{$i};
4317 doprint " ITERATE $repeat"; 4167 doprint " ITERATE $repeat";
4318 } 4168 }
4319 doprint "\n"; 4169 doprint "\n";
4320 } 4170 }
4321 4171
4322 foreach my $option (sort keys %opt) { 4172 foreach my $option (sort keys %opt) {
>> 4173
4323 if ($option =~ /\[(\d+)\]$/) { 4174 if ($option =~ /\[(\d+)\]$/) {
4324 next if ($i != $1); 4175 next if ($i != $1);
4325 } else { 4176 } else {
4326 next if ($i); 4177 next if ($i);
4327 } 4178 }
4328 4179
4329 doprint "$option = $opt{$option}\n"; 4180 doprint "$option = $opt{$option}\n";
4330 } 4181 }
4331 } 4182 }
4332 4183
4333 $SIG{INT} = qw(cancel_test); !! 4184 sub option_defined {
>> 4185 my ($option) = @_;
>> 4186
>> 4187 if (defined($opt{$option}) && $opt{$option} !~ /^\s*$/) {
>> 4188 return 1;
>> 4189 }
>> 4190
>> 4191 return 0;
>> 4192 }
>> 4193
>> 4194 sub __set_test_option {
>> 4195 my ($name, $i) = @_;
>> 4196
>> 4197 my $option = "$name\[$i\]";
>> 4198
>> 4199 if (option_defined($option)) {
>> 4200 return $opt{$option};
>> 4201 }
>> 4202
>> 4203 foreach my $test (keys %repeat_tests) {
>> 4204 if ($i >= $test &&
>> 4205 $i < $test + $repeat_tests{$test}) {
>> 4206 $option = "$name\[$test\]";
>> 4207 if (option_defined($option)) {
>> 4208 return $opt{$option};
>> 4209 }
>> 4210 }
>> 4211 }
>> 4212
>> 4213 if (option_defined($name)) {
>> 4214 return $opt{$name};
>> 4215 }
>> 4216
>> 4217 return undef;
>> 4218 }
>> 4219
>> 4220 sub set_test_option {
>> 4221 my ($name, $i) = @_;
>> 4222
>> 4223 my $option = __set_test_option($name, $i);
>> 4224 return $option if (!defined($option));
>> 4225
>> 4226 return eval_option($name, $option, $i);
>> 4227 }
4334 4228
4335 # First we need to do is the builds 4229 # First we need to do is the builds
4336 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++ 4230 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
4337 4231
4338 # Do not reboot on failing test options 4232 # Do not reboot on failing test options
4339 $no_reboot = 1; 4233 $no_reboot = 1;
4340 $reboot_success = 0; 4234 $reboot_success = 0;
4341 4235
4342 $have_version = 0; 4236 $have_version = 0;
4343 4237
4344 $iteration = $i; 4238 $iteration = $i;
4345 4239
4346 $build_time = 0; 4240 $build_time = 0;
4347 $install_time = 0; 4241 $install_time = 0;
4348 $reboot_time = 0; 4242 $reboot_time = 0;
4349 $test_time = 0; 4243 $test_time = 0;
4350 4244
4351 undef %force_config; 4245 undef %force_config;
4352 4246
4353 my $makecmd = set_test_option("MAKE_CMD", 4247 my $makecmd = set_test_option("MAKE_CMD", $i);
4354 4248
4355 $outputdir = set_test_option("OUTPUT_DIR" 4249 $outputdir = set_test_option("OUTPUT_DIR", $i);
4356 $builddir = set_test_option("BUILD_DIR", 4250 $builddir = set_test_option("BUILD_DIR", $i);
4357 4251
4358 chdir $builddir || dodie "can't change di !! 4252 chdir $builddir || die "can't change directory to $builddir";
4359 4253
4360 if (!-d $outputdir) { 4254 if (!-d $outputdir) {
4361 mkpath($outputdir) or 4255 mkpath($outputdir) or
4362 dodie "can't create $outputdir"; !! 4256 die "can't create $outputdir";
4363 } 4257 }
4364 4258
4365 $make = "$makecmd O=$outputdir"; 4259 $make = "$makecmd O=$outputdir";
4366 4260
4367 # Load all the options into their mapped 4261 # Load all the options into their mapped variable names
4368 foreach my $opt (keys %option_map) { 4262 foreach my $opt (keys %option_map) {
4369 ${$option_map{$opt}} = set_test_optio 4263 ${$option_map{$opt}} = set_test_option($opt, $i);
4370 } 4264 }
4371 4265
4372 $start_minconfig_defined = 1; 4266 $start_minconfig_defined = 1;
4373 4267
4374 # The first test may override the PRE_KTE 4268 # The first test may override the PRE_KTEST option
4375 if ($i == 1) { !! 4269 if (defined($pre_ktest) && $i == 1) {
4376 if (defined($pre_ktest)) { !! 4270 doprint "\n";
4377 doprint "\n"; !! 4271 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 } 4272 }
4386 4273
4387 # Any test can override the POST_KTEST op 4274 # Any test can override the POST_KTEST option
4388 # The last test takes precedence. 4275 # The last test takes precedence.
4389 if (defined($post_ktest)) { 4276 if (defined($post_ktest)) {
4390 $final_post_ktest = $post_ktest; 4277 $final_post_ktest = $post_ktest;
4391 } 4278 }
4392 4279
4393 if (!defined($start_minconfig)) { 4280 if (!defined($start_minconfig)) {
4394 $start_minconfig_defined = 0; 4281 $start_minconfig_defined = 0;
4395 $start_minconfig = $minconfig; 4282 $start_minconfig = $minconfig;
4396 } 4283 }
4397 4284
4398 if (!-d $tmpdir) { 4285 if (!-d $tmpdir) {
4399 mkpath($tmpdir) or 4286 mkpath($tmpdir) or
4400 dodie "can't create $tmpdir"; !! 4287 die "can't create $tmpdir";
4401 } 4288 }
4402 4289
4403 $ENV{"SSH_USER"} = $ssh_user; 4290 $ENV{"SSH_USER"} = $ssh_user;
4404 $ENV{"MACHINE"} = $machine; 4291 $ENV{"MACHINE"} = $machine;
4405 4292
4406 $buildlog = "$tmpdir/buildlog-$machine"; 4293 $buildlog = "$tmpdir/buildlog-$machine";
4407 $testlog = "$tmpdir/testlog-$machine"; 4294 $testlog = "$tmpdir/testlog-$machine";
4408 $dmesg = "$tmpdir/dmesg-$machine"; 4295 $dmesg = "$tmpdir/dmesg-$machine";
4409 $output_config = "$outputdir/.config"; 4296 $output_config = "$outputdir/.config";
4410 4297
4411 if (!$buildonly) { 4298 if (!$buildonly) {
4412 $target = "$ssh_user\@$machine"; 4299 $target = "$ssh_user\@$machine";
4413 if (($reboot_type eq "grub") or ($reb !! 4300 if ($reboot_type eq "grub") {
4414 dodie "GRUB_MENU not defined" if 4301 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
4415 } elsif ($reboot_type eq "grub2") { 4302 } elsif ($reboot_type eq "grub2") {
4416 dodie "GRUB_MENU not defined" if 4303 dodie "GRUB_MENU not defined" if (!defined($grub_menu));
4417 dodie "GRUB_FILE not defined" if 4304 dodie "GRUB_FILE not defined" if (!defined($grub_file));
4418 } elsif ($reboot_type eq "syslinux") 4305 } elsif ($reboot_type eq "syslinux") {
4419 dodie "SYSLINUX_LABEL not defined 4306 dodie "SYSLINUX_LABEL not defined" if (!defined($syslinux_label));
4420 } 4307 }
4421 } 4308 }
4422 4309
4423 my $run_type = $build_type; 4310 my $run_type = $build_type;
4424 if ($test_type eq "patchcheck") { 4311 if ($test_type eq "patchcheck") {
4425 $run_type = $patchcheck_type; 4312 $run_type = $patchcheck_type;
4426 } elsif ($test_type eq "bisect") { 4313 } elsif ($test_type eq "bisect") {
4427 $run_type = $bisect_type; 4314 $run_type = $bisect_type;
4428 } elsif ($test_type eq "config_bisect") { 4315 } elsif ($test_type eq "config_bisect") {
4429 $run_type = $config_bisect_type; 4316 $run_type = $config_bisect_type;
4430 } elsif ($test_type eq "make_min_config") 4317 } elsif ($test_type eq "make_min_config") {
4431 $run_type = ""; 4318 $run_type = "";
4432 } elsif ($test_type eq "make_warnings_fil 4319 } elsif ($test_type eq "make_warnings_file") {
4433 $run_type = ""; 4320 $run_type = "";
4434 } 4321 }
4435 4322
4436 # mistake in config file? 4323 # mistake in config file?
4437 if (!defined($run_type)) { 4324 if (!defined($run_type)) {
4438 $run_type = "ERROR"; 4325 $run_type = "ERROR";
4439 } 4326 }
4440 4327
4441 my $installme = ""; 4328 my $installme = "";
4442 $installme = " no_install" if ($no_instal 4329 $installme = " no_install" if ($no_install);
4443 4330
4444 my $name = ""; 4331 my $name = "";
4445 4332
4446 if (defined($test_name)) { 4333 if (defined($test_name)) {
4447 $name = " ($test_name)"; 4334 $name = " ($test_name)";
4448 } 4335 }
4449 4336
4450 doprint "\n\n"; 4337 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 4338 doprint "RUNNING TEST $i of $opt{NUM_TESTS}$name with option $test_type $run_type$installme\n\n";
4457 4339
4458 if (defined($pre_test)) { 4340 if (defined($pre_test)) {
4459 my $ret = run_command $pre_test; !! 4341 run_command $pre_test;
4460 if (!$ret && defined($pre_test_die) & <<
4461 $pre_test_die) { <<
4462 dodie "failed to pre_test\n"; <<
4463 } <<
4464 } 4342 }
4465 4343
4466 unlink $dmesg; 4344 unlink $dmesg;
4467 unlink $buildlog; 4345 unlink $buildlog;
4468 unlink $testlog; 4346 unlink $testlog;
4469 4347
4470 if (defined($addconfig)) { 4348 if (defined($addconfig)) {
4471 my $min = $minconfig; 4349 my $min = $minconfig;
4472 if (!defined($minconfig)) { 4350 if (!defined($minconfig)) {
4473 $min = ""; 4351 $min = "";
4474 } 4352 }
4475 run_command "cat $addconfig $min > $t 4353 run_command "cat $addconfig $min > $tmpdir/add_config" or
4476 dodie "Failed to create temp conf 4354 dodie "Failed to create temp config";
4477 $minconfig = "$tmpdir/add_config"; 4355 $minconfig = "$tmpdir/add_config";
4478 } 4356 }
4479 4357
4480 if (defined($checkout)) { 4358 if (defined($checkout)) {
4481 run_command "git checkout $checkout" 4359 run_command "git checkout $checkout" or
4482 dodie "failed to checkout $checko !! 4360 die "failed to checkout $checkout";
4483 } 4361 }
4484 4362
4485 $no_reboot = 0; 4363 $no_reboot = 0;
4486 4364
4487 # A test may opt to not reboot the box 4365 # A test may opt to not reboot the box
4488 if ($reboot_on_success) { 4366 if ($reboot_on_success) {
4489 $reboot_success = 1; 4367 $reboot_success = 1;
4490 } 4368 }
4491 4369
4492 if ($test_type eq "bisect") { 4370 if ($test_type eq "bisect") {
4493 bisect $i; 4371 bisect $i;
4494 next; 4372 next;
4495 } elsif ($test_type eq "config_bisect") { 4373 } elsif ($test_type eq "config_bisect") {
4496 config_bisect $i; 4374 config_bisect $i;
4497 next; 4375 next;
4498 } elsif ($test_type eq "patchcheck") { 4376 } elsif ($test_type eq "patchcheck") {
4499 patchcheck $i; 4377 patchcheck $i;
4500 next; 4378 next;
4501 } elsif ($test_type eq "make_min_config") 4379 } elsif ($test_type eq "make_min_config") {
4502 make_min_config $i; 4380 make_min_config $i;
4503 next; 4381 next;
4504 } elsif ($test_type eq "make_warnings_fil 4382 } elsif ($test_type eq "make_warnings_file") {
4505 $no_reboot = 1; 4383 $no_reboot = 1;
4506 make_warnings_file $i; 4384 make_warnings_file $i;
4507 next; 4385 next;
4508 } 4386 }
4509 4387
4510 if ($build_type ne "nobuild") { 4388 if ($build_type ne "nobuild") {
4511 build $build_type or next; 4389 build $build_type or next;
4512 check_buildlog or next; 4390 check_buildlog or next;
4513 } 4391 }
4514 4392
4515 if ($test_type eq "install") { 4393 if ($test_type eq "install") {
4516 get_version; 4394 get_version;
4517 install; 4395 install;
4518 success $i; 4396 success $i;
4519 next; 4397 next;
4520 } 4398 }
4521 4399
4522 if ($test_type ne "build") { 4400 if ($test_type ne "build") {
4523 my $failed = 0; 4401 my $failed = 0;
4524 start_monitor_and_install or $failed 4402 start_monitor_and_install or $failed = 1;
4525 4403
4526 if (!$failed && $test_type ne "boot" 4404 if (!$failed && $test_type ne "boot" && defined($run_test)) {
4527 do_run_test or $failed = 1; 4405 do_run_test or $failed = 1;
4528 } 4406 }
4529 end_monitor; 4407 end_monitor;
4530 if ($failed) { 4408 if ($failed) {
4531 print_times; 4409 print_times;
4532 next; 4410 next;
4533 } 4411 }
4534 } 4412 }
4535 4413
4536 print_times; 4414 print_times;
4537 4415
4538 success $i; 4416 success $i;
4539 } 4417 }
4540 4418
4541 if (defined($final_post_ktest)) { 4419 if (defined($final_post_ktest)) {
4542 !! 4420 run_command $final_post_ktest;
4543 my $cp_final_post_ktest = eval_kernel_ver <<
4544 run_command $cp_final_post_ktest; <<
4545 } 4421 }
4546 4422
4547 if ($opt{"POWEROFF_ON_SUCCESS"}) { 4423 if ($opt{"POWEROFF_ON_SUCCESS"}) {
4548 halt; 4424 halt;
4549 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not 4425 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot && $reboot_success) {
4550 reboot_to_good; 4426 reboot_to_good;
4551 } elsif (defined($switch_to_good)) { 4427 } elsif (defined($switch_to_good)) {
4552 # still need to get to the good kernel 4428 # still need to get to the good kernel
4553 run_command $switch_to_good; 4429 run_command $switch_to_good;
4554 } 4430 }
4555 4431
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 4432
4563 if (defined($opt{"LOG_FILE"})) { !! 4433 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 4434
4568 exit 0; 4435 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.