Print this page
10063 basic support for smatch
10153 checkpaths shouldn't check packaging exceptions
| 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 # Copyright 2018 Joyent, Inc.
30 30 # Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
31 31 #
32 32 # Based on the nightly script from the integration folks,
33 33 # Mostly modified and owned by mike_s.
34 34 # Changes also by kjc, dmk.
35 35 #
36 36 # BRINGOVER_WS may be specified in the env file.
37 37 # The default is the old behavior of CLONE_WS
38 38 #
39 39 # -i on the command line, means fast options, so when it's on the
40 40 # command line (only), lint and check builds are skipped no matter what
41 41 # the setting of their individual flags are in NIGHTLY_OPTIONS.
42 42 #
43 43 # LINTDIRS can be set in the env file, format is a list of:
44 44 #
45 45 # /dirname-to-run-lint-on flag
46 46 #
47 47 # Where flag is: y - enable lint noise diff output
48 48 # n - disable lint noise diff output
49 49 #
50 50 # For example: LINTDIRS="$SRC/uts n $SRC/stand y $SRC/psm y"
51 51 #
52 52 # OPTHOME may be set in the environment to override /opt
53 53 #
54 54
55 55 #
56 56 # The CDPATH variable causes ksh's `cd' builtin to emit messages to stdout
57 57 # under certain circumstances, which can really screw things up; unset it.
58 58 #
59 59 unset CDPATH
60 60
61 61 # Get the absolute path of the nightly script that the user invoked. This
62 62 # may be a relative path, and we need to do this before changing directory.
63 63 nightly_path=`whence $0`
64 64
65 65 #
66 66 # Keep track of where we found nightly so we can invoke the matching
67 67 # which_scm script. If that doesn't work, don't go guessing, just rely
68 68 # on the $PATH settings, which will generally give us either /opt/onbld
69 69 # or the user's workspace.
70 70 #
71 71 WHICH_SCM=$(dirname $nightly_path)/which_scm
72 72 if [[ ! -x $WHICH_SCM ]]; then
73 73 WHICH_SCM=which_scm
74 74 fi
75 75
76 76 function fatal_error
77 77 {
78 78 print -u2 "nightly: $*"
79 79 exit 1
80 80 }
81 81
82 82 #
83 83 # Function to do a DEBUG and non-DEBUG build. Needed because we might
84 84 # need to do another for the source build, and since we only deliver DEBUG or
85 85 # non-DEBUG packages.
86 86 #
87 87 # usage: normal_build
88 88 #
89 89 function normal_build {
90 90
91 91 typeset orig_p_FLAG="$p_FLAG"
92 92 typeset crypto_signer="$CODESIGN_USER"
93 93
94 94 suffix=""
95 95
96 96 # non-DEBUG build begins
97 97
98 98 if [ "$F_FLAG" = "n" ]; then
99 99 set_non_debug_build_flags
100 100 CODESIGN_USER="$crypto_signer" \
101 101 build "non-DEBUG" "$suffix-nd" "-nd" "$MULTI_PROTO"
102 102 else
103 103 echo "\n==== No non-DEBUG $open_only build ====\n" >> "$LOGFILE"
104 104 fi
105 105
106 106 # non-DEBUG build ends
107 107
108 108 # DEBUG build begins
109 109
110 110 if [ "$D_FLAG" = "y" ]; then
111 111 set_debug_build_flags
112 112 CODESIGN_USER="$crypto_signer" \
113 113 build "DEBUG" "$suffix" "" "$MULTI_PROTO"
114 114 else
115 115 echo "\n==== No DEBUG $open_only build ====\n" >> "$LOGFILE"
116 116 fi
117 117
118 118 # DEBUG build ends
119 119
120 120 p_FLAG="$orig_p_FLAG"
121 121 }
122 122
123 123 #
124 124 # usage: run_hook HOOKNAME ARGS...
125 125 #
126 126 # If variable "$HOOKNAME" is defined, insert a section header into
127 127 # our logs and then run the command with ARGS
128 128 #
129 129 function run_hook {
130 130 HOOKNAME=$1
131 131 eval HOOKCMD=\$$HOOKNAME
132 132 shift
133 133
134 134 if [ -n "$HOOKCMD" ]; then
135 135 (
136 136 echo "\n==== Running $HOOKNAME command: $HOOKCMD ====\n"
137 137 ( $HOOKCMD "$@" 2>&1 )
138 138 if [ "$?" -ne 0 ]; then
139 139 # Let exit status propagate up
140 140 touch $TMPDIR/abort
141 141 fi
142 142 ) | tee -a $mail_msg_file >> $LOGFILE
143 143
144 144 if [ -f $TMPDIR/abort ]; then
145 145 build_ok=n
146 146 echo "\nAborting at request of $HOOKNAME" |
147 147 tee -a $mail_msg_file >> $LOGFILE
148 148 exit 1
149 149 fi
150 150 fi
151 151 }
152 152
153 153 # Return library search directive as function of given root.
154 154 function myldlibs {
155 155 echo "-L$1/lib -L$1/usr/lib"
156 156 }
157 157
158 158 # Return header search directive as function of given root.
159 159 function myheaders {
160 160 echo "-I$1/usr/include"
161 161 }
162 162
163 163 #
164 164 # Function to do the build, including package generation.
165 165 # usage: build LABEL SUFFIX ND MULTIPROTO
166 166 # - LABEL is used to tag build output.
167 167 # - SUFFIX is used to distinguish files (e.g., DEBUG vs non-DEBUG,
168 168 # open-only vs full tree).
169 169 # - ND is "-nd" (non-DEBUG builds) or "" (DEBUG builds).
170 170 # - If MULTIPROTO is "yes", it means to name the proto area according to
171 171 # SUFFIX. Otherwise ("no"), (re)use the standard proto area.
172 172 #
173 173 function build {
174 174 LABEL=$1
175 175 SUFFIX=$2
176 176 ND=$3
177 177 MULTIPROTO=$4
178 178 INSTALLOG=install${SUFFIX}-${MACH}
179 179 NOISE=noise${SUFFIX}-${MACH}
180 180 PKGARCHIVE=${PKGARCHIVE_ORIG}${SUFFIX}
181 181
182 182 ORIGROOT=$ROOT
183 183 [ $MULTIPROTO = no ] || export ROOT=$ROOT$SUFFIX
184 184
185 185 export ENVLDLIBS1=`myldlibs $ROOT`
186 186 export ENVCPPFLAGS1=`myheaders $ROOT`
187 187
188 188 this_build_ok=y
189 189 #
190 190 # Build OS-Networking source
191 191 #
192 192 echo "\n==== Building OS-Net source at `date` ($LABEL) ====\n" \
193 193 >> $LOGFILE
194 194
195 195 rm -f $SRC/${INSTALLOG}.out
196 196 cd $SRC
197 197 /bin/time $MAKE -e install 2>&1 | \
198 198 tee -a $SRC/${INSTALLOG}.out >> $LOGFILE
199 199
200 200 echo "\n==== Build errors ($LABEL) ====\n" >> $mail_msg_file
201 201 egrep ":" $SRC/${INSTALLOG}.out |
202 202 egrep -e "(^${MAKE}:|[ ]error[: \n])" | \
203 203 egrep -v "Ignoring unknown host" | \
204 204 egrep -v "cc .* -o error " | \
205 205 egrep -v "warning" | tee $TMPDIR/build_errs${SUFFIX} \
206 206 >> $mail_msg_file
207 207 sed -n "/^Undefined[ ]*first referenced$/,/^ld: fatal:/p" \
208 208 < $SRC/${INSTALLOG}.out >> $mail_msg_file
209 209 if [[ -s $TMPDIR/build_errs${SUFFIX} ]]; then
210 210 build_ok=n
|
↓ open down ↓ |
210 lines elided |
↑ open up ↑ |
211 211 this_build_ok=n
212 212 fi
213 213 grep "bootblock image is .* bytes too big" $SRC/${INSTALLOG}.out \
214 214 >> $mail_msg_file
215 215 if [ "$?" = "0" ]; then
216 216 build_ok=n
217 217 this_build_ok=n
218 218 fi
219 219
220 220 echo "\n==== Build warnings ($LABEL) ====\n" >>$mail_msg_file
221 - egrep -i warning: $SRC/${INSTALLOG}.out \
221 + egrep -i 'warn:|warning:' $SRC/${INSTALLOG}.out \
222 222 | egrep -v '^tic:' \
223 223 | egrep -v "symbol (\`|')timezone' has differing types:" \
224 224 | egrep -v "parameter <PSTAMP> set to" \
225 225 | egrep -v "Ignoring unknown host" \
226 226 | egrep -v "redefining segment flags attribute for" \
227 227 | tee $TMPDIR/build_warnings${SUFFIX} >> $mail_msg_file
228 228 if [[ -s $TMPDIR/build_warnings${SUFFIX} ]]; then
229 229 build_ok=n
230 230 this_build_ok=n
231 231 fi
232 232
233 233 echo "\n==== Ended OS-Net source build at `date` ($LABEL) ====\n" \
234 234 >> $LOGFILE
235 235
236 236 echo "\n==== Elapsed build time ($LABEL) ====\n" >>$mail_msg_file
237 237 tail -3 $SRC/${INSTALLOG}.out >>$mail_msg_file
238 238
239 239 if [ "$i_FLAG" = "n" ]; then
240 240 rm -f $SRC/${NOISE}.ref
241 241 if [ -f $SRC/${NOISE}.out ]; then
242 242 mv $SRC/${NOISE}.out $SRC/${NOISE}.ref
243 243 fi
244 244 grep : $SRC/${INSTALLOG}.out \
245 245 | egrep -v '^/' \
246 246 | egrep -v '^(Start|Finish|real|user|sys|./bld_awk)' \
247 247 | egrep -v '^tic:' \
248 248 | egrep -v '^mcs' \
249 249 | egrep -v '^LD_LIBRARY_PATH=' \
250 250 | egrep -v 'ar: creating' \
251 251 | egrep -v 'ar: writing' \
252 252 | egrep -v 'conflicts:' \
253 253 | egrep -v ':saved created' \
254 254 | egrep -v '^stty.*c:' \
255 255 | egrep -v '^mfgname.c:' \
256 256 | egrep -v '^uname-i.c:' \
257 257 | egrep -v '^volumes.c:' \
258 258 | egrep -v '^lint library construction:' \
259 259 | egrep -v 'tsort: INFORM:' \
260 260 | egrep -v 'stripalign:' \
261 261 | egrep -v 'chars, width' \
262 262 | egrep -v "symbol (\`|')timezone' has differing types:" \
263 263 | egrep -v 'PSTAMP' \
264 264 | egrep -v '^Manifying' \
265 265 | egrep -v 'Ignoring unknown host' \
266 266 | egrep -v 'Processing method:' \
267 267 | egrep -v '^Writing' \
268 268 | egrep -v 'spellin1:' \
269 269 | egrep -v '^adding:' \
270 270 | egrep -v "^echo 'msgid" \
271 271 | egrep -v '^echo ' \
272 272 | egrep -v '\.c:$' \
273 273 | egrep -v '^Adding file:' \
274 274 | egrep -v 'CLASSPATH=' \
275 275 | egrep -v '\/var\/mail\/:saved' \
276 276 | egrep -v -- '-DUTS_VERSION=' \
277 277 | egrep -v '^Running Mkbootstrap' \
278 278 | egrep -v '^Applet length read:' \
279 279 | egrep -v 'bytes written:' \
280 280 | egrep -v '^File:SolarisAuthApplet.bin' \
281 281 | egrep -v -i 'jibversion' \
282 282 | egrep -v '^Output size:' \
283 283 | egrep -v '^Solo size statistics:' \
284 284 | egrep -v '^Using ROM API Version' \
285 285 | egrep -v '^Zero Signature length:' \
286 286 | egrep -v '^Note \(probably harmless\):' \
287 287 | egrep -v '::' \
288 288 | egrep -v '^\+' \
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 # Work around folks who have historically used GCC_ROOT and convert it to
959 959 # GNUC_ROOT. We leave GCC_ROOT in the environment for now (though this could
960 960 # mess up the case where multiple different gcc versions are being used to
961 961 # shadow).
962 962 #
963 963 if [[ -n "${GCC_ROOT}" ]]; then
964 964 export GNUC_ROOT=${GCC_ROOT}
965 965 fi
966 966
967 967 #
968 968 # Tools should only be built non-DEBUG. Keep track of the tools proto
969 969 # area path relative to $TOOLS, because the latter changes in an
970 970 # export build.
971 971 #
972 972 # TOOLS_PROTO is included below for builds other than usr/src/tools
973 973 # that look for this location. For usr/src/tools, this will be
974 974 # overridden on the $MAKE command line in build_tools().
975 975 #
976 976 TOOLS=${SRC}/tools
977 977 TOOLS_PROTO_REL=proto/root_${MACH}-nd
978 978 TOOLS_PROTO=${TOOLS}/${TOOLS_PROTO_REL}; export TOOLS_PROTO
979 979
980 980 unset CFLAGS LD_LIBRARY_PATH LDFLAGS
981 981
982 982 # create directories that are automatically removed if the nightly script
983 983 # fails to start correctly
984 984 function newdir {
985 985 dir=$1
986 986 toadd=
987 987 while [ ! -d $dir ]; do
988 988 toadd="$dir $toadd"
989 989 dir=`dirname $dir`
990 990 done
991 991 torm=
992 992 newlist=
993 993 for dir in $toadd; do
994 994 if staffer mkdir $dir; then
995 995 newlist="$ISUSER $dir $newlist"
996 996 torm="$dir $torm"
997 997 else
998 998 [ -z "$torm" ] || staffer rmdir $torm
999 999 return 1
1000 1000 fi
1001 1001 done
1002 1002 newdirlist="$newlist $newdirlist"
1003 1003 return 0
1004 1004 }
1005 1005 newdirlist=
1006 1006
1007 1007 [ -d $CODEMGR_WS ] || newdir $CODEMGR_WS || exit 1
1008 1008
1009 1009 # since this script assumes the build is from full source, it nullifies
1010 1010 # variables likely to have been set by a "ws" script; nullification
1011 1011 # confines the search space for headers and libraries to the proto area
1012 1012 # built from this immediate source.
1013 1013 ENVLDLIBS1=
1014 1014 ENVLDLIBS2=
1015 1015 ENVLDLIBS3=
1016 1016 ENVCPPFLAGS1=
1017 1017 ENVCPPFLAGS2=
1018 1018 ENVCPPFLAGS3=
1019 1019 ENVCPPFLAGS4=
1020 1020 PARENT_ROOT=
1021 1021
1022 1022 export ENVLDLIBS3 ENVCPPFLAGS1 ENVCPPFLAGS2 ENVCPPFLAGS3 ENVCPPFLAGS4 \
1023 1023 ENVLDLIBS1 ENVLDLIBS2 PARENT_ROOT
1024 1024
1025 1025 PKGARCHIVE_ORIG=$PKGARCHIVE
1026 1026
1027 1027 #
1028 1028 # Juggle the logs and optionally send mail on completion.
1029 1029 #
1030 1030
1031 1031 function logshuffle {
1032 1032 LLOG="$ATLOG/log.`date '+%F.%H:%M'`"
1033 1033 if [ -f $LLOG -o -d $LLOG ]; then
1034 1034 LLOG=$LLOG.$$
1035 1035 fi
1036 1036
1037 1037 rm -f "$ATLOG/latest" 2>/dev/null
1038 1038 mkdir -p $LLOG
1039 1039 export LLOG
1040 1040
1041 1041 if [ "$build_ok" = "y" ]; then
1042 1042 mv $ATLOG/proto_list_${MACH} $LLOG
1043 1043
1044 1044 if [ -f $ATLOG/proto_list_tools_${MACH} ]; then
1045 1045 mv $ATLOG/proto_list_tools_${MACH} $LLOG
1046 1046 fi
1047 1047
1048 1048 if [ -f $TMPDIR/wsdiff.results ]; then
1049 1049 mv $TMPDIR/wsdiff.results $LLOG
1050 1050 fi
1051 1051
1052 1052 if [ -f $TMPDIR/wsdiff-nd.results ]; then
1053 1053 mv $TMPDIR/wsdiff-nd.results $LLOG
1054 1054 fi
1055 1055 fi
1056 1056
1057 1057 #
1058 1058 # Now that we're about to send mail, it's time to check the noise
1059 1059 # file. In the event that an error occurs beyond this point, it will
1060 1060 # be recorded in the nightly.log file, but nowhere else. This would
1061 1061 # include only errors that cause the copying of the noise log to fail
1062 1062 # or the mail itself not to be sent.
1063 1063 #
1064 1064
1065 1065 exec >>$LOGFILE 2>&1
1066 1066 if [ -s $build_noise_file ]; then
1067 1067 echo "\n==== Nightly build noise ====\n" |
1068 1068 tee -a $LOGFILE >>$mail_msg_file
1069 1069 cat $build_noise_file >>$LOGFILE
1070 1070 cat $build_noise_file >>$mail_msg_file
1071 1071 echo | tee -a $LOGFILE >>$mail_msg_file
1072 1072 fi
1073 1073 rm -f $build_noise_file
1074 1074
1075 1075 case "$build_ok" in
1076 1076 y)
1077 1077 state=Completed
1078 1078 ;;
1079 1079 i)
1080 1080 state=Interrupted
1081 1081 ;;
1082 1082 *)
1083 1083 state=Failed
1084 1084 ;;
1085 1085 esac
1086 1086
1087 1087 if [[ $state != "Interrupted" && $build_extras_ok != "y" ]]; then
1088 1088 state=Failed
1089 1089 fi
1090 1090
1091 1091 NIGHTLY_STATUS=$state
1092 1092 export NIGHTLY_STATUS
1093 1093
1094 1094 run_hook POST_NIGHTLY $state
1095 1095 run_hook SYS_POST_NIGHTLY $state
1096 1096
1097 1097 #
1098 1098 # mailx(1) sets From: based on the -r flag
1099 1099 # if it is given.
1100 1100 #
1101 1101 mailx_r=
1102 1102 if [[ -n "${MAILFROM}" ]]; then
1103 1103 mailx_r="-r ${MAILFROM}"
1104 1104 fi
1105 1105
1106 1106 cat $build_time_file $build_environ_file $mail_msg_file \
1107 1107 > ${LLOG}/mail_msg
1108 1108 if [ "$m_FLAG" = "y" ]; then
1109 1109 cat ${LLOG}/mail_msg | /usr/bin/mailx ${mailx_r} -s \
1110 1110 "Nightly ${MACH} Build of `basename ${CODEMGR_WS}` ${state}." \
1111 1111 ${MAILTO}
1112 1112 fi
1113 1113
1114 1114 if [ "$u_FLAG" = "y" -a "$build_ok" = "y" ]; then
1115 1115 staffer cp ${LLOG}/mail_msg $PARENT_WS/usr/src/mail_msg-${MACH}
1116 1116 staffer cp $LOGFILE $PARENT_WS/usr/src/nightly-${MACH}.log
1117 1117 fi
1118 1118
1119 1119 mv $LOGFILE $LLOG
1120 1120
1121 1121 ln -s "$LLOG" "$ATLOG/latest"
1122 1122 }
1123 1123
1124 1124 #
1125 1125 # Remove the locks and temporary files on any exit
1126 1126 #
1127 1127 function cleanup {
1128 1128 logshuffle
1129 1129
1130 1130 [ -z "$lockfile" ] || staffer rm -f $lockfile
1131 1131 [ -z "$atloglockfile" ] || rm -f $atloglockfile
1132 1132 [ -z "$ulockfile" ] || staffer rm -f $ulockfile
1133 1133 [ -z "$Ulockfile" ] || rm -f $Ulockfile
1134 1134
1135 1135 set -- $newdirlist
1136 1136 while [ $# -gt 0 ]; do
1137 1137 ISUSER=$1 staffer rmdir $2
1138 1138 shift; shift
1139 1139 done
1140 1140 rm -rf $TMPDIR
1141 1141 }
1142 1142
1143 1143 function cleanup_signal {
1144 1144 build_ok=i
1145 1145 # this will trigger cleanup(), above.
1146 1146 exit 1
1147 1147 }
1148 1148
1149 1149 trap cleanup 0
1150 1150 trap cleanup_signal 1 2 3 15
1151 1151
1152 1152 #
1153 1153 # Generic lock file processing -- make sure that the lock file doesn't
1154 1154 # exist. If it does, it should name the build host and PID. If it
1155 1155 # doesn't, then make sure we can create it. Clean up locks that are
1156 1156 # known to be stale (assumes host name is unique among build systems
1157 1157 # for the workspace).
1158 1158 #
1159 1159 function create_lock {
1160 1160 lockf=$1
1161 1161 lockvar=$2
1162 1162
1163 1163 ldir=`dirname $lockf`
1164 1164 [ -d $ldir ] || newdir $ldir || exit 1
1165 1165 eval $lockvar=$lockf
1166 1166
1167 1167 while ! staffer ln -s $hostname.$STAFFER.$$ $lockf 2> /dev/null; do
1168 1168 basews=`basename $CODEMGR_WS`
1169 1169 ls -l $lockf | nawk '{print $NF}' | IFS=. read host user pid
1170 1170 if [ "$host" != "$hostname" ]; then
1171 1171 echo "$MACH build of $basews apparently" \
1172 1172 "already started by $user on $host as $pid."
1173 1173 exit 1
1174 1174 elif kill -s 0 $pid 2>/dev/null; then
1175 1175 echo "$MACH build of $basews already started" \
1176 1176 "by $user as $pid."
1177 1177 exit 1
1178 1178 else
1179 1179 # stale lock; clear it out and try again
1180 1180 rm -f $lockf
1181 1181 fi
1182 1182 done
1183 1183 }
1184 1184
1185 1185 #
1186 1186 # Return the list of interesting proto areas, depending on the current
1187 1187 # options.
1188 1188 #
1189 1189 function allprotos {
1190 1190 typeset roots="$ROOT"
1191 1191
1192 1192 if [[ "$F_FLAG" = n && "$MULTI_PROTO" = yes ]]; then
1193 1193 roots="$roots $ROOT-nd"
1194 1194 fi
1195 1195
1196 1196 echo $roots
1197 1197 }
1198 1198
1199 1199 # Ensure no other instance of this script is running on this host.
1200 1200 # LOCKNAME can be set in <env_file>, and is by default, but is not
1201 1201 # required due to the use of $ATLOG below.
1202 1202 if [ -n "$LOCKNAME" ]; then
1203 1203 create_lock /tmp/$LOCKNAME "lockfile"
1204 1204 fi
1205 1205 #
1206 1206 # Create from one, two, or three other locks:
1207 1207 # $ATLOG/nightly.lock
1208 1208 # - protects against multiple builds in same workspace
1209 1209 # $PARENT_WS/usr/src/nightly.$MACH.lock
1210 1210 # - protects against multiple 'u' copy-backs
1211 1211 # $NIGHTLY_PARENT_ROOT/nightly.lock
1212 1212 # - protects against multiple 'U' copy-backs
1213 1213 #
1214 1214 # Overriding ISUSER to 1 causes the lock to be created as root if the
1215 1215 # script is run as root. The default is to create it as $STAFFER.
1216 1216 ISUSER=1 create_lock $ATLOG/nightly.lock "atloglockfile"
1217 1217 if [ "$u_FLAG" = "y" ]; then
1218 1218 create_lock $PARENT_WS/usr/src/nightly.$MACH.lock "ulockfile"
1219 1219 fi
1220 1220 if [ "$U_FLAG" = "y" ]; then
1221 1221 # NIGHTLY_PARENT_ROOT is written as root if script invoked as root.
1222 1222 ISUSER=1 create_lock $NIGHTLY_PARENT_ROOT/nightly.lock "Ulockfile"
1223 1223 fi
1224 1224
1225 1225 # Locks have been taken, so we're doing a build and we're committed to
1226 1226 # the directories we may have created so far.
1227 1227 newdirlist=
1228 1228
1229 1229 #
1230 1230 # Create mail_msg_file
1231 1231 #
1232 1232 mail_msg_file="${TMPDIR}/mail_msg"
1233 1233 touch $mail_msg_file
1234 1234 build_time_file="${TMPDIR}/build_time"
1235 1235 build_environ_file="${TMPDIR}/build_environ"
1236 1236 touch $build_environ_file
1237 1237 #
1238 1238 # Move old LOGFILE aside
1239 1239 # ATLOG directory already made by 'create_lock' above
1240 1240 #
1241 1241 if [ -f $LOGFILE ]; then
1242 1242 mv -f $LOGFILE ${LOGFILE}-
1243 1243 fi
1244 1244 #
1245 1245 # Build OsNet source
1246 1246 #
1247 1247 START_DATE=`date`
1248 1248 SECONDS=0
1249 1249 echo "\n==== Nightly $maketype build started: $START_DATE ====" \
1250 1250 | tee -a $LOGFILE > $build_time_file
1251 1251
1252 1252 echo "\nBuild project: $build_project\nBuild taskid: $build_taskid" | \
1253 1253 tee -a $mail_msg_file >> $LOGFILE
1254 1254
1255 1255 # make sure we log only to the nightly build file
1256 1256 build_noise_file="${TMPDIR}/build_noise"
1257 1257 exec </dev/null >$build_noise_file 2>&1
1258 1258
1259 1259 run_hook SYS_PRE_NIGHTLY
1260 1260 run_hook PRE_NIGHTLY
1261 1261
1262 1262 echo "\n==== list of environment variables ====\n" >> $LOGFILE
1263 1263 env >> $LOGFILE
1264 1264
1265 1265 echo "\n==== Nightly argument issues ====\n" | tee -a $mail_msg_file >> $LOGFILE
1266 1266
1267 1267 if [ "$N_FLAG" = "y" ]; then
1268 1268 if [ "$p_FLAG" = "y" ]; then
1269 1269 cat <<EOF | tee -a $mail_msg_file >> $LOGFILE
1270 1270 WARNING: the p option (create packages) is set, but so is the N option (do
1271 1271 not run protocmp); this is dangerous; you should unset the N option
1272 1272 EOF
1273 1273 else
1274 1274 cat <<EOF | tee -a $mail_msg_file >> $LOGFILE
1275 1275 Warning: the N option (do not run protocmp) is set; it probably shouldn't be
1276 1276 EOF
1277 1277 fi
1278 1278 echo "" | tee -a $mail_msg_file >> $LOGFILE
1279 1279 fi
1280 1280
1281 1281 if [ "$D_FLAG" = "n" -a "$l_FLAG" = "y" ]; then
1282 1282 #
1283 1283 # In the past we just complained but went ahead with the lint
1284 1284 # pass, even though the proto area was built non-DEBUG. It's
1285 1285 # unlikely that non-DEBUG headers will make a difference, but
1286 1286 # rather than assuming it's a safe combination, force the user
1287 1287 # to specify a DEBUG build.
1288 1288 #
1289 1289 echo "WARNING: DEBUG build not requested; disabling lint.\n" \
1290 1290 | tee -a $mail_msg_file >> $LOGFILE
1291 1291 l_FLAG=n
1292 1292 fi
1293 1293
1294 1294 if [ "$f_FLAG" = "y" ]; then
1295 1295 if [ "$i_FLAG" = "y" ]; then
1296 1296 echo "WARNING: the -f flag cannot be used during incremental" \
1297 1297 "builds; ignoring -f\n" | tee -a $mail_msg_file >> $LOGFILE
1298 1298 f_FLAG=n
1299 1299 fi
1300 1300 if [ "${l_FLAG}${p_FLAG}" != "yy" ]; then
1301 1301 echo "WARNING: the -f flag requires -l, and -p;" \
1302 1302 "ignoring -f\n" | tee -a $mail_msg_file >> $LOGFILE
1303 1303 f_FLAG=n
1304 1304 fi
1305 1305 fi
1306 1306
1307 1307 if [ "$w_FLAG" = "y" -a ! -d $ROOT ]; then
1308 1308 echo "WARNING: -w specified, but $ROOT does not exist;" \
1309 1309 "ignoring -w\n" | tee -a $mail_msg_file >> $LOGFILE
1310 1310 w_FLAG=n
1311 1311 fi
1312 1312
1313 1313 case $MULTI_PROTO in
1314 1314 yes|no) ;;
1315 1315 *)
1316 1316 echo "WARNING: MULTI_PROTO is \"$MULTI_PROTO\"; " \
1317 1317 "should be \"yes\" or \"no\"." | tee -a $mail_msg_file >> $LOGFILE
1318 1318 echo "Setting MULTI_PROTO to \"no\".\n" | \
1319 1319 tee -a $mail_msg_file >> $LOGFILE
1320 1320 export MULTI_PROTO=no
1321 1321 ;;
1322 1322 esac
1323 1323
1324 1324 echo "\n==== Build version ====\n" | tee -a $mail_msg_file >> $LOGFILE
1325 1325 echo $VERSION | tee -a $mail_msg_file >> $LOGFILE
1326 1326
1327 1327 # Save the current proto area if we're comparing against the last build
1328 1328 if [ "$w_FLAG" = "y" -a -d "$ROOT" ]; then
1329 1329 if [ -d "$ROOT.prev" ]; then
1330 1330 rm -rf $ROOT.prev
1331 1331 fi
1332 1332 mv $ROOT $ROOT.prev
1333 1333 fi
1334 1334
1335 1335 # Same for non-DEBUG proto area
1336 1336 if [ "$w_FLAG" = "y" -a "$MULTI_PROTO" = yes -a -d "$ROOT-nd" ]; then
1337 1337 if [ -d "$ROOT-nd.prev" ]; then
1338 1338 rm -rf $ROOT-nd.prev
1339 1339 fi
1340 1340 mv $ROOT-nd $ROOT-nd.prev
1341 1341 fi
1342 1342
1343 1343 #
1344 1344 # Echo the SCM type of the parent workspace, this can't just be which_scm
1345 1345 # as that does not know how to identify various network repositories.
1346 1346 #
1347 1347 function parent_wstype {
1348 1348 typeset scm_type junk
1349 1349
1350 1350 CODEMGR_WS="$BRINGOVER_WS" "$WHICH_SCM" 2>/dev/null \
1351 1351 | read scm_type junk
1352 1352 if [[ -z "$scm_type" || "$scm_type" == unknown ]]; then
1353 1353 # Probe BRINGOVER_WS to determine its type
1354 1354 if [[ $BRINGOVER_WS == ssh://* ]]; then
1355 1355 scm_type="mercurial"
1356 1356 elif [[ $BRINGOVER_WS == http://* ]] && \
1357 1357 wget -q -O- --save-headers "$BRINGOVER_WS/?cmd=heads" | \
1358 1358 egrep -s "application/mercurial" 2> /dev/null; then
1359 1359 scm_type="mercurial"
1360 1360 else
1361 1361 scm_type="none"
1362 1362 fi
1363 1363 fi
1364 1364
1365 1365 # fold both unsupported and unrecognized results into "none"
1366 1366 case "$scm_type" in
1367 1367 mercurial)
1368 1368 ;;
1369 1369 *) scm_type=none
1370 1370 ;;
1371 1371 esac
1372 1372
1373 1373 echo $scm_type
1374 1374 }
1375 1375
1376 1376 # Echo the SCM types of $CODEMGR_WS and $BRINGOVER_WS
1377 1377 function child_wstype {
1378 1378 typeset scm_type junk
1379 1379
1380 1380 # Probe CODEMGR_WS to determine its type
1381 1381 if [[ -d $CODEMGR_WS ]]; then
1382 1382 $WHICH_SCM | read scm_type junk || exit 1
1383 1383 fi
1384 1384
1385 1385 case "$scm_type" in
1386 1386 none|git|mercurial)
1387 1387 ;;
1388 1388 *) scm_type=none
1389 1389 ;;
1390 1390 esac
1391 1391
1392 1392 echo $scm_type
1393 1393 }
1394 1394
1395 1395 SCM_TYPE=$(child_wstype)
1396 1396
1397 1397 #
1398 1398 # Decide whether to clobber
1399 1399 #
1400 1400 if [ "$i_FLAG" = "n" -a -d "$SRC" ]; then
1401 1401 echo "\n==== Make clobber at `date` ====\n" >> $LOGFILE
1402 1402
1403 1403 cd $SRC
1404 1404 # remove old clobber file
1405 1405 rm -f $SRC/clobber.out
1406 1406 rm -f $SRC/clobber-${MACH}.out
1407 1407
1408 1408 # Remove all .make.state* files, just in case we are restarting
1409 1409 # the build after having interrupted a previous 'make clobber'.
1410 1410 find . \( -name SCCS -o -name .hg -o -name .svn -o -name .git \
1411 1411 -o -name 'interfaces.*' \) -prune \
1412 1412 -o -name '.make.*' -print | xargs rm -f
1413 1413
1414 1414 $MAKE -ek clobber 2>&1 | tee -a $SRC/clobber-${MACH}.out >> $LOGFILE
1415 1415 echo "\n==== Make clobber ERRORS ====\n" >> $mail_msg_file
1416 1416 grep "$MAKE:" $SRC/clobber-${MACH}.out |
1417 1417 egrep -v "Ignoring unknown host" | \
1418 1418 tee $TMPDIR/clobber_errs >> $mail_msg_file
1419 1419
1420 1420 if [[ -s $TMPDIR/clobber_errs ]]; then
1421 1421 build_extras_ok=n
1422 1422 fi
1423 1423
1424 1424 if [[ "$t_FLAG" = "y" ]]; then
1425 1425 echo "\n==== Make tools clobber at `date` ====\n" >> $LOGFILE
1426 1426 cd ${TOOLS}
1427 1427 rm -f ${TOOLS}/clobber-${MACH}.out
1428 1428 $MAKE TOOLS_PROTO=$TOOLS_PROTO -ek clobber 2>&1 | \
1429 1429 tee -a ${TOOLS}/clobber-${MACH}.out >> $LOGFILE
1430 1430 echo "\n==== Make tools clobber ERRORS ====\n" \
1431 1431 >> $mail_msg_file
1432 1432 grep "$MAKE:" ${TOOLS}/clobber-${MACH}.out \
1433 1433 >> $mail_msg_file
1434 1434 if (( $? == 0 )); then
1435 1435 build_extras_ok=n
1436 1436 fi
1437 1437 rm -rf ${TOOLS_PROTO}
1438 1438 mkdir -p ${TOOLS_PROTO}
1439 1439 fi
1440 1440
1441 1441 typeset roots=$(allprotos)
1442 1442 echo "\n\nClearing $roots" >> "$LOGFILE"
1443 1443 rm -rf $roots
1444 1444
1445 1445 # Get back to a clean workspace as much as possible to catch
1446 1446 # problems that only occur on fresh workspaces.
1447 1447 # Remove all .make.state* files, libraries, and .o's that may
1448 1448 # have been omitted from clobber. A couple of libraries are
1449 1449 # under source code control, so leave them alone.
1450 1450 # We should probably blow away temporary directories too.
1451 1451 cd $SRC
1452 1452 find $relsrcdirs \( -name SCCS -o -name .hg -o -name .svn \
1453 1453 -o -name .git -o -name 'interfaces.*' \) -prune -o \
1454 1454 \( -name '.make.*' -o -name 'lib*.a' -o -name 'lib*.so*' -o \
1455 1455 -name '*.o' \) -print | \
1456 1456 grep -v 'tools/ctf/dwarf/.*/libdwarf' | xargs rm -f
1457 1457 else
1458 1458 echo "\n==== No clobber at `date` ====\n" >> $LOGFILE
1459 1459 fi
1460 1460
1461 1461 type bringover_mercurial > /dev/null 2>&1 || function bringover_mercurial {
1462 1462 typeset -x PATH=$PATH
1463 1463
1464 1464 # If the repository doesn't exist yet, then we want to populate it.
1465 1465 if [[ ! -d $CODEMGR_WS/.hg ]]; then
1466 1466 staffer hg init $CODEMGR_WS
1467 1467 staffer echo "[paths]" > $CODEMGR_WS/.hg/hgrc
1468 1468 staffer echo "default=$BRINGOVER_WS" >> $CODEMGR_WS/.hg/hgrc
1469 1469 touch $TMPDIR/new_repository
1470 1470 fi
1471 1471
1472 1472 typeset -x HGMERGE="/bin/false"
1473 1473
1474 1474 #
1475 1475 # If the user has changes, regardless of whether those changes are
1476 1476 # committed, and regardless of whether those changes conflict, then
1477 1477 # we'll attempt to merge them either implicitly (uncommitted) or
1478 1478 # explicitly (committed).
1479 1479 #
1480 1480 # These are the messages we'll use to help clarify mercurial output
1481 1481 # in those cases.
1482 1482 #
1483 1483 typeset mergefailmsg="\
1484 1484 ***\n\
1485 1485 *** nightly was unable to automatically merge your changes. You should\n\
1486 1486 *** redo the full merge manually, following the steps outlined by mercurial\n\
1487 1487 *** above, then restart nightly.\n\
1488 1488 ***\n"
1489 1489 typeset mergepassmsg="\
1490 1490 ***\n\
1491 1491 *** nightly successfully merged your changes. This means that your working\n\
1492 1492 *** directory has been updated, but those changes are not yet committed.\n\
1493 1493 *** After nightly completes, you should validate the results of the merge,\n\
1494 1494 *** then use hg commit manually.\n\
1495 1495 ***\n"
1496 1496
1497 1497 #
1498 1498 # For each repository in turn:
1499 1499 #
1500 1500 # 1. Do the pull. If this fails, dump the output and bail out.
1501 1501 #
1502 1502 # 2. If the pull resulted in an extra head, do an explicit merge.
1503 1503 # If this fails, dump the output and bail out.
1504 1504 #
1505 1505 # Because we can't rely on Mercurial to exit with a failure code
1506 1506 # when a merge fails (Mercurial issue #186), we must grep the
1507 1507 # output of pull/merge to check for attempted and/or failed merges.
1508 1508 #
1509 1509 # 3. If a merge failed, set the message and fail the bringover.
1510 1510 #
1511 1511 # 4. Otherwise, if a merge succeeded, set the message
1512 1512 #
1513 1513 # 5. Dump the output, and any message from step 3 or 4.
1514 1514 #
1515 1515
1516 1516 typeset HG_SOURCE=$BRINGOVER_WS
1517 1517 if [ ! -f $TMPDIR/new_repository ]; then
1518 1518 HG_SOURCE=$TMPDIR/open_bundle.hg
1519 1519 staffer hg --cwd $CODEMGR_WS incoming --bundle $HG_SOURCE \
1520 1520 -v $BRINGOVER_WS > $TMPDIR/incoming_open.out
1521 1521
1522 1522 #
1523 1523 # If there are no incoming changesets, then incoming will
1524 1524 # fail, and there will be no bundle file. Reset the source,
1525 1525 # to allow the remaining logic to complete with no false
1526 1526 # negatives. (Unlike incoming, pull will return success
1527 1527 # for the no-change case.)
1528 1528 #
1529 1529 if (( $? != 0 )); then
1530 1530 HG_SOURCE=$BRINGOVER_WS
1531 1531 fi
1532 1532 fi
1533 1533
1534 1534 staffer hg --cwd $CODEMGR_WS pull -u $HG_SOURCE \
1535 1535 > $TMPDIR/pull_open.out 2>&1
1536 1536 if (( $? != 0 )); then
1537 1537 printf "%s: pull failed as follows:\n\n" "$CODEMGR_WS"
1538 1538 cat $TMPDIR/pull_open.out
1539 1539 if grep "^merging.*failed" $TMPDIR/pull_open.out > /dev/null 2>&1; then
1540 1540 printf "$mergefailmsg"
1541 1541 fi
1542 1542 touch $TMPDIR/bringover_failed
1543 1543 return
1544 1544 fi
1545 1545
1546 1546 if grep "not updating" $TMPDIR/pull_open.out > /dev/null 2>&1; then
1547 1547 staffer hg --cwd $CODEMGR_WS merge \
1548 1548 >> $TMPDIR/pull_open.out 2>&1
1549 1549 if (( $? != 0 )); then
1550 1550 printf "%s: merge failed as follows:\n\n" \
1551 1551 "$CODEMGR_WS"
1552 1552 cat $TMPDIR/pull_open.out
1553 1553 if grep "^merging.*failed" $TMPDIR/pull_open.out \
1554 1554 > /dev/null 2>&1; then
1555 1555 printf "$mergefailmsg"
1556 1556 fi
1557 1557 touch $TMPDIR/bringover_failed
1558 1558 return
1559 1559 fi
1560 1560 fi
1561 1561
1562 1562 printf "updated %s with the following results:\n" "$CODEMGR_WS"
1563 1563 cat $TMPDIR/pull_open.out
1564 1564 if grep "^merging" $TMPDIR/pull_open.out >/dev/null 2>&1; then
1565 1565 printf "$mergepassmsg"
1566 1566 fi
1567 1567 printf "\n"
1568 1568
1569 1569 #
1570 1570 # Per-changeset output is neither useful nor manageable for a
1571 1571 # newly-created repository.
1572 1572 #
1573 1573 if [ -f $TMPDIR/new_repository ]; then
1574 1574 return
1575 1575 fi
1576 1576
1577 1577 printf "\nadded the following changesets to open repository:\n"
1578 1578 cat $TMPDIR/incoming_open.out
1579 1579 }
1580 1580
1581 1581 type bringover_none > /dev/null 2>&1 || function bringover_none {
1582 1582 echo "Couldn't figure out what kind of SCM to use for $BRINGOVER_WS."
1583 1583 touch $TMPDIR/bringover_failed
1584 1584 }
1585 1585
1586 1586 #
1587 1587 # Decide whether to bringover to the codemgr workspace
1588 1588 #
1589 1589 if [ "$n_FLAG" = "n" ]; then
1590 1590 PARENT_SCM_TYPE=$(parent_wstype)
1591 1591
1592 1592 if [[ $SCM_TYPE != none && $SCM_TYPE != $PARENT_SCM_TYPE ]]; then
1593 1593 echo "cannot bringover from $PARENT_SCM_TYPE to $SCM_TYPE, " \
1594 1594 "quitting at `date`." | tee -a $mail_msg_file >> $LOGFILE
1595 1595 exit 1
1596 1596 fi
1597 1597
1598 1598 run_hook PRE_BRINGOVER
1599 1599
1600 1600 echo "\n==== bringover to $CODEMGR_WS at `date` ====\n" >> $LOGFILE
1601 1601 echo "\n==== BRINGOVER LOG ====\n" >> $mail_msg_file
1602 1602
1603 1603 eval "bringover_${PARENT_SCM_TYPE}" 2>&1 |
1604 1604 tee -a $mail_msg_file >> $LOGFILE
1605 1605
1606 1606 if [ -f $TMPDIR/bringover_failed ]; then
1607 1607 rm -f $TMPDIR/bringover_failed
1608 1608 build_ok=n
1609 1609 echo "trouble with bringover, quitting at `date`." |
1610 1610 tee -a $mail_msg_file >> $LOGFILE
1611 1611 exit 1
1612 1612 fi
1613 1613
1614 1614 #
1615 1615 # It's possible that we used the bringover above to create
1616 1616 # $CODEMGR_WS. If so, then SCM_TYPE was previously "none,"
1617 1617 # but should now be the same as $BRINGOVER_WS.
1618 1618 #
1619 1619 [[ $SCM_TYPE = none ]] && SCM_TYPE=$PARENT_SCM_TYPE
1620 1620
1621 1621 run_hook POST_BRINGOVER
1622 1622
1623 1623 check_closed_bins
1624 1624
1625 1625 else
1626 1626 echo "\n==== No bringover to $CODEMGR_WS ====\n" >> $LOGFILE
1627 1627 fi
1628 1628
1629 1629 # Safeguards
1630 1630 [[ -v CODEMGR_WS ]] || fatal_error "Error: Variable CODEMGR_WS not set."
1631 1631 [[ -d "${CODEMGR_WS}" ]] || fatal_error "Error: ${CODEMGR_WS} is not a directory."
1632 1632 [[ -f "${CODEMGR_WS}/usr/src/Makefile" ]] || fatal_error "Error: ${CODEMGR_WS}/usr/src/Makefile not found."
1633 1633
1634 1634 if [[ "$t_FLAG" = "y" ]]; then
1635 1635 echo "\n==== Bootstrapping cw ====\n" >> $LOGFILE
1636 1636 ( cd ${TOOLS}
1637 1637 set_non_debug_build_flags
1638 1638 rm -f $TMPDIR/make-state
1639 1639 $MAKE -K $TMPDIR/make-state -e TARGET=install cw 2>&1 >> $LOGFILE
1640 1640 [[ "$?" -ne 0 ]] && fatal_error "Error: could not bootstrap cw"
1641 1641 )
1642 1642
1643 1643 # Switch ONBLD_TOOLS early if -t is specified so that
1644 1644 # we could use bootstrapped cw for compiler checks.
1645 1645 ONBLD_TOOLS=${TOOLS_PROTO}/opt/onbld
1646 1646 export ONBLD_TOOLS
1647 1647 fi
1648 1648
1649 1649 echo "\n==== Build environment ====\n" | tee -a $build_environ_file >> $LOGFILE
1650 1650
1651 1651 # System
1652 1652 whence uname | tee -a $build_environ_file >> $LOGFILE
1653 1653 uname -a 2>&1 | tee -a $build_environ_file >> $LOGFILE
1654 1654 echo | tee -a $build_environ_file >> $LOGFILE
1655 1655
1656 1656 # make
1657 1657 whence $MAKE | tee -a $build_environ_file >> $LOGFILE
1658 1658 $MAKE -v | tee -a $build_environ_file >> $LOGFILE
1659 1659 echo "number of concurrent jobs = $DMAKE_MAX_JOBS" |
1660 1660 tee -a $build_environ_file >> $LOGFILE
1661 1661
1662 1662 #
1663 1663 # Report the compiler versions.
1664 1664 #
1665 1665
1666 1666 if [[ ! -f $SRC/Makefile ]]; then
1667 1667 build_ok=n
1668 1668 echo "\nUnable to find \"Makefile\" in $SRC." | \
1669 1669 tee -a $build_environ_file >> $LOGFILE
1670 1670 exit 1
1671 1671 fi
1672 1672
1673 1673 ( cd $SRC
1674 1674 for target in cc-version java-version openssl-version; do
1675 1675 echo
1676 1676 #
1677 1677 # Put statefile somewhere we know we can write to rather than trip
1678 1678 # over a read-only $srcroot.
1679 1679 #
1680 1680 rm -f $TMPDIR/make-state
1681 1681 export SRC
1682 1682 if $MAKE -K $TMPDIR/make-state -e $target 2>/dev/null; then
1683 1683 continue
1684 1684 fi
1685 1685 touch $TMPDIR/nocompiler
1686 1686 done
1687 1687 echo
1688 1688 ) | tee -a $build_environ_file >> $LOGFILE
1689 1689
1690 1690 if [ -f $TMPDIR/nocompiler ]; then
1691 1691 rm -f $TMPDIR/nocompiler
1692 1692 build_ok=n
1693 1693 echo "Aborting due to missing compiler." |
1694 1694 tee -a $build_environ_file >> $LOGFILE
1695 1695 exit 1
1696 1696 fi
1697 1697
1698 1698 # as
1699 1699 whence as | tee -a $build_environ_file >> $LOGFILE
1700 1700 as -V 2>&1 | head -1 | tee -a $build_environ_file >> $LOGFILE
1701 1701 echo | tee -a $build_environ_file >> $LOGFILE
1702 1702
1703 1703 # Check that we're running a capable link-editor
1704 1704 whence ld | tee -a $build_environ_file >> $LOGFILE
1705 1705 LDVER=`ld -V 2>&1`
1706 1706 echo $LDVER | tee -a $build_environ_file >> $LOGFILE
1707 1707 LDVER=`echo $LDVER | sed -e "s/.*-1\.\([0-9]*\).*/\1/"`
1708 1708 if [ `expr $LDVER \< 422` -eq 1 ]; then
1709 1709 echo "The link-editor needs to be at version 422 or higher to build" | \
1710 1710 tee -a $build_environ_file >> $LOGFILE
1711 1711 echo "the latest stuff. Hope your build works." | \
1712 1712 tee -a $build_environ_file >> $LOGFILE
1713 1713 fi
1714 1714
1715 1715 #
1716 1716 # Build and use the workspace's tools if requested
1717 1717 #
1718 1718 if [[ "$t_FLAG" = "y" ]]; then
1719 1719 set_non_debug_build_flags
1720 1720
1721 1721 build_tools ${TOOLS_PROTO}
1722 1722 if (( $? != 0 )); then
1723 1723 build_ok=n
1724 1724 else
1725 1725 STABS=${TOOLS_PROTO}/opt/onbld/bin/${MACH}/stabs
1726 1726 export STABS
1727 1727 CTFSTABS=${TOOLS_PROTO}/opt/onbld/bin/${MACH}/ctfstabs
1728 1728 export CTFSTABS
1729 1729 GENOFFSETS=${TOOLS_PROTO}/opt/onbld/bin/genoffsets
1730 1730 export GENOFFSETS
1731 1731
1732 1732 CTFCONVERT=${TOOLS_PROTO}/opt/onbld/bin/${MACH}/ctfconvert
1733 1733 export CTFCONVERT
1734 1734 CTFMERGE=${TOOLS_PROTO}/opt/onbld/bin/${MACH}/ctfmerge
1735 1735 export CTFMERGE
1736 1736
1737 1737 PATH="${TOOLS_PROTO}/opt/onbld/bin/${MACH}:${PATH}"
1738 1738 PATH="${TOOLS_PROTO}/opt/onbld/bin:${PATH}"
1739 1739 export PATH
1740 1740
1741 1741 echo "\n==== New environment settings. ====\n" >> $LOGFILE
1742 1742 echo "STABS=${STABS}" >> $LOGFILE
1743 1743 echo "CTFSTABS=${CTFSTABS}" >> $LOGFILE
1744 1744 echo "CTFCONVERT=${CTFCONVERT}" >> $LOGFILE
1745 1745 echo "CTFMERGE=${CTFMERGE}" >> $LOGFILE
1746 1746 echo "PATH=${PATH}" >> $LOGFILE
1747 1747 echo "ONBLD_TOOLS=${ONBLD_TOOLS}" >> $LOGFILE
1748 1748 fi
1749 1749 fi
1750 1750
1751 1751 # timestamp the start of the normal build; the findunref tool uses it.
1752 1752 touch $SRC/.build.tstamp
1753 1753
1754 1754 normal_build
1755 1755
1756 1756 ORIG_SRC=$SRC
1757 1757 BINARCHIVE=${CODEMGR_WS}/bin-${MACH}.cpio.Z
1758 1758
1759 1759
1760 1760 #
1761 1761 # There are several checks that need to look at the proto area, but
1762 1762 # they only need to look at one, and they don't care whether it's
1763 1763 # DEBUG or non-DEBUG.
1764 1764 #
1765 1765 if [[ "$MULTI_PROTO" = yes && "$D_FLAG" = n ]]; then
1766 1766 checkroot=$ROOT-nd
1767 1767 else
1768 1768 checkroot=$ROOT
1769 1769 fi
1770 1770
1771 1771 if [ "$build_ok" = "y" ]; then
1772 1772 echo "\n==== Creating protolist system file at `date` ====" \
1773 1773 >> $LOGFILE
1774 1774 protolist $checkroot > $ATLOG/proto_list_${MACH}
1775 1775 echo "==== protolist system file created at `date` ====\n" \
1776 1776 >> $LOGFILE
1777 1777
1778 1778 if [ "$N_FLAG" != "y" ]; then
1779 1779
1780 1780 E1=
1781 1781 f1=
1782 1782 for f in $f1; do
1783 1783 if [ -f "$f" ]; then
1784 1784 E1="$E1 -e $f"
1785 1785 fi
1786 1786 done
1787 1787
1788 1788 E2=
1789 1789 f2=
1790 1790 if [ -d "$SRC/pkg" ]; then
1791 1791 f2="$f2 exceptions/packaging"
1792 1792 fi
1793 1793
1794 1794 for f in $f2; do
1795 1795 if [ -f "$f" ]; then
1796 1796 E2="$E2 -e $f"
1797 1797 fi
1798 1798 done
1799 1799 fi
1800 1800
1801 1801 if [ "$N_FLAG" != "y" -a -d $SRC/pkg ]; then
1802 1802 echo "\n==== Validating manifests against proto area ====\n" \
1803 1803 >> $mail_msg_file
1804 1804 ( cd $SRC/pkg ; $MAKE -e protocmp ROOT="$checkroot" ) | \
1805 1805 tee $TMPDIR/protocmp_noise >> $mail_msg_file
1806 1806 if [[ -s $TMPDIR/protocmp_noise ]]; then
1807 1807 build_extras_ok=n
1808 1808 fi
1809 1809 fi
1810 1810
1811 1811 if [ "$N_FLAG" != "y" -a -f "$REF_PROTO_LIST" ]; then
1812 1812 echo "\n==== Impact on proto area ====\n" >> $mail_msg_file
1813 1813 if [ -n "$E2" ]; then
1814 1814 ELIST=$E2
1815 1815 else
1816 1816 ELIST=$E1
1817 1817 fi
1818 1818 $PROTOCMPTERSE \
1819 1819 "Files in yesterday's proto area, but not today's:" \
1820 1820 "Files in today's proto area, but not yesterday's:" \
1821 1821 "Files that changed between yesterday and today:" \
1822 1822 ${ELIST} \
1823 1823 -d $REF_PROTO_LIST \
1824 1824 $ATLOG/proto_list_${MACH} \
1825 1825 >> $mail_msg_file
1826 1826 fi
1827 1827 fi
1828 1828
1829 1829 if [[ "$u_FLAG" == "y" && "$build_ok" == "y" && \
1830 1830 "$build_extras_ok" == "y" ]]; then
1831 1831 staffer cp $ATLOG/proto_list_${MACH} \
1832 1832 $PARENT_WS/usr/src/proto_list_${MACH}
1833 1833 fi
1834 1834
1835 1835 # Update parent proto area if necessary. This is done now
1836 1836 # so that the proto area has either DEBUG or non-DEBUG kernels.
1837 1837 # Note that this clears out the lock file, so we can dispense with
1838 1838 # the variable now.
1839 1839 if [ "$U_FLAG" = "y" -a "$build_ok" = "y" ]; then
1840 1840 echo "\n==== Copying proto area to $NIGHTLY_PARENT_ROOT ====\n" | \
1841 1841 tee -a $LOGFILE >> $mail_msg_file
1842 1842 rm -rf $NIGHTLY_PARENT_ROOT/*
1843 1843 unset Ulockfile
1844 1844 mkdir -p $NIGHTLY_PARENT_ROOT
1845 1845 if [[ "$MULTI_PROTO" = no || "$D_FLAG" = y ]]; then
1846 1846 ( cd $ROOT; tar cf - . |
1847 1847 ( cd $NIGHTLY_PARENT_ROOT; umask 0; tar xpf - ) ) 2>&1 |
1848 1848 tee -a $mail_msg_file >> $LOGFILE
1849 1849 fi
1850 1850 if [[ "$MULTI_PROTO" = yes && "$F_FLAG" = n ]]; then
1851 1851 rm -rf $NIGHTLY_PARENT_ROOT-nd/*
1852 1852 mkdir -p $NIGHTLY_PARENT_ROOT-nd
1853 1853 cd $ROOT-nd
1854 1854 ( tar cf - . |
1855 1855 ( cd $NIGHTLY_PARENT_ROOT-nd; umask 0; tar xpf - ) ) 2>&1 |
1856 1856 tee -a $mail_msg_file >> $LOGFILE
1857 1857 fi
1858 1858 if [ -n "${NIGHTLY_PARENT_TOOLS_ROOT}" ]; then
1859 1859 echo "\n==== Copying tools proto area to $NIGHTLY_PARENT_TOOLS_ROOT ====\n" | \
1860 1860 tee -a $LOGFILE >> $mail_msg_file
1861 1861 rm -rf $NIGHTLY_PARENT_TOOLS_ROOT/*
1862 1862 mkdir -p $NIGHTLY_PARENT_TOOLS_ROOT
1863 1863 if [[ "$MULTI_PROTO" = no || "$D_FLAG" = y ]]; then
1864 1864 ( cd $TOOLS_PROTO; tar cf - . |
1865 1865 ( cd $NIGHTLY_PARENT_TOOLS_ROOT;
1866 1866 umask 0; tar xpf - ) ) 2>&1 |
1867 1867 tee -a $mail_msg_file >> $LOGFILE
1868 1868 fi
1869 1869 fi
1870 1870 fi
1871 1871
1872 1872 #
1873 1873 # ELF verification: ABI (-A) and runtime (-r) checks
1874 1874 #
1875 1875 if [[ ($build_ok = y) && (($A_FLAG = y) || ($r_FLAG = y)) ]]; then
1876 1876 # Directory ELF-data.$MACH holds the files produced by these tests.
1877 1877 elf_ddir=$SRC/ELF-data.$MACH
1878 1878
1879 1879 # If there is a previous ELF-data backup directory, remove it. Then,
1880 1880 # rotate current ELF-data directory into its place and create a new
1881 1881 # empty directory
1882 1882 rm -rf $elf_ddir.ref
1883 1883 if [[ -d $elf_ddir ]]; then
1884 1884 mv $elf_ddir $elf_ddir.ref
1885 1885 fi
1886 1886 mkdir -p $elf_ddir
1887 1887
1888 1888 # Call find_elf to produce a list of the ELF objects in the proto area.
1889 1889 # This list is passed to check_rtime and interface_check, preventing
1890 1890 # them from separately calling find_elf to do the same work twice.
1891 1891 find_elf -fr $checkroot > $elf_ddir/object_list
1892 1892
1893 1893 if [[ $A_FLAG = y ]]; then
1894 1894 echo "\n==== Check versioning and ABI information ====\n" | \
1895 1895 tee -a $LOGFILE >> $mail_msg_file
1896 1896
1897 1897 # Produce interface description for the proto. Report errors.
1898 1898 interface_check -o -w $elf_ddir -f object_list \
1899 1899 -i interface -E interface.err
1900 1900 if [[ -s $elf_ddir/interface.err ]]; then
1901 1901 tee -a $LOGFILE < $elf_ddir/interface.err \
1902 1902 >> $mail_msg_file
1903 1903 build_extras_ok=n
1904 1904 fi
1905 1905
1906 1906 # If ELF_DATA_BASELINE_DIR is defined, compare the new interface
1907 1907 # description file to that from the baseline gate. Issue a
1908 1908 # warning if the baseline is not present, and keep going.
1909 1909 if [[ "$ELF_DATA_BASELINE_DIR" != '' ]]; then
1910 1910 base_ifile="$ELF_DATA_BASELINE_DIR/interface"
1911 1911
1912 1912 echo "\n==== Compare versioning and ABI information" \
1913 1913 "to baseline ====\n" | \
1914 1914 tee -a $LOGFILE >> $mail_msg_file
1915 1915 echo "Baseline: $base_ifile\n" >> $LOGFILE
1916 1916
1917 1917 if [[ -f $base_ifile ]]; then
1918 1918 interface_cmp -d -o $base_ifile \
1919 1919 $elf_ddir/interface > $elf_ddir/interface.cmp
1920 1920 if [[ -s $elf_ddir/interface.cmp ]]; then
1921 1921 echo | tee -a $LOGFILE >> $mail_msg_file
1922 1922 tee -a $LOGFILE < \
1923 1923 $elf_ddir/interface.cmp \
1924 1924 >> $mail_msg_file
1925 1925 build_extras_ok=n
1926 1926 fi
1927 1927 else
1928 1928 echo "baseline not available. comparison" \
1929 1929 "skipped" | \
1930 1930 tee -a $LOGFILE >> $mail_msg_file
1931 1931 fi
1932 1932
1933 1933 fi
1934 1934 fi
1935 1935
1936 1936 if [[ $r_FLAG = y ]]; then
1937 1937 echo "\n==== Check ELF runtime attributes ====\n" | \
1938 1938 tee -a $LOGFILE >> $mail_msg_file
1939 1939
1940 1940 # If we're doing a DEBUG build the proto area will be left
1941 1941 # with debuggable objects, thus don't assert -s.
1942 1942 if [[ $D_FLAG = y ]]; then
1943 1943 rtime_sflag=""
1944 1944 else
1945 1945 rtime_sflag="-s"
1946 1946 fi
1947 1947 check_rtime -i -m -v $rtime_sflag -o -w $elf_ddir \
1948 1948 -D object_list -f object_list -E runtime.err \
1949 1949 -I runtime.attr.raw
1950 1950 if (( $? != 0 )); then
1951 1951 build_extras_ok=n
1952 1952 fi
1953 1953
1954 1954 # check_rtime -I output needs to be sorted in order to
1955 1955 # compare it to that from previous builds.
1956 1956 sort $elf_ddir/runtime.attr.raw > $elf_ddir/runtime.attr
1957 1957 rm $elf_ddir/runtime.attr.raw
1958 1958
1959 1959 # Report errors
1960 1960 if [[ -s $elf_ddir/runtime.err ]]; then
1961 1961 tee -a $LOGFILE < $elf_ddir/runtime.err \
1962 1962 >> $mail_msg_file
1963 1963 build_extras_ok=n
1964 1964 fi
1965 1965
1966 1966 # If there is an ELF-data directory from a previous build,
1967 1967 # then diff the attr files. These files contain information
1968 1968 # about dependencies, versioning, and runpaths. There is some
1969 1969 # overlap with the ABI checking done above, but this also
1970 1970 # flushes out non-ABI interface differences along with the
1971 1971 # other information.
1972 1972 echo "\n==== Diff ELF runtime attributes" \
1973 1973 "(since last build) ====\n" | \
1974 1974 tee -a $LOGFILE >> $mail_msg_file >> $mail_msg_file
1975 1975
1976 1976 if [[ -f $elf_ddir.ref/runtime.attr ]]; then
1977 1977 diff $elf_ddir.ref/runtime.attr \
1978 1978 $elf_ddir/runtime.attr \
1979 1979 >> $mail_msg_file
1980 1980 fi
1981 1981 fi
1982 1982
1983 1983 # If -u set, copy contents of ELF-data.$MACH to the parent workspace.
1984 1984 if [[ "$u_FLAG" = "y" ]]; then
1985 1985 p_elf_ddir=$PARENT_WS/usr/src/ELF-data.$MACH
1986 1986
1987 1987 # If parent lacks the ELF-data.$MACH directory, create it
1988 1988 if [[ ! -d $p_elf_ddir ]]; then
1989 1989 staffer mkdir -p $p_elf_ddir
1990 1990 fi
1991 1991
1992 1992 # These files are used asynchronously by other builds for ABI
1993 1993 # verification, as above for the -A option. As such, we require
1994 1994 # the file replacement to be atomic. Copy the data to a temp
1995 1995 # file in the same filesystem and then rename into place.
1996 1996 (
1997 1997 cd $elf_ddir
1998 1998 for elf_dfile in *; do
1999 1999 staffer cp $elf_dfile \
2000 2000 ${p_elf_ddir}/${elf_dfile}.new
2001 2001 staffer mv -f ${p_elf_ddir}/${elf_dfile}.new \
2002 2002 ${p_elf_ddir}/${elf_dfile}
2003 2003 done
2004 2004 )
2005 2005 fi
2006 2006 fi
2007 2007
2008 2008 # DEBUG lint of kernel begins
2009 2009
2010 2010 if [ "$i_CMD_LINE_FLAG" = "n" -a "$l_FLAG" = "y" ]; then
2011 2011 if [ "$LINTDIRS" = "" ]; then
2012 2012 # LINTDIRS="$SRC/uts y $SRC/stand y $SRC/psm y"
2013 2013 LINTDIRS="$SRC y"
2014 2014 fi
2015 2015 set $LINTDIRS
2016 2016 while [ $# -gt 0 ]; do
2017 2017 dolint $1 $2; shift; shift
2018 2018 done
2019 2019 else
2020 2020 echo "\n==== No '$MAKE lint' ====\n" >> $LOGFILE
2021 2021 fi
2022 2022
2023 2023 # "make check" begins
2024 2024
2025 2025 if [ "$i_CMD_LINE_FLAG" = "n" -a "$C_FLAG" = "y" ]; then
2026 2026 # remove old check.out
2027 2027 rm -f $SRC/check.out
2028 2028
2029 2029 rm -f $SRC/check-${MACH}.out
2030 2030 cd $SRC
2031 2031 $MAKE -ek check ROOT="$checkroot" 2>&1 | tee -a $SRC/check-${MACH}.out \
2032 2032 >> $LOGFILE
2033 2033 echo "\n==== cstyle/hdrchk errors ====\n" >> $mail_msg_file
2034 2034
2035 2035 grep ":" $SRC/check-${MACH}.out |
2036 2036 egrep -v "Ignoring unknown host" | \
2037 2037 sort | uniq | tee $TMPDIR/check_errors >> $mail_msg_file
2038 2038
2039 2039 if [[ -s $TMPDIR/check_errors ]]; then
2040 2040 build_extras_ok=n
2041 2041 fi
2042 2042 else
2043 2043 echo "\n==== No '$MAKE check' ====\n" >> $LOGFILE
2044 2044 fi
2045 2045
2046 2046 echo "\n==== Find core files ====\n" | \
2047 2047 tee -a $LOGFILE >> $mail_msg_file
2048 2048
2049 2049 find $abssrcdirs -name core -a -type f -exec file {} \; | \
2050 2050 tee -a $LOGFILE >> $mail_msg_file
2051 2051
2052 2052 if [ "$f_FLAG" = "y" -a "$build_ok" = "y" ]; then
2053 2053 echo "\n==== Diff unreferenced files (since last build) ====\n" \
2054 2054 | tee -a $LOGFILE >>$mail_msg_file
2055 2055 rm -f $SRC/unref-${MACH}.ref
2056 2056 if [ -f $SRC/unref-${MACH}.out ]; then
2057 2057 mv $SRC/unref-${MACH}.out $SRC/unref-${MACH}.ref
2058 2058 fi
2059 2059
2060 2060 findunref -S $SCM_TYPE -t $SRC/.build.tstamp -s usr $CODEMGR_WS \
2061 2061 ${TOOLS}/findunref/exception_list 2>> $mail_msg_file | \
2062 2062 sort > $SRC/unref-${MACH}.out
2063 2063
2064 2064 if [ ! -f $SRC/unref-${MACH}.ref ]; then
2065 2065 cp $SRC/unref-${MACH}.out $SRC/unref-${MACH}.ref
2066 2066 fi
2067 2067
2068 2068 diff $SRC/unref-${MACH}.ref $SRC/unref-${MACH}.out >>$mail_msg_file
2069 2069 fi
2070 2070
2071 2071 # Verify that the usual lists of files, such as exception lists,
2072 2072 # contain only valid references to files. If the build has failed,
2073 2073 # then don't check the proto area.
2074 2074 CHECK_PATHS=${CHECK_PATHS:-y}
2075 2075 if [ "$CHECK_PATHS" = y -a "$N_FLAG" != y ]; then
2076 2076 echo "\n==== Check lists of files ====\n" | tee -a $LOGFILE \
2077 2077 >>$mail_msg_file
2078 2078 arg=-b
2079 2079 [ "$build_ok" = y ] && arg=
2080 2080 checkpaths $arg $checkroot > $SRC/check-paths.out 2>&1
2081 2081 if [[ -s $SRC/check-paths.out ]]; then
2082 2082 tee -a $LOGFILE < $SRC/check-paths.out >> $mail_msg_file
2083 2083 build_extras_ok=n
2084 2084 fi
2085 2085 fi
2086 2086
2087 2087 if [ "$M_FLAG" != "y" -a "$build_ok" = y ]; then
2088 2088 echo "\n==== Impact on file permissions ====\n" \
2089 2089 >> $mail_msg_file
2090 2090
2091 2091 abspkg=
2092 2092 for d in $abssrcdirs; do
2093 2093 if [ -d "$d/pkg" ]; then
2094 2094 abspkg="$abspkg $d"
2095 2095 fi
2096 2096 done
2097 2097
2098 2098 if [ -n "$abspkg" ]; then
2099 2099 for d in "$abspkg"; do
2100 2100 ( cd $d/pkg ; $MAKE -e pmodes ) >> $mail_msg_file
2101 2101 done
2102 2102 fi
2103 2103 fi
2104 2104
2105 2105 if [ "$w_FLAG" = "y" -a "$build_ok" = "y" ]; then
2106 2106 if [[ "$MULTI_PROTO" = no || "$D_FLAG" = y ]]; then
2107 2107 do_wsdiff DEBUG $ROOT.prev $ROOT
2108 2108 fi
2109 2109
2110 2110 if [[ "$MULTI_PROTO" = yes && "$F_FLAG" = n ]]; then
2111 2111 do_wsdiff non-DEBUG $ROOT-nd.prev $ROOT-nd
2112 2112 fi
2113 2113 fi
2114 2114
2115 2115 END_DATE=`date`
2116 2116 echo "==== Nightly $maketype build completed: $END_DATE ====" | \
2117 2117 tee -a $LOGFILE >> $build_time_file
2118 2118
2119 2119 typeset -i10 hours
2120 2120 typeset -Z2 minutes
2121 2121 typeset -Z2 seconds
2122 2122
2123 2123 elapsed_time=$SECONDS
2124 2124 ((hours = elapsed_time / 3600 ))
2125 2125 ((minutes = elapsed_time / 60 % 60))
2126 2126 ((seconds = elapsed_time % 60))
2127 2127
2128 2128 echo "\n==== Total build time ====" | \
2129 2129 tee -a $LOGFILE >> $build_time_file
2130 2130 echo "\nreal ${hours}:${minutes}:${seconds}" | \
2131 2131 tee -a $LOGFILE >> $build_time_file
2132 2132
2133 2133 if [ "$u_FLAG" = "y" -a "$f_FLAG" = "y" -a "$build_ok" = "y" ]; then
2134 2134 staffer cp ${SRC}/unref-${MACH}.out $PARENT_WS/usr/src/
2135 2135
2136 2136 #
2137 2137 # Produce a master list of unreferenced files -- ideally, we'd
2138 2138 # generate the master just once after all of the nightlies
2139 2139 # have finished, but there's no simple way to know when that
2140 2140 # will be. Instead, we assume that we're the last nightly to
2141 2141 # finish and merge all of the unref-${MACH}.out files in
2142 2142 # $PARENT_WS/usr/src/. If we are in fact the final ${MACH} to
2143 2143 # finish, then this file will be the authoritative master
2144 2144 # list. Otherwise, another ${MACH}'s nightly will eventually
2145 2145 # overwrite ours with its own master, but in the meantime our
2146 2146 # temporary "master" will be no worse than any older master
2147 2147 # which was already on the parent.
2148 2148 #
2149 2149
2150 2150 set -- $PARENT_WS/usr/src/unref-*.out
2151 2151 cp "$1" ${TMPDIR}/unref.merge
2152 2152 shift
2153 2153
2154 2154 for unreffile; do
2155 2155 comm -12 ${TMPDIR}/unref.merge "$unreffile" > ${TMPDIR}/unref.$$
2156 2156 mv ${TMPDIR}/unref.$$ ${TMPDIR}/unref.merge
2157 2157 done
2158 2158
2159 2159 staffer cp ${TMPDIR}/unref.merge $PARENT_WS/usr/src/unrefmaster.out
2160 2160 fi
2161 2161
2162 2162 #
2163 2163 # All done save for the sweeping up.
2164 2164 # (whichever exit we hit here will trigger the "cleanup" trap which
2165 2165 # optionally sends mail on completion).
2166 2166 #
2167 2167 if [[ "$build_ok" == "y" ]]; then
2168 2168 if [[ "$W_FLAG" == "y" || "$build_extras_ok" == "y" ]]; then
2169 2169 exit 0
2170 2170 fi
2171 2171 fi
2172 2172
2173 2173 exit 1
|
↓ open down ↓ |
1942 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX