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