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