Chapter 3. Installing Additional Server Machines

Table of Contents

Installing an Additional File Server Machine
Creating AFS Directories and Performing Platform-Specific Procedures
Starting Server Programs
Installing Client Functionality
Completing the Installation
Installing Database Server Functionality
Summary of Procedures
Instructions
Removing Database Server Functionality
Summary of Procedures
Instructions

Instructions for the following procedures appear in the indicated section of this chapter.

The instructions make the following assumptions.

Installing an Additional File Server Machine

The procedure for installing a new file server machine is similar to installing the first file server machine in your cell. There are a few parts of the installation that differ depending on whether the machine is the same AFS system type as an existing file server machine or is the first file server machine of its system type in your cell. The differences mostly concern the source for the needed binaries and files, and what portions of the Update Server you install:

  • On a new system type, you must load files and binaries from the OpenAFS distribution. You may install the server portion of the Update Server to make this machine the binary distribution machine for its system type.

  • On an existing system type, you can copy files and binaries from a previously installed file server machine, rather than from the OpenAFS distribution. You may install the client portion of the Update Server to accept updates of binaries, because a previously installed machine of this type was installed as the binary distribution machine.

  • On some system types, distribtution of the appropriate binaries may be acheived using the system's own package management system. In these cases, it is recommended that this system is used, rather than installing the binaries by hand.

These instructions are brief; for more detailed information, refer to the corresponding steps in Installing the First AFS Machine.

To install a new file server machine, perform the following procedures:

  1. Copy needed binaries and files onto this machine's local disk, as required.

  2. Incorporate AFS modifications into the kernel

  3. Configure partitions for storing volumes

  4. Replace the standard fsck utility with the AFS-modified version on some system types

  5. Start the Basic OverSeer (BOS) Server

  6. Start the appropriate portion of the Update Server, if required

  7. Start the fs process, which incorporates three component processes: the File Server, Volume Server, and Salvager

After completing the instructions in this section, you can install database server functionality on the machine according to the instructions in Installing Database Server Functionality.

Creating AFS Directories and Performing Platform-Specific Procedures

If your operating systems AFS distribution is supplied as packages, such as .rpms or .debs, you should just install those packages as detailed in the previous chapter.

Create the /usr/afs and /usr/vice/etc directories on the local disk. Subsequent instructions copy files from the AFS distribution into them, at the appropriate point for each system type.

   # mkdir /usr/afs
   # mkdir /usr/afs/bin
   # mkdir /usr/vice
   # mkdir /usr/vice/etc
   # mkdir /tmp/afsdist     

As on the first file server machine, the initial procedures in installing an additional file server machine vary a good deal from platform to platform. For convenience, the following sections group together all of the procedures for a system type. Most of the remaining procedures are the same on every system type, but differences are noted as appropriate. The initial procedures are the following.

  • Incorporate AFS modifications into the kernel, either by using a dynamic kernel loader program or by building a new static kernel

  • Configure server partitions to house AFS volumes

  • Replace the operating system vendor's fsck program with a version that recognizes AFS data

  • If the machine is to remain an AFS client machine, modify the machine's authentication system so that users obtain an AFS token as they log into the local file system. (For this procedure only, the instructions direct you to the platform-specific section in Installing the First AFS Machine.)

To continue, proceed to the section for this system type:

Getting Started on AIX Systems

Begin by running the AFS initialization script to call the AIX kernel extension facility, which dynamically loads AFS modifications into the kernel. Then configure partitions and replace the AIX fsck program with a version that correctly handles AFS volumes.

  1. Unpack the distribution tarball. The examples below assume that you have unpacked the files into the /tmp/afsdist directory. If you pick a different location, substitute this in all of the following examples. Once you have unpacked the distribution, change directory as indicated.

       # cd /tmp/afsdist/rs_aix42/dest/root.client/usr/vice/etc
    
  2. Copy the AFS kernel library files to the local /usr/vice/etc/dkload directory, and the AFS initialization script to the /etc directory.

       # cp -rp  dkload  /usr/vice/etc
       # cp -p  rc.afs  /etc/rc.afs
    
  3. Edit the /etc/rc.afs script, setting the NFS variable as indicated.

    If the machine is not to function as an NFS/AFS Translator, set the NFS variable as follows.

       NFS=$NFS_NONE
    

    If the machine is to function as an NFS/AFS Translator and is running AIX 4.2.1 or higher, set the NFS variable as follows. Note that NFS must already be loaded into the kernel, which happens automatically on systems running AIX 4.1.1 and later, as long as the file /etc/exports exists.

       NFS=$NFS_IAUTH
    
  4. Invoke the /etc/rc.afs script to load AFS modifications into the kernel. You can ignore any error messages about the inability to start the BOS Server or the Cache Manager or AFS client.

       # /etc/rc.afs
    

  5. Create a directory called /vicepxx for each AFS server partition you are configuring (there must be at least one). Repeat the command for each partition.

       # mkdir /vicepxx
    
  6. Use the SMIT program to create a journaling file system on each partition to be configured as an AFS server partition.

  7. Mount each partition at one of the /vicepxx directories. Choose one of the following three methods:

    • Use the SMIT program

    • Use the mount -a command to mount all partitions at once

    • Use the mount command on each partition in turn

    Also configure the partitions so that they are mounted automatically at each reboot. For more information, refer to the AIX documentation.

  8. On systems prior to AIX 5.1, move the AIX fsck program helper to a safe location and install the version from the AFS distribution in its place. Note that on AIX 5.1, and later, systems this step is not required, and the v3fshelper program is not shipped for these systems.

    The AFS binary distribution must still be available in the /tmp/afsdist directory.

       # cd /sbin/helpers
       # mv v3fshelper v3fshelper.noafs
       # cp -p /tmp/afsdist/rs_aix42/dest/root.server/etc/v3fshelper v3fshelper
    
  9. If the machine is to remain an AFS client, incorporate AFS into its authentication system, following the instructions in Enabling AFS Login on AIX Systems.

  10. Proceed to Starting Server Programs.

