Quick Beginnings

Installing the First AFS Machine

This chapter describes how to install the first AFS machine in your cell, configuring it as both a file server machine and a client machine. After completing all procedures in this chapter, you can remove the client functionality if you wish, as described in Removing Client Functionality.

To install additional file server machines after completing this chapter, see Installing Additional Server Machines.

To install additional client machines after completing this chapter, see Installing Additional Client Machines.

Requirements and Configuration Decisions

The instructions in this chapter assume that you meet the following requirements.

You are logged onto the machine's console as the local superuser root
A standard version of one of the operating systems supported by the current version of AFS is running on the machine
You can access the data on the AFS CD-ROMs, either through a local CD drive or via an NFS mount of a CD drive attached to a machine that is accessible by network

You must make the following configuration decisions while installing the first AFS machine. To speed the installation itself, it is best to make the decisions before beginning. See the chapter in the IBM AFS Administration Guide about issues in cell administration and configuration for detailed guidelines.

Select the first AFS machine
Select the cell name
Decide which partitions or logical volumes to configure as AFS server partitions, and choose the directory names on which to mount them
Decide whether to use the standard AFS authentication and authorization software or Kerberos as obtained from another source. On several system types, the decision determines how you incorporate AFS into the machine's authentication system. If you wish to use Kerberos, contact the AFS Product Support group now to learn about how you must modify the installation procedure.
Decide how big to make the client cache
Decide how to configure the top levels of your cell's AFS filespace

This chapter is divided into three large sections corresponding to the three parts of installing the first AFS machine. Perform all of the steps in the order they appear. Each functional section begins with a summary of the procedures to perform. The sections are as follows:

Installing server functionality (begins in Overview: Installing Server Functionality)
Installing client functionality (begins in Overview: Installing Client Functionality)
Configuring your cell's filespace, establishing further security mechanisms, and enabling access to foreign cells (begins in Overview: Completing the Installation of the First AFS Machine)

Overview: Installing Server Functionality

In the first phase of installing your cell's first AFS machine, you install file server and database server functionality by performing the following procedures:

Choose which machine to install as the first AFS machine
Create AFS-related directories on the local disk
Incorporate AFS modifications into the machine's kernel
Configure partitions or logical volumes for storing AFS volumes
On some system types, install and configure an AFS-modified version of the fsck program
If the machine is to remain a client machine, incorporate AFS into its authentication system
Start the Basic OverSeer (BOS) Server
Define the cell name and the machine's cell membership
Start the database server processes: Authentication Server, Backup Server, Protection Server, and Volume Location (VL) Server
Configure initial security mechanisms
Start the fs process, which incorporates three component processes: the File Server, Volume Server, and Salvager
Start the server portion of the Update Server
Start the controller process (called runntp) for the Network Time Protocol Daemon, which synchronizes machine clocks

Choosing the First AFS Machine

The first AFS machine you install must have sufficient disk space to store AFS volumes. To take best advantage of AFS's capabilities, store client-side binaries as well as user files in volumes. When you later install additional file server machines in your cell, you can distribute these volumes among the different machines as you see fit.

These instructions configure the first AFS machine as a database server machine, the binary distribution machine for its system type, and the cell's system control machine. For a description of these roles, see the IBM AFS Administration Guide.

Installation of additional machines is simplest if the first machine has the lowest IP address of any database server machine you currently plan to install. If you later install database server functionality on a machine with a lower IP address, you must first update the /usr/vice/etc/CellServDB file on all of your cell's client machines. For more details, see Installing Database Server Functionality.

Creating AFS Directories

Create the /usr/afs and /usr/vice/etc directories on the local disk, to house server and client files respectively. Subsequent instructions copy files from the AFS CD-ROM into them. Create the /cdrom directory as a mount point for CD-ROMs, if it does not already exist.

      
   # mkdir /usr/afs
      
   # mkdir /usr/vice
      
   # mkdir /usr/vice/etc
   
   # mkdir /cdrom

Performing Platform-Specific Procedures

Several of the initial procedures for installing a file server machine differ for each system type. For convenience, the following sections group them together for each system type:

