   Amd - The 4.4 BSD Automounter *****************************

   Amd is the 4.4 BSD Automounter.  This Info file describes how to use
and understand Amd.

Indexes

License
*******

   Amd is not in the public domain; it is copyrighted and there are
restrictions on its distribution.

   Redistribution and use in source and binary forms are permitted
provided that: (1) source distributions  retain this entire  copyright
notice and comment, and (2) distributions including  binaries display
the following acknowledgement: "This product  includes  software
developed  by   The University  of California,   Berkeley  and its
Contributors"  in   the documentation  or other materials provided with
the distribution and in all advertising materials mentioning  features
or use of this software.  neither the name of the University nor the
names of its Contributors may be  used   to endorse or promote
products  derived from  this software without specific prior written
permission.

   THIS SOFTWARE IS  PROVIDED "AS IS"  AND WITHOUT ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING,  WITHOUT  LIMITATION,  THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

Source Distribution
*******************

   If you have access to the Internet, you can get the latest
distribution version of Amd from host `usc.edu' using anonymous FTP.
Move to the directory `/pub/amd' on that host and fetch the file
`amd.tar.Z'.

   If you are in the UK, you can get the latest distribution version of
Amd from the UKnet info-server.  Start by sending email to
`info-server@doc.ic.ac.uk'.

   Sites on the UK JANET network can get the latest distribution by
using anonymous NIFTP to fetch the file `<AMD>amd.tar.Z' from host
`uk.ac.imperial.doc.src'.

   Revision 5.2 was part of the 4.3 BSD Reno distribution.

   Revision 5.3bsdnet, a late alpha version of 5.3, was part of the BSD
network version 2 distribution

Bug Reports
===========

   Send all bug reports to `jsp@doc.ic.ac.uk' quoting the details of
the release and your configuration.  These can be obtained by running
the command `amd -v'.

Mailing List
============

   There is a mailing list for people interested in keeping uptodate
with developments.  To subscribe, send a note to
`amd-workers-request@acl.lanl.gov'.

Introduction
************

   An "automounter" maintains a cache of mounted filesystems.
Filesystems are mounted on demand when they are first referenced, and
unmounted after a period of inactivity.

   Amd may be used as a replacement for Sun's automounter.  The choice
of which filesystem to mount can be controlled dynamically with
"selectors".  Selectors allow decisions of the form "hostname is THIS,"
or "architecture is not THAT."  Selectors may be combined arbitrarily.
Amd also supports a variety of filesystem types, including NFS, UFS and
the novel "program" filesystem.  The combination of selectors and
multiple filesystem types allows identical configuration files to be
used on all machines so reducing the administrative overhead.

   Amd ensures that it will not hang if a remote server goes down.
Moreover, Amd can determine when a remote server has become
inaccessible and then mount replacement filesystems as and when they
become available.

   Amd contains no proprietary source code and has been ported to
numerous flavours of Unix.

Overview
********

   Amd maintains a cache of mounted filesystems.  Filesystems are
"demand-mounted" when they are first referenced, and unmounted after a
period of inactivity.  Amd may be used as a replacement for Sun's
automount(8) program.  It contains no proprietary source code and has
been ported to numerous flavours of Unix.  See Supported Operating Systems.

   Amd was designed as the basis for experimenting with filesystem
layout and management.  Although Amd has many direct applications it is
loaded with additional features which have little practical use.  At
some point the infrequently used components may be removed to streamline
the production system.

Fundamentals
============

   The fundamental concept behind Amd is the ability to separate the
name used to refer to a file from the name used to refer to its physical
storage location.  This allows the same files to be accessed with the
same name regardless of where in the network the name is used.  This is
very different from placing `/n/hostname' in front of the pathname
since that includes location dependent information which may change if
files are moved to another machine.

   By placing the required mappings in a centrally administered
database, filesystems can be re-organised without requiring changes to
configuration files, shell scripts and so on.

Filesystems and Volumes
=======================

   Amd views the world as a set of fileservers, each containg one or
more filesystems where each filesystem contains one or more "volumes".
Here the term "volume" is used to refer to a coherent set of files such
as a user's home directory or a TeX distribution.

   In order to access the contents of a volume, Amd must be told in
which filesystem the volume resides and which host owns the filesystem.
By default the host is assumed to be local and the volume is assumed to
be the entire filesystem.  If a filesystem contains more than one
volume, then a "sublink" is used to refer to the sub-directory within
the filesystem where the volume can be found.

Volume Naming
=============

   Volume names are defined to be unique across the entire network.  A