Getting Started on HP-UX Systems

Begin by building AFS modifications into the kernel, then configure server partitions and replace the HP-UX fsck program with a version that correctly handles AFS volumes.

If the machine's hardware and software configuration exactly matches another HP-UX machine on which AFS is already built into the kernel, you can copy the kernel from that machine to this one. In general, however, it is better to build AFS modifications into the kernel on each machine according to the following instructions.

  1. Move the existing kernel-related files to a safe location.

       # cp /stand/vmunix /stand/vmunix.noafs
       # cp /stand/system /stand/system.noafs
    
  2. Unpack the OpenAFS HP-UX distribution tarball. The examples below assume that you have unpacked the files into the /tmp/afsdist directory. If you pick a different location, substitute this in all of the following examples. Once you have unpacked the distribution, change directory as indicated.

       # cd /tmp/afsdist/hp_ux110/dest/root.client
    
  3. Copy the AFS initialization file to the local directory for initialization files (by convention, /sbin/init.d on HP-UX machines). Note the removal of the .rc extension as you copy the file.

       # cp usr/vice/etc/afs.rc  /sbin/init.d/afs
    
  4. Copy the file afs.driver to the local /usr/conf/master.d directory, changing its name to afs as you do.

       # cp  usr/vice/etc/afs.driver  /usr/conf/master.d/afs
    
  5. Copy the AFS kernel module to the local /usr/conf/lib directory.

    If the machine's kernel supports NFS server functionality:

       # cp bin/libafs.a /usr/conf/lib   
    

    If the machine's kernel does not support NFS server functionality, change the file's name as you copy it:

       # cp bin/libafs.nonfs.a /usr/conf/lib/libafs.a
    
  6. Incorporate the AFS driver into the kernel, either using the SAM program or a series of individual commands.

    • To use the SAM program:

      1. Invoke the SAM program, specifying the hostname of the local machine as local_hostname. The SAM graphical user interface pops up.

           # sam -display local_hostname:0 
        
      2. Choose the Kernel Configuration icon, then the Drivers icon. From the list of drivers, select afs.

      3. Open the pull-down Actions menu and choose the Add Driver to Kernel option.

      4. Open the Actions menu again and choose the Create a New Kernel option.

      5. Confirm your choices by choosing Yes and OK when prompted by subsequent pop-up windows. The SAM program builds the kernel and reboots the system.

      6. Login again as the superuser root.

           login: root
           Password: root_password
        
    • To use individual commands:

      1. Edit the file /stand/system, adding an entry for afs to the Subsystems section.

      2. Change to the /stand/build directory and issue the mk_kernel command to build the kernel.

           # cd /stand/build
           # mk_kernel
        
      3. Move the new kernel to the standard location (/stand/vmunix), reboot the machine to start using it, and login again as the superuser root.

           # mv /stand/build/vmunix_test /stand/vmunix
           # cd /
           # shutdown -r now             
           login: root
           Password: root_password
        
  7. Create a directory called /vicepxx for each AFS server partition you are configuring (there must be at least one). Repeat the command for each partition.

       # mkdir /vicepxx
    
  8. Use the SAM program to create a file system on each partition. For instructions, consult the HP-UX documentation.

  9. On some HP-UX systems that use logical volumes, the SAM program automatically mounts the partitions. If it has not, mount each partition by issuing either the mount -a command to mount all partitions at once or the mount command to mount each partition in turn.

  10. Create the command configuration file /sbin/lib/mfsconfig.d/afs. Use a text editor to place the indicated two lines in it:

       format_revision 1
       fsck            0        m,P,p,d,f,b:c:y,n,Y,N,q,
    
  11. Create and change directory to an AFS-specific command directory called /sbin/fs/afs.

       # mkdir /sbin/fs/afs
       # cd  /sbin/fs/afs
    
  12. Copy the AFS-modified version of the fsck program (the vfsck binary) and related files from the distribution directory to the new AFS-specific command directory.

       # cp -p /tmp/afsdist/hp_ux110/dest/root.server/etc/*  .
    
  13. Change the vfsck binary's name to fsck and set the mode bits appropriately on all of the files in the /sbin/fs/afs directory.

       # mv  vfsck  fsck
       # chmod  755  *
    
  14. Edit the /etc/fstab file, changing the file system type for each AFS server partition from hfs to afs. This ensures that the AFS-modified fsck program runs on the appropriate partitions.

    The sixth line in the following example of an edited file shows an AFS server partition, /vicepa.

       /dev/vg00/lvol1 / hfs defaults 0 1
       /dev/vg00/lvol4 /opt hfs defaults 0 2
       /dev/vg00/lvol5 /tmp hfs defaults 0 2
       /dev/vg00/lvol6 /usr hfs defaults 0 2
       /dev/vg00/lvol8 /var hfs defaults 0 2
       /dev/vg00/lvol9 /vicepa afs defaults 0 2
       /dev/vg00/lvol7 /usr/vice/cache hfs defaults 0 2
    
  15. If the machine is to remain an AFS client, incorporate AFS into its authentication system, following the instructions in Enabling AFS Login on HP-UX Systems.

  16. Proceed to Starting Server Programs.

Getting Started on IRIX Systems

Begin by incorporating AFS modifications into the kernel. Either use the ml dynamic loader program, or build a static kernel. Then configure partitions to house AFS volumes. AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