Incorporate AFS modifications into the kernel.
The kernel on every AFS file server and client machine must incorporate AFS extensions. On machines that use a dynamic kernel module loader, it is conventional to alter the machine's initialization script to load the AFS extensions at each reboot.
Configure server partitions or logical volumes to house AFS volumes.
Every AFS file server machine must have at least one partition or logical volume dedicated to storing AFS volumes (for convenience, the documentation hereafter refers to partitions only). Each server partition is mounted at a directory named /vicepxx, where xx is one or two lowercase letters. By convention, the first 26 partitions are mounted on the directories called /vicepa through /vicepz, the 27th one is mounted on the /vicepaa directory, and so on through /vicepaz and /vicepba, continuing up to the index corresponding to the maximum number of server partitions supported in the current version of AFS (which is specified in the IBM AFS Release Notes).
The /vicepxx directories must reside in the file server machine's root directory, not in one of its subdirectories (for example, /usr/vicepa is not an acceptable directory location).
You can also add or remove server partitions on an existing file server machine. For instructions, see the chapter in the IBM AFS Administration Guide about maintaining server machines.
Note: Not all file system types supported by an operating system are necessarily supported as AFS server partitions. For possible restrictions, see the IBM AFS Release Notes.
On some system types, install and configure a modified fsck program which recognizes the structures that the File Server uses to organize volume data on AFS server partitions. The fsck program provided with the operating system does not understand the AFS data structures, and so removes them to the lost+found directory.
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. Using AFS is simpler and more convenient for your users if you make the modifications on all client machines. Otherwise, users must perform a two-step login procedure (login to the local file system and then issue the klog command). For further discussion of AFS authentication, see the chapter in the IBM AFS Administration Guide about cell configuration and administration issues.

To continue, proceed to the appropriate section:

Getting Started on AIX Systems
Getting Started on Digital UNIX Systems
Getting Started on HP-UX Systems
Getting Started on IRIX Systems
Getting Started on Linux Systems
Getting Started on Solaris Systems

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 use the SMIT program to configure partitions for storing AFS volumes, and replace the AIX fsck program helper with a version that correctly handles AFS volumes. If the machine is to remain an AFS client machine, incorporate AFS into the AIX secondary authentication system.

Loading AFS into the AIX Kernel

The AIX kernel extension facility is the dynamic kernel loader provided by IBM Corporation. AIX does not support incorporation of AFS modifications during a kernel build.

For AFS to function correctly, the kernel extension facility must run each time the machine reboots, so the AFS initialization script (included in the AFS distribution) invokes it automatically. In this section you copy the script to the conventional location and edit it to select the appropriate options depending on whether NFS is also to run.

After editing the script, you run it to incorporate AFS into the kernel. In later sections you verify that the script correctly initializes all AFS components, then configure the AIX inittab file so that the script runs automatically at reboot.

Mount the AFS CD-ROM for AIX on the local /cdrom directory. For instructions on mounting CD-ROMs (either locally or remotely via NFS), see your AIX documentation. Then change directory as indicated.
```
   
   # cd  /cdrom/rs_aix42/root.client/usr/vice/etc
   
```
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
    
```
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
   
```
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
   
```

Configuring Server Partitions on AIX Systems

Every AFS file server machine must have at least one partition or logical volume dedicated to storing AFS volumes. Each server partition is mounted at a directory named /vicepxx, where xx is one or two lowercase letters. The /vicepxx directories must reside in the file server machine's root directory, not in one of its subdirectories (for example, /usr/vicepa is not an acceptable directory location). For additional information, see Performing Platform-Specific Procedures.

To configure server partitions on an AIX system, perform the following procedures:

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
   
```
Use the SMIT program to create a journaling file system on each partition to be configured as an AFS server partition.
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.

Replacing the fsck Program Helper on AIX Systems

In this section, you make modifications to guarantee that the appropriate fsck program runs on AFS server partitions. The fsck program provided with the operating system must never run on AFS server partitions. Because it does not recognize the structures that the File Server uses to organize volume data, it removes all of the data. To repeat:

Never run the standard fsck program on AFS server partitions. It discards AFS volumes.

On AIX systems, you do not replace the fsck binary itself, but rather the program helper file included in the AIX distribution as /sbin/helpers/v3fshelper.