volume name is the pathname to the volume's root as known by the users
of that volume.  Since this name uniquely identifies the volume
contents, all volumes can be named and accessed from each host, subject
to administrative controls.

   Volumes may be replicated or duplicated.  Replicated volumes contain
identical copies of the same data and reside at two or more locations in
the network.  Each of the replicated volumes can be used
interchangeably.  Duplicated volumes each have the same name but contain
different, though functionally identical, data.  For example,
`/vol/tex' might be the name of a TeX distribution which varied for
each machine architecture.

   Amd provides facilities to take advantage of both replicated and
duplicated volumes.  Configuration options allow a single set of
configuration data to be shared across an entire network by taking
advantage of replicated and duplicated volumes.

   Amd can take advantage of replacement volumes by mounting them as
required should an active fileserver become unavailable.

Volume Binding
==============

   Unix implements a namespace of hierarchically mounted filesystems.
Two forms of binding between names and files are provided.  A "hard
link" completes the binding when the name is added to the filesystem.  A
"soft link" delays the binding until the name is accessed.  An
"automounter" adds a further form in which the binding of name to
filesystem is delayed until the name is accessed.

   The target volume, in its general form, is a tuple (host, filesystem,
sublink) which can be used to name the physical location of any volume
in the network.

   When a target is referenced, Amd ignores the sublink element and
determines whether the required filesystem is already mounted.  This is
done by computing the local mount point for the filesystem and checking
for an existing filesystem mounted at the same place.  If such a
filesystem already exists then it is assumed to be functionally
identical to the target filesystem.  By default there is a one-to-one
mapping between the pair (host, filesystem) and the local mount point so
this assumption is valid.

Operational Principles
======================

   Amd operates by introducing new mount points into the namespace.
These are called "automount" points.  The kernel sees these automount
points as NFS filesystems being served by Amd.  Having attached itself
to the namespace, Amd is now able to control the view the rest of the
system has of those mount points.  RPC calls are received from the
kernel one at a time.

   When a "lookup" call is received Amd checks whether the name is
already known.  If it is not, the required volume is mounted.  A
symbolic link pointing to the volume root is then returned.  Once the
symbolic link is returned, the kernel will send all other requests
direct to the mounted filesystem.

   If a volume is not yet mounted, Amd consults a configuration
"mount-map" corresponding to the automount point.  Amd then makes a
runtime decision on what and where to mount a filesystem based on the
information obtained from the map.

   Amd does not implement all the NFS requests; only those relevant to
name binding such as "lookup", "readlink" and "readdir".  Some other
calls are also implemented but most simply return an error code; for
example "mkdir" always returns "read-only filesystem".

Mounting a Volume
=================

   Each automount point has a corresponding mount map.  The mount map
contains a list of key-value pairs.  The key is the name of the volume
to be mounted.  The value is a list of locations describing where the
filesystem is stored in the network.  In the source for the map the
value would look like

     location1  location2  ...  locationN

   Amd examines each location in turn.  Each location may contain
"selectors" which control whether Amd can use that location.  For
example, the location may be restricted to use by certain hosts.  Those
locations which cannot be used are ignored.

   Amd attempts to mount the filesystem described by each remaining
location until a mount succeeds or Amd can no longer proceed.  The
latter can occur in three ways:

   * If none of the locations could be used, or if all of the locations
     caused an error, then the last error is returned.

   * If a location could be used but was being mounted in the
     background then Amd marks that mount as being "in progress" and
     continues with the next request; no reply is sent to the kernel.

   * Lastly, one or more of the mounts may have been "deferred".  A
     mount is deferred if extra information is required before the
     mount can proceed.  When the information becomes available the
     mount will take place, but in the mean time no reply is sent to
     the kernel.  If the mount is deferred, Amd continues to try any
     remaining locations.

   Once a volume has been mounted, Amd establishes a "volume mapping"
which is used to satisfy subsequent requests.

Automatic Unmounting
====================

   To avoid an ever increasing number of filesystem mounts, Amd removes
volume mappings which have not been used recently.  A time-to-live
interval is associated with each mapping and when that expires the
mapping is removed.  When the last reference to a filesystem is removed,
that filesystem is unmounted.  If the unmount fails, for example the
filesystem is still busy, the mapping is re-instated and its
time-to-live interval is extended.  The global default for this grace
period is controlled by the "-w" command-line option (see -w).
It is also possible to set this value on a per-mount basis
(see opts).

   Filesystems can be forcefully timed out using the Amq command.
See Run-time Administration.

Keep-alives
===========

   Use of some filesystem types requires the presence of a server on
another machine.  If a machine crashes then it is of no concern to
processes on that machine that the filesystem is unavailable.  However,
to processes on a remote host using that machine as a fileserver this
event is important.  This situation is most widely recognised when an
NFS server crashes and the behaviour observed on client machines is that
more and more processes hang.  In order to provide the possibility of
recovery, Amd implements a "keep-alive" interval timer for some
filesystem types.  Currently only NFS makes use of this service.

   The basis of the NFS keep-alive implementation is the observation
that most sites maintain replicated copies of common system data such as
manual pages, most or all programs, system source code and so on.  If
one of those servers goes down it would be reasonable to mount one of
the others as a replacement.

   The first part of the process is to keep track of which fileservers
are up and which are down.  Amd does this by sending RPC requests to the
servers' NFS `NullProc' and checking whether a reply is returned.
While the server state is uncertain the requests are re-transmitted at
three second intervals and if no reply is received after four attempts
the server is marked down.  If a reply is received the fileserver is
marked up and stays in that state for 30 seconds at which time another
NFS ping is sent.

   Once a fileserver is marked down, requests continue to be sent every
