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