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