]>
Commit | Line | Data |
---|---|---|
e88396c0 JJ |
1 | #! /bin/bash |
2 | ||
3 | #set -x | |
4 | ||
5 | ######################################################################## | |
6 | # | |
7 | # File: reg-hunt | |
8 | # Author: Janis Johnson <janis187@us.ibm.com> | |
9 | # Date: 2003/08/19 | |
10 | # | |
11 | # Search for the patch identifier for which results for a test changed, | |
12 | # using a binary search. The functionality for getting sources, | |
13 | # building the component to test, and running the test are in other | |
14 | # scripts that are run from here. Before the search begins, we verify | |
15 | # that we get the expected behavior for the first and last patch | |
16 | # identifiers. | |
17 | # | |
18 | # Define these in a file whose name is the argument to this script: | |
19 | # LOW_PATCH: Patch identifier. | |
20 | # HIGH_PATCH: Patch identifier. | |
21 | # REG_UPDATE: Pathname of script to update your source tree; returns | |
22 | # zero for success, nonzero for failure. | |
23 | # REG_BUILD: Pathname of script to build enough of the product to run | |
24 | # the test; returns zero for success, nonzero for failure. | |
25 | # REG_TEST: Pathname of script to run the test; returns 1 if we | |
26 | # should search later patches, 0 if we should search | |
27 | # earlier patches, and something else if there was an | |
28 | # unexpected failure. | |
29 | # Optional: | |
30 | # REG_REPORT Pathname of script to call at the end with the id of the | |
31 | # patch that caused the change in behavior. | |
32 | # REG_FINISH Pathname of script to call at the end with the two final | |
33 | # patch identifiers as arguments. | |
34 | # REG_NEWMID Pathname of script to call when a build has failed, with | |
35 | # arguments of the failed id and the current low and high | |
36 | # SKIP_LOW If 1, skip verifying the low patch identifier of the | |
37 | # range; define this only if you're restarting and have | |
38 | # already tested the low patch. | |
39 | # SKIP_HIGH If 1, skip verifying the high patch identifier of the | |
40 | # range; define this only if you're restarting and have | |
41 | # already tested the high patch. | |
42 | # FIRST_MID Use this as the first midpoint, to avoid a midpoint that | |
43 | # is known not to build. | |
44 | # VERBOSITY Default is 0, to print only errors and final message. | |
45 | # DATE_IN_MSG If set to anything but 0, include the time and date in | |
46 | # messages. | |
47 | # | |
48 | # | |
49 | # | |
a945c346 | 50 | # Copyright (C) 2002-2024 Free Software Foundation, Inc. |
e88396c0 JJ |
51 | # |
52 | # This file is free software; you can redistribute it and/or modify | |
53 | # it under the terms of the GNU General Public License as published by | |
54 | # the Free Software Foundation; either version 3 of the License, or | |
55 | # (at your option) any later version. | |
56 | # | |
57 | # This program is distributed in the hope that it will be useful, | |
58 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
59 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
60 | # GNU General Public License for more details. | |
61 | # | |
62 | # For a copy of the GNU General Public License, write the the | |
63 | # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | |
64 | # Boston, MA 02111-1301, USA. | |
65 | # | |
66 | ######################################################################## | |
67 | ||
68 | ######################################################################## | |
69 | # Functions | |
70 | ######################################################################## | |
71 | ||
72 | # Issue a message if its verbosity level is high enough. | |
73 | ||
74 | msg() { | |
75 | test ${1} -gt ${VERBOSITY} && return | |
76 | ||
77 | if [ "x${DATE_IN_MSG}" = "x" ]; then | |
78 | echo "${2}" | |
79 | else | |
80 | echo "`date` ${2}" | |
81 | fi | |
82 | } | |
83 | ||
84 | # Issue an error message and exit with a non-zero status. If there | |
85 | # is a valid current range whose end points have been tested, report | |
86 | # it so the user can start again from there. | |
87 | ||
88 | error() { | |
89 | msg 0 "error: ${1}" | |
90 | test ${VALID_RANGE} -eq 1 && \ | |
91 | echo "current range:" | |
92 | echo "LOW_PATCH=${LATER_THAN}" | |
93 | echo "HIGH_PATCH=${EARLIER_THAN}" | |
94 | exit 1 | |
95 | } | |
96 | ||
97 | # Build the components to test using sources as of a particular patch | |
98 | # and run a test case. Pass each of the scripts the patch identifier | |
99 | # that we're testing; the first one needs it, the others can ignore it | |
100 | # if they want. | |
101 | ||
102 | process_patch () { | |
103 | TEST_ID=${1} | |
104 | ||
105 | # If we're keeping track of known failures, see if TEST_ID is one and | |
106 | # if so, don't bother updating sources and trying to build. | |
107 | ||
108 | FAILS=0 | |
109 | SKIP=0 | |
110 | if [ ${SKIP_FAILURES} -eq 1 ]; then | |
111 | ${REG_CHECKFAIL} ${TEST_ID} | |
112 | if [ $? -eq 0 ]; then | |
113 | msg 1 "skipping ${TEST_ID}; it is a known build failure" | |
114 | FAILS=1 | |
115 | SKIP=1 | |
116 | fi | |
117 | fi | |
118 | ||
119 | if [ ${FAILS} -eq 0 ]; then | |
120 | ${REG_UPDATE} ${TEST_ID} || error "source update failed for ${TEST_ID}" | |
121 | ${REG_BUILD} ${TEST_ID} | |
122 | if [ $? -ne 0 ]; then | |
123 | FAILS=1 | |
124 | msg 1 "build failed for ${TEST_ID}" | |
125 | if [ ${SKIP_FAILURES} -eq 1 ]; then | |
126 | ${REG_RECORDFAIL} ${TEST_ID} | |
127 | fi | |
128 | fi | |
129 | fi | |
130 | ||
131 | if [ ${FAILS} -eq 0 ]; then | |
132 | ${REG_TEST} ${TEST_ID} | |
133 | LATER=$? | |
134 | if [ $LATER -ne 0 -a $LATER -ne 1 ]; then | |
135 | msg 0 "unexpected test failure for ${TEST_ID}" | |
136 | exit 1 | |
137 | fi | |
138 | else | |
139 | ||
140 | # The build failed, or this patch is already known to fail to build. | |
141 | # If it's an endpoint, or if we don't have a way to recover from | |
142 | # build failures, quit now. | |
143 | ||
144 | if [ ${SKIP} -eq 0 ]; then | |
120e4449 | 145 | if [ "x${REG_NEWMID}" = "x" \ |
e88396c0 JJ |
146 | -o ${TEST_ID} -eq ${LATER_THAN} \ |
147 | -o ${TEST_ID} -eq ${EARLIER_THAN} ]; then | |
148 | error "build failed for ${TEST_ID}" | |
149 | fi | |
150 | fi | |
151 | ||
152 | # Try to find a new patch to try within the current range. | |
153 | ||
154 | FIRST_MID=`${REG_NEWMID} ${LATER_THAN} ${EARLIER_THAN}` | |
155 | if [ ${FIRST_MID} -eq 0 ]; then | |
156 | ||
157 | # The heuristics in the tool ran out of patches to try next; | |
158 | # let the user handle it from here.+ | |
159 | error "build failed for ${TEST_ID}, could not find new candidate" | |
160 | fi | |
161 | msg 1 "using ${FIRST_MID}, between ${LATER_THAN} and ${EARLIER_THAN}" | |
162 | fi | |
163 | ||
164 | # Return with a valid LATER value or a new ID to try in FIRST_MID. | |
165 | } | |
166 | ||
167 | # Get the number of a patch within the range. It's not actually the | |
168 | # middle one, but the one that might minimize the number of checks. | |
169 | ||
170 | get_mid_special() { | |
171 | LOW=$1 | |
172 | HIGH=$2 | |
173 | ||
174 | let DIFF=HIGH-LOW | |
175 | M=1 | |
176 | POWER2=1 | |
177 | while | |
178 | [ $POWER2 -lt $DIFF ] | |
179 | do | |
180 | let M=POWER2 | |
181 | let POWER2=POWER2*2 | |
182 | done | |
183 | let MID=LOW+M | |
184 | } | |
185 | ||
186 | # Get the number of the patch in the middle of the range. | |
187 | ||
188 | get_mid () { | |
189 | LOW=$1 | |
190 | HIGH=$2 | |
191 | ||
192 | let DIFF=HIGH-LOW | |
193 | let M=DIFF/2 | |
194 | let MID=LOW+M | |
195 | } | |
196 | ||
197 | # Perform a binary search on patch identifiers within the range | |
198 | # specified by the arguments. | |
199 | ||
200 | search_patches () { | |
201 | LOW=$1 | |
202 | HIGH=$2 | |
203 | ||
204 | # Get an identifier within the range. The user can override the | |
205 | # initial mid patch if it is known to have problems, e.g., if a | |
206 | # build fails for that patch. | |
207 | ||
208 | if [ ${FIRST_MID} -ne 0 ]; then | |
209 | MID=${FIRST_MID} | |
210 | FIRST_MID=0 | |
211 | let DIFF=HIGH-LOW | |
212 | else | |
213 | get_mid $LOW $HIGH | |
214 | fi | |
215 | ||
216 | while [ ${DIFF} -gt 1 ]; do | |
217 | TEST_ID="${MID}" | |
218 | ||
219 | # Test it. | |
220 | ||
221 | process_patch ${TEST_ID} | |
222 | ||
223 | # FIRST_MID being set is a signal that the build failed and we | |
224 | # should start over again. | |
225 | ||
226 | test ${FIRST_MID} -ne 0 && return | |
227 | ||
228 | # Narrow the search based on the outcome of testing TEST_ID. | |
229 | ||
230 | if [ ${LATER} -eq 1 ]; then | |
231 | msg 1 "search patches later than ${TEST_ID}" | |
232 | LATER_THAN=${TEST_ID} | |
233 | let LOW=MID | |
234 | else | |
235 | msg 1 "search patches earlier than ${TEST_ID}" | |
236 | EARLIER_THAN=${TEST_ID} | |
237 | let HIGH=MID | |
238 | fi | |
239 | ||
240 | get_mid $LOW $HIGH | |
241 | done | |
242 | } | |
243 | ||
244 | ######################################################################## | |
245 | # Main program (so to speak) | |
246 | ######################################################################## | |
247 | ||
248 | # The error function uses this. | |
249 | ||
250 | VALID_RANGE=0 | |
251 | ||
252 | # Process the configuration file. | |
253 | ||
254 | if [ $# != 1 ]; then | |
255 | echo Usage: $0 config_file | |
256 | exit 1 | |
257 | fi | |
258 | ||
259 | CONFIG=${1} | |
260 | if [ ! -f ${CONFIG} ]; then | |
261 | error "configuration file ${CONFIG} does not exist" | |
262 | fi | |
263 | ||
264 | # OK, the config file exists. Source it, make sure required parameters | |
265 | # are defined and their files exist, and give default values to optional | |
266 | # parameters. | |
267 | ||
268 | . ${CONFIG} | |
269 | ||
270 | test "x${REG_UPDATE}" = "x" && error "REG_UPDATE is not defined" | |
271 | test "x${REG_BUILD}" = "x" && error "REG_BUILD is not defined" | |
272 | test "x${REG_TEST}" = "x" && error "REG_TEST is not defined" | |
273 | test -x ${REG_TEST} || error "REG_TEST is not an executable file" | |
274 | test "x${SKIP_LOW}" = "x" && SKIP_LOW=0 | |
275 | test "x${SKIP_HIGH}" = "x" && SKIP_HIGH=0 | |
276 | test "x${VERBOSITY}" = "x" && VERBOSITY=0 | |
277 | test "x${REG_FINISH}" = "x" && REG_FINISH=true | |
278 | test "x${REG_REPORT}" = "x" && REG_REPORT=true | |
279 | ||
280 | msg 2 "LOW_PATCH = ${LOW_PATCH}" | |
281 | msg 2 "HIGH_PATCH = ${HIGH_PATCH}" | |
282 | msg 2 "REG_UPDATE = ${REG_UPDATE}" | |
283 | msg 2 "REG_BUILD = ${REG_BUILD}" | |
284 | msg 2 "REG_TEST = ${REG_TEST}" | |
285 | msg 2 "REG_NEWMID = ${REG_NEWMID}" | |
286 | msg 2 "SKIP_LOW = ${SKIP_LOW}" | |
287 | msg 2 "SKIP_HIGH = ${SKIP_HIGH}" | |
288 | msg 2 "FIRST_MID = ${FIRST_MID}" | |
289 | msg 2 "VERBOSITY = ${VERBOSITY}" | |
290 | ||
291 | # If REG_NEWMID was defined, assume that we're skipping known failures | |
292 | # and adding to the list for new failures. If the list of failures | |
293 | # doesn't exist, create it. We use a different flag, SKIP_FAILURES, | |
294 | # to make it easier to separate the flag from REG_NEWMID if we want | |
295 | # to change the usage later. | |
296 | ||
297 | if [ "x${REG_NEWMID}" != "x" ]; then | |
298 | touch ${REG_FAILLIST} | |
299 | SKIP_FAILURES=1 | |
300 | else | |
301 | SKIP_FAILURES=0 | |
302 | fi | |
303 | ||
304 | # If FIRST_MID was defined, make sure it's in the range. | |
305 | ||
306 | if [ "x${FIRST_MID}" != "x" ]; then | |
307 | test ${FIRST_MID} -le ${LOW_PATCH} && \ | |
308 | error "FIRST_MID id is lower than LOW_PATCH" | |
309 | test ${FIRST_MID} -ge ${HIGH_PATCH} && \ | |
310 | error "FIRST_MID is higher than HIGH_PATCH" | |
311 | else | |
312 | FIRST_MID=0 | |
313 | fi | |
314 | ||
315 | # Keep track of the bounds of the range where the test behavior changes. | |
316 | ||
317 | LATER_THAN=${LOW_PATCH} | |
318 | EARLIER_THAN=${HIGH_PATCH} | |
319 | LATER=1 | |
320 | ||
321 | msg 1 "LATER_THAN = ${LATER_THAN}" | |
322 | msg 1 "EARLIER_THAN = ${EARLIER_THAN}" | |
323 | ||
324 | # Verify that the range isn't backwards. | |
325 | ||
326 | test ${LOW_PATCH} -lt ${HIGH_PATCH} || \ | |
327 | error "patch identifier range is backwards" | |
328 | ||
329 | # Verify that the first and last patches in the range get the results we | |
330 | # expect. If not, quit, because any of several things could be wrong. | |
331 | ||
332 | if [ ${SKIP_HIGH} -eq 0 ]; then | |
333 | process_patch ${EARLIER_THAN} | |
334 | test ${LATER} -ne 0 && \ | |
335 | error "unexpected result for high patch ${EARLIER_THAN}" | |
336 | msg 1 "result for high patch ${EARLIER_THAN} is as expected" | |
337 | fi | |
338 | ||
339 | if [ ${SKIP_LOW} -eq 0 ]; then | |
340 | process_patch ${LATER_THAN} | |
341 | test ${LATER} -ne 1 && \ | |
342 | error "unexpected result for low patch ${LATER_THAN}" | |
343 | msg 1 "result for low patch ${LATER_THAN} is as expected" | |
344 | fi | |
345 | ||
346 | # Search within the range, now that we know that the end points are valid. | |
347 | # If the build failed then FIRST_MID is set to a new patch to try. | |
348 | ||
349 | VALID_RANGE=1 | |
350 | while true; do | |
351 | search_patches ${LATER_THAN} ${EARLIER_THAN} | |
352 | test ${FIRST_MID} -eq 0 && break | |
353 | done | |
354 | ||
355 | # Report where the test behavior changes. | |
356 | ||
357 | echo "Test result changes with id ${EARLIER_THAN}" | |
358 | ${REG_REPORT} ${EARLIER_THAN} | |
359 | ||
360 | # Invoke the optional script to verify the result and report additional | |
361 | # information about changes between the two patches. | |
362 | ||
363 | ${REG_FINISH} ${LATER_THAN} ${EARLIER_THAN} |