1#!/bin/ksh 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# Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. 24# 25# Author: Jeff Bonwick 26# 27# Please report any bugs to bonwick@eng. 28# 29# How Install works: 30# 31# Install performs the following steps: 32# 33# 1. Get the list of modules, configuration files, and links 34# that are desired. 35# 36# 2. Create the requested subset of /kernel in Install's temp space 37# (/tmp/Install.username by default.) 38# 39# 3. Create a tar file (/tmp/Install.username/Install.tar) based on (3). 40# 41# 4. If -n was specified, exit. If a target was specified using -T, 42# rcp the tarfile to the target and exit. If a target was specified 43# using -t, rsh to the target machine and untar the tarfile in the 44# target directory. 45# 46# If any of these steps fail, Install will give you an error message and, 47# in most cases, suggest corrective measures. Then, you can recover the 48# install with "Install -R". (This is not required; it's just faster than 49# starting from scratch.) 50# 51# One final comment: Unfortunately, tar and I disagree on what 52# constitutes a fatal error. (tar -x will exit 0 even if it can't write 53# anything in the current directory.) Thus, I am reduced to grepping stderr 54# for (what I consider) fatal and nonfatal error messages. If you run into 55# a situation where this doesn't behave the way you think it should (either 56# an "Install failed" message after a successful install, or an "Install 57# complete" message after it bombs), please let me know. 58 59# 60# The CDPATH variable causes ksh's `cd' builtin to emit messages to stdout 61# under certain circumstances, which can really screw things up; unset it. 62# 63unset CDPATH 64 65INSTALL=`basename $0` 66DOT=`pwd` 67 68TRAILER="Install.$LOGNAME" 69INSTALL_STATE=${INSTALL_STATE-$HOME/.Install.state} 70export INSTALL_STATE 71INSTALL_DIR=${INSTALL_DIR-/tmp/$TRAILER} 72if [ "`basename $INSTALL_DIR`" != "$TRAILER" ]; then 73 INSTALL_DIR="$INSTALL_DIR/$TRAILER" 74fi 75export INSTALL_DIR 76INSTALL_LIB=${INSTALL_LIB-$HOME/LibInstall} 77export INSTALL_LIB 78INSTALL_RC=${INSTALL_RC-$HOME/.Installrc} 79export INSTALL_RC 80INSTALL_CP=${INSTALL_CP-"cp -p"} 81export INSTALL_CP 82INSTALL_RCP=${INSTALL_RCP-"rcp -p"} 83export INSTALL_RCP 84 85STATE=0 86 87DEFAULT_OPTIONS="-naq" 88GLOM=no 89GLOMNAME=kernel 90IMPL="default" 91WANT32="yes" 92WANT64="yes" 93 94modlist=/tmp/modlist$$ 95# dummy directory for make state files. 96modstatedir=/tmp/modstate$$ 97 98trap 'fail "User Interrupt" "You can resume by typing \"$INSTALL -R\""' 1 2 3 15 99 100function usage { 101 echo "" 102 echo $1 103 echo ' 104Usage: Install [ -w workspace ] 105 [ -s srcdir (default: usr/src/uts) ] 106 [ -k karch (e.g. sun4u; required if not deducible from pwd) ] 107 [ -t target (extract tar file on target, e.g. user@machine:/) ] 108 [ -T target (copy tar file to target, e.g. user@machine:/tmp) ] 109 [ -n (no target, just create tar file in /tmp (default)) ] 110 [ -u (install unix only) ] 111 [ -m (install modules only) ] 112 [ -a (install everything, i.e. unix + modules (default)) ] 113 [ -v (verbose output) ] 114 [ -V (REALLY verbose output) ] 115 [ -q (quiet (default)) ] 116 [ -c (clean up (remove temp files) when done (default) ] 117 [ -p (preserve temp files -- useful for debugging) ] 118 [ -L (library create: put tarfile in $INSTALL_LIB/env.karch) ] 119 [ -l lib (library extract: use $INSTALL_LIB/lib as source) ] 120 [ -D libdir (default: $HOME/LibInstall) ] 121 [ -d tempdir (Install work area (default: /tmp)) ] 122 [ -G glomname (put all files under platform/karch/glomname) ] 123 [ -i impl (e.g. sunfire; recommended with -G) ] 124 [ -x (update /etc/name_to_major et al) ] 125 [ -X (do not update /etc/name_to_major et al (default)) ] 126 [ -P (update /etc/path_to_inst -- generally not advisable) ] 127 [ -h (help -- prints this message) ] 128 [ -R (recover a previous Install) ] 129 [ -o objdir (object directory - either obj or debug (the default)) ] 130 [ -K (do not copy kmdb) ] 131 [ -3 32-bit modules only ] 132 [ -6 64-bit modules only ] 133 [ list of modules to install ] 134 135For full details: 136 137 man -M /ws/on297-gate/public/docs Install 138' 139 exit 1 140} 141 142# 143# Save the current state of Install 144# 145 146function save_state { 147 rm -f $INSTALL_STATE 148 (echo "# State of previous Install 149TARGET=$TARGET 150ENV_PATH=$ENV_PATH 151ENV_NAME=$ENV_NAME 152KARCH=$KARCH 153UTS=$UTS 154INSTALL_DIR=$INSTALL_DIR 155INSTALL_LIB=$INSTALL_LIB 156IMODE=$IMODE 157LIBCREATE=$LIBCREATE 158LIBSRC=$LIBSRC 159VERBOSE=$VERBOSE 160CLEANUP=$CLEANUP 161GLOM=$GLOM 162GLOMNAME=$GLOMNAME 163KMDB=$KMDB 164files='$files' 165STATE=$STATE" >$INSTALL_STATE) || verbose "Warning: cannot save state" 166} 167 168# 169# Restore the previous state of Install 170# 171 172function restore_state { 173 test -s $INSTALL_STATE || fail "Can't find $INSTALL_STATE" 174 eval "`cat $INSTALL_STATE`" 175} 176 177# 178# Install failed -- print error messages and exit 2 179# 180 181function fail { 182 save_state 183 # 184 # We might have gotten here via a trap. So wait for any 185 # children (especially "make modlist") to exit before giving 186 # the error message or cleaning up. 187 # 188 wait 189 while [ $# -gt 0 ] 190 do 191 echo $1 192 shift 193 done 194 rm -rf $modstatedir 195 rm -f $modlist 196 echo "Install failed" 197 exit 2 198} 199 200# 201# Echo a string in verbose mode only 202# 203 204function verbose { 205 test "$VERBOSE" != "q" && echo $1 206} 207 208# 209# hack for tmpfs bug -- remove files gradually 210# 211 212function remove_dir { 213 test -d $1 || return 214 local_dot=`pwd` 215 cd $1 216 touch foo 217 rm -f `find . -type f -print` 218 cd $local_dot 219 rm -rf $1 220} 221 222# 223# Create a directory if it doesn't already exist. 224# mkdir will provide an error message, so don't provide an additional 225# message. 226# 227 228function tstmkdir { 229 [ -d $1 ] || mkdir -p $1 || fail 230} 231 232# 233# Patch up target directories for glommed kernel. 234# usage: fixglom listfile glomname 235# 236 237function fixglom { 238 nawk \ 239 -v glomname=$2 \ 240 -v karch=$KARCH ' 241 $1 == "MOD" || $1 == "SYMLINK" { 242 sub(/^platform.*kernel/, "platform/" karch "/" glomname, $4) 243 sub(/^kernel/, "platform/" karch "/" glomname, $4) 244 sub(/^usr.kernel/, "platform/" karch "/" glomname, $4) 245 print 246 } 247 $1 == "LINK" { 248 sub(/^platform.*kernel/, "platform/" karch "/" glomname, $3) 249 sub(/^kernel/, "platform/" karch "/" glomname, $3) 250 sub(/^usr.kernel/, "platform/" karch "/" glomname, $3) 251 sub(/^platform.*kernel/, "platform/" karch "/" glomname, $5) 252 sub(/^kernel/, "platform/" karch "/" glomname, $5) 253 sub(/^usr.kernel/, "platform/" karch "/" glomname, $5) 254 print 255 } 256 $1 == "CONF" { 257 sub(/^platform.*kernel/, "platform/" karch "/" glomname, $3) 258 sub(/^kernel/, "platform/" karch "/" glomname, $3) 259 sub(/^usr.kernel/, "platform/" karch "/" glomname, $3) 260 print 261 } 262 ' $1 > $1.new 263 mv $1.new $1 264} 265 266# 267# Filter out implementation-specific modules, unless that 268# implementation was requested by the user. 269# usage: filtimpl listfile implname 270# 271 272function filtimpl { 273 nawk \ 274 -v impl=$2 ' 275 $1 == "MOD" || $1 == "SYMLINK" { 276 if ($6 == "all" || $6 == impl) 277 print 278 } 279 $1 == "CONF" { 280 if ($5 == "all" || $5 == impl) 281 print 282 } 283 $1 == "LINK" { 284 if ($7 == "all" || $7 == impl) 285 print 286 } 287 ' $1 > $1.new 288 mv $1.new $1 289} 290 291# 292# Filter the module list to match the user's request. 293# Usage: filtmod listfile modules 294# 295function filtmod { 296 nawk -v reqstring="$2" ' 297 function modmatch(modname) { 298 if (reqstring == "All") { 299 return (1) 300 } else if (reqstring == "Modules") { 301 if (modname != "unix" && modname != "genunix") 302 return (1) 303 } else { 304 if (modname in reqmods) 305 return (1) 306 } 307 return (0) 308 } 309 BEGIN { 310 # 311 # The split call creates indexes 1, 2, 3, ... We want 312 # the module names as indexes. 313 # 314 split(reqstring, tmpmods) 315 for (i in tmpmods) 316 reqmods[tmpmods[i]] = 1 317 } 318 $1 == "MOD" { 319 if (modmatch($3)) 320 print 321 } 322 $1 == "CONF" { 323 if (modmatch($6)) 324 print 325 } 326 $1 == "SYMLINK" { 327 if (modmatch($7)) 328 print 329 } 330 $1 == "LINK" { 331 if (modmatch($4)) 332 print 333 } 334 ' $1 > $1.new 335 mv $1.new $1 336} 337 338# 339# Unpack the crypto tarball into the given tree, then massage the 340# tree so that the binaries are all in objNN or debugNN directories. 341# 342function unpack_crypto { 343 typeset tarfile=$1 344 typeset ctop=$2 345 [ -d "$ctop" ] || fail "Can't create tree for crypto modules." 346 347 [ "$VERBOSE" = "V" ] && echo "unpacking crypto tarball into $ctop..." 348 bzcat "$tarfile" | (cd "$ctop"; tar xf -) 349 350 typeset root="$ctop/proto/root_$MACH" 351 [ $OBJD = obj ] && root="$ctop/proto/root_$MACH-nd" 352 [ -d "$root" ] || fail "Can't unpack crypto tarball." 353 354 (cd "$root"; for d in platform kernel usr/kernel; do 355 [ ! -d $d ] && continue 356 find $d -type f -print 357 done) | while read file; do 358 typeset dir=$(dirname "$file") 359 typeset base=$(basename "$file") 360 typeset type=$(basename "$dir") 361 if [ "$type" = amd64 ]; then 362 newdir="$dir/${OBJD}64" 363 elif [ "$type" = sparcv9 ]; then 364 newdir="$dir/${OBJD}64" 365 else 366 newdir="$dir/${OBJD}32" 367 fi 368 mkdir -p "$root/$newdir" 369 [ "$VERBOSE" = "V" ] && echo "mv $file $newdir" 370 mv "$root/$file" "$root/$newdir" 371 done 372} 373 374# 375# Copy a module, or create a link, as needed. 376# 377function copymod { 378 case $1 in 379 MOD) 380 targdir=$INSTALL_FILES/$4 381 tstmkdir $targdir 382 target=$targdir/$3 383 verbose "$INSTALL_CP $2/${OBJD}$5/$3 $target" 384 $INSTALL_CP $2/${OBJD}$5/$3 $target || \ 385 fail "can't create $target" 386 ;; 387 SYMLINK) 388 targdir=$INSTALL_FILES/$4 389 tstmkdir $targdir 390 target=$targdir/$5 391 rm -f $target 392 verbose "ln -s $3 $target" 393 ln -s $3 $target || fail "can't create $target" 394 ;; 395 LINK) 396 targdir=$INSTALL_FILES/$5 397 tstmkdir $targdir 398 target=$targdir/$6 399 rm -f $target 400 verbose "ln $INSTALL_FILES/$3/$4 $target" 401 ln $INSTALL_FILES/$3/$4 $target || fail "can't create $target" 402 ;; 403 CONF) 404 target=$INSTALL_FILES/$3 405 tstmkdir `dirname $target` 406 conffile=`basename $3` 407 verbose "$INSTALL_CP $4/$conffile $target" 408 $INSTALL_CP $4/$conffile $target 409 ;; 410 *) 411 fail "unrecognized modlist entry: $*" 412 ;; 413 esac 414} 415 416# Sanity-check the given module list. 417function check_modlist { 418 nawk ' 419 BEGIN { 420 nfields["MOD"] = 6 421 nfields["CONF"] = 6 422 nfields["LINK"] = 7 423 nfields["SYMLINK"] = 7 424 } 425 { 426 # This also catches unknown tags. 427 if (nfields[$1] != NF) { 428 print "error: invalid modlist record:" 429 print $0 430 print "expected", nfields[$1], "fields, found", NF 431 status=1 432 } 433 } 434 END { 435 exit status 436 } 437 ' $1 || fail "Errors in kernel module list" 438} 439 440# 441# Copy kernel modules to $INSTALL_DIR 442# 443 444function copy_kernel { 445 446 case $KARCH in 447 sun4*) ISA=sparc; MACH=sparc ;; 448 i86*) ISA=intel; MACH=i386 ;; 449 *) fail "${KARCH}: invalid kernel architecture";; 450 esac 451 export MACH 452 453 if [ "$GLOM" = "no" ]; then 454 verbose "Source = $UTS, ISA = $ISA, kernel = $KARCH" 455 else 456 verbose "Source = $UTS, ISA = $ISA, kernel = $KARCH, impl = $IMPL" 457 fi 458 459 test -d $KARCH || fail "${KARCH}: invalid kernel architecture" 460 test -d $ISA || fail "${ISA}: invalid instruction set architecture" 461 462 tstmkdir $INSTALL_FILES 463 rm -rf $modstatedir 464 tstmkdir $modstatedir 465 export MODSTATE=$modstatedir/state 466 467 # 468 # Figure out which "make" to use. dmake is faster than serial 469 # make, but dmake 7.3 has a bug that causes it to lose log 470 # output, which means the modlist might be incomplete. 471 # 472 make=dmake 473 dmvers=`$make -version` 474 if [ $? -ne 0 ]; then 475 make=/usr/ccs/bin/make 476 elif [[ $dmvers = *Distributed?Make?7.3* ]]; then 477 unset make 478 searchpath="/ws/onnv-tools/SUNWspro/SOS10/bin 479 /opt/SUNWspro/SOS10/bin 480 /opt/SUNWspro/bin" 481 for dmpath in $searchpath; do 482 verbose "Trying $dmpath/dmake" 483 if [ -x $dmpath/dmake ]; then 484 dmvers=`$dmpath/dmake -version` 485 if [[ $dmvers != *Distributed?Make?7.3* ]]; then 486 make="$dmpath/dmake" 487 break; 488 fi 489 fi 490 done 491 if [ -z $make ]; then 492 make=/usr/ccs/bin/make 493 echo "Warning: dmake 7.3 doesn't work with Install;" \ 494 "using $make" 495 fi 496 fi 497 498 # 499 # Get a list of all modules, configuration files, and links 500 # that we might want to install. 501 # 502 verbose "Building module list..." 503 (cd $KARCH; MAKEFLAGS=e $make -K $MODSTATE modlist.karch) | \ 504 egrep "^MOD|^CONF|^LINK|^SYMLINK" > $modlist 505 [ "$VERBOSE" = "V" ] && cat $modlist 506 check_modlist $modlist 507 if [ "$GLOM" = "yes" ]; then 508 fixglom $modlist $GLOMNAME 509 filtimpl $modlist $IMPL 510 fi 511 if [[ -n "$files" && "$files" != All ]]; then 512 filtmod $modlist "$files" 513 fi 514 515 # 516 # Copy modules and create links. For architectures with both 517 # 32- and 64-bit modules, we'll likely have duplicate 518 # configuration files, so do those after filtering out the 519 # duplicates. 520 # 521 verbose "Copying files to ${INSTALL_FILES}..." 522 523 # 524 # The IFS is reset to the newline character so we can buffer the 525 # output of grep without piping it directly to copymod, otherwise 526 # if fail() is called, then it will deadlock in fail()'s wait call 527 # 528 OIFS="$IFS" 529 IFS=" 530 " 531 set -- `grep -v "^CONF" $modlist`; 532 IFS="$OIFS" 533 for onemod in "$@"; do 534 copymod $onemod 535 done 536 537 OIFS="$IFS" 538 IFS=" 539 " 540 set -- `grep "^CONF" $modlist | sort | uniq`; 541 IFS="$OIFS" 542 for onemod in "$@"; do 543 copymod $onemod 544 done 545 546 # 547 # Add the glommed kernel name to the root archive 548 # 549 if [[ $GLOM == "yes" ]]; 550 then 551 filelist="$INSTALL_FILES/etc/boot/solaris/filelist.ramdisk" 552 mkdir -p `dirname $filelist` 553 echo "platform/$KARCH/$GLOMNAME" >$filelist 554 fi 555 556 STATE=1 # all kernel modules copied correctly 557 save_state 558} 559 560function kmdb_copy { 561 typeset src="$1" 562 typeset destdir="$2" 563 564 if [[ ! -d $dest ]] ; then 565 [[ "$VERBOSE" != "q" ]] && echo "mkdir -p $destdir" 566 567 mkdir -p $destdir || fail "failed to create $destdir" 568 fi 569 570 [[ "$VERBOSE" != "q" ]] && echo "cp $src $destdir" 571 572 cp $src $destdir || fail "failed to copy $src to $destdir" 573} 574 575function kmdb_copy_machkmods { 576 typeset modbase="$1" 577 typeset destdir="$2" 578 typeset dir= 579 typeset kmod= 580 581 [[ ! -d $modbase ]] && return 582 583 for dir in $(find $modbase -name kmod) ; do 584 set -- $(echo $dir |tr '/' ' ') 585 586 [[ $# -lt 2 ]] && fail "invalid mach kmod dir $dir" 587 588 shift $(($# - 2)) 589 kmod=$1 590 591 [[ ! -f $dir/$kmod ]] && continue 592 593 kmdb_copy $dir/$kmod $destdir 594 done 595} 596 597function kmdb_copy_karchkmods { 598 typeset modbase="$1" 599 typeset destdir="$2" 600 typeset bitdir="$3" 601 typeset dir= 602 typeset kmod= 603 typeset karch= 604 605 [[ ! -d $modbase ]] && return 606 607 for dir in $(find $modbase -name kmod) ; do 608 set -- $(echo $dir | tr '/' ' ') 609 610 [[ $# -lt 3 ]] && fail "invalid karch kmod dir $dir" 611 612 shift $(($# - 3)) 613 kmod=$1 614 bdir=$2 615 616 [[ $bdir != $bitdir ]] && continue 617 [[ ! -f $dir/$1 ]] && continue 618 619 kmdb_copy $dir/$kmod $destdir 620 done 621} 622 623function kmdb_copy_kmdbmod { 624 typeset kmdbpath="$1" 625 typeset destdir="$2" 626 627 [[ ! -f $kmdbpath ]] && return 1 628 629 kmdb_copy $kmdbpath $destdir 630 631 return 0 632} 633 634function copy_kmdb { 635 typeset kmdbtgtdir=$INSTALL_FILES/platform/$KARCH/$GLOMNAME/misc 636 typeset bitdirs= 637 typeset isadir= 638 typeset b64srcdir= 639 typeset b64tgtdir= 640 typeset b32srcdir= 641 typeset b32tgtdir= 642 typeset machdir= 643 typeset platdir= 644 645 if [[ $KMDB = "no" || ! -d $SRC/cmd/mdb ]] ; then 646 # The kmdb copy was suppressed or the workspace doesn't contain 647 # the mdb subtree. Either way, there's nothing to do. 648 STATE=2 649 save_state 650 return 651 fi 652 653 if [[ $(mach) = "i386" ]] ; then 654 isadir="intel" 655 b64srcdir="amd64" 656 b64tgtdir="amd64" 657 b32srcdir="ia32" 658 b32tgtdir="." 659 else 660 isadir="sparc" 661 b64srcdir="v9" 662 b64tgtdir="sparcv9" 663 b32srcdir="v7" 664 b32tgtdir="." 665 fi 666 667 typeset foundkmdb=no 668 typeset kmdbpath= 669 typeset destdir= 670 671 platdir=$INSTALL_FILES/platform/$KARCH/$GLOMNAME 672 if [[ $GLOM = "yes" ]] ; then 673 machdir=$platdir 674 else 675 machdir=$INSTALL_FILES/kernel 676 fi 677 678 srctrees=$SRC 679 if [[ $WANT64 = "yes" ]] ; then 680 # kmdbmod for sparc and x86 are built and installed 681 # in different places 682 if [[ $(mach) = "i386" ]] ; then 683 kmdbpath=$SRC/cmd/mdb/$isadir/$b64srcdir/kmdb/kmdbmod 684 destdir=$machdir/misc/$b64tgtdir 685 else 686 kmdbpath=$SRC/cmd/mdb/$KARCH/$b64srcdir/kmdb/kmdbmod 687 destdir=$platdir/misc/$b64tgtdir 688 fi 689 690 if kmdb_copy_kmdbmod $kmdbpath $destdir ; then 691 foundkmdb="yes" 692 693 for tree in $srctrees; do 694 kmdb_copy_machkmods \ 695 $tree/cmd/mdb/$isadir/$b64srcdir \ 696 $machdir/kmdb/$b64tgtdir 697 kmdb_copy_karchkmods $tree/cmd/mdb/$KARCH \ 698 $platdir/kmdb/$b64tgtdir $b64srcdir 699 done 700 fi 701 fi 702 703 if [[ $WANT32 = "yes" ]] ; then 704 kmdbpath=$SRC/cmd/mdb/$isadir/$b32srcdir/kmdb/kmdbmod 705 destdir=$machdir/misc/$b32tgtdir 706 707 if kmdb_copy_kmdbmod $kmdbpath $destdir ; then 708 foundkmdb="yes" 709 710 for tree in $srctrees; do 711 kmdb_copy_machkmods \ 712 $tree/cmd/mdb/$isadir/$b32srcdir \ 713 $machdir/kmdb/$b32tgtdir 714 kmdb_copy_karchkmods $tree/cmd/mdb/$KARCH \ 715 $platdir/kmdb/$b32tgtdir $b32srcdir 716 done 717 fi 718 fi 719 720 # A kmdb-less workspace isn't fatal, but it is potentially problematic, 721 # as the changes made to uts may have altered something upon which kmdb 722 # depends. We will therefore remind the user that they haven't built it 723 # yet. 724 if [[ $foundkmdb != "yes" ]] ; then 725 echo "WARNING: kmdb isn't built, and won't be included" 726 fi 727 728 STATE=2 729 save_state 730 return 731} 732 733# 734# Make tarfile 735# 736 737function make_tarfile { 738 echo "Creating tarfile $TARFILE" 739 test -d $INSTALL_FILES || fail "Can't find $INSTALL_FILES" 740 cd $INSTALL_FILES 741 rm -f $TARFILE files 742 743 # We don't want to change the permissions or ownership of pre-existing 744 # directories on the target machine, so we're going to take care to 745 # avoid including directories in the tarfile. On extraction, tar won't 746 # modify pre-existing directories, and will create non-existent ones as 747 # the user doing the extraction. 748 find . ! -type d -print |fgrep -vx './files' >files 749 tar cf $TARFILE -I files || fail "Couldn't create tarfile $TARFILE" 750 STATE=3 751} 752 753# 754# Routines to copy files to the target machine 755# 756 757function remote_fail { 758 fail "" "$1" "" \ 759 "Make sure that $TARGET_MACHINE is up." \ 760"Check .rhosts in the home directory of user $TARGET_USER on $TARGET_MACHINE." \ 761 "Check /etc/hosts.equiv, /etc/passwd, and /etc/shadow." \ 762 "Change permissions on $TARGET_MACHINE as necessary." \ 763 "Then, use \"$INSTALL -R\" to resume the install." "" 764} 765 766function remote_install { 767 if [ "$IMODE" = "n" ]; then 768 STATE=4 769 return 0 770 fi 771 test -s $TARFILE || fail "$TARFILE missing or empty" 772 verbose "Installing system on $TARGET" 773 test -d $INSTALL_DIR || fail "Can't find $INSTALL_DIR" 774 cd $INSTALL_DIR 775 rm -f errors fatal nonfatal 776 if [ "$IMODE" = "T" ]; then 777 EMESG="Can't rcp to $TARGET" 778 touch errors 779 sh -e${SHV}c "$INSTALL_RCP $TARFILE $TARGET/Install.tar" 780 else 781 EMESG="Can't rsh to $TARGET_MACHINE" 782 rsh -l $TARGET_USER $TARGET_MACHINE \ 783 "(cd $TARGET_DIR; /usr/bin/tar x${V}f -)" \ 784 <$TARFILE 2>errors 785 fi 786 test $? -ne 0 && remote_fail "$EMESG" 787 cd $INSTALL_DIR 788 egrep "set time|warning|blocksize" errors >nonfatal 789 egrep -v "set time|warning|blocksize" errors >fatal 790 if [ -s fatal ]; then 791 echo "Fatal errors from rsh:" 792 cat fatal 793 remote_fail "Can't install on $TARGET_MACHINE" 794 fi 795 if [ -s nonfatal -a "$VERBOSE" != "q" ]; then 796 echo "Non-fatal errors from rsh:" 797 cat nonfatal 798 fi 799 rm -f fatal nonfatal errors 800 test "$IMODE" = "T" && echo "Files can be extracted on \ 801$TARGET_MACHINE using 'tar xvf $TARGET_DIR/Install.tar'" 802 STATE=4 803} 804 805function okexit { 806 cd /tmp 807 test "$CLEANUP" = c && remove_dir $INSTALL_DIR 808 save_state 809 rm -rf $modstatedir 810 rm -f $modlist 811 [ -n "$cryptotree" ] && rm -rf "$cryptotree" 812 verbose "Install complete" 813 exit 0 814} 815 816# 817# Process options 818# 819 820RCOPTS="" 821LIBCREATE="no" 822LIBSRC="" 823ENV_PATH=$CODEMGR_WS 824OBJD="debug" 825KMDB="yes" 826 827test -s $INSTALL_RC && RCOPTS=`cat $INSTALL_RC` 828set $INSTALL $DEFAULT_OPTIONS $RCOPTS $* 829shift 830 831while getopts acd:D:G:hi:k:Kl:Lmno:pPqRs:t:T:uvVw:xX36 opt 832do 833 case $opt in 834 w) ENV_PATH="$OPTARG"; SRC="$ENV_PATH/usr/src";; 835 s) UTS="$OPTARG";; 836 k) KARCH="$OPTARG";; 837 t|T) TARGET="$OPTARG"; IMODE=$opt; CLEANUP="c";; 838 n) TARGET=""; IMODE="n"; CLEANUP="p";; 839 u) files="unix genunix";; 840 m) files="Modules";; 841 a) files="All";; 842 v|V|q) VERBOSE=$opt;; 843 c|p) CLEANUP=$opt;; 844 L) LIBCREATE="yes"; CLEANUP="c";; 845 l) LIBSRC="$OPTARG";; 846 D) INSTALL_LIB="$OPTARG";; 847 d) INSTALL_DIR="$OPTARG/$TRAILER";; 848 G) GLOM=yes; GLOMNAME="$OPTARG";; 849 P|X|x) echo "-$opt is obsolete; ignored";; 850 h) usage "${INSTALL}: installs unix and modules";; 851 R) x=$OPTIND; restore_state; OPTIND=$x;; 852 i) IMPL="$OPTARG";; 853 o) OBJD="$OPTARG";; 854 K) KMDB="no";; 855 3) WANT64="no";; 856 6) WANT32="no";; 857 \?) usage "Illegal option";; 858 esac 859done 860shift `expr $OPTIND - 1` 861 862ENV_NAME=`basename $ENV_PATH` 863 864# 865# The rest of the command line is a list of individual files to copy. 866# If non-null, this list overrides the -uma options. 867# 868 869if [[ $# -gt 0 ]] ; then 870 files="$*" 871 KMDB="no" 872fi 873 874case "$VERBOSE" in 875 v) V="v"; SHV="x";; 876 V) V="v"; SHV="x"; set -x;; 877 q) V=""; SHV="";; 878esac 879 880# 881# Create temp directory for Install's files 882# 883 884tstmkdir $INSTALL_DIR 885 886TARFILE=$INSTALL_DIR/Install.${KARCH}.tar 887INSTALL_FILES=$INSTALL_DIR/$KARCH 888 889# 890# Extract the target machine and target directory from a target of the 891# form [user@]machine:/dir . 892# 893 894if [ "$IMODE" != "n" ]; then 895 eval `echo $TARGET | nawk -F':' '{ 896 if (NF != 2 || !length($1) || !length($2)) 897 print "usage \"Invalid target\"" 898 m = $1; d = $2 899 if ($1 ~ /@/) { 900 k = split($1, f, "@"); 901 if (k != 2 || !length(f[1]) || !length (f[2])) 902 print "usage \"Invalid target\"" 903 u = f[1]; m = f[2] 904 } 905 print "TARGET_USER=" u ";" 906 print "TARGET_MACHINE=" m ";" 907 print "TARGET_DIR=" d ";" 908 }'` 909 if [ -z "$TARGET_USER" ]; then 910 TARGET_USER=$LOGNAME 911 fi 912fi 913 914# 915# Allow the use of library source or target for the install 916# 917 918if [ -n "$LIBSRC" ]; then 919 LIBSRC="`basename $LIBSRC .tar`.tar" 920 TARFILE=$INSTALL_LIB/$LIBSRC 921 test -s $TARFILE || fail "Can't find tarfile $TARFILE" 922 verbose "Installing from library tarfile $TARFILE" 923 STATE=3 924elif [ "$LIBCREATE" = "yes" ]; then 925 tstmkdir $INSTALL_LIB 926 TARFILE="$INSTALL_LIB/${ENV_NAME}.${KARCH}.tar" 927fi 928 929# 930# The next few lines allow recovery and activation with -R, 931# and library installs with -l. 932# 933 934[[ $STATE -eq 1 ]] && copy_kmdb 935[[ $STATE -eq 2 ]] && make_tarfile 936[[ $STATE -eq 3 ]] && remote_install 937[[ $STATE -eq 4 ]] && okexit 938 939save_state 940 941cd $DOT 942DOTDOT=`cd ..; pwd` 943 944# 945# Try to be smart: if DOTDOT ends in uts, then infer UTS and KARCH from DOT 946# Otherwise, if SRC is set, infer UTS = $SRC/uts. 947# 948 949if [ "`basename $DOTDOT`" = "uts" ]; then 950 UTS=$DOTDOT 951 KARCH=`basename $DOT` 952 if [ ! -n "$SRC" ]; then 953 SRC=`dirname $DOTDOT` 954 verbose "Setting SRC to $SRC" 955 fi 956 export SRC 957fi 958 959if [ -z "$UTS" -a -n "$SRC" ]; then 960 UTS="${SRC}/uts" 961 test -n "$KARCH" || fail "no karch specified (e.g. -k sun4u)" 962fi 963 964if [ "$LIBCREATE" = "yes" ]; then 965 TARFILE=$INSTALL_LIB/${ENV_NAME}.${KARCH}.tar 966else 967 TARFILE=$INSTALL_DIR/Install.${KARCH}.tar 968fi 969INSTALL_FILES=$INSTALL_DIR/$KARCH 970save_state 971 972cd $DOT 973test -z "$UTS" && fail 'Cannot find kernel sources -- $SRC not set' 974test -d "$UTS" || fail "${UTS}: no such directory" 975 976# 977# Convert UTS into an absolute path. 978# 979 980cd $UTS 981UTS=`pwd` 982 983test "`basename $UTS`" = "uts" || \ 984 verbose "Warning: source path $UTS doesn't end in 'uts'" 985 986remove_dir $INSTALL_DIR/$KARCH 987rm -f $TARFILE 988 989copy_kernel # sets STATE=1 if successful 990copy_kmdb # sets STATE=2 if successful 991make_tarfile # sets STATE=3 if successful 992remote_install # sets STATE=4 if successful 993 994okexit 995