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