You do not need to replace IRIX fsck program, because the version that SGI distributes handles AFS volumes properly.

  1. Prepare for incorporating AFS into the kernel by performing the following procedures.

    1. Unpack the OpenAFS IRIX distribution tarball. The examples below assume that you have unpacked the files into the /tmp/afsdist directory. If you pick a different location, substitue this in all of the following examples. Once you have unpacked the distribution, change directory as indicated.

         # cd /tmp/afsdist/sgi_65/dest/root.client
      
    2. Copy the AFS initialization script to the local directory for initialization files (by convention, /etc/init.d on IRIX machines). Note the removal of the .rc extension as you copy the script.

         # cp -p   usr/vice/etc/afs.rc  /etc/init.d/afs
      
    3. Issue the uname -m command to determine the machine's CPU board type. The IPxx value in the output must match one of the supported CPU board types listed in the OpenAFS Release Notes for the current version of AFS.

         # uname -m
      
  2. Incorporate AFS into the kernel, either using the ml program or by building AFS modifications into a static kernel.

    • To use the ml program:

      1. Create the local /usr/vice/etc/sgiload directory to house the AFS kernel library file.

           # mkdir /usr/vice/etc/sgiload
        
      2. Copy the appropriate AFS kernel library file to the /usr/vice/etc/sgiload directory. The IPxx portion of the library file name must match the value previously returned by the uname -m command. Also choose the file appropriate to whether the machine's kernel supports NFS server functionality (NFS must be supported for the machine to act as an NFS/AFS Translator). Single- and multiprocessor machines use the same library file.

        (You can choose to copy all of the kernel library files into the /usr/vice/etc/sgiload directory, but they require a significant amount of space.)

        If the machine's kernel supports NFS server functionality:

           # cp -p  usr/vice/etc/sgiload/libafs.IPxx.o  /usr/vice/etc/sgiload   
        

        If the machine's kernel does not support NFS server functionality:

           # cp -p  usr/vice/etc/sgiload/libafs.IPxx.nonfs.o   \
                           /usr/vice/etc/sgiload
        
      3. Issue the chkconfig command to activate the afsml configuration variable.

           # /etc/chkconfig -f afsml on   
        

        If the machine is to function as an NFS/AFS Translator and the kernel supports NFS server functionality, activate the afsxnfs variable.

           # /etc/chkconfig -f afsxnfs on
        
      4. Run the /etc/init.d/afs script to load AFS extensions into the kernel. The script invokes the ml command, automatically determining which kernel library file to use based on this machine's CPU type and the activation state of the afsxnfs variable.

        You can ignore any error messages about the inability to start the BOS Server or the Cache Manager or AFS client.

           # /etc/init.d/afs start
        
      5. Proceed to Step 3.

    • If you prefer to build a kernel, and the machine's hardware and software configuration exactly matches another IRIX machine on which AFS is already built into the kernel, you can copy the kernel from that machine to this one. In general, however, it is better to build AFS modifications into the kernel on each machine according to the following instructions.

      1. Copy the kernel initialization file afs.sm to the local /var/sysgen/system directory, and the kernel master file afs to the local /var/sysgen/master.d directory.

           # cp -p  bin/afs.sm  /var/sysgen/system
           # cp -p  bin/afs  /var/sysgen/master.d
        
      2. Copy the appropriate AFS kernel library file to the local file /var/sysgen/boot/afs.a; the IPxx portion of the library file name must match the value previously returned by the uname -m command. Also choose the file appropriate to whether the machine's kernel supports NFS server functionality (NFS must be supported for the machine to act as an NFS/AFS Translator). Single- and multiprocessor machines use the same library file.

        If the machine's kernel supports NFS server functionality:

           # cp -p   bin/libafs.IPxx.a   /var/sysgen/boot/afs.a   
        

        If the machine's kernel does not support NFS server functionality:

           # cp -p  bin/libafs.IPxx.nonfs.a  /var/sysgen/boot/afs.a
        
      3. Issue the chkconfig command to deactivate the afsml configuration variable.

           # /etc/chkconfig -f afsml off   
        

        If the machine is to function as an NFS/AFS Translator and the kernel supports NFS server functionality, activate the afsxnfs variable.

           # /etc/chkconfig -f afsxnfs on
        
      4. Copy the existing kernel file, /unix, to a safe location. Compile the new kernel, which is created in the file /unix.install. It overwrites the existing /unix file when the machine reboots in the next step.

           # cp /unix /unix_noafs
           # autoconfig
        
      5. Reboot the machine to start using the new kernel, and login again as the superuser root.

           # cd /
           # shutdown -i6 -g0 -y
           login: root
           Password: root_password
        
  3. Create a directory called /vicepxx for each AFS server partition you are configuring (there must be at least one). Repeat the command for each partition.

       # mkdir /vicepxx
    
  4. Add a line with the following format to the file systems registry file, /etc/fstab, for each partition (or logical volume created with the XLV volume manager) to be mounted on one of the directories created in the previous step.

    For an XFS partition or logical volume:

       /dev/dsk/disk  /vicepxx  xfs  rw,raw=/dev/rdsk/disk  0  0   
    

    For an EFS partition:

       /dev/dsk/disk  /vicepxx  efs  rw,raw=/dev/rdsk/disk  0  0   
    

    The following are examples of an entry for each file system type:

       /dev/dsk/dks0d2s6 /vicepa  xfs rw,raw=/dev/rdsk/dks0d2s6  0 0
       /dev/dsk/dks0d3s1 /vicepb  efs rw,raw=/dev/rdsk/dks0d3s1  0 0
    
  5. Create a file system on each partition that is to be mounted on a /vicepxx directory. The following commands are probably appropriate, but consult the IRIX documentation for more information. In both cases, raw_device is a raw device name like /dev/rdsk/dks0d0s0 for a single disk partition or /dev/rxlv/xlv0 for a logical volume.

    For XFS file systems, include the indicated options to configure the partition or logical volume with inodes large enough to accommodate AFS-specific information:

       # mkfs -t xfs -i size=512 -l size=4000b raw_device   
    

    For EFS file systems:

       # mkfs -t efs raw_device
    
  6. Mount each partition by issuing either the mount -a command to mount all partitions at once or the mount command to mount each partition in turn.

  7. (Optional) If you have configured partitions or logical volumes to use XFS, issue the following command to verify that the inodes are configured properly (are large enough to accommodate AFS-specific information). If the configuration is correct, the command returns no output. Otherwise, it specifies the command to run in order to configure each partition or logical volume properly.

       # /usr/afs/bin/xfs_size_check
    
  8. If the machine is to remain an AFS client, incorporate AFS into its authentication system, following the instructions in Enabling AFS Login on IRIX Systems.

  9. Proceed to Starting Server Programs.

