Getting Started on IRIX Systems

Getting Started on IRIX Systems Link to this page
Prev	Chapter 2. Installing the First AFS Machine	Next

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:

Unpack the OpenAFS IRIX distribution tarball. The examples below assume that you have unpacked the files into the /tmp/afsdist directory. If you pick a different location, substitue this in all of the following examples. Once you have unpacked the distribution, change directory as indicated.
```
   # cd  /tmp/afsdist/sgi_65/dest/root.client
```
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 OpenAFS 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

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.

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.

Whilst the standard IRIX command-line login program and the graphical xdm login program both have the ability to grant AFS tokens, this ability relies upon the deprecated kaserver authentication system.

Users who have been successfully authenticated via Kerberos 5 authentication may obtain AFS tokens following login by running the aklog command.

Sites which still require kaserver or external Kerberos v4 authentication should consult Enabling kaserver based AFS Login on IRIX Systems for details of how to enable IRIX login.

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

Prev	Up	Next
Getting Started on HP-UX Systems	Home	Getting Started on Linux Systems