30 seconds in order to determine when the fileserver comes back up.
During this time any reference through Amd to the filesystems on that
server fail with the error "Operation would block".  If a replacement
volume is available then it will be mounted, otherwise the error is
returned to the user.

   Although this action does not protect user files, which are unique on
the network, or processes which do not access files via Amd or already
have open files on the hung filesystem, it can prevent most new
processes from hanging.

   By default, fileserver state is not maintained for NFS/TCP mounts.
The remote fileserver is always assumed to be up.

Non-blocking Operation
======================

   Since there is only one instance of Amd for each automount point,
and usually only one instance on each machine, it is important that it
is always available to service kernel calls.  Amd goes to great lengths
to ensure that it does not block in a system call.  As a last resort
Amd will fork before it attempts a system call that may block
indefinitely, such as mounting an NFS filesystem.  Other tasks such as
obtaining filehandle information for an NFS filesystem, are done using a
purpose built non-blocking RPC library which is integrated with Amd's
task scheduler.  This library is also used to implement NFS keep-alives
(see Keep-alives.).

   Whenever a mount is deferred or backgrounded, Amd must wait for it
to complete before replying to the kernel.  However, this would cause
Amd to block waiting for a reply to be constructed.  Rather than do
this, Amd simply "drops" the call under the assumption that the kernel
RPC mechanism will automatically retry the request.

Supported Platforms
*******************

   Amd has been ported to a wide variety of machines and operating
systems.  The table below lists those platforms supported by the
current release.

Supported Operating Systems
===========================

   The following operating systems are currently supported by Amd.
Amd's conventional name for each system is given.

`acis43'
     4.3 BSD for IBM RT.  Contributed by Jan-Simon Pendry
     <jsp@doc.ic.ac.uk>

`aix3'
     AIX 3.1.  Contributed by Jan-Simon Pendry <jsp@doc.ic.ac.uk>

`aux'
     System V for Mac-II.  Contributed by Julian Onions
     <jpo@cs.nott.ac.uk>

`bsd44'
     4.4 BSD.  Contributed by Jan-Simon Pendry <jsp@doc.ic.ac.uk>

`concentrix'
     Concentrix 5.0.  Contributed by Sjoerd Mullender <sjoerd@cwi.nl>

`convex'
     Convex OS 7.1.  Contributed by Eitan Mizrotsky
     <eitan@shumuji.ac.il>

`dgux'
     Data General DG/UX.  Contributed by Mark Davies
     <mark@comp.vuw.ac.nz>

`fpx4'
     Celerity FPX 4.1/2.  Contributed by Stephen Pope
     <scp@grizzly.acl.lanl.gov>

`hcx'
     Harris HCX/UX.  Contributed by Chris Metcalf
     <metcalf@masala.lcs.mit.edu>

`hlh42'
     HLH OTS 1.x (4.2 BSD).  Contributed by Jan-Simon Pendry
     <jsp@doc.ic.ac.uk>

`hpux'
     HP-UX 6.x or 7.0.  Contributed by Jan-Simon Pendry
     <jsp@doc.ic.ac.uk>

`irix'
     SGI Irix.  Contributed by Scott R. Presnell <srp@cgl.ucsf.edu>

`next'
     Mach for NeXT.  Contributed by Bill Trost <trost%reed@cse.ogi.edu>

`pyrOSx'
     Pyramid OSx.  Contributed by Stefan Petri <petri@tubsibr.UUCP>

`riscix'
     Acorn RISC iX.  Contributed by Piete Brooks <pb@cam.cl.ac.uk>

`sos3'
     SunOS 3.4 & 3.5.  Contributed by Jan-Simon Pendry
     <jsp@doc.ic.ac.uk>