Move the AIX fsck program helper to a safe location and install the version from the AFS distribution in its place. The AFS CD-ROM must still be mounted at the /cdrom directory.

   
   # cd /sbin/helpers
   
   # mv v3fshelper v3fshelper.noafs
   
   # cp -p /cdrom/rs_aix42/root.server/etc/v3fshelper v3fshelper

If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on AIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on AIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

Follow the instructions in this section to incorporate AFS modifications into the AIX secondary authentication system.

Issue the ls command to verify that the afs_dynamic_auth and afs_dynamic_kerbauth programs are installed in the local /usr/vice/etc directory.
```
   
   # ls /usr/vice/etc   
```
If the files do not exist, mount the AFS CD-ROM for AIX (if it is not already), change directory as indicated, and copy them.
```
  
   # cd /cdrom/rs_aix42/root.client/usr/vice/etc
   
   # cp  -p  afs_dynamic*  /usr/vice/etc
   
```
Edit the local /etc/security/user file, making changes to the indicated stanzas:
- In the default stanza, set the registry attribute to DCE (not to AFS), as follows:
```
   
   registry = DCE
   
```
- In the default stanza, set the SYSTEM attribute as indicated.
  If the machine is an AFS client only, set the following value:
```
   
   SYSTEM = "AFS OR (AFS[UNAVAIL] AND compat[SUCCESS])"   
```
  If the machine is both an AFS and a DCE client, set the following value (it must appear on a single line in the file):
```
   
   SYSTEM = "DCE OR DCE[UNAVAIL] OR AFS OR (AFS[UNAVAIL]  \
       AND compat[SUCCESS])"
   
```
- In the root stanza, set the registry attribute as follows. It enables the local superuser root to log into the local file system only, based on the password listed in the local password file.
```
   
   root:
         registry = files
   
```
Edit the local /etc/security/login.cfg file, creating or editing the indicated stanzas:
- In the DCE stanza, set the program attribute as follows.
  If you use the AFS Authentication Server (kaserver process):
```
   
   DCE:
        program = /usr/vice/etc/afs_dynamic_auth   
```
  If you use a Kerberos implementation of AFS authentication:
```
   
   DCE:
        program = /usr/vice/etc/afs_dynamic_kerbauth
   
```
- In the AFS stanza, set the program attribute as follows.
  If you use the AFS Authentication Server (kaserver process):
```
   
   AFS:
        program = /usr/vice/etc/afs_dynamic_auth   
```
  If you use a Kerberos implementation of AFS authentication:
```
   
   AFS:
        program = /usr/vice/etc/afs_dynamic_kerbauth
   
```
Proceed to Starting the BOS Server (or if referring to these instructions while installing an additional file server machine, return to Starting Server Programs).

Getting Started on Digital UNIX Systems

Begin by either building AFS modifications into a new static kernel or by setting up to dynamically load the AFS kernel module. Then create partitions for storing AFS volumes, and replace the Digital UNIX fsck program with a version that correctly handles AFS volumes. If the machine is to remain an AFS client machine, incorporate AFS into the machine's Security Integration Architecture (SIA) matrix.

Loading AFS into the Digital UNIX Kernel

The sysconfig program is the dynamic kernel loader provided for Digital UNIX systems.

For AFS to function correctly, the sysconfig program must run each time the machine reboots, so the AFS initialization script (included on the AFS CD-ROM) invokes it automatically. In this section you copy the appropriate AFS library file to the location where the sysconfig program accesses it and then run the script.

Mount the AFS CD-ROM for Digital UNIX on the local /cdrom directory. For instructions on mounting CD-ROMs (either locally or remotely via NFS), see your Digital UNIX documentation. Then change directory as indicated.

   
   # cd /cdrom/alpha_dux40/root.client

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

   
   # cp usr/vice/etc/afs.rc  /sbin/init.d/afs

Copy the AFS kernel module to the local /subsys directory.

  
   # cp bin/afs.mod /subsys/afs.mod

Set up the system to load the module at startup.

   # /sbin/init.d/autosysconfig add afs

Reboot the machine to start using the new kernel, and login again as the superuser root.

   
   # cd /
   
   # shutdown -r now
   
   login: root
   Password: root_password

Building AFS into the Digital UNIX Kernel

Use the following instructions to build AFS modifications into the kernel on a Digital UNIX system.

