Print this page
NEX-9559 remove nza-closed cruft
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Reviewed by: Steve Peng <steve.peng@nexenta.com>
5773 Extra pointless steps in kernel module builds
Reviewed by: Dan McDonald <danmcd@omniti.com>
Reviewed by: Josef Sipek <jeffpc@josefsipek.net>
Reviewed by: Rich Lowe <richlowe@richlowe.net>
Reviewed by: Robert Mustacchi <rm@joyent.com>
Approved by: Rich Lowe <richlowe@richlowe.net>
NEX-1149 add debug tag to uname output on debug builds
OS-41 Support building with Jenkins
re #13825 backport illumos 3298 (link-editor version)
3298 illumos link-editor and related tools should be differentiable
Reviewed by: Joshua M. Clulow <josh@sysmgr.org>
Reviewed by: Dan McDonald <danmcd@nexenta.com>
Approved by: Garrett D'Amore <garrett@damore.org>
re #8813 rb3805 Failed to set DHCP on bnx0 network interface
8226 nza-kernel needs to be buildable by itself
Re #6790 backspace should perform delete on console
VAAI (XXX ATS support for COMSTAR, YYY Block-copy support for COMSTAR)
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/tools/scripts/nightly.sh
+++ new/usr/src/tools/scripts/nightly.sh
1 1 #!/bin/ksh -p
2 2 #
3 3 # CDDL HEADER START
4 4 #
5 5 # The contents of this file are subject to the terms of the
6 6 # Common Development and Distribution License (the "License").
7 7 # You may not use this file except in compliance with the License.
8 8 #
9 9 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 10 # or http://www.opensolaris.org/os/licensing.
11 11 # See the License for the specific language governing permissions
12 12 # and limitations under the License.
13 13 #
14 14 # When distributing Covered Code, include this CDDL HEADER in each
15 15 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
16 16 # If applicable, add the following below this CDDL HEADER, with the
17 17 # fields enclosed by brackets "[]" replaced with your own identifying
18 18 # information: Portions Copyright [yyyy] [name of copyright owner]
19 19 #
20 20 # CDDL HEADER END
21 21 #
22 22
23 23 #
24 24 # Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
25 25 # Copyright 2008, 2010, Richard Lowe
26 -# Copyright 2011 Nexenta Systems, Inc. All rights reserved.
27 26 # Copyright 2012 Joshua M. Clulow <josh@sysmgr.org>
27 +# Copyright 2014 Nexenta Systems, Inc. All rights reserved.
28 28 # Copyright (c) 2017 by Delphix. All rights reserved.
29 29 #
30 30 # Based on the nightly script from the integration folks,
31 31 # Mostly modified and owned by mike_s.
32 32 # Changes also by kjc, dmk.
33 33 #
34 34 # BRINGOVER_WS may be specified in the env file.
35 35 # The default is the old behavior of CLONE_WS
36 36 #
37 37 # -i on the command line, means fast options, so when it's on the
38 38 # command line (only), lint and check builds are skipped no matter what
39 39 # the setting of their individual flags are in NIGHTLY_OPTIONS.
40 40 #
41 41 # LINTDIRS can be set in the env file, format is a list of:
42 42 #
43 43 # /dirname-to-run-lint-on flag
44 44 #
45 45 # Where flag is: y - enable lint noise diff output
46 46 # n - disable lint noise diff output
47 47 #
48 48 # For example: LINTDIRS="$SRC/uts n $SRC/stand y $SRC/psm y"
49 49 #
50 50 # OPTHOME may be set in the environment to override /opt
51 51 #
52 52
53 53 #
54 54 # The CDPATH variable causes ksh's `cd' builtin to emit messages to stdout
55 55 # under certain circumstances, which can really screw things up; unset it.
56 56 #
57 57 unset CDPATH
58 58
59 59 # Get the absolute path of the nightly script that the user invoked. This
60 60 # may be a relative path, and we need to do this before changing directory.
61 61 nightly_path=`whence $0`
62 62
63 63 #
64 64 # Keep track of where we found nightly so we can invoke the matching
65 65 # which_scm script. If that doesn't work, don't go guessing, just rely
66 66 # on the $PATH settings, which will generally give us either /opt/onbld
67 67 # or the user's workspace.
68 68 #
69 69 WHICH_SCM=$(dirname $nightly_path)/which_scm
70 70 if [[ ! -x $WHICH_SCM ]]; then
71 71 WHICH_SCM=which_scm
72 72 fi
73 73
74 74 function fatal_error
75 75 {
76 76 print -u2 "nightly: $*"
77 77 exit 1
78 78 }
79 79
80 80 #
81 81 # Function to do a DEBUG and non-DEBUG build. Needed because we might
82 82 # need to do another for the source build, and since we only deliver DEBUG or
83 83 # non-DEBUG packages.
84 84 #
85 85 # usage: normal_build
86 86 #
87 87 function normal_build {
88 88
89 89 typeset orig_p_FLAG="$p_FLAG"
90 90 typeset crypto_signer="$CODESIGN_USER"
91 91
92 92 suffix=""
93 93
94 94 # non-DEBUG build begins
95 95
96 96 if [ "$F_FLAG" = "n" ]; then
97 97 set_non_debug_build_flags
98 98 CODESIGN_USER="$crypto_signer" \
|
↓ open down ↓ |
61 lines elided |
↑ open up ↑ |
99 99 build "non-DEBUG" "$suffix-nd" "-nd" "$MULTI_PROTO"
100 100 else
101 101 echo "\n==== No non-DEBUG $open_only build ====\n" >> "$LOGFILE"
102 102 fi
103 103
104 104 # non-DEBUG build ends
105 105
106 106 # DEBUG build begins
107 107
108 108 if [ "$D_FLAG" = "y" ]; then
109 + VERSION=$VERSION":debug"
109 110 set_debug_build_flags
110 111 CODESIGN_USER="$crypto_signer" \
111 112 build "DEBUG" "$suffix" "" "$MULTI_PROTO"
112 113 else
113 114 echo "\n==== No DEBUG $open_only build ====\n" >> "$LOGFILE"
114 115 fi
115 116
116 117 # DEBUG build ends
117 118
118 119 p_FLAG="$orig_p_FLAG"
119 120 }
120 121
121 122 #
122 123 # usage: run_hook HOOKNAME ARGS...
123 124 #
124 125 # If variable "$HOOKNAME" is defined, insert a section header into
125 126 # our logs and then run the command with ARGS
126 127 #
127 128 function run_hook {
128 129 HOOKNAME=$1
129 130 eval HOOKCMD=\$$HOOKNAME
130 131 shift
131 132
132 133 if [ -n "$HOOKCMD" ]; then
133 134 (
134 135 echo "\n==== Running $HOOKNAME command: $HOOKCMD ====\n"
135 136 ( $HOOKCMD "$@" 2>&1 )
136 137 if [ "$?" -ne 0 ]; then
137 138 # Let exit status propagate up
138 139 touch $TMPDIR/abort
139 140 fi
140 141 ) | tee -a $mail_msg_file >> $LOGFILE
141 142
142 143 if [ -f $TMPDIR/abort ]; then
143 144 build_ok=n
144 145 echo "\nAborting at request of $HOOKNAME" |
145 146 tee -a $mail_msg_file >> $LOGFILE
146 147 exit 1
147 148 fi
148 149 fi
149 150 }
150 151
151 152 # Return library search directive as function of given root.
152 153 function myldlibs {
153 154 echo "-L$1/lib -L$1/usr/lib"
154 155 }
155 156
156 157 # Return header search directive as function of given root.
157 158 function myheaders {
158 159 echo "-I$1/usr/include"
159 160 }
160 161
161 162 #
162 163 # Function to do the build, including package generation.
163 164 # usage: build LABEL SUFFIX ND MULTIPROTO
164 165 # - LABEL is used to tag build output.
165 166 # - SUFFIX is used to distinguish files (e.g., DEBUG vs non-DEBUG,
166 167 # open-only vs full tree).
167 168 # - ND is "-nd" (non-DEBUG builds) or "" (DEBUG builds).
168 169 # - If MULTIPROTO is "yes", it means to name the proto area according to
169 170 # SUFFIX. Otherwise ("no"), (re)use the standard proto area.
170 171 #
171 172 function build {
172 173 LABEL=$1
173 174 SUFFIX=$2
174 175 ND=$3
175 176 MULTIPROTO=$4
176 177 INSTALLOG=install${SUFFIX}-${MACH}
177 178 NOISE=noise${SUFFIX}-${MACH}
178 179 PKGARCHIVE=${PKGARCHIVE_ORIG}${SUFFIX}
179 180
180 181 ORIGROOT=$ROOT
181 182 [ $MULTIPROTO = no ] || export ROOT=$ROOT$SUFFIX
182 183
183 184 export ENVLDLIBS1=`myldlibs $ROOT`
184 185 export ENVCPPFLAGS1=`myheaders $ROOT`
185 186
186 187 this_build_ok=y
187 188 #
188 189 # Build OS-Networking source
189 190 #
190 191 echo "\n==== Building OS-Net source at `date` ($LABEL) ====\n" \
191 192 >> $LOGFILE
192 193
193 194 rm -f $SRC/${INSTALLOG}.out
194 195 cd $SRC
195 196 /bin/time $MAKE -e install 2>&1 | \
196 197 tee -a $SRC/${INSTALLOG}.out >> $LOGFILE
197 198
198 199 echo "\n==== Build errors ($LABEL) ====\n" >> $mail_msg_file
199 200 egrep ":" $SRC/${INSTALLOG}.out |
200 201 egrep -e "(^${MAKE}:|[ ]error[: \n])" | \
201 202 egrep -v "Ignoring unknown host" | \
202 203 egrep -v "cc .* -o error " | \
203 204 egrep -v "warning" | tee $TMPDIR/build_errs${SUFFIX} \
204 205 >> $mail_msg_file
205 206 sed -n "/^Undefined[ ]*first referenced$/,/^ld: fatal:/p" \
206 207 < $SRC/${INSTALLOG}.out >> $mail_msg_file
207 208 if [[ -s $TMPDIR/build_errs${SUFFIX} ]]; then
208 209 build_ok=n
209 210 this_build_ok=n
210 211 fi
211 212 grep "bootblock image is .* bytes too big" $SRC/${INSTALLOG}.out \
212 213 >> $mail_msg_file
213 214 if [ "$?" = "0" ]; then
214 215 build_ok=n
215 216 this_build_ok=n
216 217 fi
217 218
218 219 echo "\n==== Build warnings ($LABEL) ====\n" >>$mail_msg_file
219 220 egrep -i warning: $SRC/${INSTALLOG}.out \
220 221 | egrep -v '^tic:' \
221 222 | egrep -v "symbol (\`|')timezone' has differing types:" \
222 223 | egrep -v "parameter <PSTAMP> set to" \
223 224 | egrep -v "Ignoring unknown host" \
224 225 | egrep -v "redefining segment flags attribute for" \
225 226 | tee $TMPDIR/build_warnings${SUFFIX} >> $mail_msg_file
226 227 if [[ -s $TMPDIR/build_warnings${SUFFIX} ]]; then
227 228 build_ok=n
228 229 this_build_ok=n
229 230 fi
230 231
231 232 echo "\n==== Ended OS-Net source build at `date` ($LABEL) ====\n" \
232 233 >> $LOGFILE
233 234
234 235 echo "\n==== Elapsed build time ($LABEL) ====\n" >>$mail_msg_file
235 236 tail -3 $SRC/${INSTALLOG}.out >>$mail_msg_file
236 237
237 238 if [ "$i_FLAG" = "n" ]; then
238 239 rm -f $SRC/${NOISE}.ref
239 240 if [ -f $SRC/${NOISE}.out ]; then
240 241 mv $SRC/${NOISE}.out $SRC/${NOISE}.ref
241 242 fi
242 243 grep : $SRC/${INSTALLOG}.out \
243 244 | egrep -v '^/' \
244 245 | egrep -v '^(Start|Finish|real|user|sys|./bld_awk)' \
245 246 | egrep -v '^tic:' \
246 247 | egrep -v '^mcs' \
247 248 | egrep -v '^LD_LIBRARY_PATH=' \
248 249 | egrep -v 'ar: creating' \
249 250 | egrep -v 'ar: writing' \
250 251 | egrep -v 'conflicts:' \
251 252 | egrep -v ':saved created' \
252 253 | egrep -v '^stty.*c:' \
253 254 | egrep -v '^mfgname.c:' \
254 255 | egrep -v '^uname-i.c:' \
255 256 | egrep -v '^volumes.c:' \
256 257 | egrep -v '^lint library construction:' \
257 258 | egrep -v 'tsort: INFORM:' \
258 259 | egrep -v 'stripalign:' \
259 260 | egrep -v 'chars, width' \
260 261 | egrep -v "symbol (\`|')timezone' has differing types:" \
261 262 | egrep -v 'PSTAMP' \
262 263 | egrep -v '^Manifying' \
263 264 | egrep -v 'Ignoring unknown host' \
264 265 | egrep -v 'Processing method:' \
265 266 | egrep -v '^Writing' \
266 267 | egrep -v 'spellin1:' \
267 268 | egrep -v '^adding:' \
268 269 | egrep -v "^echo 'msgid" \
269 270 | egrep -v '^echo ' \
270 271 | egrep -v '\.c:$' \
271 272 | egrep -v '^Adding file:' \
272 273 | egrep -v 'CLASSPATH=' \
273 274 | egrep -v '\/var\/mail\/:saved' \
274 275 | egrep -v -- '-DUTS_VERSION=' \
275 276 | egrep -v '^Running Mkbootstrap' \
276 277 | egrep -v '^Applet length read:' \
277 278 | egrep -v 'bytes written:' \
278 279 | egrep -v '^File:SolarisAuthApplet.bin' \
279 280 | egrep -v -i 'jibversion' \
280 281 | egrep -v '^Output size:' \
281 282 | egrep -v '^Solo size statistics:' \
282 283 | egrep -v '^Using ROM API Version' \
283 284 | egrep -v '^Zero Signature length:' \
284 285 | egrep -v '^Note \(probably harmless\):' \
285 286 | egrep -v '::' \
286 287 | egrep -v -- '-xcache' \
287 288 | egrep -v '^\+' \
288 289 | egrep -v '^cc1: note: -fwritable-strings' \
289 290 | egrep -v 'svccfg-native -s svc:/' \
290 291 | sort | uniq >$SRC/${NOISE}.out
291 292 if [ ! -f $SRC/${NOISE}.ref ]; then
292 293 cp $SRC/${NOISE}.out $SRC/${NOISE}.ref
293 294 fi
294 295 echo "\n==== Build noise differences ($LABEL) ====\n" \
295 296 >>$mail_msg_file
296 297 diff $SRC/${NOISE}.ref $SRC/${NOISE}.out >>$mail_msg_file
297 298 fi
298 299
299 300 #
300 301 # Re-sign selected binaries using signing server
301 302 # (gatekeeper builds only)
302 303 #
303 304 if [ -n "$CODESIGN_USER" -a "$this_build_ok" = "y" ]; then
304 305 echo "\n==== Signing proto area at `date` ====\n" >> $LOGFILE
305 306 signing_file="${TMPDIR}/signing"
306 307 rm -f ${signing_file}
307 308 export CODESIGN_USER
308 309 signproto $SRC/tools/codesign/creds 2>&1 | \
309 310 tee -a ${signing_file} >> $LOGFILE
310 311 echo "\n==== Finished signing proto area at `date` ====\n" \
311 312 >> $LOGFILE
312 313 echo "\n==== Crypto module signing errors ($LABEL) ====\n" \
313 314 >> $mail_msg_file
314 315 egrep 'WARNING|ERROR' ${signing_file} >> $mail_msg_file
315 316 if (( $? == 0 )) ; then
316 317 build_ok=n
317 318 this_build_ok=n
318 319 fi
319 320 fi
320 321
321 322 #
322 323 # Building Packages
323 324 #
324 325 if [ "$p_FLAG" = "y" -a "$this_build_ok" = "y" ]; then
325 326 if [ -d $SRC/pkg ]; then
326 327 echo "\n==== Creating $LABEL packages at `date` ====\n" \
327 328 >> $LOGFILE
328 329 echo "Clearing out $PKGARCHIVE ..." >> $LOGFILE
329 330 rm -rf $PKGARCHIVE >> "$LOGFILE" 2>&1
330 331 mkdir -p $PKGARCHIVE >> "$LOGFILE" 2>&1
331 332
332 333 rm -f $SRC/pkg/${INSTALLOG}.out
333 334 cd $SRC/pkg
334 335 /bin/time $MAKE -e install 2>&1 | \
335 336 tee -a $SRC/pkg/${INSTALLOG}.out >> $LOGFILE
336 337
337 338 echo "\n==== package build errors ($LABEL) ====\n" \
338 339 >> $mail_msg_file
339 340
340 341 egrep "${MAKE}|ERROR|WARNING" $SRC/pkg/${INSTALLOG}.out | \
341 342 grep ':' | \
342 343 grep -v PSTAMP | \
343 344 egrep -v "Ignoring unknown host" | \
344 345 tee $TMPDIR/package >> $mail_msg_file
345 346 if [[ -s $TMPDIR/package ]]; then
346 347 build_extras_ok=n
347 348 this_build_ok=n
348 349 fi
349 350 else
350 351 #
351 352 # Handle it gracefully if -p was set but there so
352 353 # no pkg directory.
353 354 #
354 355 echo "\n==== No $LABEL packages to build ====\n" \
355 356 >> $LOGFILE
356 357 fi
357 358 else
358 359 echo "\n==== Not creating $LABEL packages ====\n" >> $LOGFILE
359 360 fi
360 361
361 362 ROOT=$ORIGROOT
362 363 }
363 364
364 365 # Usage: dolint /dir y|n
365 366 # Arg. 2 is a flag to turn on/off the lint diff output
366 367 function dolint {
367 368 if [ ! -d "$1" ]; then
368 369 echo "dolint error: $1 is not a directory"
369 370 exit 1
370 371 fi
371 372
372 373 if [ "$2" != "y" -a "$2" != "n" ]; then
373 374 echo "dolint internal error: $2 should be 'y' or 'n'"
374 375 exit 1
375 376 fi
376 377
377 378 lintdir=$1
378 379 dodiff=$2
379 380 base=`basename $lintdir`
380 381 LINTOUT=$lintdir/lint-${MACH}.out
381 382 LINTNOISE=$lintdir/lint-noise-${MACH}
382 383 export ENVLDLIBS1=`myldlibs $ROOT`
383 384 export ENVCPPFLAGS1=`myheaders $ROOT`
384 385
385 386 set_debug_build_flags
386 387
387 388 #
388 389 # '$MAKE lint' in $lintdir
389 390 #
390 391 echo "\n==== Begin '$MAKE lint' of $base at `date` ====\n" >> $LOGFILE
391 392
392 393 # remove old lint.out
393 394 rm -f $lintdir/lint.out $lintdir/lint-noise.out
394 395 if [ -f $lintdir/lint-noise.ref ]; then
395 396 mv $lintdir/lint-noise.ref ${LINTNOISE}.ref
396 397 fi
397 398
398 399 rm -f $LINTOUT
399 400 cd $lintdir
400 401 #
401 402 # Remove all .ln files to ensure a full reference file
402 403 #
403 404 rm -f Nothing_to_remove \
404 405 `find . \( -name SCCS -o -name .hg -o -name .svn -o -name .git \) \
405 406 -prune -o -type f -name '*.ln' -print `
406 407
407 408 /bin/time $MAKE -ek lint 2>&1 | \
408 409 tee -a $LINTOUT >> $LOGFILE
409 410
410 411 echo "\n==== '$MAKE lint' of $base ERRORS ====\n" >> $mail_msg_file
411 412
412 413 grep "$MAKE:" $LINTOUT |
413 414 egrep -v "Ignoring unknown host" | \
414 415 tee $TMPDIR/lint_errs >> $mail_msg_file
415 416 if [[ -s $TMPDIR/lint_errs ]]; then
416 417 build_extras_ok=n
417 418 fi
418 419
419 420 echo "\n==== Ended '$MAKE lint' of $base at `date` ====\n" >> $LOGFILE
420 421
421 422 echo "\n==== Elapsed time of '$MAKE lint' of $base ====\n" \
422 423 >>$mail_msg_file
423 424 tail -3 $LINTOUT >>$mail_msg_file
424 425
425 426 rm -f ${LINTNOISE}.ref
426 427 if [ -f ${LINTNOISE}.out ]; then
427 428 mv ${LINTNOISE}.out ${LINTNOISE}.ref
428 429 fi
429 430 grep : $LINTOUT | \
430 431 egrep -v '^(real|user|sys)' |
431 432 egrep -v '(library construction)' | \
432 433 egrep -v ': global crosschecks' | \
433 434 egrep -v 'Ignoring unknown host' | \
434 435 egrep -v '\.c:$' | \
435 436 sort | uniq > ${LINTNOISE}.out
436 437 if [ ! -f ${LINTNOISE}.ref ]; then
437 438 cp ${LINTNOISE}.out ${LINTNOISE}.ref
438 439 fi
439 440
440 441 if [ "$dodiff" != "n" ]; then
441 442 echo "\n==== lint warnings $base ====\n" \
442 443 >>$mail_msg_file
443 444 # should be none, though there are a few that were filtered out
444 445 # above
445 446 egrep -i '(warning|lint):' ${LINTNOISE}.out \
446 447 | sort | uniq | tee $TMPDIR/lint_warns >> $mail_msg_file
447 448 if [[ -s $TMPDIR/lint_warns ]]; then
448 449 build_extras_ok=n
449 450 fi
450 451 echo "\n==== lint noise differences $base ====\n" \
451 452 >> $mail_msg_file
452 453 diff ${LINTNOISE}.ref ${LINTNOISE}.out \
453 454 >> $mail_msg_file
454 455 fi
455 456 }
456 457
457 458 #
458 459 # Build and install the onbld tools.
459 460 #
460 461 # usage: build_tools DESTROOT
461 462 #
462 463 # returns non-zero status if the build was successful.
463 464 #
464 465 function build_tools {
465 466 DESTROOT=$1
466 467
467 468 INSTALLOG=install-${MACH}
468 469
469 470 echo "\n==== Building tools at `date` ====\n" \
470 471 >> $LOGFILE
471 472
472 473 rm -f ${TOOLS}/${INSTALLOG}.out
473 474 cd ${TOOLS}
474 475 /bin/time $MAKE TOOLS_PROTO=${DESTROOT} -e install 2>&1 | \
475 476 tee -a ${TOOLS}/${INSTALLOG}.out >> $LOGFILE
476 477
477 478 echo "\n==== Tools build errors ====\n" >> $mail_msg_file
478 479
479 480 egrep ":" ${TOOLS}/${INSTALLOG}.out |
480 481 egrep -e "(${MAKE}:|[ ]error[: \n])" | \
481 482 egrep -v "Ignoring unknown host" | \
482 483 egrep -v warning | tee $TMPDIR/tools_errors >> $mail_msg_file
483 484
484 485 if [[ -s $TMPDIR/tools_errors ]]; then
485 486 return 1
486 487 fi
487 488 return 0
488 489 }
489 490
490 491 function staffer {
491 492 if [ $ISUSER -ne 0 ]; then
492 493 "$@"
493 494 else
494 495 arg="\"$1\""
495 496 shift
496 497 for i
497 498 do
498 499 arg="$arg \"$i\""
499 500 done
500 501 eval su $STAFFER -c \'$arg\'
501 502 fi
502 503 }
503 504
504 505 #
505 506 # Verify that the closed bins are present
506 507 #
507 508 function check_closed_bins {
508 509 if [[ -n "$ON_CLOSED_BINS" && ! -d "$ON_CLOSED_BINS" ]]; then
509 510 echo "ON_CLOSED_BINS must point to the closed binaries tree."
510 511 build_ok=n
511 512 exit 1
512 513 fi
513 514 }
514 515
515 516 #
516 517 # wrapper over wsdiff.
517 518 # usage: do_wsdiff LABEL OLDPROTO NEWPROTO
518 519 #
519 520 function do_wsdiff {
520 521 label=$1
521 522 oldproto=$2
522 523 newproto=$3
523 524
524 525 wsdiff="wsdiff"
525 526 [ "$t_FLAG" = y ] && wsdiff="wsdiff -t"
526 527
527 528 echo "\n==== Getting object changes since last build at `date`" \
528 529 "($label) ====\n" | tee -a $LOGFILE >> $mail_msg_file
529 530 $wsdiff -s -r ${TMPDIR}/wsdiff.results $oldproto $newproto 2>&1 | \
530 531 tee -a $LOGFILE >> $mail_msg_file
531 532 echo "\n==== Object changes determined at `date` ($label) ====\n" | \
532 533 tee -a $LOGFILE >> $mail_msg_file
533 534 }
534 535
535 536 #
536 537 # Functions for setting build flags (DEBUG/non-DEBUG). Keep them
537 538 # together.
538 539 #
539 540
540 541 function set_non_debug_build_flags {
541 542 export RELEASE_BUILD ; RELEASE_BUILD=
542 543 unset EXTRA_OPTIONS
543 544 unset EXTRA_CFLAGS
544 545 }
545 546
546 547 function set_debug_build_flags {
547 548 unset RELEASE_BUILD
548 549 unset EXTRA_OPTIONS
549 550 unset EXTRA_CFLAGS
550 551 }
551 552
552 553
553 554 MACH=`uname -p`
554 555
555 556 if [ "$OPTHOME" = "" ]; then
556 557 OPTHOME=/opt
557 558 export OPTHOME
558 559 fi
559 560
560 561 USAGE='Usage: nightly [-in] [+t] [-V VERS ] <env_file>
561 562
562 563 Where:
563 564 -i Fast incremental options (no clobber, lint, check)
564 565 -n Do not do a bringover
565 566 +t Use the build tools in $ONBLD_TOOLS/bin
566 567 -V VERS set the build version string to VERS
567 568
568 569 <env_file> file in Bourne shell syntax that sets and exports
569 570 variables that configure the operation of this script and many of
570 571 the scripts this one calls. If <env_file> does not exist,
571 572 it will be looked for in $OPTHOME/onbld/env.
572 573
573 574 non-DEBUG is the default build type. Build options can be set in the
574 575 NIGHTLY_OPTIONS variable in the <env_file> as follows:
575 576
576 577 -A check for ABI differences in .so files
577 578 -C check for cstyle/hdrchk errors
578 579 -D do a build with DEBUG on
579 580 -F do _not_ do a non-DEBUG build
580 581 -G gate keeper default group of options (-au)
581 582 -I integration engineer default group of options (-ampu)
582 583 -M do not run pmodes (safe file permission checker)
583 584 -N do not run protocmp
584 585 -R default group of options for building a release (-mp)
585 586 -U update proto area in the parent
586 587 -V VERS set the build version string to VERS
587 588 -f find unreferenced files
588 589 -i do an incremental build (no "make clobber")
589 590 -l do "make lint" in $LINTDIRS (default: $SRC y)
590 591 -m send mail to $MAILTO at end of build
591 592 -n do not do a bringover
592 593 -p create packages
593 594 -r check ELF runtime attributes in the proto area
594 595 -t build and use the tools in $SRC/tools (default setting)
595 596 +t Use the build tools in $ONBLD_TOOLS/bin
596 597 -u update proto_list_$MACH and friends in the parent workspace;
597 598 when used with -f, also build an unrefmaster.out in the parent
598 599 -w report on differences between previous and current proto areas
599 600 '
600 601 #
601 602 # A log file will be generated under the name $LOGFILE
602 603 # for partially completed build and log.`date '+%F'`
603 604 # in the same directory for fully completed builds.
604 605 #
605 606
606 607 # default values for low-level FLAGS; G I R are group FLAGS
607 608 A_FLAG=n
608 609 C_FLAG=n
609 610 D_FLAG=n
610 611 F_FLAG=n
611 612 f_FLAG=n
612 613 i_FLAG=n; i_CMD_LINE_FLAG=n
613 614 l_FLAG=n
614 615 M_FLAG=n
615 616 m_FLAG=n
616 617 N_FLAG=n
617 618 n_FLAG=n
618 619 p_FLAG=n
619 620 r_FLAG=n
620 621 t_FLAG=y
621 622 U_FLAG=n
622 623 u_FLAG=n
623 624 V_FLAG=n
624 625 w_FLAG=n
625 626 W_FLAG=n
626 627 #
627 628 build_ok=y
628 629 build_extras_ok=y
629 630
630 631 #
631 632 # examine arguments
632 633 #
633 634
634 635 OPTIND=1
635 636 while getopts +intV:W FLAG
636 637 do
637 638 case $FLAG in
638 639 i ) i_FLAG=y; i_CMD_LINE_FLAG=y
639 640 ;;
640 641 n ) n_FLAG=y
641 642 ;;
642 643 +t ) t_FLAG=n
643 644 ;;
644 645 V ) V_FLAG=y
645 646 V_ARG="$OPTARG"
646 647 ;;
647 648 W ) W_FLAG=y
648 649 ;;
649 650 \? ) echo "$USAGE"
650 651 exit 1
651 652 ;;
652 653 esac
653 654 done
654 655
655 656 # correct argument count after options
656 657 shift `expr $OPTIND - 1`
657 658
658 659 # test that the path to the environment-setting file was given
659 660 if [ $# -ne 1 ]; then
660 661 echo "$USAGE"
661 662 exit 1
662 663 fi
663 664
664 665 # check if user is running nightly as root
665 666 # ISUSER is set non-zero if an ordinary user runs nightly, or is zero
666 667 # when root invokes nightly.
667 668 /usr/bin/id | grep '^uid=0(' >/dev/null 2>&1
668 669 ISUSER=$?; export ISUSER
669 670
670 671 #
671 672 # force locale to C
672 673 LANG=C; export LANG
673 674 LC_ALL=C; export LC_ALL
674 675 LC_COLLATE=C; export LC_COLLATE
675 676 LC_CTYPE=C; export LC_CTYPE
676 677 LC_MESSAGES=C; export LC_MESSAGES
677 678 LC_MONETARY=C; export LC_MONETARY
678 679 LC_NUMERIC=C; export LC_NUMERIC
679 680 LC_TIME=C; export LC_TIME
680 681
681 682 # clear environment variables we know to be bad for the build
682 683 unset LD_OPTIONS
683 684 unset LD_AUDIT LD_AUDIT_32 LD_AUDIT_64
684 685 unset LD_BIND_NOW LD_BIND_NOW_32 LD_BIND_NOW_64
685 686 unset LD_BREADTH LD_BREADTH_32 LD_BREADTH_64
686 687 unset LD_CONFIG LD_CONFIG_32 LD_CONFIG_64
687 688 unset LD_DEBUG LD_DEBUG_32 LD_DEBUG_64
688 689 unset LD_DEMANGLE LD_DEMANGLE_32 LD_DEMANGLE_64
689 690 unset LD_FLAGS LD_FLAGS_32 LD_FLAGS_64
690 691 unset LD_LIBRARY_PATH LD_LIBRARY_PATH_32 LD_LIBRARY_PATH_64
691 692 unset LD_LOADFLTR LD_LOADFLTR_32 LD_LOADFLTR_64
692 693 unset LD_NOAUDIT LD_NOAUDIT_32 LD_NOAUDIT_64
693 694 unset LD_NOAUXFLTR LD_NOAUXFLTR_32 LD_NOAUXFLTR_64
694 695 unset LD_NOCONFIG LD_NOCONFIG_32 LD_NOCONFIG_64
695 696 unset LD_NODIRCONFIG LD_NODIRCONFIG_32 LD_NODIRCONFIG_64
696 697 unset LD_NODIRECT LD_NODIRECT_32 LD_NODIRECT_64
697 698 unset LD_NOLAZYLOAD LD_NOLAZYLOAD_32 LD_NOLAZYLOAD_64
698 699 unset LD_NOOBJALTER LD_NOOBJALTER_32 LD_NOOBJALTER_64
699 700 unset LD_NOVERSION LD_NOVERSION_32 LD_NOVERSION_64
700 701 unset LD_ORIGIN LD_ORIGIN_32 LD_ORIGIN_64
701 702 unset LD_PRELOAD LD_PRELOAD_32 LD_PRELOAD_64
702 703 unset LD_PROFILE LD_PROFILE_32 LD_PROFILE_64
703 704
704 705 unset CONFIG
705 706 unset GROUP
706 707 unset OWNER
707 708 unset REMOTE
708 709 unset ENV
709 710 unset ARCH
710 711 unset CLASSPATH
711 712 unset NAME
712 713
713 714 #
714 715 # To get ONBLD_TOOLS from the environment, it must come from the env file.
715 716 # If it comes interactively, it is generally TOOLS_PROTO, which will be
716 717 # clobbered before the compiler version checks, which will therefore fail.
717 718 #
718 719 unset ONBLD_TOOLS
719 720
720 721 #
721 722 # Setup environmental variables
722 723 #
723 724 if [ -f /etc/nightly.conf ]; then
724 725 . /etc/nightly.conf
725 726 fi
726 727
727 728 if [ -f $1 ]; then
728 729 if [[ $1 = */* ]]; then
729 730 . $1
730 731 else
731 732 . ./$1
732 733 fi
733 734 else
734 735 if [ -f $OPTHOME/onbld/env/$1 ]; then
735 736 . $OPTHOME/onbld/env/$1
736 737 else
737 738 echo "Cannot find env file as either $1 or $OPTHOME/onbld/env/$1"
738 739 exit 1
739 740 fi
740 741 fi
741 742
742 743 # contents of stdenv.sh inserted after next line:
743 744 # STDENV_START
744 745 # STDENV_END
745 746
746 747 # Check if we have sufficient data to continue...
747 748 [[ -v CODEMGR_WS ]] || fatal_error "Error: Variable CODEMGR_WS not set."
748 749 if [[ "${NIGHTLY_OPTIONS}" == ~(F)n ]] ; then
749 750 # Check if the gate data are valid if we don't do a "bringover" below
750 751 [[ -d "${CODEMGR_WS}" ]] || \
751 752 fatal_error "Error: ${CODEMGR_WS} is not a directory."
752 753 [[ -f "${CODEMGR_WS}/usr/src/Makefile" ]] || \
753 754 fatal_error "Error: ${CODEMGR_WS}/usr/src/Makefile not found."
754 755 fi
755 756
756 757 #
757 758 # place ourselves in a new task, respecting BUILD_PROJECT if set.
758 759 #
759 760 if [ -z "$BUILD_PROJECT" ]; then
760 761 /usr/bin/newtask -c $$
761 762 else
762 763 /usr/bin/newtask -c $$ -p $BUILD_PROJECT
763 764 fi
764 765
765 766 ps -o taskid= -p $$ | read build_taskid
766 767 ps -o project= -p $$ | read build_project
767 768
768 769 #
769 770 # See if NIGHTLY_OPTIONS is set
770 771 #
771 772 if [ "$NIGHTLY_OPTIONS" = "" ]; then
772 773 NIGHTLY_OPTIONS="-aBm"
773 774 fi
774 775
775 776 #
776 777 # If BRINGOVER_WS was not specified, let it default to CLONE_WS
777 778 #
778 779 if [ "$BRINGOVER_WS" = "" ]; then
779 780 BRINGOVER_WS=$CLONE_WS
780 781 fi
781 782
782 783 #
783 784 # If BRINGOVER_FILES was not specified, default to usr
784 785 #
785 786 if [ "$BRINGOVER_FILES" = "" ]; then
786 787 BRINGOVER_FILES="usr"
787 788 fi
788 789
789 790 check_closed_bins
790 791
791 792 #
792 793 # Note: changes to the option letters here should also be applied to the
793 794 # bldenv script. `d' is listed for backward compatibility.
794 795 #
795 796 NIGHTLY_OPTIONS=-${NIGHTLY_OPTIONS#-}
796 797 OPTIND=1
797 798 while getopts +ABCDdFfGIilMmNnpRrtUuwW FLAG $NIGHTLY_OPTIONS
798 799 do
799 800 case $FLAG in
800 801 A ) A_FLAG=y
801 802 ;;
802 803 B ) D_FLAG=y
803 804 ;; # old version of D
804 805 C ) C_FLAG=y
805 806 ;;
806 807 D ) D_FLAG=y
807 808 ;;
808 809 F ) F_FLAG=y
809 810 ;;
810 811 f ) f_FLAG=y
811 812 ;;
812 813 G ) u_FLAG=y
813 814 ;;
814 815 I ) m_FLAG=y
815 816 p_FLAG=y
816 817 u_FLAG=y
817 818 ;;
818 819 i ) i_FLAG=y
819 820 ;;
820 821 l ) l_FLAG=y
821 822 ;;
822 823 M ) M_FLAG=y
823 824 ;;
824 825 m ) m_FLAG=y
825 826 ;;
826 827 N ) N_FLAG=y
827 828 ;;
828 829 n ) n_FLAG=y
829 830 ;;
830 831 p ) p_FLAG=y
831 832 ;;
832 833 R ) m_FLAG=y
833 834 p_FLAG=y
834 835 ;;
835 836 r ) r_FLAG=y
836 837 ;;
837 838 +t ) t_FLAG=n
838 839 ;;
839 840 U ) if [ -z "${PARENT_ROOT}" ]; then
840 841 echo "PARENT_ROOT must be set if the U flag is" \
841 842 "present in NIGHTLY_OPTIONS."
842 843 exit 1
843 844 fi
844 845 NIGHTLY_PARENT_ROOT=$PARENT_ROOT
845 846 if [ -n "${PARENT_TOOLS_ROOT}" ]; then
846 847 NIGHTLY_PARENT_TOOLS_ROOT=$PARENT_TOOLS_ROOT
847 848 fi
848 849 U_FLAG=y
849 850 ;;
850 851 u ) u_FLAG=y
851 852 ;;
852 853 w ) w_FLAG=y
853 854 ;;
854 855 W ) W_FLAG=y
855 856 ;;
856 857 \? ) echo "$USAGE"
857 858 exit 1
858 859 ;;
859 860 esac
860 861 done
861 862
862 863 if [ $ISUSER -ne 0 ]; then
863 864 # Set default value for STAFFER, if needed.
864 865 if [ -z "$STAFFER" -o "$STAFFER" = "nobody" ]; then
865 866 STAFFER=`/usr/xpg4/bin/id -un`
866 867 export STAFFER
867 868 fi
868 869 fi
869 870
870 871 if [ -z "$MAILTO" -o "$MAILTO" = "nobody" ]; then
871 872 MAILTO=$STAFFER
872 873 export MAILTO
873 874 fi
874 875
875 876 PATH="$OPTHOME/onbld/bin:$OPTHOME/onbld/bin/${MACH}:/usr/ccs/bin"
876 877 PATH="$PATH:$OPTHOME/SUNWspro/bin:/usr/bin:/usr/sbin:/usr/ucb"
877 878 PATH="$PATH:/usr/openwin/bin:/usr/sfw/bin:/opt/sfw/bin:."
878 879 export PATH
879 880
880 881 # roots of source trees, both relative to $SRC and absolute.
881 882 relsrcdirs="."
882 883 abssrcdirs="$SRC"
883 884
884 885 PROTOCMPTERSE="protocmp.terse -gu"
885 886 POUND_SIGN="#"
886 887 # have we set RELEASE_DATE in our env file?
887 888 if [ -z "$RELEASE_DATE" ]; then
888 889 RELEASE_DATE=$(LC_ALL=C date +"%B %Y")
889 890 fi
890 891 BUILD_DATE=$(LC_ALL=C date +%Y-%b-%d)
891 892 BASEWSDIR=$(basename $CODEMGR_WS)
892 893 DEV_CM="\"@(#)SunOS Internal Development: $LOGNAME $BUILD_DATE [$BASEWSDIR]\""
893 894
894 895 # we export POUND_SIGN, RELEASE_DATE and DEV_CM to speed up the build process
895 896 # by avoiding repeated shell invocations to evaluate Makefile.master
896 897 # definitions.
897 898 export POUND_SIGN RELEASE_DATE DEV_CM
898 899
899 900 maketype="distributed"
900 901 if [[ -z "$MAKE" ]]; then
901 902 MAKE=dmake
902 903 elif [[ ! -x "$MAKE" ]]; then
903 904 echo "\$MAKE is set to garbage in the environment"
904 905 exit 1
905 906 fi
906 907 export PATH
907 908 export MAKE
908 909
909 910 if [ "${SUNWSPRO}" != "" ]; then
910 911 PATH="${SUNWSPRO}/bin:$PATH"
911 912 export PATH
912 913 fi
913 914
914 915 hostname=$(uname -n)
915 916 if [[ $DMAKE_MAX_JOBS != +([0-9]) || $DMAKE_MAX_JOBS -eq 0 ]]
916 917 then
917 918 maxjobs=
918 919 if [[ -f $HOME/.make.machines ]]
919 920 then
920 921 # Note: there is a hard tab and space character in the []s
921 922 # below.
922 923 egrep -i "^[ ]*$hostname[ \.]" \
923 924 $HOME/.make.machines | read host jobs
924 925 maxjobs=${jobs##*=}
925 926 fi
926 927
927 928 if [[ $maxjobs != +([0-9]) || $maxjobs -eq 0 ]]
928 929 then
929 930 # default
930 931 maxjobs=4
931 932 fi
932 933
933 934 export DMAKE_MAX_JOBS=$maxjobs
934 935 fi
935 936
936 937 DMAKE_MODE=parallel;
937 938 export DMAKE_MODE
938 939
939 940 if [ -z "${ROOT}" ]; then
940 941 echo "ROOT must be set."
941 942 exit 1
942 943 fi
943 944
944 945 #
945 946 # if -V flag was given, reset VERSION to V_ARG
946 947 #
947 948 if [ "$V_FLAG" = "y" ]; then
948 949 VERSION=$V_ARG
949 950 fi
950 951
951 952 TMPDIR="/tmp/nightly.tmpdir.$$"
952 953 export TMPDIR
953 954 rm -rf ${TMPDIR}
954 955 mkdir -p $TMPDIR || exit 1
955 956 chmod 777 $TMPDIR
956 957
957 958 #
958 959 # Tools should only be built non-DEBUG. Keep track of the tools proto
959 960 # area path relative to $TOOLS, because the latter changes in an
960 961 # export build.
961 962 #
962 963 # TOOLS_PROTO is included below for builds other than usr/src/tools
963 964 # that look for this location. For usr/src/tools, this will be
964 965 # overridden on the $MAKE command line in build_tools().
965 966 #
966 967 TOOLS=${SRC}/tools
967 968 TOOLS_PROTO_REL=proto/root_${MACH}-nd
968 969 TOOLS_PROTO=${TOOLS}/${TOOLS_PROTO_REL}; export TOOLS_PROTO
969 970
970 971 unset CFLAGS LD_LIBRARY_PATH LDFLAGS
971 972
972 973 # create directories that are automatically removed if the nightly script
973 974 # fails to start correctly
974 975 function newdir {
975 976 dir=$1
976 977 toadd=
977 978 while [ ! -d $dir ]; do
978 979 toadd="$dir $toadd"
979 980 dir=`dirname $dir`
980 981 done
981 982 torm=
982 983 newlist=
983 984 for dir in $toadd; do
984 985 if staffer mkdir $dir; then
985 986 newlist="$ISUSER $dir $newlist"
986 987 torm="$dir $torm"
987 988 else
988 989 [ -z "$torm" ] || staffer rmdir $torm
989 990 return 1
990 991 fi
991 992 done
992 993 newdirlist="$newlist $newdirlist"
993 994 return 0
994 995 }
995 996 newdirlist=
996 997
997 998 [ -d $CODEMGR_WS ] || newdir $CODEMGR_WS || exit 1
998 999
999 1000 # since this script assumes the build is from full source, it nullifies
1000 1001 # variables likely to have been set by a "ws" script; nullification
1001 1002 # confines the search space for headers and libraries to the proto area
1002 1003 # built from this immediate source.
1003 1004 ENVLDLIBS1=
1004 1005 ENVLDLIBS2=
1005 1006 ENVLDLIBS3=
1006 1007 ENVCPPFLAGS1=
1007 1008 ENVCPPFLAGS2=
1008 1009 ENVCPPFLAGS3=
1009 1010 ENVCPPFLAGS4=
1010 1011 PARENT_ROOT=
1011 1012
1012 1013 export ENVLDLIBS3 ENVCPPFLAGS1 ENVCPPFLAGS2 ENVCPPFLAGS3 ENVCPPFLAGS4 \
1013 1014 ENVLDLIBS1 ENVLDLIBS2 PARENT_ROOT
1014 1015
1015 1016 PKGARCHIVE_ORIG=$PKGARCHIVE
1016 1017
1017 1018 #
1018 1019 # Juggle the logs and optionally send mail on completion.
1019 1020 #
1020 1021
1021 1022 function logshuffle {
1022 1023 LLOG="$ATLOG/log.`date '+%F.%H:%M'`"
1023 1024 if [ -f $LLOG -o -d $LLOG ]; then
1024 1025 LLOG=$LLOG.$$
1025 1026 fi
1026 1027 mkdir $LLOG
1027 1028 export LLOG
1028 1029
1029 1030 if [ "$build_ok" = "y" ]; then
1030 1031 mv $ATLOG/proto_list_${MACH} $LLOG
1031 1032
1032 1033 if [ -f $ATLOG/proto_list_tools_${MACH} ]; then
1033 1034 mv $ATLOG/proto_list_tools_${MACH} $LLOG
1034 1035 fi
1035 1036
1036 1037 if [ -f $TMPDIR/wsdiff.results ]; then
1037 1038 mv $TMPDIR/wsdiff.results $LLOG
1038 1039 fi
1039 1040
1040 1041 if [ -f $TMPDIR/wsdiff-nd.results ]; then
1041 1042 mv $TMPDIR/wsdiff-nd.results $LLOG
1042 1043 fi
1043 1044 fi
1044 1045
1045 1046 #
1046 1047 # Now that we're about to send mail, it's time to check the noise
1047 1048 # file. In the event that an error occurs beyond this point, it will
1048 1049 # be recorded in the nightly.log file, but nowhere else. This would
1049 1050 # include only errors that cause the copying of the noise log to fail
1050 1051 # or the mail itself not to be sent.
1051 1052 #
1052 1053
1053 1054 exec >>$LOGFILE 2>&1
1054 1055 if [ -s $build_noise_file ]; then
1055 1056 echo "\n==== Nightly build noise ====\n" |
1056 1057 tee -a $LOGFILE >>$mail_msg_file
1057 1058 cat $build_noise_file >>$LOGFILE
1058 1059 cat $build_noise_file >>$mail_msg_file
1059 1060 echo | tee -a $LOGFILE >>$mail_msg_file
1060 1061 fi
1061 1062 rm -f $build_noise_file
1062 1063
1063 1064 case "$build_ok" in
1064 1065 y)
1065 1066 state=Completed
1066 1067 ;;
1067 1068 i)
1068 1069 state=Interrupted
1069 1070 ;;
1070 1071 *)
1071 1072 state=Failed
|
↓ open down ↓ |
953 lines elided |
↑ open up ↑ |
1072 1073 ;;
1073 1074 esac
1074 1075
1075 1076 if [[ $state != "Interrupted" && $build_extras_ok != "y" ]]; then
1076 1077 state=Failed
1077 1078 fi
1078 1079
1079 1080 NIGHTLY_STATUS=$state
1080 1081 export NIGHTLY_STATUS
1081 1082
1083 + # Want ${LLOG}/mail_msg available to POST_NIGHTLY
1084 + cat $build_time_file $build_environ_file $mail_msg_file \
1085 + > ${LLOG}/mail_msg
1086 +
1082 1087 run_hook POST_NIGHTLY $state
1083 1088 run_hook SYS_POST_NIGHTLY $state
1084 1089
1085 1090 #
1086 1091 # mailx(1) sets From: based on the -r flag
1087 1092 # if it is given.
1088 1093 #
1089 1094 mailx_r=
1090 1095 if [[ -n "${MAILFROM}" ]]; then
1091 1096 mailx_r="-r ${MAILFROM}"
1092 1097 fi
1093 1098
1094 - cat $build_time_file $build_environ_file $mail_msg_file \
1095 - > ${LLOG}/mail_msg
1096 1099 if [ "$m_FLAG" = "y" ]; then
1097 1100 cat ${LLOG}/mail_msg | /usr/bin/mailx ${mailx_r} -s \
1098 1101 "Nightly ${MACH} Build of `basename ${CODEMGR_WS}` ${state}." \
1099 1102 ${MAILTO}
1100 1103 fi
1101 1104
1102 1105 if [ "$u_FLAG" = "y" -a "$build_ok" = "y" ]; then
1103 1106 staffer cp ${LLOG}/mail_msg $PARENT_WS/usr/src/mail_msg-${MACH}
1104 1107 staffer cp $LOGFILE $PARENT_WS/usr/src/nightly-${MACH}.log
1105 1108 fi
1106 1109
1107 1110 mv $LOGFILE $LLOG
1108 1111 }
1109 1112
1110 1113 #
1111 1114 # Remove the locks and temporary files on any exit
1112 1115 #
1113 1116 function cleanup {
1114 1117 logshuffle
1115 1118
1116 1119 [ -z "$lockfile" ] || staffer rm -f $lockfile
1117 1120 [ -z "$atloglockfile" ] || rm -f $atloglockfile
1118 1121 [ -z "$ulockfile" ] || staffer rm -f $ulockfile
1119 1122 [ -z "$Ulockfile" ] || rm -f $Ulockfile
1120 1123
1121 1124 set -- $newdirlist
1122 1125 while [ $# -gt 0 ]; do
1123 1126 ISUSER=$1 staffer rmdir $2
1124 1127 shift; shift
1125 1128 done
1126 1129 rm -rf $TMPDIR
1127 1130 }
1128 1131
1129 1132 function cleanup_signal {
1130 1133 build_ok=i
1131 1134 # this will trigger cleanup(), above.
1132 1135 exit 1
1133 1136 }
1134 1137
1135 1138 trap cleanup 0
1136 1139 trap cleanup_signal 1 2 3 15
1137 1140
1138 1141 #
1139 1142 # Generic lock file processing -- make sure that the lock file doesn't
1140 1143 # exist. If it does, it should name the build host and PID. If it
1141 1144 # doesn't, then make sure we can create it. Clean up locks that are
1142 1145 # known to be stale (assumes host name is unique among build systems
1143 1146 # for the workspace).
1144 1147 #
1145 1148 function create_lock {
1146 1149 lockf=$1
1147 1150 lockvar=$2
1148 1151
1149 1152 ldir=`dirname $lockf`
1150 1153 [ -d $ldir ] || newdir $ldir || exit 1
1151 1154 eval $lockvar=$lockf
1152 1155
1153 1156 while ! staffer ln -s $hostname.$STAFFER.$$ $lockf 2> /dev/null; do
1154 1157 basews=`basename $CODEMGR_WS`
1155 1158 ls -l $lockf | nawk '{print $NF}' | IFS=. read host user pid
1156 1159 if [ "$host" != "$hostname" ]; then
1157 1160 echo "$MACH build of $basews apparently" \
1158 1161 "already started by $user on $host as $pid."
1159 1162 exit 1
1160 1163 elif kill -s 0 $pid 2>/dev/null; then
1161 1164 echo "$MACH build of $basews already started" \
1162 1165 "by $user as $pid."
1163 1166 exit 1
1164 1167 else
1165 1168 # stale lock; clear it out and try again
1166 1169 rm -f $lockf
1167 1170 fi
1168 1171 done
1169 1172 }
1170 1173
1171 1174 #
1172 1175 # Return the list of interesting proto areas, depending on the current
1173 1176 # options.
1174 1177 #
1175 1178 function allprotos {
1176 1179 typeset roots="$ROOT"
1177 1180
1178 1181 if [[ "$F_FLAG" = n && "$MULTI_PROTO" = yes ]]; then
1179 1182 roots="$roots $ROOT-nd"
1180 1183 fi
1181 1184
1182 1185 echo $roots
1183 1186 }
1184 1187
1185 1188 # Ensure no other instance of this script is running on this host.
1186 1189 # LOCKNAME can be set in <env_file>, and is by default, but is not
1187 1190 # required due to the use of $ATLOG below.
1188 1191 if [ -n "$LOCKNAME" ]; then
1189 1192 create_lock /tmp/$LOCKNAME "lockfile"
1190 1193 fi
1191 1194 #
1192 1195 # Create from one, two, or three other locks:
1193 1196 # $ATLOG/nightly.lock
1194 1197 # - protects against multiple builds in same workspace
1195 1198 # $PARENT_WS/usr/src/nightly.$MACH.lock
1196 1199 # - protects against multiple 'u' copy-backs
1197 1200 # $NIGHTLY_PARENT_ROOT/nightly.lock
1198 1201 # - protects against multiple 'U' copy-backs
1199 1202 #
1200 1203 # Overriding ISUSER to 1 causes the lock to be created as root if the
1201 1204 # script is run as root. The default is to create it as $STAFFER.
1202 1205 ISUSER=1 create_lock $ATLOG/nightly.lock "atloglockfile"
1203 1206 if [ "$u_FLAG" = "y" ]; then
1204 1207 create_lock $PARENT_WS/usr/src/nightly.$MACH.lock "ulockfile"
1205 1208 fi
1206 1209 if [ "$U_FLAG" = "y" ]; then
1207 1210 # NIGHTLY_PARENT_ROOT is written as root if script invoked as root.
1208 1211 ISUSER=1 create_lock $NIGHTLY_PARENT_ROOT/nightly.lock "Ulockfile"
1209 1212 fi
1210 1213
1211 1214 # Locks have been taken, so we're doing a build and we're committed to
1212 1215 # the directories we may have created so far.
1213 1216 newdirlist=
1214 1217
1215 1218 #
1216 1219 # Create mail_msg_file
1217 1220 #
1218 1221 mail_msg_file="${TMPDIR}/mail_msg"
1219 1222 touch $mail_msg_file
1220 1223 build_time_file="${TMPDIR}/build_time"
1221 1224 build_environ_file="${TMPDIR}/build_environ"
1222 1225 touch $build_environ_file
1223 1226 #
1224 1227 # Move old LOGFILE aside
1225 1228 # ATLOG directory already made by 'create_lock' above
1226 1229 #
1227 1230 if [ -f $LOGFILE ]; then
1228 1231 mv -f $LOGFILE ${LOGFILE}-
1229 1232 fi
1230 1233 #
1231 1234 # Build OsNet source
1232 1235 #
1233 1236 START_DATE=`date`
1234 1237 SECONDS=0
1235 1238 echo "\n==== Nightly $maketype build started: $START_DATE ====" \
1236 1239 | tee -a $LOGFILE > $build_time_file
1237 1240
1238 1241 echo "\nBuild project: $build_project\nBuild taskid: $build_taskid" | \
1239 1242 tee -a $mail_msg_file >> $LOGFILE
1240 1243
1241 1244 # make sure we log only to the nightly build file
1242 1245 build_noise_file="${TMPDIR}/build_noise"
1243 1246 exec </dev/null >$build_noise_file 2>&1
1244 1247
1245 1248 run_hook SYS_PRE_NIGHTLY
1246 1249 run_hook PRE_NIGHTLY
1247 1250
1248 1251 echo "\n==== list of environment variables ====\n" >> $LOGFILE
1249 1252 env >> $LOGFILE
1250 1253
1251 1254 echo "\n==== Nightly argument issues ====\n" | tee -a $mail_msg_file >> $LOGFILE
1252 1255
1253 1256 if [ "$N_FLAG" = "y" ]; then
1254 1257 if [ "$p_FLAG" = "y" ]; then
1255 1258 cat <<EOF | tee -a $mail_msg_file >> $LOGFILE
1256 1259 WARNING: the p option (create packages) is set, but so is the N option (do
1257 1260 not run protocmp); this is dangerous; you should unset the N option
1258 1261 EOF
1259 1262 else
1260 1263 cat <<EOF | tee -a $mail_msg_file >> $LOGFILE
1261 1264 Warning: the N option (do not run protocmp) is set; it probably shouldn't be
1262 1265 EOF
1263 1266 fi
1264 1267 echo "" | tee -a $mail_msg_file >> $LOGFILE
1265 1268 fi
1266 1269
1267 1270 if [ "$D_FLAG" = "n" -a "$l_FLAG" = "y" ]; then
1268 1271 #
1269 1272 # In the past we just complained but went ahead with the lint
1270 1273 # pass, even though the proto area was built non-DEBUG. It's
1271 1274 # unlikely that non-DEBUG headers will make a difference, but
1272 1275 # rather than assuming it's a safe combination, force the user
1273 1276 # to specify a DEBUG build.
1274 1277 #
1275 1278 echo "WARNING: DEBUG build not requested; disabling lint.\n" \
1276 1279 | tee -a $mail_msg_file >> $LOGFILE
1277 1280 l_FLAG=n
1278 1281 fi
1279 1282
1280 1283 if [ "$f_FLAG" = "y" ]; then
1281 1284 if [ "$i_FLAG" = "y" ]; then
1282 1285 echo "WARNING: the -f flag cannot be used during incremental" \
1283 1286 "builds; ignoring -f\n" | tee -a $mail_msg_file >> $LOGFILE
1284 1287 f_FLAG=n
1285 1288 fi
1286 1289 if [ "${l_FLAG}${p_FLAG}" != "yy" ]; then
1287 1290 echo "WARNING: the -f flag requires -l, and -p;" \
1288 1291 "ignoring -f\n" | tee -a $mail_msg_file >> $LOGFILE
1289 1292 f_FLAG=n
1290 1293 fi
1291 1294 fi
1292 1295
1293 1296 if [ "$w_FLAG" = "y" -a ! -d $ROOT ]; then
1294 1297 echo "WARNING: -w specified, but $ROOT does not exist;" \
1295 1298 "ignoring -w\n" | tee -a $mail_msg_file >> $LOGFILE
1296 1299 w_FLAG=n
1297 1300 fi
1298 1301
1299 1302 case $MULTI_PROTO in
1300 1303 yes|no) ;;
1301 1304 *)
1302 1305 echo "WARNING: MULTI_PROTO is \"$MULTI_PROTO\"; " \
1303 1306 "should be \"yes\" or \"no\"." | tee -a $mail_msg_file >> $LOGFILE
1304 1307 echo "Setting MULTI_PROTO to \"no\".\n" | \
1305 1308 tee -a $mail_msg_file >> $LOGFILE
1306 1309 export MULTI_PROTO=no
1307 1310 ;;
1308 1311 esac
1309 1312
1310 1313 echo "\n==== Build version ====\n" | tee -a $mail_msg_file >> $LOGFILE
1311 1314 echo $VERSION | tee -a $mail_msg_file >> $LOGFILE
1312 1315
1313 1316 # Save the current proto area if we're comparing against the last build
1314 1317 if [ "$w_FLAG" = "y" -a -d "$ROOT" ]; then
1315 1318 if [ -d "$ROOT.prev" ]; then
1316 1319 rm -rf $ROOT.prev
1317 1320 fi
1318 1321 mv $ROOT $ROOT.prev
1319 1322 fi
1320 1323
1321 1324 # Same for non-DEBUG proto area
1322 1325 if [ "$w_FLAG" = "y" -a "$MULTI_PROTO" = yes -a -d "$ROOT-nd" ]; then
1323 1326 if [ -d "$ROOT-nd.prev" ]; then
1324 1327 rm -rf $ROOT-nd.prev
1325 1328 fi
1326 1329 mv $ROOT-nd $ROOT-nd.prev
1327 1330 fi
1328 1331
1329 1332 #
1330 1333 # Echo the SCM type of the parent workspace, this can't just be which_scm
1331 1334 # as that does not know how to identify various network repositories.
1332 1335 #
1333 1336 function parent_wstype {
1334 1337 typeset scm_type junk
1335 1338
1336 1339 CODEMGR_WS="$BRINGOVER_WS" "$WHICH_SCM" 2>/dev/null \
1337 1340 | read scm_type junk
1338 1341 if [[ -z "$scm_type" || "$scm_type" == unknown ]]; then
1339 1342 # Probe BRINGOVER_WS to determine its type
1340 1343 if [[ $BRINGOVER_WS == ssh://* ]]; then
1341 1344 scm_type="mercurial"
1342 1345 elif [[ $BRINGOVER_WS == http://* ]] && \
1343 1346 wget -q -O- --save-headers "$BRINGOVER_WS/?cmd=heads" | \
1344 1347 egrep -s "application/mercurial" 2> /dev/null; then
1345 1348 scm_type="mercurial"
1346 1349 else
1347 1350 scm_type="none"
1348 1351 fi
1349 1352 fi
1350 1353
1351 1354 # fold both unsupported and unrecognized results into "none"
1352 1355 case "$scm_type" in
1353 1356 mercurial)
1354 1357 ;;
1355 1358 *) scm_type=none
1356 1359 ;;
1357 1360 esac
1358 1361
1359 1362 echo $scm_type
1360 1363 }
1361 1364
1362 1365 # Echo the SCM types of $CODEMGR_WS and $BRINGOVER_WS
1363 1366 function child_wstype {
1364 1367 typeset scm_type junk
1365 1368
1366 1369 # Probe CODEMGR_WS to determine its type
1367 1370 if [[ -d $CODEMGR_WS ]]; then
1368 1371 $WHICH_SCM | read scm_type junk || exit 1
1369 1372 fi
1370 1373
1371 1374 case "$scm_type" in
1372 1375 none|git|mercurial)
1373 1376 ;;
1374 1377 *) scm_type=none
1375 1378 ;;
1376 1379 esac
1377 1380
1378 1381 echo $scm_type
1379 1382 }
1380 1383
1381 1384 SCM_TYPE=$(child_wstype)
1382 1385
1383 1386 #
1384 1387 # Decide whether to clobber
1385 1388 #
1386 1389 if [ "$i_FLAG" = "n" -a -d "$SRC" ]; then
1387 1390 echo "\n==== Make clobber at `date` ====\n" >> $LOGFILE
1388 1391
1389 1392 cd $SRC
1390 1393 # remove old clobber file
1391 1394 rm -f $SRC/clobber.out
1392 1395 rm -f $SRC/clobber-${MACH}.out
1393 1396
1394 1397 # Remove all .make.state* files, just in case we are restarting
1395 1398 # the build after having interrupted a previous 'make clobber'.
1396 1399 find . \( -name SCCS -o -name .hg -o -name .svn -o -name .git \
1397 1400 -o -name 'interfaces.*' \) -prune \
1398 1401 -o -name '.make.*' -print | xargs rm -f
1399 1402
1400 1403 $MAKE -ek clobber 2>&1 | tee -a $SRC/clobber-${MACH}.out >> $LOGFILE
1401 1404 echo "\n==== Make clobber ERRORS ====\n" >> $mail_msg_file
1402 1405 grep "$MAKE:" $SRC/clobber-${MACH}.out |
1403 1406 egrep -v "Ignoring unknown host" | \
1404 1407 tee $TMPDIR/clobber_errs >> $mail_msg_file
1405 1408
1406 1409 if [[ -s $TMPDIR/clobber_errs ]]; then
1407 1410 build_extras_ok=n
1408 1411 fi
1409 1412
1410 1413 if [[ "$t_FLAG" = "y" ]]; then
1411 1414 echo "\n==== Make tools clobber at `date` ====\n" >> $LOGFILE
1412 1415 cd ${TOOLS}
1413 1416 rm -f ${TOOLS}/clobber-${MACH}.out
1414 1417 $MAKE TOOLS_PROTO=$TOOLS_PROTO -ek clobber 2>&1 | \
1415 1418 tee -a ${TOOLS}/clobber-${MACH}.out >> $LOGFILE
1416 1419 echo "\n==== Make tools clobber ERRORS ====\n" \
1417 1420 >> $mail_msg_file
1418 1421 grep "$MAKE:" ${TOOLS}/clobber-${MACH}.out \
1419 1422 >> $mail_msg_file
1420 1423 if (( $? == 0 )); then
1421 1424 build_extras_ok=n
1422 1425 fi
1423 1426 rm -rf ${TOOLS_PROTO}
1424 1427 mkdir -p ${TOOLS_PROTO}
1425 1428 fi
1426 1429
1427 1430 typeset roots=$(allprotos)
1428 1431 echo "\n\nClearing $roots" >> "$LOGFILE"
1429 1432 rm -rf $roots
1430 1433
1431 1434 # Get back to a clean workspace as much as possible to catch
1432 1435 # problems that only occur on fresh workspaces.
1433 1436 # Remove all .make.state* files, libraries, and .o's that may
1434 1437 # have been omitted from clobber. A couple of libraries are
1435 1438 # under source code control, so leave them alone.
1436 1439 # We should probably blow away temporary directories too.
1437 1440 cd $SRC
1438 1441 find $relsrcdirs \( -name SCCS -o -name .hg -o -name .svn \
1439 1442 -o -name .git -o -name 'interfaces.*' \) -prune -o \
1440 1443 \( -name '.make.*' -o -name 'lib*.a' -o -name 'lib*.so*' -o \
1441 1444 -name '*.o' \) -print | \
1442 1445 grep -v 'tools/ctf/dwarf/.*/libdwarf' | xargs rm -f
1443 1446 else
1444 1447 echo "\n==== No clobber at `date` ====\n" >> $LOGFILE
1445 1448 fi
1446 1449
1447 1450 type bringover_mercurial > /dev/null 2>&1 || function bringover_mercurial {
1448 1451 typeset -x PATH=$PATH
1449 1452
1450 1453 # If the repository doesn't exist yet, then we want to populate it.
1451 1454 if [[ ! -d $CODEMGR_WS/.hg ]]; then
1452 1455 staffer hg init $CODEMGR_WS
1453 1456 staffer echo "[paths]" > $CODEMGR_WS/.hg/hgrc
1454 1457 staffer echo "default=$BRINGOVER_WS" >> $CODEMGR_WS/.hg/hgrc
1455 1458 touch $TMPDIR/new_repository
1456 1459 fi
1457 1460
1458 1461 typeset -x HGMERGE="/bin/false"
1459 1462
1460 1463 #
1461 1464 # If the user has changes, regardless of whether those changes are
1462 1465 # committed, and regardless of whether those changes conflict, then
1463 1466 # we'll attempt to merge them either implicitly (uncommitted) or
1464 1467 # explicitly (committed).
1465 1468 #
1466 1469 # These are the messages we'll use to help clarify mercurial output
1467 1470 # in those cases.
1468 1471 #
1469 1472 typeset mergefailmsg="\
1470 1473 ***\n\
1471 1474 *** nightly was unable to automatically merge your changes. You should\n\
1472 1475 *** redo the full merge manually, following the steps outlined by mercurial\n\
1473 1476 *** above, then restart nightly.\n\
1474 1477 ***\n"
1475 1478 typeset mergepassmsg="\
1476 1479 ***\n\
1477 1480 *** nightly successfully merged your changes. This means that your working\n\
1478 1481 *** directory has been updated, but those changes are not yet committed.\n\
1479 1482 *** After nightly completes, you should validate the results of the merge,\n\
1480 1483 *** then use hg commit manually.\n\
1481 1484 ***\n"
1482 1485
1483 1486 #
1484 1487 # For each repository in turn:
1485 1488 #
1486 1489 # 1. Do the pull. If this fails, dump the output and bail out.
1487 1490 #
1488 1491 # 2. If the pull resulted in an extra head, do an explicit merge.
1489 1492 # If this fails, dump the output and bail out.
1490 1493 #
1491 1494 # Because we can't rely on Mercurial to exit with a failure code
1492 1495 # when a merge fails (Mercurial issue #186), we must grep the
1493 1496 # output of pull/merge to check for attempted and/or failed merges.
1494 1497 #
1495 1498 # 3. If a merge failed, set the message and fail the bringover.
1496 1499 #
1497 1500 # 4. Otherwise, if a merge succeeded, set the message
1498 1501 #
1499 1502 # 5. Dump the output, and any message from step 3 or 4.
1500 1503 #
1501 1504
1502 1505 typeset HG_SOURCE=$BRINGOVER_WS
1503 1506 if [ ! -f $TMPDIR/new_repository ]; then
1504 1507 HG_SOURCE=$TMPDIR/open_bundle.hg
1505 1508 staffer hg --cwd $CODEMGR_WS incoming --bundle $HG_SOURCE \
1506 1509 -v $BRINGOVER_WS > $TMPDIR/incoming_open.out
1507 1510
1508 1511 #
1509 1512 # If there are no incoming changesets, then incoming will
1510 1513 # fail, and there will be no bundle file. Reset the source,
1511 1514 # to allow the remaining logic to complete with no false
1512 1515 # negatives. (Unlike incoming, pull will return success
1513 1516 # for the no-change case.)
1514 1517 #
1515 1518 if (( $? != 0 )); then
1516 1519 HG_SOURCE=$BRINGOVER_WS
1517 1520 fi
1518 1521 fi
1519 1522
1520 1523 staffer hg --cwd $CODEMGR_WS pull -u $HG_SOURCE \
1521 1524 > $TMPDIR/pull_open.out 2>&1
1522 1525 if (( $? != 0 )); then
1523 1526 printf "%s: pull failed as follows:\n\n" "$CODEMGR_WS"
1524 1527 cat $TMPDIR/pull_open.out
1525 1528 if grep "^merging.*failed" $TMPDIR/pull_open.out > /dev/null 2>&1; then
1526 1529 printf "$mergefailmsg"
1527 1530 fi
1528 1531 touch $TMPDIR/bringover_failed
1529 1532 return
1530 1533 fi
1531 1534
1532 1535 if grep "not updating" $TMPDIR/pull_open.out > /dev/null 2>&1; then
1533 1536 staffer hg --cwd $CODEMGR_WS merge \
1534 1537 >> $TMPDIR/pull_open.out 2>&1
1535 1538 if (( $? != 0 )); then
1536 1539 printf "%s: merge failed as follows:\n\n" \
1537 1540 "$CODEMGR_WS"
1538 1541 cat $TMPDIR/pull_open.out
1539 1542 if grep "^merging.*failed" $TMPDIR/pull_open.out \
1540 1543 > /dev/null 2>&1; then
1541 1544 printf "$mergefailmsg"
1542 1545 fi
1543 1546 touch $TMPDIR/bringover_failed
1544 1547 return
1545 1548 fi
1546 1549 fi
1547 1550
1548 1551 printf "updated %s with the following results:\n" "$CODEMGR_WS"
1549 1552 cat $TMPDIR/pull_open.out
1550 1553 if grep "^merging" $TMPDIR/pull_open.out >/dev/null 2>&1; then
1551 1554 printf "$mergepassmsg"
1552 1555 fi
1553 1556 printf "\n"
1554 1557
1555 1558 #
1556 1559 # Per-changeset output is neither useful nor manageable for a
1557 1560 # newly-created repository.
1558 1561 #
1559 1562 if [ -f $TMPDIR/new_repository ]; then
1560 1563 return
1561 1564 fi
1562 1565
1563 1566 printf "\nadded the following changesets to open repository:\n"
1564 1567 cat $TMPDIR/incoming_open.out
1565 1568 }
1566 1569
1567 1570 type bringover_none > /dev/null 2>&1 || function bringover_none {
1568 1571 echo "Couldn't figure out what kind of SCM to use for $BRINGOVER_WS."
1569 1572 touch $TMPDIR/bringover_failed
1570 1573 }
1571 1574
1572 1575 #
1573 1576 # Decide whether to bringover to the codemgr workspace
1574 1577 #
1575 1578 if [ "$n_FLAG" = "n" ]; then
1576 1579 PARENT_SCM_TYPE=$(parent_wstype)
1577 1580
1578 1581 if [[ $SCM_TYPE != none && $SCM_TYPE != $PARENT_SCM_TYPE ]]; then
1579 1582 echo "cannot bringover from $PARENT_SCM_TYPE to $SCM_TYPE, " \
1580 1583 "quitting at `date`." | tee -a $mail_msg_file >> $LOGFILE
1581 1584 exit 1
1582 1585 fi
1583 1586
1584 1587 run_hook PRE_BRINGOVER
1585 1588
1586 1589 echo "\n==== bringover to $CODEMGR_WS at `date` ====\n" >> $LOGFILE
1587 1590 echo "\n==== BRINGOVER LOG ====\n" >> $mail_msg_file
1588 1591
1589 1592 eval "bringover_${PARENT_SCM_TYPE}" 2>&1 |
1590 1593 tee -a $mail_msg_file >> $LOGFILE
1591 1594
1592 1595 if [ -f $TMPDIR/bringover_failed ]; then
1593 1596 rm -f $TMPDIR/bringover_failed
1594 1597 build_ok=n
1595 1598 echo "trouble with bringover, quitting at `date`." |
1596 1599 tee -a $mail_msg_file >> $LOGFILE
1597 1600 exit 1
1598 1601 fi
1599 1602
1600 1603 #
1601 1604 # It's possible that we used the bringover above to create
1602 1605 # $CODEMGR_WS. If so, then SCM_TYPE was previously "none,"
1603 1606 # but should now be the same as $BRINGOVER_WS.
1604 1607 #
1605 1608 [[ $SCM_TYPE = none ]] && SCM_TYPE=$PARENT_SCM_TYPE
1606 1609
1607 1610 run_hook POST_BRINGOVER
1608 1611
1609 1612 check_closed_bins
1610 1613
1611 1614 else
1612 1615 echo "\n==== No bringover to $CODEMGR_WS ====\n" >> $LOGFILE
1613 1616 fi
1614 1617
1615 1618 # Safeguards
1616 1619 [[ -v CODEMGR_WS ]] || fatal_error "Error: Variable CODEMGR_WS not set."
1617 1620 [[ -d "${CODEMGR_WS}" ]] || fatal_error "Error: ${CODEMGR_WS} is not a directory."
1618 1621 [[ -f "${CODEMGR_WS}/usr/src/Makefile" ]] || fatal_error "Error: ${CODEMGR_WS}/usr/src/Makefile not found."
1619 1622
1620 1623 if [[ "$t_FLAG" = "y" ]]; then
1621 1624 echo "\n==== Bootstrapping cw ====\n" >> $LOGFILE
1622 1625 ( cd ${TOOLS}
1623 1626 set_non_debug_build_flags
1624 1627 rm -f $TMPDIR/make-state
1625 1628 $MAKE -K $TMPDIR/make-state -e TARGET=install cw 2>&1 >> $LOGFILE
1626 1629 [[ "$?" -ne 0 ]] && fatal_error "Error: could not bootstrap cw"
1627 1630 )
1628 1631
1629 1632 # Switch ONBLD_TOOLS early if -t is specified so that
1630 1633 # we could use bootstrapped cw for compiler checks.
1631 1634 ONBLD_TOOLS=${TOOLS_PROTO}/opt/onbld
1632 1635 export ONBLD_TOOLS
1633 1636 fi
1634 1637
1635 1638 echo "\n==== Build environment ====\n" | tee -a $build_environ_file >> $LOGFILE
1636 1639
1637 1640 # System
1638 1641 whence uname | tee -a $build_environ_file >> $LOGFILE
1639 1642 uname -a 2>&1 | tee -a $build_environ_file >> $LOGFILE
1640 1643 echo | tee -a $build_environ_file >> $LOGFILE
1641 1644
1642 1645 # make
1643 1646 whence $MAKE | tee -a $build_environ_file >> $LOGFILE
1644 1647 $MAKE -v | tee -a $build_environ_file >> $LOGFILE
1645 1648 echo "number of concurrent jobs = $DMAKE_MAX_JOBS" |
1646 1649 tee -a $build_environ_file >> $LOGFILE
1647 1650
1648 1651 #
1649 1652 # Report the compiler versions.
1650 1653 #
1651 1654
1652 1655 if [[ ! -f $SRC/Makefile ]]; then
1653 1656 build_ok=n
1654 1657 echo "\nUnable to find \"Makefile\" in $SRC." | \
1655 1658 tee -a $build_environ_file >> $LOGFILE
1656 1659 exit 1
1657 1660 fi
1658 1661
1659 1662 ( cd $SRC
1660 1663 for target in cc-version cc64-version java-version; do
1661 1664 echo
1662 1665 #
1663 1666 # Put statefile somewhere we know we can write to rather than trip
1664 1667 # over a read-only $srcroot.
1665 1668 #
1666 1669 rm -f $TMPDIR/make-state
1667 1670 export SRC
1668 1671 if $MAKE -K $TMPDIR/make-state -e $target 2>/dev/null; then
1669 1672 continue
1670 1673 fi
1671 1674 touch $TMPDIR/nocompiler
1672 1675 done
1673 1676 echo
1674 1677 ) | tee -a $build_environ_file >> $LOGFILE
1675 1678
1676 1679 if [ -f $TMPDIR/nocompiler ]; then
1677 1680 rm -f $TMPDIR/nocompiler
1678 1681 build_ok=n
1679 1682 echo "Aborting due to missing compiler." |
1680 1683 tee -a $build_environ_file >> $LOGFILE
1681 1684 exit 1
1682 1685 fi
1683 1686
1684 1687 # as
1685 1688 whence as | tee -a $build_environ_file >> $LOGFILE
1686 1689 as -V 2>&1 | head -1 | tee -a $build_environ_file >> $LOGFILE
1687 1690 echo | tee -a $build_environ_file >> $LOGFILE
1688 1691
1689 1692 # Check that we're running a capable link-editor
1690 1693 whence ld | tee -a $build_environ_file >> $LOGFILE
1691 1694 LDVER=`ld -V 2>&1`
1692 1695 echo $LDVER | tee -a $build_environ_file >> $LOGFILE
1693 1696 LDVER=`echo $LDVER | sed -e "s/.*-1\.\([0-9]*\).*/\1/"`
1694 1697 if [ `expr $LDVER \< 422` -eq 1 ]; then
1695 1698 echo "The link-editor needs to be at version 422 or higher to build" | \
1696 1699 tee -a $build_environ_file >> $LOGFILE
1697 1700 echo "the latest stuff. Hope your build works." | \
1698 1701 tee -a $build_environ_file >> $LOGFILE
1699 1702 fi
1700 1703
1701 1704 #
1702 1705 # Build and use the workspace's tools if requested
1703 1706 #
1704 1707 if [[ "$t_FLAG" = "y" ]]; then
1705 1708 set_non_debug_build_flags
1706 1709
1707 1710 build_tools ${TOOLS_PROTO}
1708 1711 if (( $? != 0 )); then
1709 1712 build_ok=n
1710 1713 else
1711 1714 STABS=${TOOLS_PROTO}/opt/onbld/bin/${MACH}/stabs
1712 1715 export STABS
1713 1716 CTFSTABS=${TOOLS_PROTO}/opt/onbld/bin/${MACH}/ctfstabs
1714 1717 export CTFSTABS
1715 1718 GENOFFSETS=${TOOLS_PROTO}/opt/onbld/bin/genoffsets
1716 1719 export GENOFFSETS
1717 1720
1718 1721 CTFCONVERT=${TOOLS_PROTO}/opt/onbld/bin/${MACH}/ctfconvert
1719 1722 export CTFCONVERT
1720 1723 CTFMERGE=${TOOLS_PROTO}/opt/onbld/bin/${MACH}/ctfmerge
1721 1724 export CTFMERGE
1722 1725
1723 1726 PATH="${TOOLS_PROTO}/opt/onbld/bin/${MACH}:${PATH}"
1724 1727 PATH="${TOOLS_PROTO}/opt/onbld/bin:${PATH}"
1725 1728 export PATH
1726 1729
1727 1730 echo "\n==== New environment settings. ====\n" >> $LOGFILE
1728 1731 echo "STABS=${STABS}" >> $LOGFILE
1729 1732 echo "CTFSTABS=${CTFSTABS}" >> $LOGFILE
1730 1733 echo "CTFCONVERT=${CTFCONVERT}" >> $LOGFILE
1731 1734 echo "CTFMERGE=${CTFMERGE}" >> $LOGFILE
1732 1735 echo "PATH=${PATH}" >> $LOGFILE
1733 1736 echo "ONBLD_TOOLS=${ONBLD_TOOLS}" >> $LOGFILE
1734 1737 fi
1735 1738 fi
1736 1739
1737 1740 # timestamp the start of the normal build; the findunref tool uses it.
1738 1741 touch $SRC/.build.tstamp
1739 1742
1740 1743 normal_build
1741 1744
1742 1745 ORIG_SRC=$SRC
1743 1746 BINARCHIVE=${CODEMGR_WS}/bin-${MACH}.cpio.Z
1744 1747
1745 1748
1746 1749 #
1747 1750 # There are several checks that need to look at the proto area, but
1748 1751 # they only need to look at one, and they don't care whether it's
1749 1752 # DEBUG or non-DEBUG.
1750 1753 #
1751 1754 if [[ "$MULTI_PROTO" = yes && "$D_FLAG" = n ]]; then
1752 1755 checkroot=$ROOT-nd
1753 1756 else
1754 1757 checkroot=$ROOT
1755 1758 fi
1756 1759
1757 1760 if [ "$build_ok" = "y" ]; then
1758 1761 echo "\n==== Creating protolist system file at `date` ====" \
1759 1762 >> $LOGFILE
1760 1763 protolist $checkroot > $ATLOG/proto_list_${MACH}
1761 1764 echo "==== protolist system file created at `date` ====\n" \
1762 1765 >> $LOGFILE
1763 1766
1764 1767 if [ "$N_FLAG" != "y" ]; then
1765 1768
1766 1769 E1=
1767 1770 f1=
1768 1771 for f in $f1; do
1769 1772 if [ -f "$f" ]; then
1770 1773 E1="$E1 -e $f"
1771 1774 fi
1772 1775 done
1773 1776
1774 1777 E2=
1775 1778 f2=
1776 1779 if [ -d "$SRC/pkg" ]; then
1777 1780 f2="$f2 exceptions/packaging"
1778 1781 fi
1779 1782
1780 1783 for f in $f2; do
1781 1784 if [ -f "$f" ]; then
1782 1785 E2="$E2 -e $f"
1783 1786 fi
1784 1787 done
1785 1788 fi
1786 1789
1787 1790 if [ "$N_FLAG" != "y" -a -d $SRC/pkg ]; then
1788 1791 echo "\n==== Validating manifests against proto area ====\n" \
1789 1792 >> $mail_msg_file
1790 1793 ( cd $SRC/pkg ; $MAKE -e protocmp ROOT="$checkroot" ) | \
1791 1794 tee $TMPDIR/protocmp_noise >> $mail_msg_file
1792 1795 if [[ -s $TMPDIR/protocmp_noise ]]; then
1793 1796 build_extras_ok=n
1794 1797 fi
1795 1798 fi
1796 1799
1797 1800 if [ "$N_FLAG" != "y" -a -f "$REF_PROTO_LIST" ]; then
1798 1801 echo "\n==== Impact on proto area ====\n" >> $mail_msg_file
1799 1802 if [ -n "$E2" ]; then
1800 1803 ELIST=$E2
1801 1804 else
1802 1805 ELIST=$E1
1803 1806 fi
1804 1807 $PROTOCMPTERSE \
1805 1808 "Files in yesterday's proto area, but not today's:" \
1806 1809 "Files in today's proto area, but not yesterday's:" \
1807 1810 "Files that changed between yesterday and today:" \
1808 1811 ${ELIST} \
1809 1812 -d $REF_PROTO_LIST \
1810 1813 $ATLOG/proto_list_${MACH} \
1811 1814 >> $mail_msg_file
1812 1815 fi
1813 1816 fi
1814 1817
1815 1818 if [[ "$u_FLAG" == "y" && "$build_ok" == "y" && \
1816 1819 "$build_extras_ok" == "y" ]]; then
1817 1820 staffer cp $ATLOG/proto_list_${MACH} \
1818 1821 $PARENT_WS/usr/src/proto_list_${MACH}
1819 1822 fi
1820 1823
1821 1824 # Update parent proto area if necessary. This is done now
1822 1825 # so that the proto area has either DEBUG or non-DEBUG kernels.
1823 1826 # Note that this clears out the lock file, so we can dispense with
1824 1827 # the variable now.
1825 1828 if [ "$U_FLAG" = "y" -a "$build_ok" = "y" ]; then
1826 1829 echo "\n==== Copying proto area to $NIGHTLY_PARENT_ROOT ====\n" | \
1827 1830 tee -a $LOGFILE >> $mail_msg_file
1828 1831 rm -rf $NIGHTLY_PARENT_ROOT/*
1829 1832 unset Ulockfile
1830 1833 mkdir -p $NIGHTLY_PARENT_ROOT
1831 1834 if [[ "$MULTI_PROTO" = no || "$D_FLAG" = y ]]; then
1832 1835 ( cd $ROOT; tar cf - . |
1833 1836 ( cd $NIGHTLY_PARENT_ROOT; umask 0; tar xpf - ) ) 2>&1 |
1834 1837 tee -a $mail_msg_file >> $LOGFILE
1835 1838 fi
1836 1839 if [[ "$MULTI_PROTO" = yes && "$F_FLAG" = n ]]; then
1837 1840 rm -rf $NIGHTLY_PARENT_ROOT-nd/*
1838 1841 mkdir -p $NIGHTLY_PARENT_ROOT-nd
1839 1842 cd $ROOT-nd
1840 1843 ( tar cf - . |
1841 1844 ( cd $NIGHTLY_PARENT_ROOT-nd; umask 0; tar xpf - ) ) 2>&1 |
1842 1845 tee -a $mail_msg_file >> $LOGFILE
1843 1846 fi
1844 1847 if [ -n "${NIGHTLY_PARENT_TOOLS_ROOT}" ]; then
1845 1848 echo "\n==== Copying tools proto area to $NIGHTLY_PARENT_TOOLS_ROOT ====\n" | \
1846 1849 tee -a $LOGFILE >> $mail_msg_file
1847 1850 rm -rf $NIGHTLY_PARENT_TOOLS_ROOT/*
1848 1851 mkdir -p $NIGHTLY_PARENT_TOOLS_ROOT
1849 1852 if [[ "$MULTI_PROTO" = no || "$D_FLAG" = y ]]; then
1850 1853 ( cd $TOOLS_PROTO; tar cf - . |
1851 1854 ( cd $NIGHTLY_PARENT_TOOLS_ROOT;
1852 1855 umask 0; tar xpf - ) ) 2>&1 |
1853 1856 tee -a $mail_msg_file >> $LOGFILE
1854 1857 fi
1855 1858 fi
1856 1859 fi
1857 1860
1858 1861 #
1859 1862 # ELF verification: ABI (-A) and runtime (-r) checks
1860 1863 #
1861 1864 if [[ ($build_ok = y) && (($A_FLAG = y) || ($r_FLAG = y)) ]]; then
1862 1865 # Directory ELF-data.$MACH holds the files produced by these tests.
1863 1866 elf_ddir=$SRC/ELF-data.$MACH
1864 1867
1865 1868 # If there is a previous ELF-data backup directory, remove it. Then,
1866 1869 # rotate current ELF-data directory into its place and create a new
1867 1870 # empty directory
1868 1871 rm -rf $elf_ddir.ref
1869 1872 if [[ -d $elf_ddir ]]; then
1870 1873 mv $elf_ddir $elf_ddir.ref
1871 1874 fi
1872 1875 mkdir -p $elf_ddir
1873 1876
1874 1877 # Call find_elf to produce a list of the ELF objects in the proto area.
1875 1878 # This list is passed to check_rtime and interface_check, preventing
1876 1879 # them from separately calling find_elf to do the same work twice.
1877 1880 find_elf -fr $checkroot > $elf_ddir/object_list
1878 1881
1879 1882 if [[ $A_FLAG = y ]]; then
1880 1883 echo "\n==== Check versioning and ABI information ====\n" | \
1881 1884 tee -a $LOGFILE >> $mail_msg_file
1882 1885
1883 1886 # Produce interface description for the proto. Report errors.
1884 1887 interface_check -o -w $elf_ddir -f object_list \
1885 1888 -i interface -E interface.err
1886 1889 if [[ -s $elf_ddir/interface.err ]]; then
1887 1890 tee -a $LOGFILE < $elf_ddir/interface.err \
1888 1891 >> $mail_msg_file
1889 1892 build_extras_ok=n
1890 1893 fi
1891 1894
1892 1895 # If ELF_DATA_BASELINE_DIR is defined, compare the new interface
1893 1896 # description file to that from the baseline gate. Issue a
1894 1897 # warning if the baseline is not present, and keep going.
1895 1898 if [[ "$ELF_DATA_BASELINE_DIR" != '' ]]; then
1896 1899 base_ifile="$ELF_DATA_BASELINE_DIR/interface"
1897 1900
1898 1901 echo "\n==== Compare versioning and ABI information" \
1899 1902 "to baseline ====\n" | \
1900 1903 tee -a $LOGFILE >> $mail_msg_file
1901 1904 echo "Baseline: $base_ifile\n" >> $LOGFILE
1902 1905
1903 1906 if [[ -f $base_ifile ]]; then
1904 1907 interface_cmp -d -o $base_ifile \
1905 1908 $elf_ddir/interface > $elf_ddir/interface.cmp
1906 1909 if [[ -s $elf_ddir/interface.cmp ]]; then
1907 1910 echo | tee -a $LOGFILE >> $mail_msg_file
1908 1911 tee -a $LOGFILE < \
1909 1912 $elf_ddir/interface.cmp \
1910 1913 >> $mail_msg_file
1911 1914 build_extras_ok=n
1912 1915 fi
1913 1916 else
1914 1917 echo "baseline not available. comparison" \
1915 1918 "skipped" | \
1916 1919 tee -a $LOGFILE >> $mail_msg_file
1917 1920 fi
1918 1921
1919 1922 fi
1920 1923 fi
1921 1924
1922 1925 if [[ $r_FLAG = y ]]; then
1923 1926 echo "\n==== Check ELF runtime attributes ====\n" | \
1924 1927 tee -a $LOGFILE >> $mail_msg_file
1925 1928
1926 1929 # If we're doing a DEBUG build the proto area will be left
1927 1930 # with debuggable objects, thus don't assert -s.
1928 1931 if [[ $D_FLAG = y ]]; then
1929 1932 rtime_sflag=""
1930 1933 else
1931 1934 rtime_sflag="-s"
1932 1935 fi
1933 1936 check_rtime -i -m -v $rtime_sflag -o -w $elf_ddir \
1934 1937 -D object_list -f object_list -E runtime.err \
1935 1938 -I runtime.attr.raw
1936 1939 if (( $? != 0 )); then
1937 1940 build_extras_ok=n
1938 1941 fi
1939 1942
1940 1943 # check_rtime -I output needs to be sorted in order to
1941 1944 # compare it to that from previous builds.
1942 1945 sort $elf_ddir/runtime.attr.raw > $elf_ddir/runtime.attr
1943 1946 rm $elf_ddir/runtime.attr.raw
1944 1947
1945 1948 # Report errors
1946 1949 if [[ -s $elf_ddir/runtime.err ]]; then
1947 1950 tee -a $LOGFILE < $elf_ddir/runtime.err \
1948 1951 >> $mail_msg_file
1949 1952 build_extras_ok=n
1950 1953 fi
1951 1954
1952 1955 # If there is an ELF-data directory from a previous build,
1953 1956 # then diff the attr files. These files contain information
1954 1957 # about dependencies, versioning, and runpaths. There is some
1955 1958 # overlap with the ABI checking done above, but this also
1956 1959 # flushes out non-ABI interface differences along with the
1957 1960 # other information.
1958 1961 echo "\n==== Diff ELF runtime attributes" \
1959 1962 "(since last build) ====\n" | \
1960 1963 tee -a $LOGFILE >> $mail_msg_file >> $mail_msg_file
1961 1964
1962 1965 if [[ -f $elf_ddir.ref/runtime.attr ]]; then
1963 1966 diff $elf_ddir.ref/runtime.attr \
1964 1967 $elf_ddir/runtime.attr \
1965 1968 >> $mail_msg_file
1966 1969 fi
1967 1970 fi
1968 1971
1969 1972 # If -u set, copy contents of ELF-data.$MACH to the parent workspace.
1970 1973 if [[ "$u_FLAG" = "y" ]]; then
1971 1974 p_elf_ddir=$PARENT_WS/usr/src/ELF-data.$MACH
1972 1975
1973 1976 # If parent lacks the ELF-data.$MACH directory, create it
1974 1977 if [[ ! -d $p_elf_ddir ]]; then
1975 1978 staffer mkdir -p $p_elf_ddir
1976 1979 fi
1977 1980
1978 1981 # These files are used asynchronously by other builds for ABI
1979 1982 # verification, as above for the -A option. As such, we require
1980 1983 # the file replacement to be atomic. Copy the data to a temp
1981 1984 # file in the same filesystem and then rename into place.
1982 1985 (
1983 1986 cd $elf_ddir
1984 1987 for elf_dfile in *; do
1985 1988 staffer cp $elf_dfile \
1986 1989 ${p_elf_ddir}/${elf_dfile}.new
1987 1990 staffer mv -f ${p_elf_ddir}/${elf_dfile}.new \
1988 1991 ${p_elf_ddir}/${elf_dfile}
1989 1992 done
1990 1993 )
1991 1994 fi
1992 1995 fi
1993 1996
1994 1997 # DEBUG lint of kernel begins
1995 1998
1996 1999 if [ "$i_CMD_LINE_FLAG" = "n" -a "$l_FLAG" = "y" ]; then
1997 2000 if [ "$LINTDIRS" = "" ]; then
1998 2001 # LINTDIRS="$SRC/uts y $SRC/stand y $SRC/psm y"
1999 2002 LINTDIRS="$SRC y"
2000 2003 fi
2001 2004 set $LINTDIRS
2002 2005 while [ $# -gt 0 ]; do
2003 2006 dolint $1 $2; shift; shift
2004 2007 done
2005 2008 else
2006 2009 echo "\n==== No '$MAKE lint' ====\n" >> $LOGFILE
2007 2010 fi
2008 2011
2009 2012 # "make check" begins
2010 2013
2011 2014 if [ "$i_CMD_LINE_FLAG" = "n" -a "$C_FLAG" = "y" ]; then
2012 2015 # remove old check.out
2013 2016 rm -f $SRC/check.out
2014 2017
2015 2018 rm -f $SRC/check-${MACH}.out
2016 2019 cd $SRC
2017 2020 $MAKE -ek check ROOT="$checkroot" 2>&1 | tee -a $SRC/check-${MACH}.out \
2018 2021 >> $LOGFILE
2019 2022 echo "\n==== cstyle/hdrchk errors ====\n" >> $mail_msg_file
2020 2023
2021 2024 grep ":" $SRC/check-${MACH}.out |
2022 2025 egrep -v "Ignoring unknown host" | \
2023 2026 sort | uniq | tee $TMPDIR/check_errors >> $mail_msg_file
2024 2027
2025 2028 if [[ -s $TMPDIR/check_errors ]]; then
2026 2029 build_extras_ok=n
2027 2030 fi
2028 2031 else
2029 2032 echo "\n==== No '$MAKE check' ====\n" >> $LOGFILE
2030 2033 fi
2031 2034
2032 2035 echo "\n==== Find core files ====\n" | \
2033 2036 tee -a $LOGFILE >> $mail_msg_file
2034 2037
2035 2038 find $abssrcdirs -name core -a -type f -exec file {} \; | \
2036 2039 tee -a $LOGFILE >> $mail_msg_file
2037 2040
2038 2041 if [ "$f_FLAG" = "y" -a "$build_ok" = "y" ]; then
2039 2042 echo "\n==== Diff unreferenced files (since last build) ====\n" \
2040 2043 | tee -a $LOGFILE >>$mail_msg_file
2041 2044 rm -f $SRC/unref-${MACH}.ref
2042 2045 if [ -f $SRC/unref-${MACH}.out ]; then
2043 2046 mv $SRC/unref-${MACH}.out $SRC/unref-${MACH}.ref
2044 2047 fi
2045 2048
2046 2049 findunref -S $SCM_TYPE -t $SRC/.build.tstamp -s usr $CODEMGR_WS \
2047 2050 ${TOOLS}/findunref/exception_list 2>> $mail_msg_file | \
2048 2051 sort > $SRC/unref-${MACH}.out
2049 2052
2050 2053 if [ ! -f $SRC/unref-${MACH}.ref ]; then
2051 2054 cp $SRC/unref-${MACH}.out $SRC/unref-${MACH}.ref
2052 2055 fi
2053 2056
2054 2057 diff $SRC/unref-${MACH}.ref $SRC/unref-${MACH}.out >>$mail_msg_file
2055 2058 fi
2056 2059
2057 2060 # Verify that the usual lists of files, such as exception lists,
2058 2061 # contain only valid references to files. If the build has failed,
2059 2062 # then don't check the proto area.
2060 2063 CHECK_PATHS=${CHECK_PATHS:-y}
2061 2064 if [ "$CHECK_PATHS" = y -a "$N_FLAG" != y ]; then
2062 2065 echo "\n==== Check lists of files ====\n" | tee -a $LOGFILE \
2063 2066 >>$mail_msg_file
2064 2067 arg=-b
2065 2068 [ "$build_ok" = y ] && arg=
2066 2069 checkpaths $arg $checkroot > $SRC/check-paths.out 2>&1
2067 2070 if [[ -s $SRC/check-paths.out ]]; then
2068 2071 tee -a $LOGFILE < $SRC/check-paths.out >> $mail_msg_file
2069 2072 build_extras_ok=n
2070 2073 fi
2071 2074 fi
2072 2075
2073 2076 if [ "$M_FLAG" != "y" -a "$build_ok" = y ]; then
2074 2077 echo "\n==== Impact on file permissions ====\n" \
2075 2078 >> $mail_msg_file
2076 2079
2077 2080 abspkg=
2078 2081 for d in $abssrcdirs; do
2079 2082 if [ -d "$d/pkg" ]; then
2080 2083 abspkg="$abspkg $d"
2081 2084 fi
2082 2085 done
2083 2086
2084 2087 if [ -n "$abspkg" ]; then
2085 2088 for d in "$abspkg"; do
2086 2089 ( cd $d/pkg ; $MAKE -e pmodes ) >> $mail_msg_file
2087 2090 done
2088 2091 fi
2089 2092 fi
2090 2093
2091 2094 if [ "$w_FLAG" = "y" -a "$build_ok" = "y" ]; then
2092 2095 if [[ "$MULTI_PROTO" = no || "$D_FLAG" = y ]]; then
2093 2096 do_wsdiff DEBUG $ROOT.prev $ROOT
2094 2097 fi
2095 2098
2096 2099 if [[ "$MULTI_PROTO" = yes && "$F_FLAG" = n ]]; then
2097 2100 do_wsdiff non-DEBUG $ROOT-nd.prev $ROOT-nd
2098 2101 fi
2099 2102 fi
2100 2103
2101 2104 END_DATE=`date`
2102 2105 echo "==== Nightly $maketype build completed: $END_DATE ====" | \
2103 2106 tee -a $LOGFILE >> $build_time_file
2104 2107
2105 2108 typeset -i10 hours
2106 2109 typeset -Z2 minutes
2107 2110 typeset -Z2 seconds
2108 2111
2109 2112 elapsed_time=$SECONDS
2110 2113 ((hours = elapsed_time / 3600 ))
2111 2114 ((minutes = elapsed_time / 60 % 60))
2112 2115 ((seconds = elapsed_time % 60))
2113 2116
2114 2117 echo "\n==== Total build time ====" | \
2115 2118 tee -a $LOGFILE >> $build_time_file
2116 2119 echo "\nreal ${hours}:${minutes}:${seconds}" | \
2117 2120 tee -a $LOGFILE >> $build_time_file
2118 2121
2119 2122 if [ "$u_FLAG" = "y" -a "$f_FLAG" = "y" -a "$build_ok" = "y" ]; then
2120 2123 staffer cp ${SRC}/unref-${MACH}.out $PARENT_WS/usr/src/
2121 2124
2122 2125 #
2123 2126 # Produce a master list of unreferenced files -- ideally, we'd
2124 2127 # generate the master just once after all of the nightlies
2125 2128 # have finished, but there's no simple way to know when that
2126 2129 # will be. Instead, we assume that we're the last nightly to
2127 2130 # finish and merge all of the unref-${MACH}.out files in
2128 2131 # $PARENT_WS/usr/src/. If we are in fact the final ${MACH} to
2129 2132 # finish, then this file will be the authoritative master
2130 2133 # list. Otherwise, another ${MACH}'s nightly will eventually
2131 2134 # overwrite ours with its own master, but in the meantime our
2132 2135 # temporary "master" will be no worse than any older master
2133 2136 # which was already on the parent.
2134 2137 #
2135 2138
2136 2139 set -- $PARENT_WS/usr/src/unref-*.out
2137 2140 cp "$1" ${TMPDIR}/unref.merge
2138 2141 shift
2139 2142
2140 2143 for unreffile; do
2141 2144 comm -12 ${TMPDIR}/unref.merge "$unreffile" > ${TMPDIR}/unref.$$
2142 2145 mv ${TMPDIR}/unref.$$ ${TMPDIR}/unref.merge
2143 2146 done
2144 2147
2145 2148 staffer cp ${TMPDIR}/unref.merge $PARENT_WS/usr/src/unrefmaster.out
2146 2149 fi
2147 2150
2148 2151 #
2149 2152 # All done save for the sweeping up.
2150 2153 # (whichever exit we hit here will trigger the "cleanup" trap which
2151 2154 # optionally sends mail on completion).
2152 2155 #
2153 2156 if [[ "$build_ok" == "y" ]]; then
2154 2157 if [[ "$W_FLAG" == "y" || "$build_extras_ok" == "y" ]]; then
2155 2158 exit 0
2156 2159 fi
2157 2160 fi
2158 2161
2159 2162 exit 1
|
↓ open down ↓ |
1054 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX