Print this page
4265 remove INTERNAL_RELEASE_BUILD
Split |
Close |
Expand all |
Collapse all |
--- old/usr/src/tools/scripts/nightly.sh
+++ new/usr/src/tools/scripts/nightly.sh
1 1 #!/bin/ksh -p
2 2 #
3 3 # CDDL HEADER START
4 4 #
5 5 # The contents of this file are subject to the terms of the
6 6 # Common Development and Distribution License (the "License").
7 7 # You may not use this file except in compliance with the License.
8 8 #
9 9 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 10 # or http://www.opensolaris.org/os/licensing.
11 11 # See the License for the specific language governing permissions
12 12 # and limitations under the License.
13 13 #
14 14 # When distributing Covered Code, include this CDDL HEADER in each
15 15 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 16 # If applicable, add the following below this CDDL HEADER, with the
17 17 # fields enclosed by brackets "[]" replaced with your own identifying
18 18 # information: Portions Copyright [yyyy] [name of copyright owner]
19 19 #
20 20 # CDDL HEADER END
21 21 #
22 22
23 23 #
24 24 # Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
25 25 # Copyright 2008, 2010, Richard Lowe
26 26 # Copyright 2011 Nexenta Systems, Inc. All rights reserved.
27 27 # Copyright 2012 Joshua M. Clulow <josh@sysmgr.org>
28 28 #
29 29 # Based on the nightly script from the integration folks,
30 30 # Mostly modified and owned by mike_s.
31 31 # Changes also by kjc, dmk.
32 32 #
33 33 # BRINGOVER_WS may be specified in the env file.
34 34 # The default is the old behavior of CLONE_WS
35 35 #
36 36 # -i on the command line, means fast options, so when it's on the
37 37 # command line (only), lint and check builds are skipped no matter what
38 38 # the setting of their individual flags are in NIGHTLY_OPTIONS.
39 39 #
40 40 # LINTDIRS can be set in the env file, format is a list of:
41 41 #
42 42 # /dirname-to-run-lint-on flag
43 43 #
44 44 # Where flag is: y - enable lint noise diff output
45 45 # n - disable lint noise diff output
46 46 #
47 47 # For example: LINTDIRS="$SRC/uts n $SRC/stand y $SRC/psm y"
48 48 #
49 49 # OPTHOME and TEAMWARE may be set in the environment to override /opt
50 50 # and /opt/teamware defaults.
51 51 #
52 52
53 53 #
54 54 # The CDPATH variable causes ksh's `cd' builtin to emit messages to stdout
55 55 # under certain circumstances, which can really screw things up; unset it.
56 56 #
57 57 unset CDPATH
58 58
59 59 # Get the absolute path of the nightly script that the user invoked. This
60 60 # may be a relative path, and we need to do this before changing directory.
61 61 nightly_path=`whence $0`
62 62
63 63 #
64 64 # Keep track of where we found nightly so we can invoke the matching
65 65 # which_scm script. If that doesn't work, don't go guessing, just rely
66 66 # on the $PATH settings, which will generally give us either /opt/onbld
67 67 # or the user's workspace.
68 68 #
69 69 WHICH_SCM=$(dirname $nightly_path)/which_scm
70 70 if [[ ! -x $WHICH_SCM ]]; then
71 71 WHICH_SCM=which_scm
72 72 fi
73 73
74 74 function fatal_error
75 75 {
76 76 print -u2 "nightly: $*"
77 77 exit 1
78 78 }
79 79
80 80 #
81 81 # Function to do a DEBUG and non-DEBUG build. Needed because we might
82 82 # need to do another for the source build, and since we only deliver DEBUG or
83 83 # non-DEBUG packages.
84 84 #
85 85 # usage: normal_build
86 86 #
87 87 function normal_build {
88 88
89 89 typeset orig_p_FLAG="$p_FLAG"
90 90 typeset crypto_signer="$CODESIGN_USER"
91 91
92 92 suffix=""
93 93
94 94 # non-DEBUG build begins
95 95
96 96 if [ "$F_FLAG" = "n" ]; then
97 97 set_non_debug_build_flags
98 98 CODESIGN_USER="$crypto_signer" \
99 99 build "non-DEBUG" "$suffix-nd" "-nd" "$MULTI_PROTO"
100 100 if [ "$build_ok" = "y" -a "$X_FLAG" = "y" -a \
101 101 "$p_FLAG" = "y" ]; then
102 102 copy_ihv_pkgs non-DEBUG -nd
103 103 fi
104 104 else
105 105 echo "\n==== No non-DEBUG $open_only build ====\n" >> "$LOGFILE"
106 106 fi
107 107
108 108 # non-DEBUG build ends
109 109
110 110 # DEBUG build begins
111 111
112 112 if [ "$D_FLAG" = "y" ]; then
113 113 set_debug_build_flags
114 114 CODESIGN_USER="$crypto_signer" \
115 115 build "DEBUG" "$suffix" "" "$MULTI_PROTO"
116 116 if [ "$build_ok" = "y" -a "$X_FLAG" = "y" -a \
117 117 "$p_FLAG" = "y" ]; then
118 118 copy_ihv_pkgs DEBUG ""
119 119 fi
120 120 else
121 121 echo "\n==== No DEBUG $open_only build ====\n" >> "$LOGFILE"
122 122 fi
123 123
124 124 # DEBUG build ends
125 125
126 126 p_FLAG="$orig_p_FLAG"
127 127 }
128 128
129 129 #
130 130 # usage: run_hook HOOKNAME ARGS...
131 131 #
132 132 # If variable "$HOOKNAME" is defined, insert a section header into
133 133 # our logs and then run the command with ARGS
134 134 #
135 135 function run_hook {
136 136 HOOKNAME=$1
137 137 eval HOOKCMD=\$$HOOKNAME
138 138 shift
139 139
140 140 if [ -n "$HOOKCMD" ]; then
141 141 (
142 142 echo "\n==== Running $HOOKNAME command: $HOOKCMD ====\n"
143 143 ( $HOOKCMD "$@" 2>&1 )
144 144 if [ "$?" -ne 0 ]; then
145 145 # Let exit status propagate up
146 146 touch $TMPDIR/abort
147 147 fi
148 148 ) | tee -a $mail_msg_file >> $LOGFILE
149 149
150 150 if [ -f $TMPDIR/abort ]; then
151 151 build_ok=n
152 152 echo "\nAborting at request of $HOOKNAME" |
153 153 tee -a $mail_msg_file >> $LOGFILE
154 154 exit 1
155 155 fi
156 156 fi
157 157 }
158 158
159 159 #
160 160 # usage: filelist DESTDIR PATTERN
161 161 #
162 162 function filelist {
163 163 DEST=$1
164 164 PATTERN=$2
165 165 cd ${DEST}
166 166 }
167 167
168 168 # function to save off binaries after a full build for later
169 169 # restoration
170 170 function save_binaries {
171 171 # save off list of binaries
172 172 echo "\n==== Saving binaries from build at `date` ====\n" | \
173 173 tee -a $mail_msg_file >> $LOGFILE
174 174 rm -f ${BINARCHIVE}
175 175 cd ${CODEMGR_WS}
176 176 filelist ${CODEMGR_WS} '^preserve:' >> $LOGFILE
177 177 filelist ${CODEMGR_WS} '^preserve:' | \
178 178 cpio -ocB 2>/dev/null | compress \
179 179 > ${BINARCHIVE}
180 180 }
181 181
182 182 # delete files
183 183 # usage: hybridize_files DESTDIR MAKE_TARGET
184 184 function hybridize_files {
185 185 DEST=$1
186 186 MAKETARG=$2
187 187
188 188 echo "\n==== Hybridizing files at `date` ====\n" | \
189 189 tee -a $mail_msg_file >> $LOGFILE
190 190 for i in `filelist ${DEST} '^delete:'`
191 191 do
192 192 echo "removing ${i}." | tee -a $mail_msg_file >> $LOGFILE
193 193 rm -rf "${i}"
194 194 done
195 195 for i in `filelist ${DEST} '^hybridize:' `
196 196 do
197 197 echo "hybridizing ${i}." | tee -a $mail_msg_file >> $LOGFILE
198 198 rm -f ${i}+
199 199 sed -e "/^# HYBRID DELETE START/,/^# HYBRID DELETE END/d" \
200 200 < ${i} > ${i}+
201 201 mv ${i}+ ${i}
202 202 done
203 203 }
204 204
205 205 # restore binaries into the proper source tree.
206 206 # usage: restore_binaries DESTDIR MAKE_TARGET
207 207 function restore_binaries {
208 208 DEST=$1
209 209 MAKETARG=$2
210 210
211 211 echo "\n==== Restoring binaries to ${MAKETARG} at `date` ====\n" | \
212 212 tee -a $mail_msg_file >> $LOGFILE
213 213 cd ${DEST}
214 214 zcat ${BINARCHIVE} | \
215 215 cpio -idmucvB 2>/dev/null | tee -a $mail_msg_file >> ${LOGFILE}
216 216 }
217 217
218 218 # rename files we save binaries of
219 219 # usage: rename_files DESTDIR MAKE_TARGET
220 220 function rename_files {
221 221 DEST=$1
222 222 MAKETARG=$2
223 223 echo "\n==== Renaming source files in ${MAKETARG} at `date` ====\n" | \
224 224 tee -a $mail_msg_file >> $LOGFILE
225 225 for i in `filelist ${DEST} '^rename:'`
226 226 do
227 227 echo ${i} | tee -a $mail_msg_file >> ${LOGFILE}
228 228 rm -f ${i}.export
229 229 mv ${i} ${i}.export
230 230 done
231 231 }
232 232
233 233 # Return library search directive as function of given root.
234 234 function myldlibs {
235 235 echo "-L$1/lib -L$1/usr/lib"
236 236 }
237 237
238 238 # Return header search directive as function of given root.
239 239 function myheaders {
240 240 echo "-I$1/usr/include"
241 241 }
242 242
243 243 #
244 244 # Function to do the build, including package generation.
245 245 # usage: build LABEL SUFFIX ND MULTIPROTO
246 246 # - LABEL is used to tag build output.
247 247 # - SUFFIX is used to distinguish files (e.g., DEBUG vs non-DEBUG,
248 248 # open-only vs full tree).
249 249 # - ND is "-nd" (non-DEBUG builds) or "" (DEBUG builds).
250 250 # - If MULTIPROTO is "yes", it means to name the proto area according to
251 251 # SUFFIX. Otherwise ("no"), (re)use the standard proto area.
252 252 #
253 253 function build {
254 254 LABEL=$1
255 255 SUFFIX=$2
256 256 ND=$3
257 257 MULTIPROTO=$4
258 258 INSTALLOG=install${SUFFIX}-${MACH}
259 259 NOISE=noise${SUFFIX}-${MACH}
260 260 PKGARCHIVE=${PKGARCHIVE_ORIG}${SUFFIX}
261 261
262 262 ORIGROOT=$ROOT
263 263 [ $MULTIPROTO = no ] || export ROOT=$ROOT$SUFFIX
264 264
265 265 export ENVLDLIBS1=`myldlibs $ROOT`
266 266 export ENVCPPFLAGS1=`myheaders $ROOT`
267 267
268 268 this_build_ok=y
269 269 #
270 270 # Build OS-Networking source
271 271 #
272 272 echo "\n==== Building OS-Net source at `date` ($LABEL) ====\n" \
273 273 >> $LOGFILE
274 274
275 275 rm -f $SRC/${INSTALLOG}.out
276 276 cd $SRC
277 277 /bin/time $MAKE -e install 2>&1 | \
278 278 tee -a $SRC/${INSTALLOG}.out >> $LOGFILE
279 279
280 280 if [[ "$SCM_TYPE" = teamware ]]; then
281 281 echo "\n==== SCCS Noise ($LABEL) ====\n" >> $mail_msg_file
282 282 egrep 'sccs(check:| *get)' $SRC/${INSTALLOG}.out >> \
283 283 $mail_msg_file
284 284 fi
285 285
286 286 echo "\n==== Build errors ($LABEL) ====\n" >> $mail_msg_file
287 287 egrep ":" $SRC/${INSTALLOG}.out |
288 288 egrep -e "(^${MAKE}:|[ ]error[: \n])" | \
289 289 egrep -v "Ignoring unknown host" | \
290 290 egrep -v "cc .* -o error " | \
291 291 egrep -v "warning" >> $mail_msg_file
292 292 if [ "$?" = "0" ]; then
293 293 build_ok=n
294 294 this_build_ok=n
295 295 fi
296 296 grep "bootblock image is .* bytes too big" $SRC/${INSTALLOG}.out \
297 297 >> $mail_msg_file
298 298 if [ "$?" = "0" ]; then
299 299 build_ok=n
300 300 this_build_ok=n
301 301 fi
302 302
303 303 if [ "$W_FLAG" = "n" ]; then
304 304 echo "\n==== Build warnings ($LABEL) ====\n" >>$mail_msg_file
305 305 egrep -i warning: $SRC/${INSTALLOG}.out \
306 306 | egrep -v '^tic:' \
307 307 | egrep -v "symbol (\`|')timezone' has differing types:" \
308 308 | egrep -v "parameter <PSTAMP> set to" \
309 309 | egrep -v "Ignoring unknown host" \
310 310 | egrep -v "redefining segment flags attribute for" \
311 311 >> $mail_msg_file
312 312 fi
313 313
314 314 echo "\n==== Ended OS-Net source build at `date` ($LABEL) ====\n" \
315 315 >> $LOGFILE
316 316
317 317 echo "\n==== Elapsed build time ($LABEL) ====\n" >>$mail_msg_file
318 318 tail -3 $SRC/${INSTALLOG}.out >>$mail_msg_file
319 319
320 320 if [ "$i_FLAG" = "n" -a "$W_FLAG" = "n" ]; then
321 321 rm -f $SRC/${NOISE}.ref
322 322 if [ -f $SRC/${NOISE}.out ]; then
323 323 mv $SRC/${NOISE}.out $SRC/${NOISE}.ref
324 324 fi
325 325 grep : $SRC/${INSTALLOG}.out \
326 326 | egrep -v '^/' \
327 327 | egrep -v '^(Start|Finish|real|user|sys|./bld_awk)' \
328 328 | egrep -v '^tic:' \
329 329 | egrep -v '^mcs' \
330 330 | egrep -v '^LD_LIBRARY_PATH=' \
331 331 | egrep -v 'ar: creating' \
332 332 | egrep -v 'ar: writing' \
333 333 | egrep -v 'conflicts:' \
334 334 | egrep -v ':saved created' \
335 335 | egrep -v '^stty.*c:' \
336 336 | egrep -v '^mfgname.c:' \
337 337 | egrep -v '^uname-i.c:' \
338 338 | egrep -v '^volumes.c:' \
339 339 | egrep -v '^lint library construction:' \
340 340 | egrep -v 'tsort: INFORM:' \
341 341 | egrep -v 'stripalign:' \
342 342 | egrep -v 'chars, width' \
343 343 | egrep -v "symbol (\`|')timezone' has differing types:" \
344 344 | egrep -v 'PSTAMP' \
345 345 | egrep -v '|%WHOANDWHERE%|' \
346 346 | egrep -v '^Manifying' \
347 347 | egrep -v 'Ignoring unknown host' \
348 348 | egrep -v 'Processing method:' \
349 349 | egrep -v '^Writing' \
350 350 | egrep -v 'spellin1:' \
351 351 | egrep -v '^adding:' \
352 352 | egrep -v "^echo 'msgid" \
353 353 | egrep -v '^echo ' \
354 354 | egrep -v '\.c:$' \
355 355 | egrep -v '^Adding file:' \
356 356 | egrep -v 'CLASSPATH=' \
357 357 | egrep -v '\/var\/mail\/:saved' \
358 358 | egrep -v -- '-DUTS_VERSION=' \
359 359 | egrep -v '^Running Mkbootstrap' \
360 360 | egrep -v '^Applet length read:' \
361 361 | egrep -v 'bytes written:' \
362 362 | egrep -v '^File:SolarisAuthApplet.bin' \
363 363 | egrep -v -i 'jibversion' \
364 364 | egrep -v '^Output size:' \
365 365 | egrep -v '^Solo size statistics:' \
366 366 | egrep -v '^Using ROM API Version' \
367 367 | egrep -v '^Zero Signature length:' \
368 368 | egrep -v '^Note \(probably harmless\):' \
369 369 | egrep -v '::' \
370 370 | egrep -v -- '-xcache' \
371 371 | egrep -v '^\+' \
372 372 | egrep -v '^cc1: note: -fwritable-strings' \
373 373 | egrep -v 'svccfg-native -s svc:/' \
374 374 | sort | uniq >$SRC/${NOISE}.out
375 375 if [ ! -f $SRC/${NOISE}.ref ]; then
376 376 cp $SRC/${NOISE}.out $SRC/${NOISE}.ref
377 377 fi
378 378 echo "\n==== Build noise differences ($LABEL) ====\n" \
379 379 >>$mail_msg_file
380 380 diff $SRC/${NOISE}.ref $SRC/${NOISE}.out >>$mail_msg_file
381 381 fi
382 382
383 383 #
384 384 # Re-sign selected binaries using signing server
385 385 # (gatekeeper builds only)
386 386 #
387 387 if [ -n "$CODESIGN_USER" -a "$this_build_ok" = "y" ]; then
388 388 echo "\n==== Signing proto area at `date` ====\n" >> $LOGFILE
389 389 signing_file="${TMPDIR}/signing"
390 390 rm -f ${signing_file}
391 391 export CODESIGN_USER
392 392 signproto $SRC/tools/codesign/creds 2>&1 | \
393 393 tee -a ${signing_file} >> $LOGFILE
394 394 echo "\n==== Finished signing proto area at `date` ====\n" \
395 395 >> $LOGFILE
396 396 echo "\n==== Crypto module signing errors ($LABEL) ====\n" \
397 397 >> $mail_msg_file
398 398 egrep 'WARNING|ERROR' ${signing_file} >> $mail_msg_file
399 399 if (( $? == 0 )) ; then
400 400 build_ok=n
401 401 this_build_ok=n
402 402 fi
403 403 fi
404 404
405 405 #
406 406 # Building Packages
407 407 #
408 408 if [ "$p_FLAG" = "y" -a "$this_build_ok" = "y" ]; then
409 409 if [ -d $SRC/pkg -o -d $SRC/pkgdefs ]; then
410 410 echo "\n==== Creating $LABEL packages at `date` ====\n" \
411 411 >> $LOGFILE
412 412 echo "Clearing out $PKGARCHIVE ..." >> $LOGFILE
413 413 rm -rf $PKGARCHIVE >> "$LOGFILE" 2>&1
414 414 mkdir -p $PKGARCHIVE >> "$LOGFILE" 2>&1
415 415
416 416 for d in pkg pkgdefs; do
417 417 if [ ! -f "$SRC/$d/Makefile" ]; then
418 418 continue
419 419 fi
420 420 rm -f $SRC/$d/${INSTALLOG}.out
421 421 cd $SRC/$d
422 422 /bin/time $MAKE -e install 2>&1 | \
423 423 tee -a $SRC/$d/${INSTALLOG}.out >> $LOGFILE
424 424 done
425 425
426 426 echo "\n==== package build errors ($LABEL) ====\n" \
427 427 >> $mail_msg_file
428 428
429 429 for d in pkg pkgdefs; do
430 430 if [ ! -f "$SRC/$d/Makefile" ]; then
431 431 continue
432 432 fi
433 433
434 434 egrep "${MAKE}|ERROR|WARNING" $SRC/$d/${INSTALLOG}.out | \
435 435 grep ':' | \
436 436 grep -v PSTAMP | \
437 437 egrep -v "Ignoring unknown host" \
438 438 >> $mail_msg_file
439 439 done
440 440 else
441 441 #
442 442 # Handle it gracefully if -p was set but there are
443 443 # neither pkg nor pkgdefs directories.
444 444 #
445 445 echo "\n==== No $LABEL packages to build ====\n" \
446 446 >> $LOGFILE
447 447 fi
448 448 else
449 449 echo "\n==== Not creating $LABEL packages ====\n" >> $LOGFILE
450 450 fi
451 451
452 452 ROOT=$ORIGROOT
453 453 }
454 454
455 455 # Usage: dolint /dir y|n
456 456 # Arg. 2 is a flag to turn on/off the lint diff output
457 457 function dolint {
458 458 if [ ! -d "$1" ]; then
459 459 echo "dolint error: $1 is not a directory"
460 460 exit 1
461 461 fi
462 462
463 463 if [ "$2" != "y" -a "$2" != "n" ]; then
464 464 echo "dolint internal error: $2 should be 'y' or 'n'"
465 465 exit 1
466 466 fi
467 467
468 468 lintdir=$1
469 469 dodiff=$2
470 470 base=`basename $lintdir`
471 471 LINTOUT=$lintdir/lint-${MACH}.out
472 472 LINTNOISE=$lintdir/lint-noise-${MACH}
473 473 export ENVLDLIBS1=`myldlibs $ROOT`
474 474 export ENVCPPFLAGS1=`myheaders $ROOT`
475 475
476 476 set_debug_build_flags
477 477
478 478 #
479 479 # '$MAKE lint' in $lintdir
480 480 #
481 481 echo "\n==== Begin '$MAKE lint' of $base at `date` ====\n" >> $LOGFILE
482 482
483 483 # remove old lint.out
484 484 rm -f $lintdir/lint.out $lintdir/lint-noise.out
485 485 if [ -f $lintdir/lint-noise.ref ]; then
486 486 mv $lintdir/lint-noise.ref ${LINTNOISE}.ref
487 487 fi
488 488
489 489 rm -f $LINTOUT
490 490 cd $lintdir
491 491 #
492 492 # Remove all .ln files to ensure a full reference file
493 493 #
494 494 rm -f Nothing_to_remove \
495 495 `find . \( -name SCCS -o -name .hg -o -name .svn -o -name .git \) \
496 496 -prune -o -type f -name '*.ln' -print `
497 497
498 498 /bin/time $MAKE -ek lint 2>&1 | \
499 499 tee -a $LINTOUT >> $LOGFILE
500 500 echo "\n==== '$MAKE lint' of $base ERRORS ====\n" >> $mail_msg_file
501 501 grep "$MAKE:" $LINTOUT |
502 502 egrep -v "Ignoring unknown host" \
503 503 >> $mail_msg_file
504 504
505 505 echo "\n==== Ended '$MAKE lint' of $base at `date` ====\n" >> $LOGFILE
506 506
507 507 echo "\n==== Elapsed time of '$MAKE lint' of $base ====\n" \
508 508 >>$mail_msg_file
509 509 tail -3 $LINTOUT >>$mail_msg_file
510 510
511 511 rm -f ${LINTNOISE}.ref
512 512 if [ -f ${LINTNOISE}.out ]; then
513 513 mv ${LINTNOISE}.out ${LINTNOISE}.ref
514 514 fi
515 515 grep : $LINTOUT | \
516 516 egrep -v '^(real|user|sys)' |
517 517 egrep -v '(library construction)' | \
518 518 egrep -v ': global crosschecks' | \
519 519 egrep -v 'Ignoring unknown host' | \
520 520 egrep -v '\.c:$' | \
521 521 sort | uniq > ${LINTNOISE}.out
522 522 if [ ! -f ${LINTNOISE}.ref ]; then
523 523 cp ${LINTNOISE}.out ${LINTNOISE}.ref
524 524 fi
525 525 if [ "$dodiff" != "n" ]; then
526 526 echo "\n==== lint warnings $base ====\n" \
527 527 >>$mail_msg_file
528 528 # should be none, though there are a few that were filtered out
529 529 # above
530 530 egrep -i '(warning|lint):' ${LINTNOISE}.out \
531 531 | sort | uniq >> $mail_msg_file
532 532 echo "\n==== lint noise differences $base ====\n" \
533 533 >> $mail_msg_file
534 534 diff ${LINTNOISE}.ref ${LINTNOISE}.out \
535 535 >> $mail_msg_file
536 536 fi
537 537 }
538 538
539 539 # Install proto area from IHV build
540 540
541 541 function copy_ihv_proto {
542 542
543 543 echo "\n==== Installing IHV proto area ====\n" \
544 544 >> $LOGFILE
545 545 if [ -d "$IA32_IHV_ROOT" ]; then
546 546 if [ ! -d "$ROOT" ]; then
547 547 echo "mkdir -p $ROOT" >> $LOGFILE
548 548 mkdir -p $ROOT
549 549 fi
550 550 echo "copying $IA32_IHV_ROOT to $ROOT\n" >> $LOGFILE
551 551 cd $IA32_IHV_ROOT
552 552 tar cf - . | (cd $ROOT; umask 0; tar xpf - ) 2>&1 >> $LOGFILE
553 553 else
554 554 echo "$IA32_IHV_ROOT: not found" >> $LOGFILE
555 555 fi
556 556
557 557 if [ "$MULTI_PROTO" = yes ]; then
558 558 if [ ! -d "$ROOT-nd" ]; then
559 559 echo "mkdir -p $ROOT-nd" >> $LOGFILE
560 560 mkdir -p $ROOT-nd
561 561 fi
562 562 # If there's a non-DEBUG version of the IHV proto area,
563 563 # copy it, but copy something if there's not.
564 564 if [ -d "$IA32_IHV_ROOT-nd" ]; then
565 565 echo "copying $IA32_IHV_ROOT-nd to $ROOT-nd\n" >> $LOGFILE
566 566 cd $IA32_IHV_ROOT-nd
567 567 elif [ -d "$IA32_IHV_ROOT" ]; then
568 568 echo "copying $IA32_IHV_ROOT to $ROOT-nd\n" >> $LOGFILE
569 569 cd $IA32_IHV_ROOT
570 570 else
571 571 echo "$IA32_IHV_ROOT{-nd,}: not found" >> $LOGFILE
572 572 return
573 573 fi
574 574 tar cf - . | (cd $ROOT-nd; umask 0; tar xpf - ) 2>&1 >> $LOGFILE
575 575 fi
576 576 }
577 577
578 578 # Install IHV packages in PKGARCHIVE
579 579 # usage: copy_ihv_pkgs LABEL SUFFIX
580 580 function copy_ihv_pkgs {
581 581 LABEL=$1
582 582 SUFFIX=$2
583 583 # always use non-DEBUG IHV packages
584 584 IA32_IHV_PKGS=${IA32_IHV_PKGS_ORIG}-nd
585 585 PKGARCHIVE=${PKGARCHIVE_ORIG}${SUFFIX}
586 586
587 587 echo "\n==== Installing IHV packages from $IA32_IHV_PKGS ($LABEL) ====\n" \
588 588 >> $LOGFILE
589 589 if [ -d "$IA32_IHV_PKGS" ]; then
590 590 cd $IA32_IHV_PKGS
591 591 tar cf - * | \
592 592 (cd $PKGARCHIVE; umask 0; tar xpf - ) 2>&1 >> $LOGFILE
593 593 else
594 594 echo "$IA32_IHV_PKGS: not found" >> $LOGFILE
595 595 fi
596 596
597 597 echo "\n==== Installing IHV packages from $IA32_IHV_BINARY_PKGS ($LABEL) ====\n" \
598 598 >> $LOGFILE
599 599 if [ -d "$IA32_IHV_BINARY_PKGS" ]; then
600 600 cd $IA32_IHV_BINARY_PKGS
601 601 tar cf - * | \
602 602 (cd $PKGARCHIVE; umask 0; tar xpf - ) 2>&1 >> $LOGFILE
603 603 else
604 604 echo "$IA32_IHV_BINARY_PKGS: not found" >> $LOGFILE
605 605 fi
606 606 }
607 607
608 608 #
609 609 # Build and install the onbld tools.
610 610 #
611 611 # usage: build_tools DESTROOT
612 612 #
613 613 # returns non-zero status if the build was successful.
614 614 #
615 615 function build_tools {
616 616 DESTROOT=$1
617 617
618 618 INSTALLOG=install-${MACH}
619 619
620 620 echo "\n==== Building tools at `date` ====\n" \
621 621 >> $LOGFILE
622 622
623 623 rm -f ${TOOLS}/${INSTALLOG}.out
624 624 cd ${TOOLS}
625 625 /bin/time $MAKE TOOLS_PROTO=${DESTROOT} -e install 2>&1 | \
626 626 tee -a ${TOOLS}/${INSTALLOG}.out >> $LOGFILE
627 627
628 628 echo "\n==== Tools build errors ====\n" >> $mail_msg_file
629 629
630 630 egrep ":" ${TOOLS}/${INSTALLOG}.out |
631 631 egrep -e "(${MAKE}:|[ ]error[: \n])" | \
632 632 egrep -v "Ignoring unknown host" | \
633 633 egrep -v warning >> $mail_msg_file
634 634 return $?
635 635 }
636 636
637 637 #
638 638 # Set up to use locally installed tools.
639 639 #
640 640 # usage: use_tools TOOLSROOT
641 641 #
642 642 function use_tools {
643 643 TOOLSROOT=$1
644 644
645 645 #
646 646 # If we're not building ON workspace, then the TOOLSROOT
647 647 # settings here are clearly ignored by the workspace
648 648 # makefiles, prepending nonexistent directories to PATH is
649 649 # harmless, and we clearly do not wish to override
650 650 # ONBLD_TOOLS.
651 651 #
652 652 # If we're building an ON workspace, then the prepended PATH
653 653 # elements should supercede the preexisting ONBLD_TOOLS paths,
654 654 # and we want to override ONBLD_TOOLS to catch the tools that
655 655 # don't have specific path env vars here.
656 656 #
657 657 # So the only conditional behavior is overriding ONBLD_TOOLS,
658 658 # and we check for "an ON workspace" by looking for
659 659 # ${TOOLSROOT}/opt/onbld.
660 660 #
661 661
662 662 STABS=${TOOLSROOT}/opt/onbld/bin/${MACH}/stabs
663 663 export STABS
664 664 CTFSTABS=${TOOLSROOT}/opt/onbld/bin/${MACH}/ctfstabs
665 665 export CTFSTABS
666 666 GENOFFSETS=${TOOLSROOT}/opt/onbld/bin/genoffsets
667 667 export GENOFFSETS
668 668
669 669 CTFCONVERT=${TOOLSROOT}/opt/onbld/bin/${MACH}/ctfconvert
670 670 export CTFCONVERT
671 671 CTFMERGE=${TOOLSROOT}/opt/onbld/bin/${MACH}/ctfmerge
672 672 export CTFMERGE
673 673
674 674 CTFCVTPTBL=${TOOLSROOT}/opt/onbld/bin/ctfcvtptbl
675 675 export CTFCVTPTBL
676 676 CTFFINDMOD=${TOOLSROOT}/opt/onbld/bin/ctffindmod
677 677 export CTFFINDMOD
678 678
679 679 if [ "$VERIFY_ELFSIGN" = "y" ]; then
680 680 ELFSIGN=${TOOLSROOT}/opt/onbld/bin/elfsigncmp
681 681 else
682 682 ELFSIGN=${TOOLSROOT}/opt/onbld/bin/${MACH}/elfsign
683 683 fi
684 684 export ELFSIGN
685 685
686 686 PATH="${TOOLSROOT}/opt/onbld/bin/${MACH}:${PATH}"
687 687 PATH="${TOOLSROOT}/opt/onbld/bin:${PATH}"
688 688 export PATH
689 689
690 690 if [ -d "${TOOLSROOT}/opt/onbld" ]; then
691 691 ONBLD_TOOLS=${TOOLSROOT}/opt/onbld
692 692 export ONBLD_TOOLS
693 693 fi
694 694
695 695 echo "\n==== New environment settings. ====\n" >> $LOGFILE
696 696 echo "STABS=${STABS}" >> $LOGFILE
697 697 echo "CTFSTABS=${CTFSTABS}" >> $LOGFILE
698 698 echo "CTFCONVERT=${CTFCONVERT}" >> $LOGFILE
699 699 echo "CTFMERGE=${CTFMERGE}" >> $LOGFILE
700 700 echo "CTFCVTPTBL=${CTFCVTPTBL}" >> $LOGFILE
701 701 echo "CTFFINDMOD=${CTFFINDMOD}" >> $LOGFILE
702 702 echo "ELFSIGN=${ELFSIGN}" >> $LOGFILE
703 703 echo "PATH=${PATH}" >> $LOGFILE
704 704 echo "ONBLD_TOOLS=${ONBLD_TOOLS}" >> $LOGFILE
705 705 }
706 706
707 707 function staffer {
708 708 if [ $ISUSER -ne 0 ]; then
709 709 "$@"
710 710 else
711 711 arg="\"$1\""
712 712 shift
713 713 for i
714 714 do
715 715 arg="$arg \"$i\""
716 716 done
717 717 eval su $STAFFER -c \'$arg\'
718 718 fi
719 719 }
720 720
721 721 #
722 722 # Verify that the closed tree is present if it needs to be.
723 723 #
724 724 function check_closed_tree {
725 725 if [[ ! -d "$ON_CLOSED_BINS" ]]; then
726 726 echo "ON_CLOSED_BINS must point to the closed binaries tree."
727 727 build_ok=n
728 728 exit 1
729 729 fi
730 730 }
731 731
732 732 function obsolete_build {
733 733 echo "WARNING: Obsolete $1 build requested; request will be ignored"
734 734 }
735 735
736 736 #
737 737 # wrapper over wsdiff.
738 738 # usage: do_wsdiff LABEL OLDPROTO NEWPROTO
739 739 #
740 740 function do_wsdiff {
741 741 label=$1
742 742 oldproto=$2
743 743 newproto=$3
744 744
745 745 wsdiff="wsdiff"
746 746 [ "$t_FLAG" = y ] && wsdiff="wsdiff -t"
747 747
748 748 echo "\n==== Getting object changes since last build at `date`" \
749 749 "($label) ====\n" | tee -a $LOGFILE >> $mail_msg_file
750 750 $wsdiff -s -r ${TMPDIR}/wsdiff.results $oldproto $newproto 2>&1 | \
751 751 tee -a $LOGFILE >> $mail_msg_file
↓ open down ↓ |
751 lines elided |
↑ open up ↑ |
752 752 echo "\n==== Object changes determined at `date` ($label) ====\n" | \
753 753 tee -a $LOGFILE >> $mail_msg_file
754 754 }
755 755
756 756 #
757 757 # Functions for setting build flags (DEBUG/non-DEBUG). Keep them
758 758 # together.
759 759 #
760 760
761 761 function set_non_debug_build_flags {
762 - export INTERNAL_RELEASE_BUILD ; INTERNAL_RELEASE_BUILD=
763 762 export RELEASE_BUILD ; RELEASE_BUILD=
764 763 unset EXTRA_OPTIONS
765 764 unset EXTRA_CFLAGS
766 765 }
767 766
768 767 function set_debug_build_flags {
769 - export INTERNAL_RELEASE_BUILD ; INTERNAL_RELEASE_BUILD=
770 768 unset RELEASE_BUILD
771 769 unset EXTRA_OPTIONS
772 770 unset EXTRA_CFLAGS
773 771 }
774 772
775 773
776 774 MACH=`uname -p`
777 775
778 776 if [ "$OPTHOME" = "" ]; then
779 777 OPTHOME=/opt
780 778 export OPTHOME
781 779 fi
782 780 if [ "$TEAMWARE" = "" ]; then
783 781 TEAMWARE=$OPTHOME/teamware
784 782 export TEAMWARE
785 783 fi
786 784
787 785 USAGE='Usage: nightly [-in] [+t] [-V VERS ] <env_file>
788 786
789 787 Where:
790 788 -i Fast incremental options (no clobber, lint, check)
791 789 -n Do not do a bringover
792 790 +t Use the build tools in $ONBLD_TOOLS/bin
793 791 -V VERS set the build version string to VERS
794 792
795 793 <env_file> file in Bourne shell syntax that sets and exports
796 794 variables that configure the operation of this script and many of
797 795 the scripts this one calls. If <env_file> does not exist,
798 796 it will be looked for in $OPTHOME/onbld/env.
799 797
800 798 non-DEBUG is the default build type. Build options can be set in the
801 799 NIGHTLY_OPTIONS variable in the <env_file> as follows:
802 800
803 801 -A check for ABI differences in .so files
804 802 -C check for cstyle/hdrchk errors
805 803 -D do a build with DEBUG on
806 804 -F do _not_ do a non-DEBUG build
807 805 -G gate keeper default group of options (-au)
808 806 -I integration engineer default group of options (-ampu)
809 807 -M do not run pmodes (safe file permission checker)
810 808 -N do not run protocmp
811 809 -R default group of options for building a release (-mp)
812 810 -U update proto area in the parent
813 811 -V VERS set the build version string to VERS
814 812 -X copy x86 IHV proto area
815 813 -f find unreferenced files
816 814 -i do an incremental build (no "make clobber")
817 815 -l do "make lint" in $LINTDIRS (default: $SRC y)
818 816 -m send mail to $MAILTO at end of build
819 817 -n do not do a bringover
820 818 -o build using root privileges to set OWNER/GROUP (old style)
821 819 -p create packages
822 820 -r check ELF runtime attributes in the proto area
823 821 -t build and use the tools in $SRC/tools (default setting)
824 822 +t Use the build tools in $ONBLD_TOOLS/bin
825 823 -u update proto_list_$MACH and friends in the parent workspace;
826 824 when used with -f, also build an unrefmaster.out in the parent
827 825 -w report on differences between previous and current proto areas
828 826 -z compress cpio archives with gzip
829 827 -W Do not report warnings (freeware gate ONLY)
830 828 '
831 829 #
832 830 # A log file will be generated under the name $LOGFILE
833 831 # for partially completed build and log.`date '+%F'`
834 832 # in the same directory for fully completed builds.
835 833 #
836 834
837 835 # default values for low-level FLAGS; G I R are group FLAGS
838 836 A_FLAG=n
839 837 C_FLAG=n
840 838 D_FLAG=n
841 839 F_FLAG=n
842 840 f_FLAG=n
843 841 i_FLAG=n; i_CMD_LINE_FLAG=n
844 842 l_FLAG=n
845 843 M_FLAG=n
846 844 m_FLAG=n
847 845 N_FLAG=n
848 846 n_FLAG=n
849 847 o_FLAG=n
850 848 P_FLAG=n
851 849 p_FLAG=n
852 850 r_FLAG=n
853 851 T_FLAG=n
854 852 t_FLAG=y
855 853 U_FLAG=n
856 854 u_FLAG=n
857 855 V_FLAG=n
858 856 W_FLAG=n
859 857 w_FLAG=n
860 858 X_FLAG=n
861 859 #
862 860 XMOD_OPT=
863 861 #
864 862 build_ok=y
865 863
866 864 #
867 865 # examine arguments
868 866 #
869 867
870 868 OPTIND=1
871 869 while getopts +intV: FLAG
872 870 do
873 871 case $FLAG in
874 872 i ) i_FLAG=y; i_CMD_LINE_FLAG=y
875 873 ;;
876 874 n ) n_FLAG=y
877 875 ;;
878 876 +t ) t_FLAG=n
879 877 ;;
880 878 V ) V_FLAG=y
881 879 V_ARG="$OPTARG"
882 880 ;;
883 881 \? ) echo "$USAGE"
884 882 exit 1
885 883 ;;
886 884 esac
887 885 done
888 886
889 887 # correct argument count after options
890 888 shift `expr $OPTIND - 1`
891 889
892 890 # test that the path to the environment-setting file was given
893 891 if [ $# -ne 1 ]; then
894 892 echo "$USAGE"
895 893 exit 1
896 894 fi
897 895
898 896 # check if user is running nightly as root
899 897 # ISUSER is set non-zero if an ordinary user runs nightly, or is zero
900 898 # when root invokes nightly.
901 899 /usr/bin/id | grep '^uid=0(' >/dev/null 2>&1
902 900 ISUSER=$?; export ISUSER
903 901
904 902 #
905 903 # force locale to C
906 904 LC_COLLATE=C; export LC_COLLATE
907 905 LC_CTYPE=C; export LC_CTYPE
908 906 LC_MESSAGES=C; export LC_MESSAGES
909 907 LC_MONETARY=C; export LC_MONETARY
910 908 LC_NUMERIC=C; export LC_NUMERIC
911 909 LC_TIME=C; export LC_TIME
912 910
913 911 # clear environment variables we know to be bad for the build
914 912 unset LD_OPTIONS
915 913 unset LD_AUDIT LD_AUDIT_32 LD_AUDIT_64
916 914 unset LD_BIND_NOW LD_BIND_NOW_32 LD_BIND_NOW_64
917 915 unset LD_BREADTH LD_BREADTH_32 LD_BREADTH_64
918 916 unset LD_CONFIG LD_CONFIG_32 LD_CONFIG_64
919 917 unset LD_DEBUG LD_DEBUG_32 LD_DEBUG_64
920 918 unset LD_DEMANGLE LD_DEMANGLE_32 LD_DEMANGLE_64
921 919 unset LD_FLAGS LD_FLAGS_32 LD_FLAGS_64
922 920 unset LD_LIBRARY_PATH LD_LIBRARY_PATH_32 LD_LIBRARY_PATH_64
923 921 unset LD_LOADFLTR LD_LOADFLTR_32 LD_LOADFLTR_64
924 922 unset LD_NOAUDIT LD_NOAUDIT_32 LD_NOAUDIT_64
925 923 unset LD_NOAUXFLTR LD_NOAUXFLTR_32 LD_NOAUXFLTR_64
926 924 unset LD_NOCONFIG LD_NOCONFIG_32 LD_NOCONFIG_64
927 925 unset LD_NODIRCONFIG LD_NODIRCONFIG_32 LD_NODIRCONFIG_64
928 926 unset LD_NODIRECT LD_NODIRECT_32 LD_NODIRECT_64
929 927 unset LD_NOLAZYLOAD LD_NOLAZYLOAD_32 LD_NOLAZYLOAD_64
930 928 unset LD_NOOBJALTER LD_NOOBJALTER_32 LD_NOOBJALTER_64
931 929 unset LD_NOVERSION LD_NOVERSION_32 LD_NOVERSION_64
932 930 unset LD_ORIGIN LD_ORIGIN_32 LD_ORIGIN_64
933 931 unset LD_PRELOAD LD_PRELOAD_32 LD_PRELOAD_64
934 932 unset LD_PROFILE LD_PROFILE_32 LD_PROFILE_64
935 933
936 934 unset CONFIG
937 935 unset GROUP
938 936 unset OWNER
939 937 unset REMOTE
940 938 unset ENV
941 939 unset ARCH
942 940 unset CLASSPATH
943 941 unset NAME
944 942
945 943 #
946 944 # To get ONBLD_TOOLS from the environment, it must come from the env file.
947 945 # If it comes interactively, it is generally TOOLS_PROTO, which will be
948 946 # clobbered before the compiler version checks, which will therefore fail.
949 947 #
950 948 unset ONBLD_TOOLS
951 949
952 950 #
953 951 # Setup environmental variables
954 952 #
955 953 if [ -f /etc/nightly.conf ]; then
956 954 . /etc/nightly.conf
957 955 fi
958 956
959 957 if [ -f $1 ]; then
960 958 if [[ $1 = */* ]]; then
961 959 . $1
962 960 else
963 961 . ./$1
964 962 fi
965 963 else
966 964 if [ -f $OPTHOME/onbld/env/$1 ]; then
967 965 . $OPTHOME/onbld/env/$1
968 966 else
969 967 echo "Cannot find env file as either $1 or $OPTHOME/onbld/env/$1"
970 968 exit 1
971 969 fi
972 970 fi
973 971
974 972 # contents of stdenv.sh inserted after next line:
975 973 # STDENV_START
976 974 # STDENV_END
977 975
978 976 # Check if we have sufficient data to continue...
979 977 [[ -v CODEMGR_WS ]] || fatal_error "Error: Variable CODEMGR_WS not set."
980 978 if [[ "${NIGHTLY_OPTIONS}" == ~(F)n ]] ; then
981 979 # Check if the gate data are valid if we don't do a "bringover" below
982 980 [[ -d "${CODEMGR_WS}" ]] || \
983 981 fatal_error "Error: ${CODEMGR_WS} is not a directory."
984 982 [[ -f "${CODEMGR_WS}/usr/src/Makefile" ]] || \
985 983 fatal_error "Error: ${CODEMGR_WS}/usr/src/Makefile not found."
986 984 fi
987 985
988 986 #
989 987 # place ourselves in a new task, respecting BUILD_PROJECT if set.
990 988 #
991 989 if [ -z "$BUILD_PROJECT" ]; then
992 990 /usr/bin/newtask -c $$
993 991 else
994 992 /usr/bin/newtask -c $$ -p $BUILD_PROJECT
995 993 fi
996 994
997 995 ps -o taskid= -p $$ | read build_taskid
998 996 ps -o project= -p $$ | read build_project
999 997
1000 998 #
1001 999 # See if NIGHTLY_OPTIONS is set
1002 1000 #
1003 1001 if [ "$NIGHTLY_OPTIONS" = "" ]; then
1004 1002 NIGHTLY_OPTIONS="-aBm"
1005 1003 fi
1006 1004
1007 1005 #
1008 1006 # If BRINGOVER_WS was not specified, let it default to CLONE_WS
1009 1007 #
1010 1008 if [ "$BRINGOVER_WS" = "" ]; then
1011 1009 BRINGOVER_WS=$CLONE_WS
1012 1010 fi
1013 1011
1014 1012 #
1015 1013 # If CLOSED_BRINGOVER_WS was not specified, let it default to CLOSED_CLONE_WS
1016 1014 #
1017 1015 if [ "$CLOSED_BRINGOVER_WS" = "" ]; then
1018 1016 CLOSED_BRINGOVER_WS=$CLOSED_CLONE_WS
1019 1017 fi
1020 1018
1021 1019 #
1022 1020 # If BRINGOVER_FILES was not specified, default to usr
1023 1021 #
1024 1022 if [ "$BRINGOVER_FILES" = "" ]; then
1025 1023 BRINGOVER_FILES="usr"
1026 1024 fi
1027 1025
1028 1026 check_closed_tree
1029 1027
1030 1028 #
1031 1029 # Note: changes to the option letters here should also be applied to the
1032 1030 # bldenv script. `d' is listed for backward compatibility.
1033 1031 #
1034 1032 NIGHTLY_OPTIONS=-${NIGHTLY_OPTIONS#-}
1035 1033 OPTIND=1
1036 1034 while getopts +ABCDdFfGIilMmNnoPpRrTtUuWwXxz FLAG $NIGHTLY_OPTIONS
1037 1035 do
1038 1036 case $FLAG in
1039 1037 A ) A_FLAG=y
1040 1038 ;;
1041 1039 B ) D_FLAG=y
1042 1040 ;; # old version of D
1043 1041 C ) C_FLAG=y
1044 1042 ;;
1045 1043 D ) D_FLAG=y
1046 1044 ;;
1047 1045 F ) F_FLAG=y
1048 1046 ;;
1049 1047 f ) f_FLAG=y
1050 1048 ;;
1051 1049 G ) u_FLAG=y
1052 1050 ;;
1053 1051 I ) m_FLAG=y
1054 1052 p_FLAG=y
1055 1053 u_FLAG=y
1056 1054 ;;
1057 1055 i ) i_FLAG=y
1058 1056 ;;
1059 1057 l ) l_FLAG=y
1060 1058 ;;
1061 1059 M ) M_FLAG=y
1062 1060 ;;
1063 1061 m ) m_FLAG=y
1064 1062 ;;
1065 1063 N ) N_FLAG=y
1066 1064 ;;
1067 1065 n ) n_FLAG=y
1068 1066 ;;
1069 1067 o ) o_FLAG=y
1070 1068 ;;
1071 1069 P ) P_FLAG=y
1072 1070 ;; # obsolete
1073 1071 p ) p_FLAG=y
1074 1072 ;;
1075 1073 R ) m_FLAG=y
1076 1074 p_FLAG=y
1077 1075 ;;
1078 1076 r ) r_FLAG=y
1079 1077 ;;
1080 1078 T ) T_FLAG=y
1081 1079 ;; # obsolete
1082 1080 +t ) t_FLAG=n
1083 1081 ;;
1084 1082 U ) if [ -z "${PARENT_ROOT}" ]; then
1085 1083 echo "PARENT_ROOT must be set if the U flag is" \
1086 1084 "present in NIGHTLY_OPTIONS."
1087 1085 exit 1
1088 1086 fi
1089 1087 NIGHTLY_PARENT_ROOT=$PARENT_ROOT
1090 1088 if [ -n "${PARENT_TOOLS_ROOT}" ]; then
1091 1089 NIGHTLY_PARENT_TOOLS_ROOT=$PARENT_TOOLS_ROOT
1092 1090 fi
1093 1091 U_FLAG=y
1094 1092 ;;
1095 1093 u ) u_FLAG=y
1096 1094 ;;
1097 1095 W ) W_FLAG=y
1098 1096 ;;
1099 1097
1100 1098 w ) w_FLAG=y
1101 1099 ;;
1102 1100 X ) # now that we no longer need realmode builds, just
1103 1101 # copy IHV packages. only meaningful on x86.
1104 1102 if [ "$MACH" = "i386" ]; then
1105 1103 X_FLAG=y
1106 1104 fi
1107 1105 ;;
1108 1106 x ) XMOD_OPT="-x"
1109 1107 ;;
1110 1108 \? ) echo "$USAGE"
1111 1109 exit 1
1112 1110 ;;
1113 1111 esac
1114 1112 done
1115 1113
1116 1114 if [ $ISUSER -ne 0 ]; then
1117 1115 if [ "$o_FLAG" = "y" ]; then
1118 1116 echo "Old-style build requires root permission."
1119 1117 exit 1
1120 1118 fi
1121 1119
1122 1120 # Set default value for STAFFER, if needed.
1123 1121 if [ -z "$STAFFER" -o "$STAFFER" = "nobody" ]; then
1124 1122 STAFFER=`/usr/xpg4/bin/id -un`
1125 1123 export STAFFER
1126 1124 fi
1127 1125 fi
1128 1126
1129 1127 if [ -z "$MAILTO" -o "$MAILTO" = "nobody" ]; then
1130 1128 MAILTO=$STAFFER
1131 1129 export MAILTO
1132 1130 fi
1133 1131
1134 1132 PATH="$OPTHOME/onbld/bin:$OPTHOME/onbld/bin/${MACH}:/usr/ccs/bin"
1135 1133 PATH="$PATH:$OPTHOME/SUNWspro/bin:$TEAMWARE/bin:/usr/bin:/usr/sbin:/usr/ucb"
1136 1134 PATH="$PATH:/usr/openwin/bin:/usr/sfw/bin:/opt/sfw/bin:."
1137 1135 export PATH
1138 1136
1139 1137 # roots of source trees, both relative to $SRC and absolute.
1140 1138 relsrcdirs="."
1141 1139 abssrcdirs="$SRC"
1142 1140
1143 1141 unset CH
1144 1142 if [ "$o_FLAG" = "y" ]; then
1145 1143 # root invoked old-style build -- make sure it works as it always has
1146 1144 # by exporting 'CH'. The current Makefile.master doesn't use this, but
1147 1145 # the old ones still do.
1148 1146 PROTOCMPTERSE="protocmp.terse"
1149 1147 CH=
1150 1148 export CH
1151 1149 else
1152 1150 PROTOCMPTERSE="protocmp.terse -gu"
1153 1151 fi
1154 1152 POUND_SIGN="#"
1155 1153 # have we set RELEASE_DATE in our env file?
1156 1154 if [ -z "$RELEASE_DATE" ]; then
1157 1155 RELEASE_DATE=$(LC_ALL=C date +"%B %Y")
1158 1156 fi
1159 1157 BUILD_DATE=$(LC_ALL=C date +%Y-%b-%d)
1160 1158 BASEWSDIR=$(basename $CODEMGR_WS)
1161 1159 DEV_CM="\"@(#)SunOS Internal Development: $LOGNAME $BUILD_DATE [$BASEWSDIR]\""
1162 1160
1163 1161 # we export POUND_SIGN, RELEASE_DATE and DEV_CM to speed up the build process
1164 1162 # by avoiding repeated shell invocations to evaluate Makefile.master definitions.
1165 1163 # we export o_FLAG and X_FLAG for use by makebfu, and by usr/src/pkg/Makefile
1166 1164 export o_FLAG X_FLAG POUND_SIGN RELEASE_DATE DEV_CM
1167 1165
1168 1166 maketype="distributed"
1169 1167 if [[ -z "$MAKE" ]]; then
1170 1168 MAKE=dmake
1171 1169 elif [[ ! -x "$MAKE" ]]; then
1172 1170 echo "\$MAKE is set to garbage in the environment"
1173 1171 exit 1
1174 1172 fi
1175 1173 # get the dmake version string alone
1176 1174 DMAKE_VERSION=$( $MAKE -v )
1177 1175 DMAKE_VERSION=${DMAKE_VERSION#*: }
1178 1176 # focus in on just the dotted version number alone
1179 1177 DMAKE_MAJOR=$( echo $DMAKE_VERSION | \
1180 1178 sed -e 's/.*\<\([^.]*\.[^ ]*\).*$/\1/' )
1181 1179 # extract the second (or final) integer
1182 1180 DMAKE_MINOR=${DMAKE_MAJOR#*.}
1183 1181 DMAKE_MINOR=${DMAKE_MINOR%%.*}
1184 1182 # extract the first integer
1185 1183 DMAKE_MAJOR=${DMAKE_MAJOR%%.*}
1186 1184 CHECK_DMAKE=${CHECK_DMAKE:-y}
1187 1185 # x86 was built on the 12th, sparc on the 13th.
1188 1186 if [ "$CHECK_DMAKE" = "y" -a \
1189 1187 "$DMAKE_VERSION" != "Sun Distributed Make 7.3 2003/03/12" -a \
1190 1188 "$DMAKE_VERSION" != "Sun Distributed Make 7.3 2003/03/13" -a \( \
1191 1189 "$DMAKE_MAJOR" -lt 7 -o \
1192 1190 "$DMAKE_MAJOR" -eq 7 -a "$DMAKE_MINOR" -lt 4 \) ]; then
1193 1191 if [ -z "$DMAKE_VERSION" ]; then
1194 1192 echo "$MAKE is missing."
1195 1193 exit 1
1196 1194 fi
1197 1195 echo `whence $MAKE`" version is:"
1198 1196 echo " ${DMAKE_VERSION}"
1199 1197 cat <<EOF
1200 1198
1201 1199 This version may not be safe for use. Either set TEAMWARE to a better
1202 1200 path or (if you really want to use this version of dmake anyway), add
1203 1201 the following to your environment to disable this check:
1204 1202
1205 1203 CHECK_DMAKE=n
1206 1204 EOF
1207 1205 exit 1
1208 1206 fi
1209 1207 export PATH
1210 1208 export MAKE
1211 1209
1212 1210 if [ "${SUNWSPRO}" != "" ]; then
1213 1211 PATH="${SUNWSPRO}/bin:$PATH"
1214 1212 export PATH
1215 1213 fi
1216 1214
1217 1215 hostname=$(uname -n)
1218 1216 if [[ $DMAKE_MAX_JOBS != +([0-9]) || $DMAKE_MAX_JOBS -eq 0 ]]
1219 1217 then
1220 1218 maxjobs=
1221 1219 if [[ -f $HOME/.make.machines ]]
1222 1220 then
1223 1221 # Note: there is a hard tab and space character in the []s
1224 1222 # below.
1225 1223 egrep -i "^[ ]*$hostname[ \.]" \
1226 1224 $HOME/.make.machines | read host jobs
1227 1225 maxjobs=${jobs##*=}
1228 1226 fi
1229 1227
1230 1228 if [[ $maxjobs != +([0-9]) || $maxjobs -eq 0 ]]
1231 1229 then
1232 1230 # default
1233 1231 maxjobs=4
1234 1232 fi
1235 1233
1236 1234 export DMAKE_MAX_JOBS=$maxjobs
1237 1235 fi
1238 1236
1239 1237 DMAKE_MODE=parallel;
1240 1238 export DMAKE_MODE
1241 1239
1242 1240 if [ -z "${ROOT}" ]; then
1243 1241 echo "ROOT must be set."
1244 1242 exit 1
1245 1243 fi
1246 1244
1247 1245 #
1248 1246 # if -V flag was given, reset VERSION to V_ARG
1249 1247 #
1250 1248 if [ "$V_FLAG" = "y" ]; then
1251 1249 VERSION=$V_ARG
1252 1250 fi
1253 1251
1254 1252 #
1255 1253 # Check for IHV root for copying ihv proto area
1256 1254 #
1257 1255 if [ "$X_FLAG" = "y" ]; then
1258 1256 if [ "$IA32_IHV_ROOT" = "" ]; then
1259 1257 echo "IA32_IHV_ROOT: must be set for copying ihv proto"
1260 1258 args_ok=n
1261 1259 fi
1262 1260 if [ ! -d "$IA32_IHV_ROOT" ]; then
1263 1261 echo "$IA32_IHV_ROOT: not found"
1264 1262 args_ok=n
1265 1263 fi
1266 1264 if [ "$IA32_IHV_WS" = "" ]; then
1267 1265 echo "IA32_IHV_WS: must be set for copying ihv proto"
1268 1266 args_ok=n
1269 1267 fi
1270 1268 if [ ! -d "$IA32_IHV_WS" ]; then
1271 1269 echo "$IA32_IHV_WS: not found"
1272 1270 args_ok=n
1273 1271 fi
1274 1272 fi
1275 1273
1276 1274 TMPDIR="/tmp/nightly.tmpdir.$$"
1277 1275 export TMPDIR
1278 1276 rm -rf ${TMPDIR}
1279 1277 mkdir -p $TMPDIR || exit 1
1280 1278 chmod 777 $TMPDIR
1281 1279
1282 1280 #
1283 1281 # Keep elfsign's use of pkcs11_softtoken from looking in the user home
1284 1282 # directory, which doesn't always work. Needed until all build machines
1285 1283 # have the fix for 6271754
1286 1284 #
1287 1285 SOFTTOKEN_DIR=$TMPDIR
1288 1286 export SOFTTOKEN_DIR
1289 1287
1290 1288 #
1291 1289 # Tools should only be built non-DEBUG. Keep track of the tools proto
1292 1290 # area path relative to $TOOLS, because the latter changes in an
1293 1291 # export build.
1294 1292 #
1295 1293 # TOOLS_PROTO is included below for builds other than usr/src/tools
1296 1294 # that look for this location. For usr/src/tools, this will be
1297 1295 # overridden on the $MAKE command line in build_tools().
1298 1296 #
1299 1297 TOOLS=${SRC}/tools
1300 1298 TOOLS_PROTO_REL=proto/root_${MACH}-nd
1301 1299 TOOLS_PROTO=${TOOLS}/${TOOLS_PROTO_REL}; export TOOLS_PROTO
1302 1300
1303 1301 unset CFLAGS LD_LIBRARY_PATH LDFLAGS
1304 1302
1305 1303 # create directories that are automatically removed if the nightly script
1306 1304 # fails to start correctly
1307 1305 function newdir {
1308 1306 dir=$1
1309 1307 toadd=
1310 1308 while [ ! -d $dir ]; do
1311 1309 toadd="$dir $toadd"
1312 1310 dir=`dirname $dir`
1313 1311 done
1314 1312 torm=
1315 1313 newlist=
1316 1314 for dir in $toadd; do
1317 1315 if staffer mkdir $dir; then
1318 1316 newlist="$ISUSER $dir $newlist"
1319 1317 torm="$dir $torm"
1320 1318 else
1321 1319 [ -z "$torm" ] || staffer rmdir $torm
1322 1320 return 1
1323 1321 fi
1324 1322 done
1325 1323 newdirlist="$newlist $newdirlist"
1326 1324 return 0
1327 1325 }
1328 1326 newdirlist=
1329 1327
1330 1328 [ -d $CODEMGR_WS ] || newdir $CODEMGR_WS || exit 1
1331 1329
1332 1330 # since this script assumes the build is from full source, it nullifies
1333 1331 # variables likely to have been set by a "ws" script; nullification
1334 1332 # confines the search space for headers and libraries to the proto area
1335 1333 # built from this immediate source.
1336 1334 ENVLDLIBS1=
1337 1335 ENVLDLIBS2=
1338 1336 ENVLDLIBS3=
1339 1337 ENVCPPFLAGS1=
1340 1338 ENVCPPFLAGS2=
1341 1339 ENVCPPFLAGS3=
1342 1340 ENVCPPFLAGS4=
1343 1341 PARENT_ROOT=
1344 1342
1345 1343 export ENVLDLIBS3 ENVCPPFLAGS1 ENVCPPFLAGS2 ENVCPPFLAGS3 ENVCPPFLAGS4 \
1346 1344 ENVLDLIBS1 ENVLDLIBS2 PARENT_ROOT
1347 1345
1348 1346 PKGARCHIVE_ORIG=$PKGARCHIVE
1349 1347 IA32_IHV_PKGS_ORIG=$IA32_IHV_PKGS
1350 1348
1351 1349 #
1352 1350 # Juggle the logs and optionally send mail on completion.
1353 1351 #
1354 1352
1355 1353 function logshuffle {
1356 1354 LLOG="$ATLOG/log.`date '+%F.%H:%M'`"
1357 1355 if [ -f $LLOG -o -d $LLOG ]; then
1358 1356 LLOG=$LLOG.$$
1359 1357 fi
1360 1358 mkdir $LLOG
1361 1359 export LLOG
1362 1360
1363 1361 if [ "$build_ok" = "y" ]; then
1364 1362 mv $ATLOG/proto_list_${MACH} $LLOG
1365 1363
1366 1364 if [ -f $ATLOG/proto_list_tools_${MACH} ]; then
1367 1365 mv $ATLOG/proto_list_tools_${MACH} $LLOG
1368 1366 fi
1369 1367
1370 1368 if [ -f $TMPDIR/wsdiff.results ]; then
1371 1369 mv $TMPDIR/wsdiff.results $LLOG
1372 1370 fi
1373 1371
1374 1372 if [ -f $TMPDIR/wsdiff-nd.results ]; then
1375 1373 mv $TMPDIR/wsdiff-nd.results $LLOG
1376 1374 fi
1377 1375 fi
1378 1376
1379 1377 #
1380 1378 # Now that we're about to send mail, it's time to check the noise
1381 1379 # file. In the event that an error occurs beyond this point, it will
1382 1380 # be recorded in the nightly.log file, but nowhere else. This would
1383 1381 # include only errors that cause the copying of the noise log to fail
1384 1382 # or the mail itself not to be sent.
1385 1383 #
1386 1384
1387 1385 exec >>$LOGFILE 2>&1
1388 1386 if [ -s $build_noise_file ]; then
1389 1387 echo "\n==== Nightly build noise ====\n" |
1390 1388 tee -a $LOGFILE >>$mail_msg_file
1391 1389 cat $build_noise_file >>$LOGFILE
1392 1390 cat $build_noise_file >>$mail_msg_file
1393 1391 echo | tee -a $LOGFILE >>$mail_msg_file
1394 1392 fi
1395 1393 rm -f $build_noise_file
1396 1394
1397 1395 case "$build_ok" in
1398 1396 y)
1399 1397 state=Completed
1400 1398 ;;
1401 1399 i)
1402 1400 state=Interrupted
1403 1401 ;;
1404 1402 *)
1405 1403 state=Failed
1406 1404 ;;
1407 1405 esac
1408 1406 NIGHTLY_STATUS=$state
1409 1407 export NIGHTLY_STATUS
1410 1408
1411 1409 run_hook POST_NIGHTLY $state
1412 1410 run_hook SYS_POST_NIGHTLY $state
1413 1411
1414 1412 #
1415 1413 # mailx(1) sets From: based on the -r flag
1416 1414 # if it is given.
1417 1415 #
1418 1416 mailx_r=
1419 1417 if [[ -n "${MAILFROM}" ]]; then
1420 1418 mailx_r="-r ${MAILFROM}"
1421 1419 fi
1422 1420
1423 1421 cat $build_time_file $build_environ_file $mail_msg_file \
1424 1422 > ${LLOG}/mail_msg
1425 1423 if [ "$m_FLAG" = "y" ]; then
1426 1424 cat ${LLOG}/mail_msg | /usr/bin/mailx ${mailx_r} -s \
1427 1425 "Nightly ${MACH} Build of `basename ${CODEMGR_WS}` ${state}." \
1428 1426 ${MAILTO}
1429 1427 fi
1430 1428
1431 1429 if [ "$u_FLAG" = "y" -a "$build_ok" = "y" ]; then
1432 1430 staffer cp ${LLOG}/mail_msg $PARENT_WS/usr/src/mail_msg-${MACH}
1433 1431 staffer cp $LOGFILE $PARENT_WS/usr/src/nightly-${MACH}.log
1434 1432 fi
1435 1433
1436 1434 mv $LOGFILE $LLOG
1437 1435 }
1438 1436
1439 1437 #
1440 1438 # Remove the locks and temporary files on any exit
1441 1439 #
1442 1440 function cleanup {
1443 1441 logshuffle
1444 1442
1445 1443 [ -z "$lockfile" ] || staffer rm -f $lockfile
1446 1444 [ -z "$atloglockfile" ] || rm -f $atloglockfile
1447 1445 [ -z "$ulockfile" ] || staffer rm -f $ulockfile
1448 1446 [ -z "$Ulockfile" ] || rm -f $Ulockfile
1449 1447
1450 1448 set -- $newdirlist
1451 1449 while [ $# -gt 0 ]; do
1452 1450 ISUSER=$1 staffer rmdir $2
1453 1451 shift; shift
1454 1452 done
1455 1453 rm -rf $TMPDIR
1456 1454 }
1457 1455
1458 1456 function cleanup_signal {
1459 1457 build_ok=i
1460 1458 # this will trigger cleanup(), above.
1461 1459 exit 1
1462 1460 }
1463 1461
1464 1462 trap cleanup 0
1465 1463 trap cleanup_signal 1 2 3 15
1466 1464
1467 1465 #
1468 1466 # Generic lock file processing -- make sure that the lock file doesn't
1469 1467 # exist. If it does, it should name the build host and PID. If it
1470 1468 # doesn't, then make sure we can create it. Clean up locks that are
1471 1469 # known to be stale (assumes host name is unique among build systems
1472 1470 # for the workspace).
1473 1471 #
1474 1472 function create_lock {
1475 1473 lockf=$1
1476 1474 lockvar=$2
1477 1475
1478 1476 ldir=`dirname $lockf`
1479 1477 [ -d $ldir ] || newdir $ldir || exit 1
1480 1478 eval $lockvar=$lockf
1481 1479
1482 1480 while ! staffer ln -s $hostname.$STAFFER.$$ $lockf 2> /dev/null; do
1483 1481 basews=`basename $CODEMGR_WS`
1484 1482 ls -l $lockf | nawk '{print $NF}' | IFS=. read host user pid
1485 1483 if [ "$host" != "$hostname" ]; then
1486 1484 echo "$MACH build of $basews apparently" \
1487 1485 "already started by $user on $host as $pid."
1488 1486 exit 1
1489 1487 elif kill -s 0 $pid 2>/dev/null; then
1490 1488 echo "$MACH build of $basews already started" \
1491 1489 "by $user as $pid."
1492 1490 exit 1
1493 1491 else
1494 1492 # stale lock; clear it out and try again
1495 1493 rm -f $lockf
1496 1494 fi
1497 1495 done
1498 1496 }
1499 1497
1500 1498 #
1501 1499 # Return the list of interesting proto areas, depending on the current
1502 1500 # options.
1503 1501 #
1504 1502 function allprotos {
1505 1503 typeset roots="$ROOT"
1506 1504
1507 1505 if [[ "$F_FLAG" = n && "$MULTI_PROTO" = yes ]]; then
1508 1506 roots="$roots $ROOT-nd"
1509 1507 fi
1510 1508
1511 1509 echo $roots
1512 1510 }
1513 1511
1514 1512 # Ensure no other instance of this script is running on this host.
1515 1513 # LOCKNAME can be set in <env_file>, and is by default, but is not
1516 1514 # required due to the use of $ATLOG below.
1517 1515 if [ -n "$LOCKNAME" ]; then
1518 1516 create_lock /tmp/$LOCKNAME "lockfile"
1519 1517 fi
1520 1518 #
1521 1519 # Create from one, two, or three other locks:
1522 1520 # $ATLOG/nightly.lock
1523 1521 # - protects against multiple builds in same workspace
1524 1522 # $PARENT_WS/usr/src/nightly.$MACH.lock
1525 1523 # - protects against multiple 'u' copy-backs
1526 1524 # $NIGHTLY_PARENT_ROOT/nightly.lock
1527 1525 # - protects against multiple 'U' copy-backs
1528 1526 #
1529 1527 # Overriding ISUSER to 1 causes the lock to be created as root if the
1530 1528 # script is run as root. The default is to create it as $STAFFER.
1531 1529 ISUSER=1 create_lock $ATLOG/nightly.lock "atloglockfile"
1532 1530 if [ "$u_FLAG" = "y" ]; then
1533 1531 create_lock $PARENT_WS/usr/src/nightly.$MACH.lock "ulockfile"
1534 1532 fi
1535 1533 if [ "$U_FLAG" = "y" ]; then
1536 1534 # NIGHTLY_PARENT_ROOT is written as root if script invoked as root.
1537 1535 ISUSER=1 create_lock $NIGHTLY_PARENT_ROOT/nightly.lock "Ulockfile"
1538 1536 fi
1539 1537
1540 1538 # Locks have been taken, so we're doing a build and we're committed to
1541 1539 # the directories we may have created so far.
1542 1540 newdirlist=
1543 1541
1544 1542 #
1545 1543 # Create mail_msg_file
1546 1544 #
1547 1545 mail_msg_file="${TMPDIR}/mail_msg"
1548 1546 touch $mail_msg_file
1549 1547 build_time_file="${TMPDIR}/build_time"
1550 1548 build_environ_file="${TMPDIR}/build_environ"
1551 1549 touch $build_environ_file
1552 1550 #
1553 1551 # Move old LOGFILE aside
1554 1552 # ATLOG directory already made by 'create_lock' above
1555 1553 #
1556 1554 if [ -f $LOGFILE ]; then
1557 1555 mv -f $LOGFILE ${LOGFILE}-
1558 1556 fi
1559 1557 #
1560 1558 # Build OsNet source
1561 1559 #
1562 1560 START_DATE=`date`
1563 1561 SECONDS=0
1564 1562 echo "\n==== Nightly $maketype build started: $START_DATE ====" \
1565 1563 | tee -a $LOGFILE > $build_time_file
1566 1564
1567 1565 echo "\nBuild project: $build_project\nBuild taskid: $build_taskid" | \
1568 1566 tee -a $mail_msg_file >> $LOGFILE
1569 1567
1570 1568 # make sure we log only to the nightly build file
1571 1569 build_noise_file="${TMPDIR}/build_noise"
1572 1570 exec </dev/null >$build_noise_file 2>&1
1573 1571
1574 1572 run_hook SYS_PRE_NIGHTLY
1575 1573 run_hook PRE_NIGHTLY
1576 1574
1577 1575 echo "\n==== list of environment variables ====\n" >> $LOGFILE
1578 1576 env >> $LOGFILE
1579 1577
1580 1578 echo "\n==== Nightly argument issues ====\n" | tee -a $mail_msg_file >> $LOGFILE
1581 1579
1582 1580 if [ "$P_FLAG" = "y" ]; then
1583 1581 obsolete_build GPROF | tee -a $mail_msg_file >> $LOGFILE
1584 1582 fi
1585 1583
1586 1584 if [ "$T_FLAG" = "y" ]; then
1587 1585 obsolete_build TRACE | tee -a $mail_msg_file >> $LOGFILE
1588 1586 fi
1589 1587
1590 1588 if [ "$N_FLAG" = "y" ]; then
1591 1589 if [ "$p_FLAG" = "y" ]; then
1592 1590 cat <<EOF | tee -a $mail_msg_file >> $LOGFILE
1593 1591 WARNING: the p option (create packages) is set, but so is the N option (do
1594 1592 not run protocmp); this is dangerous; you should unset the N option
1595 1593 EOF
1596 1594 else
1597 1595 cat <<EOF | tee -a $mail_msg_file >> $LOGFILE
1598 1596 Warning: the N option (do not run protocmp) is set; it probably shouldn't be
1599 1597 EOF
1600 1598 fi
1601 1599 echo "" | tee -a $mail_msg_file >> $LOGFILE
1602 1600 fi
1603 1601
1604 1602 if [ "$D_FLAG" = "n" -a "$l_FLAG" = "y" ]; then
1605 1603 #
1606 1604 # In the past we just complained but went ahead with the lint
1607 1605 # pass, even though the proto area was built non-DEBUG. It's
1608 1606 # unlikely that non-DEBUG headers will make a difference, but
1609 1607 # rather than assuming it's a safe combination, force the user
1610 1608 # to specify a DEBUG build.
1611 1609 #
1612 1610 echo "WARNING: DEBUG build not requested; disabling lint.\n" \
1613 1611 | tee -a $mail_msg_file >> $LOGFILE
1614 1612 l_FLAG=n
1615 1613 fi
1616 1614
1617 1615 if [ "$f_FLAG" = "y" ]; then
1618 1616 if [ "$i_FLAG" = "y" ]; then
1619 1617 echo "WARNING: the -f flag cannot be used during incremental" \
1620 1618 "builds; ignoring -f\n" | tee -a $mail_msg_file >> $LOGFILE
1621 1619 f_FLAG=n
1622 1620 fi
1623 1621 if [ "${l_FLAG}${p_FLAG}" != "yy" ]; then
1624 1622 echo "WARNING: the -f flag requires -l, and -p;" \
1625 1623 "ignoring -f\n" | tee -a $mail_msg_file >> $LOGFILE
1626 1624 f_FLAG=n
1627 1625 fi
1628 1626 fi
1629 1627
1630 1628 if [ "$w_FLAG" = "y" -a ! -d $ROOT ]; then
1631 1629 echo "WARNING: -w specified, but $ROOT does not exist;" \
1632 1630 "ignoring -w\n" | tee -a $mail_msg_file >> $LOGFILE
1633 1631 w_FLAG=n
1634 1632 fi
1635 1633
1636 1634 if [ "$t_FLAG" = "n" ]; then
1637 1635 #
1638 1636 # We're not doing a tools build, so make sure elfsign(1) is
1639 1637 # new enough to safely sign non-crypto binaries. We test
1640 1638 # debugging output from elfsign to detect the old version.
1641 1639 #
1642 1640 newelfsigntest=`SUNW_CRYPTO_DEBUG=stderr /usr/bin/elfsign verify \
1643 1641 -e /usr/lib/security/pkcs11_softtoken.so.1 2>&1 \
1644 1642 | egrep algorithmOID`
1645 1643 if [ -z "$newelfsigntest" ]; then
1646 1644 echo "WARNING: /usr/bin/elfsign out of date;" \
1647 1645 "will only sign crypto modules\n" | \
1648 1646 tee -a $mail_msg_file >> $LOGFILE
1649 1647 export ELFSIGN_OBJECT=true
1650 1648 elif [ "$VERIFY_ELFSIGN" = "y" ]; then
1651 1649 echo "WARNING: VERIFY_ELFSIGN=y requires" \
1652 1650 "the -t flag; ignoring VERIFY_ELFSIGN\n" | \
1653 1651 tee -a $mail_msg_file >> $LOGFILE
1654 1652 fi
1655 1653 fi
1656 1654
1657 1655 case $MULTI_PROTO in
1658 1656 yes|no) ;;
1659 1657 *)
1660 1658 echo "WARNING: MULTI_PROTO is \"$MULTI_PROTO\"; " \
1661 1659 "should be \"yes\" or \"no\"." | tee -a $mail_msg_file >> $LOGFILE
1662 1660 echo "Setting MULTI_PROTO to \"no\".\n" | \
1663 1661 tee -a $mail_msg_file >> $LOGFILE
1664 1662 export MULTI_PROTO=no
1665 1663 ;;
1666 1664 esac
1667 1665
1668 1666 echo "\n==== Build version ====\n" | tee -a $mail_msg_file >> $LOGFILE
1669 1667 echo $VERSION | tee -a $mail_msg_file >> $LOGFILE
1670 1668
1671 1669 # Save the current proto area if we're comparing against the last build
1672 1670 if [ "$w_FLAG" = "y" -a -d "$ROOT" ]; then
1673 1671 if [ -d "$ROOT.prev" ]; then
1674 1672 rm -rf $ROOT.prev
1675 1673 fi
1676 1674 mv $ROOT $ROOT.prev
1677 1675 fi
1678 1676
1679 1677 # Same for non-DEBUG proto area
1680 1678 if [ "$w_FLAG" = "y" -a "$MULTI_PROTO" = yes -a -d "$ROOT-nd" ]; then
1681 1679 if [ -d "$ROOT-nd.prev" ]; then
1682 1680 rm -rf $ROOT-nd.prev
1683 1681 fi
1684 1682 mv $ROOT-nd $ROOT-nd.prev
1685 1683 fi
1686 1684
1687 1685 #
1688 1686 # Echo the SCM type of the parent workspace, this can't just be which_scm
1689 1687 # as that does not know how to identify various network repositories.
1690 1688 #
1691 1689 function parent_wstype {
1692 1690 typeset scm_type junk
1693 1691
1694 1692 CODEMGR_WS="$BRINGOVER_WS" "$WHICH_SCM" 2>/dev/null \
1695 1693 | read scm_type junk
1696 1694 if [[ -z "$scm_type" || "$scm_type" == unknown ]]; then
1697 1695 # Probe BRINGOVER_WS to determine its type
1698 1696 if [[ $BRINGOVER_WS == svn*://* ]]; then
1699 1697 scm_type="subversion"
1700 1698 elif [[ $BRINGOVER_WS == file://* ]] &&
1701 1699 egrep -s "This is a Subversion repository" \
1702 1700 ${BRINGOVER_WS#file://}/README.txt 2> /dev/null; then
1703 1701 scm_type="subversion"
1704 1702 elif [[ $BRINGOVER_WS == ssh://* ]]; then
1705 1703 scm_type="mercurial"
1706 1704 elif [[ $BRINGOVER_WS == http://* ]] && \
1707 1705 wget -q -O- --save-headers "$BRINGOVER_WS/?cmd=heads" | \
1708 1706 egrep -s "application/mercurial" 2> /dev/null; then
1709 1707 scm_type="mercurial"
1710 1708 elif svn info $BRINGOVER_WS > /dev/null 2>&1; then
1711 1709 scm_type="subversion"
1712 1710 else
1713 1711 scm_type="none"
1714 1712 fi
1715 1713 fi
1716 1714
1717 1715 # fold both unsupported and unrecognized results into "none"
1718 1716 case "$scm_type" in
1719 1717 none|subversion|teamware|mercurial)
1720 1718 ;;
1721 1719 *) scm_type=none
1722 1720 ;;
1723 1721 esac
1724 1722
1725 1723 echo $scm_type
1726 1724 }
1727 1725
1728 1726 # Echo the SCM types of $CODEMGR_WS and $BRINGOVER_WS
1729 1727 function child_wstype {
1730 1728 typeset scm_type junk
1731 1729
1732 1730 # Probe CODEMGR_WS to determine its type
1733 1731 if [[ -d $CODEMGR_WS ]]; then
1734 1732 $WHICH_SCM | read scm_type junk || exit 1
1735 1733 fi
1736 1734
1737 1735 case "$scm_type" in
1738 1736 none|subversion|git|teamware|mercurial)
1739 1737 ;;
1740 1738 *) scm_type=none
1741 1739 ;;
1742 1740 esac
1743 1741
1744 1742 echo $scm_type
1745 1743 }
1746 1744
1747 1745 SCM_TYPE=$(child_wstype)
1748 1746
1749 1747 #
1750 1748 # Decide whether to clobber
1751 1749 #
1752 1750 if [ "$i_FLAG" = "n" -a -d "$SRC" ]; then
1753 1751 echo "\n==== Make clobber at `date` ====\n" >> $LOGFILE
1754 1752
1755 1753 cd $SRC
1756 1754 # remove old clobber file
1757 1755 rm -f $SRC/clobber.out
1758 1756 rm -f $SRC/clobber-${MACH}.out
1759 1757
1760 1758 # Remove all .make.state* files, just in case we are restarting
1761 1759 # the build after having interrupted a previous 'make clobber'.
1762 1760 find . \( -name SCCS -o -name .hg -o -name .svn -o -name .git \
1763 1761 -o -name 'interfaces.*' \) -prune \
1764 1762 -o -name '.make.*' -print | xargs rm -f
1765 1763
1766 1764 $MAKE -ek clobber 2>&1 | tee -a $SRC/clobber-${MACH}.out >> $LOGFILE
1767 1765 echo "\n==== Make clobber ERRORS ====\n" >> $mail_msg_file
1768 1766 grep "$MAKE:" $SRC/clobber-${MACH}.out |
1769 1767 egrep -v "Ignoring unknown host" \
1770 1768 >> $mail_msg_file
1771 1769
1772 1770 if [[ "$t_FLAG" = "y" ]]; then
1773 1771 echo "\n==== Make tools clobber at `date` ====\n" >> $LOGFILE
1774 1772 cd ${TOOLS}
1775 1773 rm -f ${TOOLS}/clobber-${MACH}.out
1776 1774 $MAKE TOOLS_PROTO=$TOOLS_PROTO -ek clobber 2>&1 | \
1777 1775 tee -a ${TOOLS}/clobber-${MACH}.out >> $LOGFILE
1778 1776 echo "\n==== Make tools clobber ERRORS ====\n" \
1779 1777 >> $mail_msg_file
1780 1778 grep "$MAKE:" ${TOOLS}/clobber-${MACH}.out \
1781 1779 >> $mail_msg_file
1782 1780 rm -rf ${TOOLS_PROTO}
1783 1781 mkdir -p ${TOOLS_PROTO}
1784 1782 fi
1785 1783
1786 1784 typeset roots=$(allprotos)
1787 1785 echo "\n\nClearing $roots" >> "$LOGFILE"
1788 1786 rm -rf $roots
1789 1787
1790 1788 # Get back to a clean workspace as much as possible to catch
1791 1789 # problems that only occur on fresh workspaces.
1792 1790 # Remove all .make.state* files, libraries, and .o's that may
1793 1791 # have been omitted from clobber. A couple of libraries are
1794 1792 # under source code control, so leave them alone.
1795 1793 # We should probably blow away temporary directories too.
1796 1794 cd $SRC
1797 1795 find $relsrcdirs \( -name SCCS -o -name .hg -o -name .svn \
1798 1796 -o -name .git -o -name 'interfaces.*' \) -prune -o \
1799 1797 \( -name '.make.*' -o -name 'lib*.a' -o -name 'lib*.so*' -o \
1800 1798 -name '*.o' \) -print | \
1801 1799 grep -v 'tools/ctf/dwarf/.*/libdwarf' | xargs rm -f
1802 1800 else
1803 1801 echo "\n==== No clobber at `date` ====\n" >> $LOGFILE
1804 1802 fi
1805 1803
1806 1804 type bringover_teamware > /dev/null 2>&1 || function bringover_teamware {
1807 1805 # sleep on the parent workspace's lock
1808 1806 while egrep -s write $BRINGOVER_WS/Codemgr_wsdata/locks
1809 1807 do
1810 1808 sleep 120
1811 1809 done
1812 1810
1813 1811 if [[ -z $BRINGOVER ]]; then
1814 1812 BRINGOVER=$TEAMWARE/bin/bringover
1815 1813 fi
1816 1814
1817 1815 staffer $BRINGOVER -c "nightly update" -p $BRINGOVER_WS \
1818 1816 -w $CODEMGR_WS $BRINGOVER_FILES < /dev/null 2>&1 ||
1819 1817 touch $TMPDIR/bringover_failed
1820 1818
1821 1819 staffer bringovercheck $CODEMGR_WS >$TMPDIR/bringovercheck.out 2>&1
1822 1820 if [ -s $TMPDIR/bringovercheck.out ]; then
1823 1821 echo "\n==== POST-BRINGOVER CLEANUP NOISE ====\n"
1824 1822 cat $TMPDIR/bringovercheck.out
1825 1823 fi
1826 1824 }
1827 1825
1828 1826 type bringover_mercurial > /dev/null 2>&1 || function bringover_mercurial {
1829 1827 typeset -x PATH=$PATH
1830 1828
1831 1829 # If the repository doesn't exist yet, then we want to populate it.
1832 1830 if [[ ! -d $CODEMGR_WS/.hg ]]; then
1833 1831 staffer hg init $CODEMGR_WS
1834 1832 staffer echo "[paths]" > $CODEMGR_WS/.hg/hgrc
1835 1833 staffer echo "default=$BRINGOVER_WS" >> $CODEMGR_WS/.hg/hgrc
1836 1834 touch $TMPDIR/new_repository
1837 1835 fi
1838 1836
1839 1837 typeset -x HGMERGE="/bin/false"
1840 1838
1841 1839 #
1842 1840 # If the user has changes, regardless of whether those changes are
1843 1841 # committed, and regardless of whether those changes conflict, then
1844 1842 # we'll attempt to merge them either implicitly (uncommitted) or
1845 1843 # explicitly (committed).
1846 1844 #
1847 1845 # These are the messages we'll use to help clarify mercurial output
1848 1846 # in those cases.
1849 1847 #
1850 1848 typeset mergefailmsg="\
1851 1849 ***\n\
1852 1850 *** nightly was unable to automatically merge your changes. You should\n\
1853 1851 *** redo the full merge manually, following the steps outlined by mercurial\n\
1854 1852 *** above, then restart nightly.\n\
1855 1853 ***\n"
1856 1854 typeset mergepassmsg="\
1857 1855 ***\n\
1858 1856 *** nightly successfully merged your changes. This means that your working\n\
1859 1857 *** directory has been updated, but those changes are not yet committed.\n\
1860 1858 *** After nightly completes, you should validate the results of the merge,\n\
1861 1859 *** then use hg commit manually.\n\
1862 1860 ***\n"
1863 1861
1864 1862 #
1865 1863 # For each repository in turn:
1866 1864 #
1867 1865 # 1. Do the pull. If this fails, dump the output and bail out.
1868 1866 #
1869 1867 # 2. If the pull resulted in an extra head, do an explicit merge.
1870 1868 # If this fails, dump the output and bail out.
1871 1869 #
1872 1870 # Because we can't rely on Mercurial to exit with a failure code
1873 1871 # when a merge fails (Mercurial issue #186), we must grep the
1874 1872 # output of pull/merge to check for attempted and/or failed merges.
1875 1873 #
1876 1874 # 3. If a merge failed, set the message and fail the bringover.
1877 1875 #
1878 1876 # 4. Otherwise, if a merge succeeded, set the message
1879 1877 #
1880 1878 # 5. Dump the output, and any message from step 3 or 4.
1881 1879 #
1882 1880
1883 1881 typeset HG_SOURCE=$BRINGOVER_WS
1884 1882 if [ ! -f $TMPDIR/new_repository ]; then
1885 1883 HG_SOURCE=$TMPDIR/open_bundle.hg
1886 1884 staffer hg --cwd $CODEMGR_WS incoming --bundle $HG_SOURCE \
1887 1885 -v $BRINGOVER_WS > $TMPDIR/incoming_open.out
1888 1886
1889 1887 #
1890 1888 # If there are no incoming changesets, then incoming will
1891 1889 # fail, and there will be no bundle file. Reset the source,
1892 1890 # to allow the remaining logic to complete with no false
1893 1891 # negatives. (Unlike incoming, pull will return success
1894 1892 # for the no-change case.)
1895 1893 #
1896 1894 if (( $? != 0 )); then
1897 1895 HG_SOURCE=$BRINGOVER_WS
1898 1896 fi
1899 1897 fi
1900 1898
1901 1899 staffer hg --cwd $CODEMGR_WS pull -u $HG_SOURCE \
1902 1900 > $TMPDIR/pull_open.out 2>&1
1903 1901 if (( $? != 0 )); then
1904 1902 printf "%s: pull failed as follows:\n\n" "$CODEMGR_WS"
1905 1903 cat $TMPDIR/pull_open.out
1906 1904 if grep "^merging.*failed" $TMPDIR/pull_open.out > /dev/null 2>&1; then
1907 1905 printf "$mergefailmsg"
1908 1906 fi
1909 1907 touch $TMPDIR/bringover_failed
1910 1908 return
1911 1909 fi
1912 1910
1913 1911 if grep "not updating" $TMPDIR/pull_open.out > /dev/null 2>&1; then
1914 1912 staffer hg --cwd $CODEMGR_WS merge \
1915 1913 >> $TMPDIR/pull_open.out 2>&1
1916 1914 if (( $? != 0 )); then
1917 1915 printf "%s: merge failed as follows:\n\n" \
1918 1916 "$CODEMGR_WS"
1919 1917 cat $TMPDIR/pull_open.out
1920 1918 if grep "^merging.*failed" $TMPDIR/pull_open.out \
1921 1919 > /dev/null 2>&1; then
1922 1920 printf "$mergefailmsg"
1923 1921 fi
1924 1922 touch $TMPDIR/bringover_failed
1925 1923 return
1926 1924 fi
1927 1925 fi
1928 1926
1929 1927 printf "updated %s with the following results:\n" "$CODEMGR_WS"
1930 1928 cat $TMPDIR/pull_open.out
1931 1929 if grep "^merging" $TMPDIR/pull_open.out >/dev/null 2>&1; then
1932 1930 printf "$mergepassmsg"
1933 1931 fi
1934 1932 printf "\n"
1935 1933
1936 1934 #
1937 1935 # Per-changeset output is neither useful nor manageable for a
1938 1936 # newly-created repository.
1939 1937 #
1940 1938 if [ -f $TMPDIR/new_repository ]; then
1941 1939 return
1942 1940 fi
1943 1941
1944 1942 printf "\nadded the following changesets to open repository:\n"
1945 1943 cat $TMPDIR/incoming_open.out
1946 1944
1947 1945 #
1948 1946 # The closed repository could have been newly created, even though
1949 1947 # the open one previously existed...
1950 1948 #
1951 1949 if [ -f $TMPDIR/new_closed ]; then
1952 1950 return
1953 1951 fi
1954 1952
1955 1953 if [ -f $TMPDIR/incoming_closed.out ]; then
1956 1954 printf "\nadded the following changesets to closed repository:\n"
1957 1955 cat $TMPDIR/incoming_closed.out
1958 1956 fi
1959 1957 }
1960 1958
1961 1959 type bringover_subversion > /dev/null 2>&1 || function bringover_subversion {
1962 1960 typeset -x PATH=$PATH
1963 1961
1964 1962 if [[ ! -d $CODEMGR_WS/.svn ]]; then
1965 1963 staffer svn checkout $BRINGOVER_WS $CODEMGR_WS ||
1966 1964 touch $TMPDIR/bringover_failed
1967 1965 else
1968 1966 typeset root
1969 1967 root=$(staffer svn info $CODEMGR_WS |
1970 1968 nawk '/^Repository Root:/ {print $NF}')
1971 1969 if [[ $root != $BRINGOVER_WS ]]; then
1972 1970 # We fail here because there's no way to update
1973 1971 # from a named repo.
1974 1972 cat <<-EOF
1975 1973 \$BRINGOVER_WS doesn't match repository root:
1976 1974 \$BRINGOVER_WS: $BRINGOVER_WS
1977 1975 Repository root: $root
1978 1976 EOF
1979 1977 touch $TMPDIR/bringover_failed
1980 1978 else
1981 1979 # If a conflict happens, svn still exits 0.
1982 1980 staffer svn update $CODEMGR_WS | tee $TMPDIR/pull.out ||
1983 1981 touch $TMPDIR/bringover_failed
1984 1982 if grep "^C" $TMPDIR/pull.out > /dev/null 2>&1; then
1985 1983 touch $TMPDIR/bringover_failed
1986 1984 fi
1987 1985 fi
1988 1986 fi
1989 1987 }
1990 1988
1991 1989 type bringover_none > /dev/null 2>&1 || function bringover_none {
1992 1990 echo "Couldn't figure out what kind of SCM to use for $BRINGOVER_WS."
1993 1991 touch $TMPDIR/bringover_failed
1994 1992 }
1995 1993
1996 1994 #
1997 1995 # Decide whether to bringover to the codemgr workspace
1998 1996 #
1999 1997 if [ "$n_FLAG" = "n" ]; then
2000 1998 PARENT_SCM_TYPE=$(parent_wstype)
2001 1999
2002 2000 if [[ $SCM_TYPE != none && $SCM_TYPE != $PARENT_SCM_TYPE ]]; then
2003 2001 echo "cannot bringover from $PARENT_SCM_TYPE to $SCM_TYPE, " \
2004 2002 "quitting at `date`." | tee -a $mail_msg_file >> $LOGFILE
2005 2003 exit 1
2006 2004 fi
2007 2005
2008 2006 run_hook PRE_BRINGOVER
2009 2007
2010 2008 echo "\n==== bringover to $CODEMGR_WS at `date` ====\n" >> $LOGFILE
2011 2009 echo "\n==== BRINGOVER LOG ====\n" >> $mail_msg_file
2012 2010
2013 2011 eval "bringover_${PARENT_SCM_TYPE}" 2>&1 |
2014 2012 tee -a $mail_msg_file >> $LOGFILE
2015 2013
2016 2014 if [ -f $TMPDIR/bringover_failed ]; then
2017 2015 rm -f $TMPDIR/bringover_failed
2018 2016 build_ok=n
2019 2017 echo "trouble with bringover, quitting at `date`." |
2020 2018 tee -a $mail_msg_file >> $LOGFILE
2021 2019 exit 1
2022 2020 fi
2023 2021
2024 2022 #
2025 2023 # It's possible that we used the bringover above to create
2026 2024 # $CODEMGR_WS. If so, then SCM_TYPE was previously "none,"
2027 2025 # but should now be the same as $BRINGOVER_WS.
2028 2026 #
2029 2027 [[ $SCM_TYPE = none ]] && SCM_TYPE=$PARENT_SCM_TYPE
2030 2028
2031 2029 run_hook POST_BRINGOVER
2032 2030
2033 2031 check_closed_tree
2034 2032
2035 2033 else
2036 2034 echo "\n==== No bringover to $CODEMGR_WS ====\n" >> $LOGFILE
2037 2035 fi
2038 2036
2039 2037 # Safeguards
2040 2038 [[ -v CODEMGR_WS ]] || fatal_error "Error: Variable CODEMGR_WS not set."
2041 2039 [[ -d "${CODEMGR_WS}" ]] || fatal_error "Error: ${CODEMGR_WS} is not a directory."
2042 2040 [[ -f "${CODEMGR_WS}/usr/src/Makefile" ]] || fatal_error "Error: ${CODEMGR_WS}/usr/src/Makefile not found."
2043 2041
2044 2042 echo "\n==== Build environment ====\n" | tee -a $build_environ_file >> $LOGFILE
2045 2043
2046 2044 # System
2047 2045 whence uname | tee -a $build_environ_file >> $LOGFILE
2048 2046 uname -a 2>&1 | tee -a $build_environ_file >> $LOGFILE
2049 2047 echo | tee -a $build_environ_file >> $LOGFILE
2050 2048
2051 2049 # make
2052 2050 whence $MAKE | tee -a $build_environ_file >> $LOGFILE
2053 2051 $MAKE -v | tee -a $build_environ_file >> $LOGFILE
2054 2052 echo "number of concurrent jobs = $DMAKE_MAX_JOBS" |
2055 2053 tee -a $build_environ_file >> $LOGFILE
2056 2054
2057 2055 #
2058 2056 # Report the compiler versions.
2059 2057 #
2060 2058
2061 2059 if [[ ! -f $SRC/Makefile ]]; then
2062 2060 build_ok=n
2063 2061 echo "\nUnable to find \"Makefile\" in $SRC." | \
2064 2062 tee -a $build_environ_file >> $LOGFILE
2065 2063 exit 1
2066 2064 fi
2067 2065
2068 2066 ( cd $SRC
2069 2067 for target in cc-version cc64-version java-version; do
2070 2068 echo
2071 2069 #
2072 2070 # Put statefile somewhere we know we can write to rather than trip
2073 2071 # over a read-only $srcroot.
2074 2072 #
2075 2073 rm -f $TMPDIR/make-state
2076 2074 export SRC
2077 2075 if $MAKE -K $TMPDIR/make-state -e $target 2>/dev/null; then
2078 2076 continue
2079 2077 fi
2080 2078 touch $TMPDIR/nocompiler
2081 2079 done
2082 2080 echo
2083 2081 ) | tee -a $build_environ_file >> $LOGFILE
2084 2082
2085 2083 if [ -f $TMPDIR/nocompiler ]; then
2086 2084 rm -f $TMPDIR/nocompiler
2087 2085 build_ok=n
2088 2086 echo "Aborting due to missing compiler." |
2089 2087 tee -a $build_environ_file >> $LOGFILE
2090 2088 exit 1
2091 2089 fi
2092 2090
2093 2091 # as
2094 2092 whence as | tee -a $build_environ_file >> $LOGFILE
2095 2093 as -V 2>&1 | head -1 | tee -a $build_environ_file >> $LOGFILE
2096 2094 echo | tee -a $build_environ_file >> $LOGFILE
2097 2095
2098 2096 # Check that we're running a capable link-editor
2099 2097 whence ld | tee -a $build_environ_file >> $LOGFILE
2100 2098 LDVER=`ld -V 2>&1`
2101 2099 echo $LDVER | tee -a $build_environ_file >> $LOGFILE
2102 2100 LDVER=`echo $LDVER | sed -e "s/.*-1\.\([0-9]*\).*/\1/"`
2103 2101 if [ `expr $LDVER \< 422` -eq 1 ]; then
2104 2102 echo "The link-editor needs to be at version 422 or higher to build" | \
2105 2103 tee -a $build_environ_file >> $LOGFILE
2106 2104 echo "the latest stuff. Hope your build works." | \
2107 2105 tee -a $build_environ_file >> $LOGFILE
2108 2106 fi
2109 2107
2110 2108 #
2111 2109 # Build and use the workspace's tools if requested
2112 2110 #
2113 2111 if [[ "$t_FLAG" = "y" ]]; then
2114 2112 set_non_debug_build_flags
2115 2113
2116 2114 build_tools ${TOOLS_PROTO}
2117 2115 if [[ $? != 0 && "$t_FLAG" = y ]]; then
2118 2116 use_tools $TOOLS_PROTO
2119 2117 fi
2120 2118 fi
2121 2119
2122 2120 #
2123 2121 # copy ihv proto area in addition to the build itself
2124 2122 #
2125 2123 if [ "$X_FLAG" = "y" ]; then
2126 2124 copy_ihv_proto
2127 2125 fi
2128 2126
2129 2127 # timestamp the start of the normal build; the findunref tool uses it.
2130 2128 touch $SRC/.build.tstamp
2131 2129
2132 2130 normal_build
2133 2131
2134 2132 ORIG_SRC=$SRC
2135 2133 BINARCHIVE=${CODEMGR_WS}/bin-${MACH}.cpio.Z
2136 2134
2137 2135
2138 2136 #
2139 2137 # There are several checks that need to look at the proto area, but
2140 2138 # they only need to look at one, and they don't care whether it's
2141 2139 # DEBUG or non-DEBUG.
2142 2140 #
2143 2141 if [[ "$MULTI_PROTO" = yes && "$D_FLAG" = n ]]; then
2144 2142 checkroot=$ROOT-nd
2145 2143 else
2146 2144 checkroot=$ROOT
2147 2145 fi
2148 2146
2149 2147 if [ "$build_ok" = "y" ]; then
2150 2148 echo "\n==== Creating protolist system file at `date` ====" \
2151 2149 >> $LOGFILE
2152 2150 protolist $checkroot > $ATLOG/proto_list_${MACH}
2153 2151 echo "==== protolist system file created at `date` ====\n" \
2154 2152 >> $LOGFILE
2155 2153
2156 2154 if [ "$N_FLAG" != "y" ]; then
2157 2155
2158 2156 E1=
2159 2157 f1=
2160 2158 if [ -d "$SRC/pkgdefs" ]; then
2161 2159 f1="$SRC/pkgdefs/etc/exception_list_$MACH"
2162 2160 if [ "$X_FLAG" = "y" ]; then
2163 2161 f1="$f1 $IA32_IHV_WS/usr/src/pkgdefs/etc/exception_list_$MACH"
2164 2162 fi
2165 2163 fi
2166 2164
2167 2165 for f in $f1; do
2168 2166 if [ -f "$f" ]; then
2169 2167 E1="$E1 -e $f"
2170 2168 fi
2171 2169 done
2172 2170
2173 2171 E2=
2174 2172 f2=
2175 2173 if [ -d "$SRC/pkg" ]; then
2176 2174 f2="$f2 exceptions/packaging"
2177 2175 fi
2178 2176
2179 2177 for f in $f2; do
2180 2178 if [ -f "$f" ]; then
2181 2179 E2="$E2 -e $f"
2182 2180 fi
2183 2181 done
2184 2182
2185 2183 if [ -f "$REF_PROTO_LIST" ]; then
2186 2184 #
2187 2185 # For builds that copy the IHV proto area (-X), add the
2188 2186 # IHV proto list to the reference list if the reference
2189 2187 # was built without -X.
2190 2188 #
2191 2189 # For builds that don't copy the IHV proto area, add the
2192 2190 # IHV proto list to the build's proto list if the
2193 2191 # reference was built with -X.
2194 2192 #
2195 2193 # Use the presence of the first file entry of the cached
2196 2194 # IHV proto list in the reference list to determine
2197 2195 # whether it was built with -X or not.
2198 2196 #
2199 2197 IHV_REF_PROTO_LIST=$SRC/pkg/proto_list_ihv_$MACH
2200 2198 grepfor=$(nawk '$1 == "f" { print $2; exit }' \
2201 2199 $IHV_REF_PROTO_LIST 2> /dev/null)
2202 2200 if [ $? = 0 -a -n "$grepfor" ]; then
2203 2201 if [ "$X_FLAG" = "y" ]; then
2204 2202 grep -w "$grepfor" \
2205 2203 $REF_PROTO_LIST > /dev/null
2206 2204 if [ ! "$?" = "0" ]; then
2207 2205 REF_IHV_PROTO="-d $IHV_REF_PROTO_LIST"
2208 2206 fi
2209 2207 else
2210 2208 grep -w "$grepfor" \
2211 2209 $REF_PROTO_LIST > /dev/null
2212 2210 if [ "$?" = "0" ]; then
2213 2211 IHV_PROTO_LIST="$IHV_REF_PROTO_LIST"
2214 2212 fi
2215 2213 fi
2216 2214 fi
2217 2215 fi
2218 2216 fi
2219 2217
2220 2218 if [ "$N_FLAG" != "y" -a -f $SRC/pkgdefs/Makefile ]; then
2221 2219 echo "\n==== Impact on SVr4 packages ====\n" >> $mail_msg_file
2222 2220 #
2223 2221 # Compare the build's proto list with current package
2224 2222 # definitions to audit the quality of package
2225 2223 # definitions and makefile install targets. Use the
2226 2224 # current exception list.
2227 2225 #
2228 2226 PKGDEFS_LIST=""
2229 2227 for d in $abssrcdirs; do
2230 2228 if [ -d $d/pkgdefs ]; then
2231 2229 PKGDEFS_LIST="$PKGDEFS_LIST -d $d/pkgdefs"
2232 2230 fi
2233 2231 done
2234 2232 if [ "$X_FLAG" = "y" -a \
2235 2233 -d $IA32_IHV_WS/usr/src/pkgdefs ]; then
2236 2234 PKGDEFS_LIST="$PKGDEFS_LIST -d $IA32_IHV_WS/usr/src/pkgdefs"
2237 2235 fi
2238 2236 $PROTOCMPTERSE \
2239 2237 "Files missing from the proto area:" \
2240 2238 "Files missing from packages:" \
2241 2239 "Inconsistencies between pkgdefs and proto area:" \
2242 2240 ${E1} \
2243 2241 ${PKGDEFS_LIST} \
2244 2242 $ATLOG/proto_list_${MACH} \
2245 2243 >> $mail_msg_file
2246 2244 fi
2247 2245
2248 2246 if [ "$N_FLAG" != "y" -a -d $SRC/pkg ]; then
2249 2247 echo "\n==== Validating manifests against proto area ====\n" \
2250 2248 >> $mail_msg_file
2251 2249 ( cd $SRC/pkg ; $MAKE -e protocmp ROOT="$checkroot" ) \
2252 2250 >> $mail_msg_file
2253 2251
2254 2252 fi
2255 2253
2256 2254 if [ "$N_FLAG" != "y" -a -f "$REF_PROTO_LIST" ]; then
2257 2255 echo "\n==== Impact on proto area ====\n" >> $mail_msg_file
2258 2256 if [ -n "$E2" ]; then
2259 2257 ELIST=$E2
2260 2258 else
2261 2259 ELIST=$E1
2262 2260 fi
2263 2261 $PROTOCMPTERSE \
2264 2262 "Files in yesterday's proto area, but not today's:" \
2265 2263 "Files in today's proto area, but not yesterday's:" \
2266 2264 "Files that changed between yesterday and today:" \
2267 2265 ${ELIST} \
2268 2266 -d $REF_PROTO_LIST \
2269 2267 $REF_IHV_PROTO \
2270 2268 $ATLOG/proto_list_${MACH} \
2271 2269 $IHV_PROTO_LIST \
2272 2270 >> $mail_msg_file
2273 2271 fi
2274 2272 fi
2275 2273
2276 2274 if [ "$u_FLAG" = "y" -a "$build_ok" = "y" ]; then
2277 2275 staffer cp $ATLOG/proto_list_${MACH} \
2278 2276 $PARENT_WS/usr/src/proto_list_${MACH}
2279 2277 fi
2280 2278
2281 2279 # Update parent proto area if necessary. This is done now
2282 2280 # so that the proto area has either DEBUG or non-DEBUG kernels.
2283 2281 # Note that this clears out the lock file, so we can dispense with
2284 2282 # the variable now.
2285 2283 if [ "$U_FLAG" = "y" -a "$build_ok" = "y" ]; then
2286 2284 echo "\n==== Copying proto area to $NIGHTLY_PARENT_ROOT ====\n" | \
2287 2285 tee -a $LOGFILE >> $mail_msg_file
2288 2286 rm -rf $NIGHTLY_PARENT_ROOT/*
2289 2287 unset Ulockfile
2290 2288 mkdir -p $NIGHTLY_PARENT_ROOT
2291 2289 if [[ "$MULTI_PROTO" = no || "$D_FLAG" = y ]]; then
2292 2290 ( cd $ROOT; tar cf - . |
2293 2291 ( cd $NIGHTLY_PARENT_ROOT; umask 0; tar xpf - ) ) 2>&1 |
2294 2292 tee -a $mail_msg_file >> $LOGFILE
2295 2293 fi
2296 2294 if [[ "$MULTI_PROTO" = yes && "$F_FLAG" = n ]]; then
2297 2295 rm -rf $NIGHTLY_PARENT_ROOT-nd/*
2298 2296 mkdir -p $NIGHTLY_PARENT_ROOT-nd
2299 2297 cd $ROOT-nd
2300 2298 ( tar cf - . |
2301 2299 ( cd $NIGHTLY_PARENT_ROOT-nd; umask 0; tar xpf - ) ) 2>&1 |
2302 2300 tee -a $mail_msg_file >> $LOGFILE
2303 2301 fi
2304 2302 if [ -n "${NIGHTLY_PARENT_TOOLS_ROOT}" ]; then
2305 2303 echo "\n==== Copying tools proto area to $NIGHTLY_PARENT_TOOLS_ROOT ====\n" | \
2306 2304 tee -a $LOGFILE >> $mail_msg_file
2307 2305 rm -rf $NIGHTLY_PARENT_TOOLS_ROOT/*
2308 2306 mkdir -p $NIGHTLY_PARENT_TOOLS_ROOT
2309 2307 if [[ "$MULTI_PROTO" = no || "$D_FLAG" = y ]]; then
2310 2308 ( cd $TOOLS_PROTO; tar cf - . |
2311 2309 ( cd $NIGHTLY_PARENT_TOOLS_ROOT;
2312 2310 umask 0; tar xpf - ) ) 2>&1 |
2313 2311 tee -a $mail_msg_file >> $LOGFILE
2314 2312 fi
2315 2313 fi
2316 2314 fi
2317 2315
2318 2316 #
2319 2317 # ELF verification: ABI (-A) and runtime (-r) checks
2320 2318 #
2321 2319 if [[ ($build_ok = y) && ( ($A_FLAG = y) || ($r_FLAG = y) ) ]]; then
2322 2320 # Directory ELF-data.$MACH holds the files produced by these tests.
2323 2321 elf_ddir=$SRC/ELF-data.$MACH
2324 2322
2325 2323 # If there is a previous ELF-data backup directory, remove it. Then,
2326 2324 # rotate current ELF-data directory into its place and create a new
2327 2325 # empty directory
2328 2326 rm -rf $elf_ddir.ref
2329 2327 if [[ -d $elf_ddir ]]; then
2330 2328 mv $elf_ddir $elf_ddir.ref
2331 2329 fi
2332 2330 mkdir -p $elf_ddir
2333 2331
2334 2332 # Call find_elf to produce a list of the ELF objects in the proto area.
2335 2333 # This list is passed to check_rtime and interface_check, preventing
2336 2334 # them from separately calling find_elf to do the same work twice.
2337 2335 find_elf -fr $checkroot > $elf_ddir/object_list
2338 2336
2339 2337 if [[ $A_FLAG = y ]]; then
2340 2338 echo "\n==== Check versioning and ABI information ====\n" | \
2341 2339 tee -a $LOGFILE >> $mail_msg_file
2342 2340
2343 2341 # Produce interface description for the proto. Report errors.
2344 2342 interface_check -o -w $elf_ddir -f object_list \
2345 2343 -i interface -E interface.err
2346 2344 if [[ -s $elf_ddir/interface.err ]]; then
2347 2345 tee -a $LOGFILE < $elf_ddir/interface.err \
2348 2346 >> $mail_msg_file
2349 2347 fi
2350 2348
2351 2349 # If ELF_DATA_BASELINE_DIR is defined, compare the new interface
2352 2350 # description file to that from the baseline gate. Issue a
2353 2351 # warning if the baseline is not present, and keep going.
2354 2352 if [[ "$ELF_DATA_BASELINE_DIR" != '' ]]; then
2355 2353 base_ifile="$ELF_DATA_BASELINE_DIR/interface"
2356 2354
2357 2355 echo "\n==== Compare versioning and ABI information" \
2358 2356 "to baseline ====\n" | \
2359 2357 tee -a $LOGFILE >> $mail_msg_file
2360 2358 echo "Baseline: $base_ifile\n" >> $LOGFILE
2361 2359
2362 2360 if [[ -f $base_ifile ]]; then
2363 2361 interface_cmp -d -o $base_ifile \
2364 2362 $elf_ddir/interface > $elf_ddir/interface.cmp
2365 2363 if [[ -s $elf_ddir/interface.cmp ]]; then
2366 2364 echo | tee -a $LOGFILE >> $mail_msg_file
2367 2365 tee -a $LOGFILE < \
2368 2366 $elf_ddir/interface.cmp \
2369 2367 >> $mail_msg_file
2370 2368 fi
2371 2369 else
2372 2370 echo "baseline not available. comparison" \
2373 2371 "skipped" | \
2374 2372 tee -a $LOGFILE >> $mail_msg_file
2375 2373 fi
2376 2374
2377 2375 fi
2378 2376 fi
2379 2377
2380 2378 if [[ $r_FLAG = y ]]; then
2381 2379 echo "\n==== Check ELF runtime attributes ====\n" | \
2382 2380 tee -a $LOGFILE >> $mail_msg_file
2383 2381
2384 2382 # If we're doing a DEBUG build the proto area will be left
2385 2383 # with debuggable objects, thus don't assert -s.
2386 2384 if [[ $D_FLAG = y ]]; then
2387 2385 rtime_sflag=""
2388 2386 else
2389 2387 rtime_sflag="-s"
2390 2388 fi
2391 2389 check_rtime -i -m -v $rtime_sflag -o -w $elf_ddir \
2392 2390 -D object_list -f object_list -E runtime.err \
2393 2391 -I runtime.attr.raw
2394 2392
2395 2393 # check_rtime -I output needs to be sorted in order to
2396 2394 # compare it to that from previous builds.
2397 2395 sort $elf_ddir/runtime.attr.raw > $elf_ddir/runtime.attr
2398 2396 rm $elf_ddir/runtime.attr.raw
2399 2397
2400 2398 # Report errors
2401 2399 if [[ -s $elf_ddir/runtime.err ]]; then
2402 2400 tee -a $LOGFILE < $elf_ddir/runtime.err \
2403 2401 >> $mail_msg_file
2404 2402 fi
2405 2403
2406 2404 # If there is an ELF-data directory from a previous build,
2407 2405 # then diff the attr files. These files contain information
2408 2406 # about dependencies, versioning, and runpaths. There is some
2409 2407 # overlap with the ABI checking done above, but this also
2410 2408 # flushes out non-ABI interface differences along with the
2411 2409 # other information.
2412 2410 echo "\n==== Diff ELF runtime attributes" \
2413 2411 "(since last build) ====\n" | \
2414 2412 tee -a $LOGFILE >> $mail_msg_file >> $mail_msg_file
2415 2413
2416 2414 if [[ -f $elf_ddir.ref/runtime.attr ]]; then
2417 2415 diff $elf_ddir.ref/runtime.attr \
2418 2416 $elf_ddir/runtime.attr \
2419 2417 >> $mail_msg_file
2420 2418 fi
2421 2419 fi
2422 2420
2423 2421 # If -u set, copy contents of ELF-data.$MACH to the parent workspace.
2424 2422 if [[ "$u_FLAG" = "y" ]]; then
2425 2423 p_elf_ddir=$PARENT_WS/usr/src/ELF-data.$MACH
2426 2424
2427 2425 # If parent lacks the ELF-data.$MACH directory, create it
2428 2426 if [[ ! -d $p_elf_ddir ]]; then
2429 2427 staffer mkdir -p $p_elf_ddir
2430 2428 fi
2431 2429
2432 2430 # These files are used asynchronously by other builds for ABI
2433 2431 # verification, as above for the -A option. As such, we require
2434 2432 # the file replacement to be atomic. Copy the data to a temp
2435 2433 # file in the same filesystem and then rename into place.
2436 2434 (
2437 2435 cd $elf_ddir
2438 2436 for elf_dfile in *; do
2439 2437 staffer cp $elf_dfile \
2440 2438 ${p_elf_ddir}/${elf_dfile}.new
2441 2439 staffer mv -f ${p_elf_ddir}/${elf_dfile}.new \
2442 2440 ${p_elf_ddir}/${elf_dfile}
2443 2441 done
2444 2442 )
2445 2443 fi
2446 2444 fi
2447 2445
2448 2446 # DEBUG lint of kernel begins
2449 2447
2450 2448 if [ "$i_CMD_LINE_FLAG" = "n" -a "$l_FLAG" = "y" ]; then
2451 2449 if [ "$LINTDIRS" = "" ]; then
2452 2450 # LINTDIRS="$SRC/uts y $SRC/stand y $SRC/psm y"
2453 2451 LINTDIRS="$SRC y"
2454 2452 fi
2455 2453 set $LINTDIRS
2456 2454 while [ $# -gt 0 ]; do
2457 2455 dolint $1 $2; shift; shift
2458 2456 done
2459 2457 else
2460 2458 echo "\n==== No '$MAKE lint' ====\n" >> $LOGFILE
2461 2459 fi
2462 2460
2463 2461 # "make check" begins
2464 2462
2465 2463 if [ "$i_CMD_LINE_FLAG" = "n" -a "$C_FLAG" = "y" ]; then
2466 2464 # remove old check.out
2467 2465 rm -f $SRC/check.out
2468 2466
2469 2467 rm -f $SRC/check-${MACH}.out
2470 2468 cd $SRC
2471 2469 $MAKE -ek check ROOT="$checkroot" 2>&1 | tee -a $SRC/check-${MACH}.out \
2472 2470 >> $LOGFILE
2473 2471 echo "\n==== cstyle/hdrchk errors ====\n" >> $mail_msg_file
2474 2472
2475 2473 grep ":" $SRC/check-${MACH}.out |
2476 2474 egrep -v "Ignoring unknown host" | \
2477 2475 sort | uniq >> $mail_msg_file
2478 2476 else
2479 2477 echo "\n==== No '$MAKE check' ====\n" >> $LOGFILE
2480 2478 fi
2481 2479
2482 2480 echo "\n==== Find core files ====\n" | \
2483 2481 tee -a $LOGFILE >> $mail_msg_file
2484 2482
2485 2483 find $abssrcdirs -name core -a -type f -exec file {} \; | \
2486 2484 tee -a $LOGFILE >> $mail_msg_file
2487 2485
2488 2486 if [ "$f_FLAG" = "y" -a "$build_ok" = "y" ]; then
2489 2487 echo "\n==== Diff unreferenced files (since last build) ====\n" \
2490 2488 | tee -a $LOGFILE >>$mail_msg_file
2491 2489 rm -f $SRC/unref-${MACH}.ref
2492 2490 if [ -f $SRC/unref-${MACH}.out ]; then
2493 2491 mv $SRC/unref-${MACH}.out $SRC/unref-${MACH}.ref
2494 2492 fi
2495 2493
2496 2494 findunref -S $SCM_TYPE -t $SRC/.build.tstamp -s usr $CODEMGR_WS \
2497 2495 ${TOOLS}/findunref/exception_list 2>> $mail_msg_file | \
2498 2496 sort > $SRC/unref-${MACH}.out
2499 2497
2500 2498 if [ ! -f $SRC/unref-${MACH}.ref ]; then
2501 2499 cp $SRC/unref-${MACH}.out $SRC/unref-${MACH}.ref
2502 2500 fi
2503 2501
2504 2502 diff $SRC/unref-${MACH}.ref $SRC/unref-${MACH}.out >>$mail_msg_file
2505 2503 fi
2506 2504
2507 2505 #
2508 2506 # Generate the OpenSolaris deliverables if requested. Some of these
2509 2507 # steps need to come after findunref and are commented below.
2510 2508 #
2511 2509
2512 2510 # Verify that the usual lists of files, such as exception lists,
2513 2511 # contain only valid references to files. If the build has failed,
2514 2512 # then don't check the proto area.
2515 2513 CHECK_PATHS=${CHECK_PATHS:-y}
2516 2514 if [ "$CHECK_PATHS" = y -a "$N_FLAG" != y ]; then
2517 2515 echo "\n==== Check lists of files ====\n" | tee -a $LOGFILE \
2518 2516 >>$mail_msg_file
2519 2517 arg=-b
2520 2518 [ "$build_ok" = y ] && arg=
2521 2519 checkpaths $arg $checkroot 2>&1 | tee -a $LOGFILE >>$mail_msg_file
2522 2520 fi
2523 2521
2524 2522 if [ "$M_FLAG" != "y" -a "$build_ok" = y ]; then
2525 2523 echo "\n==== Impact on file permissions ====\n" \
2526 2524 >> $mail_msg_file
2527 2525
2528 2526 abspkgdefs=
2529 2527 abspkg=
2530 2528 for d in $abssrcdirs; do
2531 2529 if [ -d "$d/pkgdefs" ]; then
2532 2530 abspkgdefs="$abspkgdefs $d"
2533 2531 fi
2534 2532 if [ -d "$d/pkg" ]; then
2535 2533 abspkg="$abspkg $d"
2536 2534 fi
2537 2535 done
2538 2536
2539 2537 if [ -n "$abspkgdefs" ]; then
2540 2538 pmodes -qvdP \
2541 2539 `find $abspkgdefs -name pkginfo.tmpl -print -o \
2542 2540 -name .del\* -prune | sed -e 's:/pkginfo.tmpl$::' | \
2543 2541 sort -u` >> $mail_msg_file
2544 2542 fi
2545 2543
2546 2544 if [ -n "$abspkg" ]; then
2547 2545 for d in "$abspkg"; do
2548 2546 ( cd $d/pkg ; $MAKE -e pmodes ) >> $mail_msg_file
2549 2547 done
2550 2548 fi
2551 2549 fi
2552 2550
2553 2551 if [ "$w_FLAG" = "y" -a "$build_ok" = "y" ]; then
2554 2552 if [[ "$MULTI_PROTO" = no || "$D_FLAG" = y ]]; then
2555 2553 do_wsdiff DEBUG $ROOT.prev $ROOT
2556 2554 fi
2557 2555
2558 2556 if [[ "$MULTI_PROTO" = yes && "$F_FLAG" = n ]]; then
2559 2557 do_wsdiff non-DEBUG $ROOT-nd.prev $ROOT-nd
2560 2558 fi
2561 2559 fi
2562 2560
2563 2561 END_DATE=`date`
2564 2562 echo "==== Nightly $maketype build completed: $END_DATE ====" | \
2565 2563 tee -a $LOGFILE >> $build_time_file
2566 2564
2567 2565 typeset -i10 hours
2568 2566 typeset -Z2 minutes
2569 2567 typeset -Z2 seconds
2570 2568
2571 2569 elapsed_time=$SECONDS
2572 2570 ((hours = elapsed_time / 3600 ))
2573 2571 ((minutes = elapsed_time / 60 % 60))
2574 2572 ((seconds = elapsed_time % 60))
2575 2573
2576 2574 echo "\n==== Total build time ====" | \
2577 2575 tee -a $LOGFILE >> $build_time_file
2578 2576 echo "\nreal ${hours}:${minutes}:${seconds}" | \
2579 2577 tee -a $LOGFILE >> $build_time_file
2580 2578
2581 2579 if [ "$u_FLAG" = "y" -a "$f_FLAG" = "y" -a "$build_ok" = "y" ]; then
2582 2580 staffer cp ${SRC}/unref-${MACH}.out $PARENT_WS/usr/src/
2583 2581
2584 2582 #
2585 2583 # Produce a master list of unreferenced files -- ideally, we'd
2586 2584 # generate the master just once after all of the nightlies
2587 2585 # have finished, but there's no simple way to know when that
2588 2586 # will be. Instead, we assume that we're the last nightly to
2589 2587 # finish and merge all of the unref-${MACH}.out files in
2590 2588 # $PARENT_WS/usr/src/. If we are in fact the final ${MACH} to
2591 2589 # finish, then this file will be the authoritative master
2592 2590 # list. Otherwise, another ${MACH}'s nightly will eventually
2593 2591 # overwrite ours with its own master, but in the meantime our
2594 2592 # temporary "master" will be no worse than any older master
2595 2593 # which was already on the parent.
2596 2594 #
2597 2595
2598 2596 set -- $PARENT_WS/usr/src/unref-*.out
2599 2597 cp "$1" ${TMPDIR}/unref.merge
2600 2598 shift
2601 2599
2602 2600 for unreffile; do
2603 2601 comm -12 ${TMPDIR}/unref.merge "$unreffile" > ${TMPDIR}/unref.$$
2604 2602 mv ${TMPDIR}/unref.$$ ${TMPDIR}/unref.merge
2605 2603 done
2606 2604
2607 2605 staffer cp ${TMPDIR}/unref.merge $PARENT_WS/usr/src/unrefmaster.out
2608 2606 fi
2609 2607
2610 2608 #
2611 2609 # All done save for the sweeping up.
2612 2610 # (whichever exit we hit here will trigger the "cleanup" trap which
2613 2611 # optionally sends mail on completion).
2614 2612 #
2615 2613 if [ "$build_ok" = "y" ]; then
2616 2614 exit 0
2617 2615 fi
2618 2616 exit 1
↓ open down ↓ |
1839 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX