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