Create a copy called AFS of the basic kernel configuration file included in the Digital UNIX distribution as /usr/sys/conf/machine_name, where machine_name is the machine's hostname in all uppercase letters.
```
   
   # cd /usr/sys/conf
   
   # cp machine_name AFS
   
```

Add AFS to the list of options in the configuration file you created in the previous step, so that the result looks like the following:

          .                   .
          .                   .
       options               UFS
       options               NFS
       options               AFS
          .                   .
          .                   .

Add an entry for AFS to two places in the file /usr/sys/conf/files.

Add a line for AFS to the list of OPTIONS, so that the result looks like the following:

             .                .      .
             .                .      .
      OPTIONS/nfs          optional nfs 
      OPTIONS/afs          optional afs 
      OPTIONS/nfs_server   optional nfs_server
             .                .      .
             .                .      .

Add an entry for AFS to the list of MODULES, so that the result looks like the following:

             .                  .        .          .
             .                  .        .          .
      #
      MODULE/nfs_server	    optional nfs_server Binary
      nfs/nfs_server.c      module nfs_server optimize -g3
      nfs/nfs3_server.c	    module nfs_server optimize -g3
      #
      MODULE/afs            optional afs Binary
      afs/libafs.c          module afs
      #

Add an entry for AFS to two places in the file /usr/sys/vfs/vfs_conf.c.

Add AFS to the list of defined file systems, so that the result looks like the following:

        .       .              
        .       .              
     #include <afs.h>
     #if defined(AFS) && AFS
            extern struct vfsops afs_vfsops;
     #endif  
        .       .              
        .       .

Put a declaration for AFS in the vfssw[] table's MOUNT_ADDON slot, so that the result looks like the following:

        .                          .              .
        .                          .              .
      &fdfs_vfsops,         "fdfs",   /* 12 = MOUNT_FDFS */
   #if	defined(AFS)
      &afs_vfsops,          "afs",
   #else
      (struct vfsops *)0,   "",       /* 13 = MOUNT_ADDON */
   #endif
   #if NFS && INFS_DYNAMIC   
       &nfs3_vfsops,        "nfsv3",  /* 14 = MOUNT_NFS3 */

Mount the AFS CD-ROM for Digital UNIX on the local /cdrom directory. For instructions on mounting CD-ROMs (either locally or remotely via NFS), see your Digital UNIX documentation. Then change directory as indicated.
```
   
   # cd /cdrom/alpha_dux40/root.client
   
```
Copy the AFS initialization script to the local directory for initialization files (by convention, /sbin/init.d on Digital UNIX machines). Note the removal of the .rc extension as you copy the script.
```
   
   # cp usr/vice/etc/afs.rc  /sbin/init.d/afs
   
```
Copy the AFS kernel module to the local /usr/sys/BINARY directory.
If the machine's kernel supports NFS server functionality:
```
  
   # cp bin/libafs.o /usr/sys/BINARY/afs.mod   
```
If the machine's kernel does not support NFS server functionality:
```
  
   # cp bin/libafs.nonfs.o /usr/sys/BINARY/afs.mod
   
```
Configure and build the kernel. Respond to any prompts by pressing <Return>. The resulting kernel resides in the file /sys/AFS/vmunix.
```
   
   # doconfig -c AFS
   
```

Rename the existing kernel file and copy the new, AFS-modified file to the standard location.

   
   # mv /vmunix /vmunix_noafs
   
   # cp /sys/AFS/vmunix /vmunix

Reboot the machine to start using the new kernel, and login again as the superuser root.

   
   # cd /
   
   # shutdown -r now
   
   login: root
   Password: root_password

Configuring Server Partitions on Digital UNIX Systems

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
   
```
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 ufs rw 0 2
```
The following is an example for the first partition being configured.
```
   
   /dev/rz3a /vicepa ufs rw 0 2
   
```
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 Digital UNIX documentation for more information.
```
   
   # newfs -v /dev/disk
   
```
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.

Replacing the fsck Program on Digital UNIX Systems

Never run the standard fsck program on AFS server partitions. It discards AFS volumes.

On Digital UNIX systems, the files /sbin/fsck and /usr/sbin/fsck are driver programs. Rather than replacing either of them, you replace the actual binary included in the Digital UNIX distribution as /sbin/ufs_fsck and /usr/sbin/ufs_fsck.