`sos4'
     SunOS 4.x.  Contributed by Jan-Simon Pendry <jsp@doc.ic.ac.uk>

`u2_2'
     Ultrix 2.2.  Contributed by Piete Brooks <pb@cam.cl.ac.uk>

`u3_0'
     Ultrix 3.  Contributed by Piete Brooks <pb@cam.cl.ac.uk>

`u4_0'
     Ultrix 4.0.  Contributed by Chris Lindblad <cjl@ai.mit.edu>

`umax43'
     Umax 4.3 BSD.  Contributed by Sjoerd Mullender <sjoerd@cwi.nl>

`utek'
     Utek 4.0.  Contributed by Bill Trost <trost%reed@cse.ogi.edu>

`xinu43'
     mt Xinu MORE/bsd.  Contributed by Jan-Simon Pendry
     <jsp@doc.ic.ac.uk>

`linux'
     Linux i386/i486. Contributed by Mitchum D'Souza
     <m.dsouza@mrc-apu.cam.ac.uk>

Supported Machine Architectures
===============================

`alliant'
     Alliant FX/4

`arm'
     Acorn ARM

`aviion'
     Data General AViiON

`encore'
     Encore

`fps500'
     FPS Model 500

`hp9000'
     HP 9000/300 family

`hp9k8'
     HP 9000/800 family

`ibm032'
     IBM RT

`ibm6000'
     IBM RISC System/6000

`iris4d'
     SGI Iris 4D

`macII'
     Apple Mac II

`mips'
     MIPS RISC

`multimax'
     Encore Multimax

`orion105'
     HLH Orion 1/05

`sun3'
     Sun-3 family

`sun4'
     Sun-4 family

`tahoe'
     Tahoe family

`vax'
     DEC Vax

`linux'
     i386/i486 family

Mount Maps
**********

   Amd has no built-in knowledge of machines or filesystems.  External
"mount-maps" are used to provide the required information.
Specifically, Amd needs to know when and under what conditions it
should mount filesystems.

   The map entry corresponding to the requested name contains a list of
possible locations from which to resolve the request.  Each location
specifies filesystem type, information required by that filesystem (for
example the block special device in the case of UFS), and some
information describing where to mount the filesystem (see fs Option.).
A location may also contain "selectors" (see
Selectors.).

Map Types
=========

   A mount-map provides the run-time configuration information to Amd.
Maps can be implemented in many ways.  Some of the forms supported by
Amd are regular files, ndbm databases, NIS maps the "Hesiod" name
server and even the password file.

   A mount-map "name" is a sequence of characters.  When an automount
point is created a handle on the mount-map is obtained.  For each map
type configured Amd attempts to reference the a map of the appropriate
type.  If a map is found, Amd notes the type for future use and deletes
the reference, for example closing any open file descriptors.  The
available maps are configure when Amd is built and can be displayed by
running the command `amd -v'.

   By default, Amd caches data in a mode dependent on the type of map.
This is the same as specifying `cache:=mapdefault' and selects a
suitable default cache mode depending on the map type.  The individual
defaults are described below.  The CACHE option can be specified on
automount points to alter the caching behaviour (see Automount Filesystem.).

   The following map types have been implemented, though some are not
available on all machines.  Run the command `amd -v' to obtain a list
of map types configured on your machine.

File maps
---------

   When Amd searches a file for a map entry it does a simple scan of