Getting Started on Linux Systems

Begin by running the AFS initialization script to call the insmod program, which dynamically loads AFS modifications into the kernel. Then create partitions for storing AFS volumes. You do not need to replace the Linux fsck program.

The procedure for starting up OpenAFS depends upon your distribution

  1. For Fedora and RedHat Enterprise Linux systems (or their derivateds), download and install the RPM set for your operating system from the OpenAFS distribution site. You will need the openafs and openafs-server packages, along with an openafs-kernel package matching your current, running, kernel. If you wish to install client functionality, you will also require the openafs-client package.

    You can find the version of your current kernel by running

      # uname -r
    2.6.20-1.2933.fc6
    

    Once downloaded, the packages may be installed with the rpm command

      # rpm -U openafs-* openafs-client-* openafs-server-* openafs-kernel-*
    
  2. For systems which are provided as a tarball, or built from source, unpack the distribution tarball. The examples below assume that you have unpacked the files into the /tmp/afsdistdirectory. If you pick a different location, substitute this in all of the following examples. Once you have unpacked the distribution, change directory as indicated.

      # cd /tmp/afsdist/linux/dest/root.client/usr/vice/etc
    

    Copy the AFS kernel library files to the local /usr/vice/etc/modload directory. The filenames for the libraries have the format libafs-version.o, where version indicates the kernel build level. The string .mp in the version indicates that the file is appropriate for machines running a multiprocessor kernel.

       # cp -rp  modload  /usr/vice/etc
    

    Copy the AFS initialization script to the local directory for initialization files (by convention, /etc/rc.d/init.d on Linux machines). Note the removal of the .rc extension as you copy the script.

       # cp -p   afs.rc  /etc/rc.d/init.d/afs 
    
  3. Create a directory called /vicepxx for each AFS server partition you are configuring (there must be at least one). Repeat the command for each partition.

       # mkdir /vicepxx
    
  4. Add a line with the following format to the file systems registry file, /etc/fstab, for each directory just created. The entry maps the directory name to the disk partition to be mounted on it.

       /dev/disk  /vicepxx  ext2  defaults  0  2   
    

    The following is an example for the first partition being configured.

       /dev/sda8 /vicepa ext2 defaults 0 2
    
  5. Create a file system on each partition that is to be mounted at a /vicepxx directory. The following command is probably appropriate, but consult the Linux documentation for more information.

       # mkfs -v /dev/disk
    
  6. Mount each partition by issuing either the mount -a command to mount all partitions at once or the mount command to mount each partition in turn.

  7. If the machine is to remain an AFS client, incorporate AFS into its authentication system, following the instructions in Enabling AFS Login on Linux Systems.

  8. Proceed to Starting Server Programs.

Getting Started on Solaris Systems

