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