the file and supports both comments and continuation lines.

   Continuation lines are indicated by a backslash character (`\') as
the last character of a line in the file.  The backslash, newline
character *and any leading white space on the following line* are
discarded.  A maximum line length of 2047 characters is enforced after
continuation lines are read but before comments are stripped.  Each
line must end with a newline character; that is newlines are
terminators, not separators.  The following examples illustrate this:

     key     valA   valB;   \
               valC

   specifies *three* locations, and is identical to

     key     valA   valB;   valC

   However,

     key     valA   valB;\
               valC

   specifies only *two* locations, and is identical to

     key     valA   valB;valC

   After a complete line has been read from the file, including
continuations, Amd determines whether there is a comment on the line.
A comment begins with a hash ("`#'") character and continues to the end
of the line.  There is no way to escape or change the comment lead-in
character.

   Note that continuation lines and comment support "only" apply to
file maps, or ndbm maps built with the `mk-amd-map' program.

   When caching is enabled, file maps have a default cache mode of
`all' (see Automount Filesystem.).

ndbm maps
---------

   An ndbm map may be used as a fast access form of a file map.  The
program, `mk-amd-map', converts a normal map file into an ndbm database.
This program supports the same continuation and comment conventions that
are provided for file maps.  Note that ndbm format files may *not* be
sharable across machine architectures.  The notion of speed generally
only applies to large maps; a small map, less than a single disk block,
is almost certainly better implemented as a file map.

   ndbm maps do not support cache mode `all' and, when caching is
enabled, have a default cache mode of `inc' (see Automount Filesystem.).

NIS maps
--------

   When using NIS (formerly YP), an Amd map is implemented directly by
the underlying NIS map.  Comments and continuation lines are *not*
supported in the automounter and must be stripped when constructing the
NIS server's database.

   NIS maps do not support cache mode `all' and, when caching is
enabled, have a default cache mode of `inc' (see Automount Filesystem.).

   The following rule illustrates what could be added to your NIS
`Makefile', in this case causing the `amd.home' map to be rebuilt:
     $(YPTSDIR)/amd.home.time: $(ETCDIR)/amd.home
             -@sed -e "s/#.*$$//" -e "/^$$/d" $(ETCDIR)/amd.home | \
               awk '{  \
                      for (i = 1; i <= NF; i++) \
                          if (i == NF) { \
                              if (substr($$i, length($$i), 1) == "\\") \
                                  printf("%s", substr($$i, 1, length($$i) - 1)); \
                              else \
                                  printf("%s\n", $$i); \
                          } \
                          else \
                              printf("%s ", $$i); \
                  }' | \
             $(MAKEDBM) - $(YPDBDIR)/amd.home; \
             touch $(YPTSDIR)/amd.home.time; \
             echo "updated amd.home"; \
             if [ ! $(NOPUSH) ]; then \
                     $(YPPUSH) amd.home; \
                     echo "pushed amd.home"; \
             else \
                     : ; \
             fi

   Here `$(YPTSDIR)' contains the time stamp files, and `$(YPDBDIR)'
contains the dbm format NIS files.

Hesiod maps
-----------

   When the map name begins with the string `hesiod.' lookups are made
using the "Hesiod" name server.  The string following the dot is used
as a name qualifier and is prepended with the key being located.  The
entire string is then resolved in the `automount' context.  For
example, if the the key is `jsp' and map name is `hesiod.homes' then
"Hesiod" is asked to resolve `jsp.homes.automount'.

   Hesiod maps do not support cache mode `all' and, when caching is
enabled, have a default cache mode of `inc' (see Automount Filesystem.).

   The following is an example of a "Hesiod" map entry:

     jsp.homes.automount HS TXT "rfs:=/home/charm;rhost:=charm;sublink:=jsp"
     njw.homes.automount HS TXT "rfs:=/home/dylan/dk2;rhost:=dylan;sublink:=njw"

Password maps
-------------

   The password map support is unlike the four previous map types.  When
the map name is the string `/etc/passwd' Amd can lookup a user name in
the password file and re-arrange the home directory field to produce a
usable map entry.

   Amd assumes the home directory has the format
`/anydir/dom1/../domN/login'.  It breaks this string into a map entry
where `${rfs}' has the value `/anydir/domN', `${rhost}' has the value
`domN.....dom1', and `${sublink}' has the value `login'.

   Thus if the password file entry was

     /home/achilles/jsp

   the map entry used by Amd would be

     rfs:=/home/achilles;rhost:=achilles;sublink:=jsp

   Similarly, if the password file entry was

     /home/cc/sugar/mjh

   the map entry used by Amd would be

     rfs:=/home/sugar;rhost:=sugar.cc;sublink:=jsp

Union maps
----------

   The union map support is provided specifically for use with the union
filesystem, see Union Filesystem..

   It is identified by the string `union:' which is followed by a colon
separated list of directories.  The directories are read in order, and
the names of all entries are recorded in the map cache.  Later
directories take precedence over earlier ones.  The union filesystem
type then uses the map cache to determine the union of the names in all
the directories.

How keys are looked up
======================

   The key is located in the map whose type was determined when the
automount point was first created.  In general the key is a pathname
component.  In some circumstances this may be modified by variable
expansion (see Variable Expansion.) and prefixing.  If the automount
point has a prefix, specified by the PREF option, then that is
prepended to the search key before the map is searched.

   If the map cache is a `regexp' cache then the key is treated as an
egrep-style regular expression, otherwise a normal string comparison is
made.

   If the key cannot be found then a "wildcard" match is attempted.
Amd repeatedly strips the basename from the key, appends `/*' and
attempts a lookup.  Finally, Amd attempts to locate the special key `*'.

   For example, the following sequence would be checked if
`home/dylan/dk2' was being located:

        home/dylan/dk2
        home/dylan/*
        home/*
        *

   At any point when a wildcard is found, Amd proceeds as if an exact
match had been found and the value field is then used to resolve the
mount request, otherwise an error code is propagated back to the kernel.
(see Filesystem Types.).

Location Format
===============

   The value field from the lookup provides the information required to
mount a filesystem.  The information is parsed according to the syntax
shown below.

     location-list:
                       location-selection
                       location-list white-space || white-space location-selection
     location-selection:
                       location
                       location-selection white-space location
     location:
                       location-info
                       -location-info
                       -
     location-info:
                       sel-or-opt
                       location-info;sel-or-opt
                       ;
     sel-or-opt:
                       selection
                       opt-ass
     selection:
                       selector==value
                       selector!=value
     opt-ass:
                       option:=value
     white-space:
                       space
                       tab

   Note that unquoted whitespace is not allowed in a location
description.  White space is only allowed, and is mandatory, where
shown with non-terminal `white-space'.

   A "location-selection" is a list of possible volumes with which to
satisfy the request.  "location-selection"s are separated by the `||'
operator.  The effect of this operator is to prevent use of
location-selections to its right if any of the location-selections on
its left were selected whether or not any of them were successfully
mounted (see Selectors.).

   The location-selection, and singleton "location-list",
`type:=ufs;dev:=/dev/xd1g' would inform Amd to mount a UFS filesystem
from the block special device `/dev/xd1g'.

   The "sel-or-opt" component is either the name of an option required
by a specific filesystem, or it is the name of a built-in, predefined
selector such as the architecture type.  The value may be quoted with
double quotes `"', for example `type:="ufs";dev:="/dev/xd1g"'.  These
quotes are stripped when the value is parsed and there is no way to get
a double quote into a value field.  Double quotes are used to get white
space into a value field, which is needed for the program filesystem
(see Program Filesystem.).

Map Defaults
------------

   A location beginning with a dash `-' is used to specify default
values for subsequent locations.  Any previously specified defaults in
the location-list are discarded.  The default string can be empty in
which case no defaults apply.

   The location `-fs:=/mnt;opts:=ro' would set the local mount point to
`/mnt' and cause mounts to be read-only by default.  Defaults specified
this way are appended to, and so override, any global map defaults
given with `/defaults').

Variable Expansion
------------------

   To allow generic location specifications Amd does variable expansion
on each location and also on some of the option strings.  Any option or
selector appearing in the form `$"var"' is replaced by the current
value of that option or selector.  For example, if the value of
`${key}' was `bin', `${autodir}' was `/a' and `${fs}' was
`${autodir}/local/${key}' then after expansion `${fs}' would have the
value `/a/local/bin'.  Any environment variable can be accessed in a
similar way.

   Two pathname operators are available when expanding a variable.  If
the variable name begins with `/' then only the last component of then
pathname is substituted.  For example, if `${path}' was `/foo/bar' then
`${/path}' would be expanded to `bar'.  Similarly, if the variable name
ends with `/' then all but the last component of the pathname is
substituted.  In the previous example, `${path/}' would be expanded to
`/foo'.

   Two domain name operators are also provided.  If the variable name
begins with `.' then only the domain part of the name is substituted.
For example, if `${rhost}' was `swan.doc.ic.ac.uk' then `${.rhost}'
would be expanded to `doc.ic.ac.uk'.  Similarly, if the variable name
ends with `.' then only the host component is substituted.  In the
previous example, `${rhost.}' would be expanded to `swan'.

   Variable expansion is a two phase process.  Before a location is
parsed, all references to selectors, eg `${path}', are expanded.  The
location is then parsed, selections are evaluated and option assignments
recorded.  If there were no selections or they all succeeded the
location is used and the values of the following options are expanded in
the order given: SUBLINK, RFS, FS, OPTS, REMOPTS, MOUNT and UNMOUNT.

   Note that expansion of option values is done after "all" assignments
have been completed and not in a purely left to right order as is done
by the shell.  This generally has the desired effect but care must be
taken if one of the options references another, in which case the
ordering can become significant.

   There are two special cases concerning variable expansion:

  1. before a map is consulted, any selectors in the name received from
     the kernel are expanded.  For example, if the request from the
     kernel was for `${arch}.bin' and the machine architecture was
     `vax', the value given to `${key}' would be `vax.bin'.

  2. the value of `${rhost}' is expanded and normalized before the
     other options are expanded.  The normalization process strips any
     local sub-domain components.  For example, if `${domain}' was
     `Berkeley.EDU' and `${rhost}' was initially `snow.Berkeley.EDU',
     after the normalization it would simply be `snow'.  Hostname
     normalization is currently done in a *case-dependent* manner.

Selectors
---------

   Selectors are used to control the use of a location.  It is possible
to share a mount map between many machines in such a way that filesystem
location, architecture and operating system differences are hidden from
the users.  A selector of the form `arch==sun3;os==sos4' would only
apply on Sun-3s running SunOS 4.x.

   Selectors are evaluated left to right.  If a selector fails then that
location is ignored.  Thus the selectors form a conjunction and the
locations form a disjunction.  If all the locations are ignored or
otherwise fail then Amd uses the "error" filesystem (see Error Filesystem.).
This is equivalent to having a location `type:=error'
at the end of each mount-map entry.

   The selectors currently implemented are:

`arch'
     the machine architecture which was automatically determined at
     compile time.  The architecture type can be displayed by running
     the command `amd -v'.  See Supported Machine Architectures.

`autodir'
     the default directory under which to mount filesystems.  This may
     be changed by the "-a" command line option.  See the FS option.

`byte'
     the machine's byte ordering.  This is either `little', indicating
     little-endian, or `big', indicating big-endian.  One possible use
     is to share `rwho' databases (see rwho servers.).  Another is
     to share ndbm databases, however this use can be considered a
     courageous juggling act.

`cluster'
     is provided as a hook for the name of the local cluster.  This can
     be used to decide which servers to use for copies of replicated
     filesystems.  `${cluster}' defaults to the value of `${domain}'
     unless a different value is set with the "-C" command line option.

`domain'
     the local domain name as specified by the "-d" command line option.
     See `host'.

`host'
     the local hostname as determined by gethostname(2).  If no domain
     name was specified on the command line and the hostname contains a
     period `.' then the string before the period is used as the host
     name, and the string after the period is assigned to `${domain}'.
     For example, if the hostname is `styx.doc.ic.ac.uk' then `host'
     would be `styx' and `domain' would be `doc.ic.ac.uk'.  `hostd'
     would be `styx.doc.ic.ac.uk'.

`hostd'
     is `${host}' and `${domain}' concatenated with a `.' inserted
     between them if required.  If `${domain}' is an empty string then
     `${host}' and `${hostd}' will be identical.

`karch'
     is provided as a hook for the kernel architecture.  This is used on
     SunOS 4, for example, to distinguish between different `/usr/kvm'
     volumes.  `${karch}' defaults to the value of `${arch}' unless a
     different value is set with the "-k" command line option.

`os'
     the operating system.  Like the machine architecture, this is
     automatically determined at compile time.  The operating system
     name can be displayed by running the command `amd -v'.  See
     Supported Operating Systems.

   The following selectors are also provided.  Unlike the other
selectors, they vary for each lookup.  Note that when the name from the
kernel is expanded prior to a map lookup, these selectors are all
defined as empty strings.

`key'
     the name being resolved.  For example, if `/home' is an automount
     point, then accessing `/home/foo' would set `${key}' to the string
     `foo'.  The key is prefixed by the PREF option set in the parent
     mount point.  The default prefix is an empty string.  If the
     prefix was `blah/' then `${key}' would be set to `blah/foo'.

`map'
     the name of the mount map being used.

`path'
     the full pathname of the name being resolved.  For example
     `/home/foo' in the example above.

`wire'
     the name of the network to which the primary network interface is
     attached.  If a symbolic name cannot be found in the networks or
     hosts database then dotted IP address format is used.  This value
     is also output by the "-v" option.

   Selectors can be negated by using `!=' instead of `=='.  For example
to select a location on all non-Vax machines the selector `arch!=vax'
would be used.

Map Options
-----------

   Options are parsed concurrently with selectors.  The difference is
that when an option is seen the string following the `:=' is recorded
for later use.  As a minimum the TYPE option must be specified.  Each
filesystem type has other options which must also be specified.  See
Filesystem Types, for details on the filesystem specific options.

   Superfluous option specifications are ignored and are not reported
as errors.

   The following options apply to more than one filesystem type.

delay Option
............

   The delay, in seconds, before an attempt will be made to mount from
the current location.  Auxilliary data, such as network address, file
handles and so on are computed regardless of this value.

   A delay can be used to implement the notion of primary and secondary
file servers.  The secondary servers would have a delay of a few
seconds, thus giving the primary servers a chance to respond first.

fs Option
.........

   The local mount point.  The semantics of this option vary between
filesystems.

   For NFS and UFS filesystems the value of `${fs}' is used as the
local mount point.  For other filesystem types it has other meanings
which are described in the section describing the respective filesystem
type.  It is important that this string uniquely identifies the
filesystem being mounted.  To satisfy this requirement, it should
contain the name of the host on which the filesystem is resident and the
pathname of the filesystem on the local or remote host.

   The reason for requiring the hostname is clear if replicated
filesystems are considered.  If a fileserver goes down and a
replacement filesystem is mounted then the "local" mount point "must"
be different from that of the filesystem which is hung.  Some encoding
of the filesystem name is required if more than one filesystem is to be
mounted from any given host.

   If the hostname is first in the path then all mounts from a
particular host will be gathered below a single directory.  If that
server goes down then the hung mount points are less likely to be
accidentally referenced, for example when getwd(3) traverses the
namespace to find the pathname of the current directory.

   The `fs' option defaults to `${autodir}/${rhost}${rfs}'.  In
addition, `rhost' defaults to the local host name (`${host}') and `rfs'
defaults to the value of `${path}', which is the full path of the
requested file; `/home/foo' in the example above (see Selectors.).
`${autodir}' defaults to `/a' but may be changed with the "-a" command
line option.  Sun's automounter defaults to `/tmp_mnt'.  Note that
there is no `/' between the `${rhost}' and `${rfs}' since `${rfs}'
begins with a `/'.

opts Option
...........

   The options to pass to the mount system call.  A leading `-' is
silently ignored.  The mount options supported generally correspond to
those used by mount(8) and are listed below.  Some additional
pseudo-options are interpreted by Amd and are also listed.

   Unless specifically overridden, each of the system default mount
options applies.  Any options not recognised are ignored.  If no
options list is supplied the string `rw,defaults' is used and all the
system default mount options apply.  Options which are not applicable
for a particular operating system are silently ignored.  For example,
only 4.4 BSD is known to implement the `compress' and `spongy' options.

`compress'
     Use NFS compression protocol.

`grpid'
     Use BSD directory group-id semantics.

`intr'
     Allow keyboard interrupts on hard mounts.

`noconn'
     Don't make a connection on datagram transports.

`nocto'
     No close-to-open consistency.

`nodevs'
     Don't allow local special devices on this filesystem.

`nosuid'
     Don't allow set-uid or set-gid executables on this filesystem.

`quota'
     Enable quota checking on this mount.

`retrans=n'
     The number of NFS retransmits made before a user error is
     generated by a `soft' mounted filesystem, and before a `hard'
     mounted filesystem reports `NFS server "yoyo" not responding still
     trying'.

`ro'
     Mount this filesystem readonly.

`rsize=N'
     The NFS read packet size.  You may need to set this if you are
     using NFS/UDP through a gateway.

`soft'
     Give up after "retrans" retransmissions.

`spongy'
     Like `soft' for status requests, and `hard' for data transfers.

`tcp'
     Use TCP/IP instead of UDP/IP, ignored if the NFS implementation
     does not support TCP/IP mounts.

`timeo=N'
     The NFS timeout, in tenth-seconds, before a request is
     retransmitted.

`wsize=N'
     The NFS write packet size.  You may need to set this if you are
     using NFS/UDP through a gateway.

   The following options are implemented by Amd, rather than being
passed to the kernel.

`nounmount'
     Configures the mount so that its time-to-live will never expire.
     This is also the default for some filesystem types.

`ping=N'
     The interval, in seconds, between keep-alive pings.  When four
     consecutive pings have failed the mount point is marked as hung.
     This interval defaults to 30 seconds.  If the ping interval is
     less than zero, no pings are sent and the host is assumed to be
     always up.  By default, pings are not sent for an NFS/TCP mount.

`retry=N'
     The number of times to retry the mount system call.

`utimeout=N'
     The interval, in seconds, by which the mount's time-to-live is
     extended after an unmount attempt has failed.  In fact the
     interval is extended before the unmount is attempted to avoid
     thrashing.  The default value is 120 seconds (two minutes) or as
     set by the "-w" command line option.

remopts Option
..............

   This option has the same use as `${opts}' but applies only when the
remote host is on a non-local network.  For example, when using NFS
across a gateway it is often necessary to use smaller values for the
data read and write sizes.  This can simply be done by specifying the
small values in REMOPTS.  When a non-local host is accessed, the
smaller sizes will automatically be used.

   Amd determines whether a host is local by examining the network
interface configuration at startup.  Any interface changes made after
Amd has been started will not be noticed.  The likely effect will be
that a host may incorrectly be declared non-local.

   Unless otherwise set, the value of `${rem}' is the same as the value
of `${opts}'.

sublink Option
..............

   The subdirectory within the mounted filesystem to which the reference
should point.  This can be used to prevent duplicate mounts in cases
where multiple directories in the same mounted filesystem are used.

type Option
...........

   The filesystem type to be used.  See Filesystem Types, for a full
description of each type.