Install the vfsck binary to the /sbin and /usr/sbin directories. The AFS CD-ROM must still be mounted at the /cdrom directory.

   
   # cd /cdrom/alpha_dux40/root.server/etc
   
   # cp vfsck /sbin/vfsck
   
   # cp vfsck /usr/sbin/vfsck

Rename the Digital UNIX fsck binaries and create symbolic links to the vfsck program.

   
   # cd /sbin
   
   # mv ufs_fsck ufs_fsck.noafs
   
   # ln -s vfsck ufs_fsck
   
   # cd /usr/sbin
   
   # mv ufs_fsck ufs_fsck.noafs
   
   # ln -s vfsck ufs_fsck

If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on Digital UNIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on Digital UNIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

On Digital UNIX systems, the AFS initialization script automatically incorporates the AFS authentication library file into the Security Integration Architecture (SIA) matrix on the machine, so that users with AFS accounts obtain a token at login. In this section you copy the library file to the appropriate location.

For more information on SIA, see the Digital UNIX reference page for matrix.conf, or consult the section on security in your Digital UNIX documentation.

Note:

If the machine runs both the DCE and AFS client software, AFS must start after DCE. Consult the AFS initialization script for suggested symbolic links to create for correct ordering. Also, the system startup script order must initialize SIA before any long-running process that uses authentication.

Perform the following steps to enable AFS login.

Mount the AFS CD-ROM for Digital UNIX on the local /cdrom directory, if it is not already. Change directory as indicated.
```
   
   # cd /cdrom/alpha_dux40/lib/afs
   
```
Copy the appropriate AFS authentication library file to the local /usr/shlib directory.
If you use the AFS Authentication Server (kaserver process) in the cell:
```
   
   # cp  libafssiad.so  /usr/shlib   
```
If you use a Kerberos implementation of AFS authentication, rename the library file as you copy it:
```
   
   # cp  libafssiad.krb.so  /usr/shlib/libafssiad.so
   
```
Proceed to Starting the BOS Server (or if referring to these instructions while installing an additional file server machine, return to Starting Server Programs).

Getting Started on HP-UX Systems

Begin by building AFS modifications into a new kernel; HP-UX does not support dynamic loading. Then create partitions for storing AFS volumes, and install and configure the AFS-modified fsck program to run on AFS server partitions. If the machine is to remain an AFS client machine, incorporate AFS into the machine's Pluggable Authentication Module (PAM) scheme.

Building AFS into the HP-UX Kernel

Use the following instructions to build AFS modifications into the kernel on an HP-UX system.

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

   
   # cp /stand/vmunix /stand/vmunix.noafs
   
   # cp /stand/system /stand/system.noafs

Mount the AFS CD-ROM for HP-UX on the local /cdrom directory. For instructions on mounting CD-ROMs (either locally or remotely via NFS), see your HP-UX documentation. Then change directory as indicated.
```
   
   # cd /cdrom/hp_ux110/root.client
   
```
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
   
```
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
   
```
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
   
```
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
   
```

Configuring Server Partitions on HP-UX Systems

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
   
