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