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