Begin by running the AFS initialization script to call the modload program, which dynamically loads AFS modifications into the kernel. Then configure partitions and replace the Solaris fsck program with a version that correctly handles AFS volumes.

  1. Unpack the OpenAFS Solaris distribution tarball. The examples below assume that you have unpacked the files into the /tmp/afsdist directory. If you pick a diferent location, substitute this in all of the following exmaples. Once you have unpacked the distribution, change directory as indicated.

       # cd  /tmp/afsdist/sun4x_56/dest/root.client/usr/vice/etc
    
  2. Copy the AFS initialization script to the local directory for initialization files (by convention, /etc/init.d on Solaris machines). Note the removal of the .rc extension as you copy the script.

       # cp -p  afs.rc  /etc/init.d/afs
    
  3. Copy the appropriate AFS kernel library file to the local file /kernel/fs/afs.

    If the machine is running Solaris 11 on the x86_64 platform:

       # cp -p modload/libafs64.o /kernel/drv/amd64/afs
    

    If the machine is running Solaris 10 on the x86_64 platform:

       # cp -p modload/libafs64.o /kernel/fs/amd64/afs
    

    If the machine is running Solaris 2.6 or the 32-bit version of Solaris 7, its kernel supports NFS server functionality, and the nfsd process is running:

       # cp -p modload/libafs.o /kernel/fs/afs   
    

    If the machine is running Solaris 2.6 or the 32-bit version of Solaris 7, and its kernel does not support NFS server functionality or the nfsd process is not running:

       # cp -p modload/libafs.nonfs.o /kernel/fs/afs   
    

    If the machine is running the 64-bit version of Solaris 7, its kernel supports NFS server functionality, and the nfsd process is running:

       # cp -p modload/libafs64.o /kernel/fs/sparcv9/afs   
    

    If the machine is running the 64-bit version of Solaris 7, and its kernel does not support NFS server functionality or the nfsd process is not running:

       # cp -p modload/libafs64.nonfs.o /kernel/fs/sparcv9/afs
    
  4. Run the AFS initialization script to load AFS modifications into the kernel. You can ignore any error messages about the inability to start the BOS Server or the Cache Manager or AFS client.

       # /etc/init.d/afs start   
    

    When an entry called afs does not already exist in the local /etc/name_to_sysnum file, the script automatically creates it and reboots the machine to start using the new version of the file. If this happens, log in again as the superuser root after the reboot and run the initialization script again. This time the required entry exists in the /etc/name_to_sysnum file, and the modload program runs.

       login: root
       Password: root_password
       # /etc/init.d/afs start
    
  5. Create the /usr/lib/fs/afs directory to house the AFS-modified fsck program and related files.

       # mkdir /usr/lib/fs/afs
       # cd /usr/lib/fs/afs  
    
  6. Copy the vfsck binary to the newly created directory, changing the name as you do so.

       # cp  /cdrom/sun4x_56/dest/root.server/etc/vfsck  fsck
    
  7. Working in the /usr/lib/fs/afs directory, create the following links to Solaris libraries:

       # ln -s /usr/lib/fs/ufs/clri  
       # ln -s /usr/lib/fs/ufs/df
       # ln -s /usr/lib/fs/ufs/edquota
       # ln -s /usr/lib/fs/ufs/ff
       # ln -s /usr/lib/fs/ufs/fsdb  
       # ln -s /usr/lib/fs/ufs/fsirand
       # ln -s /usr/lib/fs/ufs/fstyp
       # ln -s /usr/lib/fs/ufs/labelit
       # ln -s /usr/lib/fs/ufs/lockfs
       # ln -s /usr/lib/fs/ufs/mkfs  
       # ln -s /usr/lib/fs/ufs/mount
       # ln -s /usr/lib/fs/ufs/ncheck
       # ln -s /usr/lib/fs/ufs/newfs
       # ln -s /usr/lib/fs/ufs/quot
       # ln -s /usr/lib/fs/ufs/quota
       # ln -s /usr/lib/fs/ufs/quotaoff
       # ln -s /usr/lib/fs/ufs/quotaon
       # ln -s /usr/lib/fs/ufs/repquota
       # ln -s /usr/lib/fs/ufs/tunefs
       # ln -s /usr/lib/fs/ufs/ufsdump
       # ln -s /usr/lib/fs/ufs/ufsrestore
       # ln -s /usr/lib/fs/ufs/volcopy
    
  8. Append the following line to the end of the file /etc/dfs/fstypes.

       afs AFS Utilities
    
  9. Edit the /sbin/mountall file, making two changes.

    • Add an entry for AFS to the case statement for option 2, so that it reads as follows:

         case "$2" in
         ufs)    foptions="-o p"
                 ;;
         afs)    foptions="-o p"
                 ;;
         s5)     foptions="-y -t /var/tmp/tmp$$ -D"
                 ;;
         *)      foptions="-y"
                 ;;
      
    • Edit the file so that all AFS and UFS partitions are checked in parallel. Replace the following section of code:

         # For  fsck purposes, we make a distinction between ufs and
         # other file systems
         #
         if [ "$fstype" = "ufs" ]; then
              ufs_fscklist="$ufs_fscklist $fsckdev"
              saveentry $fstype "$OPTIONS" $special $mountp
              continue
         fi  
      

      with the following section of code:

         # For fsck purposes, we make a distinction between ufs/afs
         # and other file systems.
         #
         if [ "$fstype" = "ufs" -o "$fstype" = "afs" ]; then
              ufs_fscklist="$ufs_fscklist $fsckdev"
              saveentry $fstype "$OPTIONS" $special $mountp
              continue
         fi
      
  10. Create a directory called /vicepxx for each AFS server partition you are configuring (there must be at least one). Repeat the command for each partition.

       # mkdir /vicepxx
    
  11. Add a line with the following format to the file systems registry file, /etc/vfstab, for each partition to be mounted on a directory created in the previous step. Note the value afs in the fourth field, which tells Solaris to use the AFS-modified fsck program on this partition.

       /dev/dsk/disk   /dev/rdsk/disk   /vicepxx   afs   boot_order  yes  
    

    The following is an example for the first partition being configured.

       /dev/dsk/c0t6d0s1 /dev/rdsk/c0t6d0s1 /vicepa afs 3 yes
    
  12. Create a file system on each partition that is to be mounted at a /vicepxx directory. The following command is probably appropriate, but consult the Solaris documentation for more information.

       # newfs -v /dev/rdsk/disk
    
  13. Issue the mountall command to mount all partitions at once.

  14. If the machine is to remain an AFS client, incorporate AFS into its authentication system, following the instructions in Enabling AFS Login and Editing the File Systems Clean-up Script on Solaris Systems.

  15. Proceed to Starting Server Programs.

Starting Server Programs

