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