```
Use the SAM program to create a file system on each partition. For instructions, consult the HP-UX documentation.
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.

Configuring the AFS-modified fsck Program on HP-UX Systems

Never run the standard fsck program on AFS server partitions. It discards AFS volumes.

On HP-UX systems, there are several configuration files to install in addition to the AFS-modified fsck program (the vfsck binary).

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,
   
```
Create and change directory to an AFS-specific command directory called /sbin/fs/afs.
```
   
   # mkdir /sbin/fs/afs
   
   # cd  /sbin/fs/afs
   
```
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 /cdrom/hp_ux110/root.server/etc/*  .
          
```
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  *
   
```

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

If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on HP-UX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on HP-UX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

At this point you incorporate AFS into the operating system's Pluggable Authentication Module (PAM) scheme. PAM integrates all authentication mechanisms on the machine, including login, to provide the security infrastructure for authenticated access to and from the machine.

Explaining PAM is beyond the scope of this document. It is assumed that you understand the syntax and meanings of settings in the PAM configuration file (for example, how the other entry works, the effect of marking an entry as required, optional, or sufficient, and so on).

The following instructions explain how to alter the entries in the PAM configuration file for each service for which you wish to use AFS authentication. Other configurations possibly also work, but the instructions specify the recommended and tested configuration.

Note:

The instructions specify that you mark each entry as optional. However, marking some modules as optional can mean that they grant access to the corresponding service even when the user does not meet all of the module's requirements. In some operating system revisions, for example, if you mark as optional the module that controls login via a dial-up connection, it allows users to login without providing a password. See the IBM AFS Release Notes for a discussion of any limitations that apply to this operating system.

Also, with some operating system versions you must install patches for PAM to interact correctly with certain authentication programs. For details, see the IBM AFS Release Notes.

The recommended AFS-related entries in the PAM configuration file make use of one or more of the following three attributes.

try_first_pass: This is a standard PAM attribute that can be included on entries after the first one for a service; it directs the module to use the password that was provided to the first module. For the AFS module, it means that AFS authentication succeeds if the password provided to the module listed first is the user's correct AFS password. For further discussion of this attribute and its alternatives, see the operating system's PAM documentation.
ignore_root: This attribute, specific to the AFS PAM module, directs it to ignore not only the local superuser root, but also any user with UID 0 (zero).
setenv_password_expires: This attribute, specific to the AFS PAM module, sets the environment variable PASSWORD_EXPIRES to the expiration date of the user's AFS password, which is recorded in the Authentication Database.

Perform the following steps to enable AFS login.

Mount the AFS CD-ROM for HP-UX on the /cdrom directory, if it is not already. Then change directory as indicated.
```
  
   # cd /usr/lib/security
   
```
Copy the AFS authentication library file to the /usr/lib/security directory. Then create a symbolic link to it whose name does not mention the version. Omitting the version eliminates the need to edit the PAM configuration file if you later update the library file.
If you use the AFS Authentication Server (kaserver process) in the cell:
```
   
   # cp /cdrom/hp_ux110/lib/pam_afs.so.1  .
  
   # ln -s  pam_afs.so.1  pam_afs.so   
```
If you use a Kerberos implementation of AFS authentication:
```
  
   # cp /cdrom/hp_ux110/lib/pam_afs.krb.so.1   .
  
   # ln -s pam_afs.krb.so.1 pam_afs.so
   
```
Edit the Authentication management section of the HP-UX PAM configuration file, /etc/pam.conf by convention. The entries in this section have the value auth in their second field.
First edit the standard entries, which refer to the HP-UX PAM module (usually, the file /usr/lib/security/libpam_unix.1) in their fourth field. For each service for which you want to use AFS authentication, edit the third field of its entry to read optional. The pam.conf file in the HP-UX distribution usually includes standard entries for the login and ftp services, for instance.
If there are services for which you want to use AFS authentication, but for which the pam.conf file does not already include a standard entry, you must create that entry and place the value optional in its third field. For instance, the HP-UX pam.conf file does not usually include standard entries for the remsh or telnet services.
Then create an AFS-related entry for each service, placing it immediately below the standard entry. The following example shows what the Authentication Management section looks like after you have you edited or created entries for the services mentioned previously. Note that the example AFS entries appear on two lines only for legibility.
```
   
   login   auth  optional  /usr/lib/security/libpam_unix.1
   login   auth  optional  /usr/lib/security/pam_afs.so      \
         try_first_pass  ignore_root  setenv_password_expires
   ftp     auth  optional  /usr/lib/security/libpam_unix.1
   ftp     auth  optional  /usr/lib/security/pam_afs.so      \
         try_first_pass  ignore_root
   remsh   auth  optional  /usr/lib/security/libpam_unix.1
   remsh   auth  optional  /usr/lib/security/pam_afs.so      \
         try_first_pass  ignore_root		
   telnet  auth  optional  /usr/lib/security/libpam_unix.1
   telnet  auth  optional  /usr/lib/security/pam_afs.so      \
         try_first_pass  ignore_root  setenv_password_expires
   
```

If you use the Common Desktop Environment (CDE) on the machine and want users to obtain an AFS token as they log in, also add or edit the following four entries in the Authentication management section. Note that the AFS-related entries appear on two lines here only for legibility.

  
   dtlogin   auth  optional  /usr/lib/security/libpam_unix.1
   dtlogin   auth  optional  /usr/lib/security/pam_afs.so     \
         try_first_pass  ignore_root
   dtaction  auth  optional  /usr/lib/security/libpam_unix.1
   dtaction  auth  optional  /usr/lib/security/pam_afs.so     \
         try_first_pass  ignore_root

Proceed to Starting the BOS Server (or if referring to these instructions while installing an additional file server machine, return to Starting Server Programs).

Getting Started on IRIX Systems

To incorporate AFS into the kernel on IRIX systems, choose one of two methods:

Run the AFS initialization script to invoke the ml program distributed by Silicon Graphics, Incorporated (SGI), which dynamically loads AFS modifications into the kernel
Build a new static kernel

Then create partitions for storing AFS volumes. You do not need to replace the IRIX fsck program because SGI has already modified it to handle AFS volumes properly. If the machine is to remain an AFS client machine, verify that the IRIX login utility installed on the machine grants an AFS token.

In preparation for either dynamic loading or kernel building, perform the following procedures:

Mount the AFS CD-ROM for IRIX on the /cdrom directory. For instructions on mounting CD-ROMs (either locally or remotely via NFS), see your IRIX documentation. Then change directory as indicated.
```
   
   # cd  /cdrom/sgi_65/root.client
   
```
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
   
```
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 IBM AFS Release Notes for the current version of AFS.
```
   
   # uname -m
    
```
Proceed to either Loading AFS into the IRIX Kernel or Building AFS into the IRIX Kernel.

Loading AFS into the IRIX Kernel

The ml program is the dynamic kernel loader provided by SGI for IRIX systems. If you use it rather than building AFS modifications into a static kernel, then for AFS to function correctly the ml program must run each time the machine reboots. Therefore, the AFS initialization script (included on the AFS CD-ROM) invokes it automatically when the afsml configuration variable is activated. In this section you activate the variable and run the script.

In later sections you verify that the script correctly initializes all AFS components, then create the links that incorporate AFS into the IRIX startup and shutdown sequence.

Create the local /usr/vice/etc/sgiload directory to house the AFS kernel library file.
```
   
   # mkdir /usr/vice/etc/sgiload
   
```
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
   
```
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
   
```
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
   
```
Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

The standard IRIX command-line login program and the graphical xdm login program both automatically grant an AFS token when AFS is incorporated into the machine's kernel. However, some IRIX distributions use another login utility by default, and it does not necessarily incorporate the required AFS modifications. If that is the case, you must disable the default utility if you want AFS users to obtain AFS tokens at login. For further discussion, see the IBM AFS Release Notes.

If you configure the machine to use an AFS-modified login utility, then the afsauthlib.so and afskauthlib.so files (included in the AFS distribution) must reside in the /usr/vice/etc directory. Issue the ls command to verify.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

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. If the machine is to remain an AFS client machine, incorporate AFS into the machine's Pluggable Authentication Module (PAM) scheme. /etc/init.d/afs start

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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

Configuring Server Partitions on IRIX Systems

AFS supports use of both EFS and XFS partitions for housing AFS volumes. SGI encourages use of XFS partitions.

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
   
```
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
   
```
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
   
```
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.
(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
   
```
If you plan to retain client functionality on this machine after completing the installation, proceed to Enabling AFS Login on IRIX Systems. Otherwise, proceed to Starting the BOS Server.

Enabling AFS Login on IRIX Systems

Note:

If you plan to remove client functionality from this machine after completing the installation, skip this section and proceed to Starting the BOS Server.

  
   # ls /usr/vice/etc

If the files do not exist, mount the AFS CD-ROM for IRIX (if it is not already), change directory as indicated, and copy them.

  
   # cd /cdrom/sgi_65/root.client/usr/vice/etc
   
   # cp  -p  *authlib*  /usr/vice/etc

After taking any necessary action, proceed to Starting the BOS Server.

Getting Started on Linux Systems

Proceed to Configuring Server Partitions on IRIX Systems.

Building AFS into the IRIX Kernel

Use the following instructions to build AFS modifications into the kernel on an IRIX system.

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
   
```
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
   
```
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
   
```
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
   
```

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