In this section you initialize the BOS Server, the Update Server, the controller process for NTPD, and the fs process. You begin by copying the necessary server files to the local disk.

  1. Copy file server binaries to the local /usr/afs/bin directory.

    • On a machine of an existing system type, you can either copy files from the OpenAFS binary distribution or use a remote file transfer protocol to copy files from an existing server machine of the same system type. To load from the binary distribution, see the instructions just following for a machine of a new system type. If using a remote file transfer protocol, copy the complete contents of the existing server machine's /usr/afs/bin directory.

    • If you are working from a tarball distribtion, rather than one distributed in a packaged format, you must use the following instructions to copy files from the OpenAFS Binary Distribution.

      1. Unpack the distribution tarball. The examples below assume that you have unpacked the files into the /tmp/afsdist directory. If you pick a different location, substitute this in all of the following examples.

      2. Copy files from the distribution to the local /usr/afs directory.

           # cd /tmp/afsdist/sysname/root.server/usr/afs
           # cp -rp  *  /usr/afs
        
  2. Copy the contents of the /usr/afs/etc directory from an existing file server machine, using a remote file transfer protocol such as sftp or scp. If you use a system control machine, it is best to copy the contents of its /usr/afs/etc directory. If you choose not to run a system control machine, copy the directory's contents from any existing file server machine.

  3. Change to the /usr/afs/bin directory and start the BOS Server (bosserver process). Include the -noauth flag to prevent the AFS processes from performing authorization checking. This is a grave compromise of security; finish the remaining instructions in this section in an uninterrupted pass.

       # cd /usr/afs/bin
       # ./bosserver -noauth
    

  4. If you run a system control machine, create the upclientetc process as an instance of the client portion of the Update Server. It accepts updates of the common configuration files stored in the system control machine's /usr/afs/etc directory from the upserver process (server portion of the Update Server) running on that machine. The cell's first file server machine was installed as the system control machine in Starting the Server Portion of the Update Server. (If you do not run a system control machine, you must update the contents of the /usr/afs/etc directory on each file server machine, using the appropriate bos commands.)

    By default, the Update Server performs updates every 300 seconds (five minutes). Use the -t argument to specify a different number of seconds. For the machine name argument, substitute the name of the machine you are installing. The command appears on multiple lines here only for legibility reasons.

       # ./bos create  <machine name> upclientetc simple  \ 
             "/usr/afs/bin/upclient  <system control machine>  \  
             [-t  <time>]  /usr/afs/etc" -cell  <cell name>  -noauth
    
  5. Create an instance of the Update Server to handle distribution of the file server binaries stored in the /usr/afs/bin directory. If your architecture using a package management system such as 'rpm' or 'apt' to maintain its binaries, note that distributing binaries via this system may interfere with your local package management tools.

    • If this is the first file server machine of its AFS system type, create the upserver process as an instance of the server portion of the Update Server. It distributes its copy of the file server process binaries to the other file server machines of this system type that you install in future. Creating this process makes this machine the binary distribution machine for its type.

         # ./bos create  <machine name> upserver  simple  \ 
               "/usr/afs/bin/upserver -clear /usr/afs/bin"   \
               -cell <cell name>  -noauth
      
    • If this machine is an existing system type, create the upclientbin process as an instance of the client portion of the Update Server. It accepts updates of the AFS binaries from the upserver process running on the binary distribution machine for its system type. For distribution to work properly, the upserver process must already by running on that machine.

      Use the -clear argument to specify that the upclientbin process requests unencrypted transfer of the binaries in the /usr/afs/bin directory. Binaries are not sensitive and encrypting them is time-consuming.

      By default, the Update Server performs updates every 300 seconds (five minutes). Use the -t argument to specify an different number of seconds.

         # ./bos create  <machine name> upclientbin simple  \ 
              "/usr/afs/bin/upclient <binary distribution machine>   \
              [-t <time>] -clear /usr/afs/bin" -cell <cell name>  -noauth
      
  6. Note

    Historically, AFS provided its own version of the Network Time Protocol Daemon. Whilst this is still provided for existing sites, we recommend that you configure and run your own timeservice independently of AFS. The instructions below are provided for those sites still reliant upon OpenAFS's ntp system.

    Start the runntp process, which configures the Network Time Protocol Daemon (NTPD) to choose a database server machine chosen randomly from the local /usr/afs/etc/CellServDB file as its time source. In the standard configuration, the first database server machine installed in your cell refers to a time source outside the cell, and serves as the basis for clock synchronization on all server machines.

       # ./bos create  <machine name> runntp simple  \ 
             /usr/afs/bin/runntp -cell <cell name>  -noauth
    

    Note

    Do not run the runntp process if NTPD or another time synchronization protocol is already running on the machine. Some versions of some operating systems run a time synchronization program by default, as detailed in the OpenAFS Release Notes.

    Attempting to run multiple instances of the NTPD causes an error. Running NTPD together with another time synchronization protocol is unnecessary and can cause instability in the clock setting.

  7. Issue the bos create command to start the fs process or the dafs process, depending on if you want to run the Demand-Attach File Server or not. See Appendix C, The Demand-Attach File Server for more information on whether you want to run it or not.

    • If you do not want to run the Demand-Attach File Server, start the fs process, which binds together the File Server, Volume Server, and Salvager.

         # ./bos create  <machine name> fs fs   \ 
               /usr/afs/bin/fileserver /usr/afs/bin/volserver  \ 
               /usr/afs/bin/salvager -cell <cell name>  -noauth
      
    • If you want to run the Demand-Attach File Server, start the dafs process, which binds together the File Server, Volume Server, Salvage Server, and Salvager.

         # ./bos create  <machine name> dafs dafs   \ 
               /usr/afs/bin/dafileserver /usr/afs/bin/davolserver  \ 
               /usr/afs/bin/salvageserver  \ 
               /usr/afs/bin/dasalvager -cell <cell name>  -noauth
      

Installing Client Functionality

If you want this machine to be a client as well as a server, follow the instructions in this section. Otherwise, skip to Completing the Installation.

Begin by loading the necessary client files to the local disk. Then create the necessary configuration files and start the Cache Manager. For more detailed explanation of the procedures involved, see the corresponding instructions in Installing the First AFS Machine (in the sections following Overview: Installing Client Functionality).

If another AFS machine of this machine's system type exists, the AFS binaries are probably already accessible in your AFS filespace (the conventional location is /afs/cellname/sysname/usr/afsws). If not, or if this is the first AFS machine of its type, copy the AFS binaries for this system type into an AFS volume by following the instructions in Storing AFS Binaries in AFS. Because this machine is not yet an AFS client, you must perform the procedure on an existing AFS machine. However, remember to perform the final step (linking the local directory /usr/afsws to the appropriate location in the AFS file tree) on this machine itself. If you also want to create AFS volumes to house UNIX system binaries for the new system type, see Storing System Binaries in AFS.

  1. Copy client binaries and files to the local disk.

    • On a machine of an existing system type, you can either load files from the OpenAFS Binary Distribution or use a remote file transfer protocol to copy files from an existing server machine of the same system type. To load from the binary distribution, see the instructions just following for a machine of a new system type. If using a remote file transfer protocol, copy the complete contents of the existing client machine's /usr/vice/etc directory.

    • On a machine of a new system type, you must use the following instructions to copy files from the OpenAFS Binary Distribution. If your distribution is provided in a packaged format, then simply installing the packages will perform the necessary actions.

      1. Unpack the distribution tarball. The examples below assume that you have unpacked the files into the /tmp/afsdist directory. If you pick a different location, substitute this in all of the following examples.

      2. Copy files to the local /usr/vice/etc directory.

        This step places a copy of the AFS initialization script (and related files, if applicable) into the /usr/vice/etc directory. In the preceding instructions for incorporating AFS into the kernel, you copied the script directly to the operating system's conventional location for initialization files. When you incorporate AFS into the machine's startup sequence in a later step, you can choose to link the two files.

        On some system types that use a dynamic kernel loader program, you previously copied AFS library files into a subdirectory of the /usr/vice/etc directory. On other system types, you copied the appropriate AFS library file directly to the directory where the operating system accesses it. The following commands do not copy or recopy the AFS library files into the /usr/vice/etc directory, because on some system types the library files consume a large amount of space. If you want to copy them, add the -r flag to the first cp command and skip the second cp command.

           # cd /tmp/afsdist/sysname/root.client/usr/vice/etc
           # cp -p  *  /usr/vice/etc
           # cp -rp  C  /usr/vice/etc
        
  2. Change to the /usr/vice/etc directory and create the ThisCell file as a copy of the /usr/afs/etc/ThisCell file. You must first remove the symbolic link to the /usr/afs/etc/ThisCell file that the BOS Server created automatically in Starting Server Programs.

       # cd  /usr/vice/etc
       # rm  ThisCell
       # cp  /usr/afs/etc/ThisCell  ThisCell
    
  3. Remove the symbolic link to the /usr/afs/etc/CellServDB file.

       # rm  CellServDB
    

  4. Create the /usr/vice/etc/CellServDB file. Use a network file transfer program such as sftp or scp to copy it from one of the following sources, which are listed in decreasing order of preference:

    • Your cell's central CellServDB source file (the conventional location is /afs/cellname/common/etc/CellServDB)

    • The global CellServDB file maintained at grand.central.org

    • An existing client machine in your cell

    • The CellServDB.sample file included in the sysname/root.client/usr/vice/etc directory of each OpenAFS distribution; add an entry for the local cell by following the instructions in Creating the Client CellServDB File

  5. Create the cacheinfo file for either a disk cache or a memory cache. For a discussion of the appropriate values to record in the file, see Configuring the Cache.

    To configure a disk cache, issue the following commands. If you are devoting a partition exclusively to caching, as recommended, you must also configure it, make a file system on it, and mount it at the directory created in this step.

       # mkdir /usr/vice/cache
       # echo "/afs:/usr/vice/cache:#blocks" > cacheinfo   
    

    To configure a memory cache:

       # echo "/afs:/usr/vice/cache:#blocks" > cacheinfo
    
  6. Create the local directory on which to mount the AFS filespace, by convention /afs. If the directory already exists, verify that it is empty.

       # mkdir /afs
    
  7. On AIX systems, add the following line to the /etc/vfs file. It enables AIX to unmount AFS correctly during shutdown.

       afs     4     none     none
    
  8. On non-packaged Linux systems, copy the afsd options file from the /usr/vice/etc directory to the /etc/sysconfig directory, removing the .conf extension as you do so.

       # cp /usr/vice/etc/afs.conf /etc/sysconfig/afs
    
  9. Edit the machine's AFS initialization script or afsd options file to set appropriate values for afsd command parameters. The script resides in the indicated location on each system type:

    • On AIX systems, /etc/rc.afs

    • On HP-UX systems, /sbin/init.d/afs

    • On IRIX systems, /etc/init.d/afs

    • On Fedora and RHEL systems, /etc/sysconfig/openafs. Note that this file has a different format from a standard afsd options file.

    • On non-packaged Linux systems, /etc/sysconfig/afs (the afsd options file)

    • On Solaris systems, /etc/init.d/afs

    Use one of the methods described in Configuring the Cache Manager to add the following flags to the afsd command line. If you intend for the machine to remain an AFS client, also set any performance-related arguments you wish.

    • Add the -memcache flag if the machine is to use a memory cache.

    • Add the -verbose flag to display a trace of the Cache Manager's initialization on the standard output stream.

    • Add the --dynroot or --afsdb options if you wish to have a synthetic AFS root, as discussed in Enabling Access to Foreign Cells

  10. If appropriate, follow the instructions in Storing AFS Binaries in AFS to copy the AFS binaries for this system type into an AFS volume. See the introduction to this section for further discussion.

Completing the Installation

At this point you run the machine's AFS initialization script to verify that it correctly loads AFS modifications into the kernel and starts the BOS Server, which starts the other server processes. If you have installed client files, the script also starts the Cache Manager. If the script works correctly, perform the steps that incorporate it into the machine's startup and shutdown sequence. If there are problems during the initialization, attempt to resolve them. The AFS Product Support group can provide assistance if necessary.

If the machine is configured as a client using a disk cache, it can take a while for the afsd program to create all of the Vn files in the cache directory. Messages on the console trace the initialization process.

  1. Issue the bos shutdown command to shut down the AFS server processes other than the BOS Server. Include the -wait flag to delay return of the command shell prompt until all processes shut down completely.

       # /usr/afs/bin/bos shutdown <machine name> -wait
    
  2. Issue the ps command to learn the BOS Server's process ID number (PID), and then the kill command to stop the bosserver process.

       # ps appropriate_ps_options | grep bosserver
       # kill bosserver_PID
    

  3. Run the AFS initialization script by issuing the appropriate commands for this system type.

    On AIX systems:

    1. Reboot the machine and log in again as the local superuser root.

         # cd /
         # shutdown -r now
         login: root
         Password: root_password
      
    2. Run the AFS initialization script.

         # /etc/rc.afs
      
    3. Edit the AIX initialization file, /etc/inittab, adding the following line to invoke the AFS initialization script. Place it just after the line that starts NFS daemons.

         rcafs:2:wait:/etc/rc.afs > /dev/console 2>&1 # Start AFS services
      
    4. (Optional) There are now copies of the AFS initialization file in both the /usr/vice/etc and /etc directories. If you want to avoid potential confusion by guaranteeing that they are always the same, create a link between them. You can always retrieve the original script from the AFS CD-ROM if necessary.

         # cd  /usr/vice/etc
         # rm  rc.afs
         # ln -s  /etc/rc.afs
      
    5. Proceed to Step 4.

    On HP-UX systems:

    1. Run the AFS initialization script.

         # /sbin/init.d/afs  start
      
    2. Change to the /sbin/init.d directory and issue the ln -s command to create symbolic links that incorporate the AFS initialization script into the HP-UX startup and shutdown sequence.

         # cd /sbin/init.d
         # ln -s ../init.d/afs /sbin/rc2.d/S460afs
         # ln -s ../init.d/afs /sbin/rc2.d/K800afs
      
    3. (Optional) There are now copies of the AFS initialization file in both the /usr/vice/etc and /sbin/init.d directories. If you want to avoid potential confusion by guaranteeing that they are always the same, create a link between them. You can always retrieve the original script from the AFS CD-ROM if necessary.

         # cd /usr/vice/etc
         # rm afs.rc
         # ln -s  /sbin/init.d/afs  afs.rc
      
    4. Proceed to Step 4.

    On IRIX systems:

    1. If you have configured the machine to use the ml dynamic loader program, reboot the machine and log in again as the local superuser root.

         # cd /
         # shutdown -i6 -g0 -y
         login: root
         Password: root_password
      
    2. Issue the chkconfig command to activate the afsserver configuration variable.

         # /etc/chkconfig -f afsserver on   
      

      If you have configured this machine as an AFS client and want to it remain one, also issue the chkconfig command to activate the afsclient configuration variable.

         # /etc/chkconfig -f afsclient on 
      
    3. Run the AFS initialization script.

         # /etc/init.d/afs  start
      
    4. Change to the /etc/init.d directory and issue the ln -s command to create symbolic links that incorporate the AFS initialization script into the IRIX startup and shutdown sequence.

         # cd /etc/init.d
         # ln -s ../init.d/afs /etc/rc2.d/S35afs
         # ln -s ../init.d/afs /etc/rc0.d/K35afs
      
    5. (Optional) There are now copies of the AFS initialization file in both the /usr/vice/etc and /etc/init.d directories. If you want to avoid potential confusion by guaranteeing that they are always the same, create a link between them. You can always retrieve the original script from the AFS CD-ROM if necessary.

         # cd /usr/vice/etc
         # rm afs.rc
         # ln -s  /etc/init.d/afs  afs.rc
      
    6. Proceed to Step 4.

    On Fedora or RHEL Linux systems:

    1. Reboot the machine and log in again as the local superuser root.

         # cd /
         # shutdown -r now
         login: root
         Password: root_password
      
    2. Run the OpenAFS initialization scripts.

         # /etc/rc.d/init.d/openafs-client  start
         # /etc/rc.d/init.d/openafs-server  start
      
    3. Issue the chkconfig command to activate the openafs-client and openafs-server configuration variables. Based on the instruction in the AFS initialization files that begins with the string #chkconfig, the command automatically creates the symbolic links that incorporate the script into the Linux startup and shutdown sequence.

         # /sbin/chkconfig  --add openafs-client
         # /sbin/chkconfig  --add openafs-server
      

    On Linux systems:

    1. Reboot the machine and log in again as the local superuser root.

         # cd /
         # shutdown -r now
         login: root
         Password: root_password
      
    2. Run the OpenAFS initialization script.

         # /etc/rc.d/init.d/afs  start
      
    3. Issue the chkconfig command to activate the afs configuration variable. Based on the instruction in the AFS initialization file that begins with the string #chkconfig, the command automatically creates the symbolic links that incorporate the script into the Linux startup and shutdown sequence.

         # /sbin/chkconfig  --add afs
      
    4. (Optional) There are now copies of the AFS initialization file in both the /usr/vice/etc and /etc/rc.d/init.d directories, and copies of the afsd options file in both the /usr/vice/etc and /etc/sysconfig directories. If you want to avoid potential confusion by guaranteeing that the two copies of each file are always the same, create a link between them. You can always retrieve the original script or options file from the AFS CD-ROM if necessary.

         # cd /usr/vice/etc
         # rm afs.rc afs.conf
         # ln -s  /etc/rc.d/init.d/afs  afs.rc
         # ln -s  /etc/sysconfig/afs  afs.conf
      
    5. Proceed to Step 4.

    On Solaris systems:

    1. Reboot the machine and log in again as the local superuser root.

         # cd /
         # shutdown -i6 -g0 -y
         login: root
         Password: root_password
      
    2. Run the AFS initialization script.

         # /etc/init.d/afs  start
      
    3. Change to the /etc/init.d directory and issue the ln -s command to create symbolic links that incorporate the AFS initialization script into the Solaris startup and shutdown sequence.

         # cd /etc/init.d
         # ln -s ../init.d/afs /etc/rc3.d/S99afs
         # ln -s ../init.d/afs /etc/rc0.d/K66afs
      
    4. (Optional) There are now copies of the AFS initialization file in both the /usr/vice/etc and /etc/init.d directories. If you want to avoid potential confusion by guaranteeing that they are always the same, create a link between them. You can always retrieve the original script from the OpenAFS Binary Distribution if necessary.

         # cd /usr/vice/etc
         # rm afs.rc
         # ln -s  /etc/init.d/afs  afs.rc
      
  4. Verify that /usr/afs and its subdirectories on the new file server machine meet the ownership and mode bit requirements outlined in Protecting Sensitive AFS Directories. If necessary, use the chmod command to correct the mode bits.

  5. To configure this machine as a database server machine, proceed to Installing Database Server Functionality.