| |
man : amdref
File: amdref.info, Node: Top, Next: License, Up: (DIR)
Amd - The 4.4 BSD Automounter *****************************
Amd is the 4.4 BSD Automounter. This Info file describes how to use
and understand Amd.
* Menu:
* License:: Explains the terms and conditions for using
and distributing Amd.
* Distrib:: How to get the latest Amd distribution.
* Intro:: An introduction to Automounting concepts.
* Overview:: An overview of Amd.
* Supported Platforms:: Machines and Systems supported by Amd.
* Mount Maps:: Details of mount maps
* Amd Command Line Options:: All the Amd command line options explained.
* Filesystem Types:: The different mount types supported by Amd.
* Run-time Administration:: How to start, stop and control Amd.
* Examples:: Some examples showing how Amd might be used.
* Internals:: Implementation details.
* Acknowledgements & Trademarks:: Legal notes.
Indexes
* Index:: An item for each concept.
File: amdref.info, Node: License, Next: Distrib, Prev: Top, Up: Top
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.
File: amdref.info, Node: Distrib, Next: Intro, Prev: License, Up: Top
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-serverATdoc.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 `jspATdoc.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-requestATacl.gov'.
File: amdref.info, Node: Intro, Next: Overview, Prev: Distrib, Up: Top
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.
File: amdref.info, Node: Overview, Next: Supported Platforms, Prev: Intro, Up: Top
1 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. *Note 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.
* Menu:
* Fundamentals::
* Filesystems and Volumes::
* Volume Naming::
* Volume Binding::
* Operational Principles::
* Mounting a Volume::
* Automatic Unmounting::
* Keep-alives::
* Non-blocking Operation::
File: amdref.info, Node: Fundamentals, Next: Filesystems and Volumes, Prev: Overview, Up: Overview
1.1 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.
File: amdref.info, Node: Filesystems and Volumes, Next: Volume Naming, Prev: Fundamentals, Up: Overview
1.2 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.
File: amdref.info, Node: Volume Naming, Next: Volume Binding, Prev: Filesystems and Volumes, Up: Overview
1.3 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.
File: amdref.info, Node: Volume Binding, Next: Operational Principles, Prev: Volume Naming, Up: Overview
1.4 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.
File: amdref.info, Node: Operational Principles, Next: Mounting a Volume, Prev: Volume Binding, Up: Overview
1.5 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".
File: amdref.info, Node: Mounting a Volume, Next: Automatic Unmounting, Prev: Operational Principles, Up: Overview
1.6 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.
File: amdref.info, Node: Automatic Unmounting, Next: Keep-alives, Prev: Mounting a Volume, Up: Overview
1.7 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 (*note -w: -w
Option.). It is also possible to set this value on a per-mount basis
(*note opts: opts Option.).
Filesystems can be forcefully timed out using the Amq command.
*Note Run-time Administration::.
File: amdref.info, Node: Keep-alives, Next: Non-blocking Operation, Prev: Automatic Unmounting, Up: Overview
1.8 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.
File: amdref.info, Node: Non-blocking Operation, Prev: Keep-alives, Up: Overview
1.9 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
(*note 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.
File: amdref.info, Node: Supported Platforms, Next: Mount Maps, Prev: Overview, Up: Top
2 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.
* Menu:
* Supported Operating Systems::
* Supported Machine Architectures::
File: amdref.info, Node: Supported Operating Systems, Next: Supported Machine Architectures, Prev: Supported Platforms, Up: Supported Platforms
2.1 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
<jspATdoc.uk>
`aix3'
AIX 3.1. Contributed by Jan-Simon Pendry <jspATdoc.uk>
`aux'
System V for Mac-II. Contributed by Julian Onions
<jpoATcs.uk>
`bsd44'
4.4 BSD. Contributed by Jan-Simon Pendry <jspATdoc.uk>
`concentrix'
Concentrix 5.0. Contributed by Sjoerd Mullender <sjoerdATcwi.nl>
`convex'
Convex OS 7.1. Contributed by Eitan Mizrotsky
<eitanATshumuji.il>
`dgux'
Data General DG/UX. Contributed by Mark Davies
<markATcomp.nz>
`fpx4'
Celerity FPX 4.1/2. Contributed by Stephen Pope
<scpATgrizzly.gov>
`hcx'
Harris HCX/UX. Contributed by Chris Metcalf
<metcalfATmasala.edu>
`hlh42'
HLH OTS 1.x (4.2 BSD). Contributed by Jan-Simon Pendry
<jspATdoc.uk>
`hpux'
HP-UX 6.x or 7.0. Contributed by Jan-Simon Pendry
<jspATdoc.uk>
`irix'
SGI Irix. Contributed by Scott R. Presnell <srpATcgl.edu>
`next'
Mach for NeXT. Contributed by Bill Trost <trost%reedATcse.edu>
`pyrOSx'
Pyramid OSx. Contributed by Stefan Petri <petriATtubsibr.UUCP>
`riscix'
Acorn RISC iX. Contributed by Piete Brooks <pbATcam.uk>
`sos3'
SunOS 3.4 & 3.5. Contributed by Jan-Simon Pendry
<jspATdoc.uk>
`sos4'
SunOS 4.x. Contributed by Jan-Simon Pendry <jspATdoc.uk>
`u2_2'
Ultrix 2.2. Contributed by Piete Brooks <pbATcam.uk>
`u3_0'
Ultrix 3. Contributed by Piete Brooks <pbATcam.uk>
`u4_0'
Ultrix 4.0. Contributed by Chris Lindblad <cjlATai.edu>
`umax43'
Umax 4.3 BSD. Contributed by Sjoerd Mullender <sjoerdATcwi.nl>
`utek'
Utek 4.0. Contributed by Bill Trost <trost%reedATcse.edu>
`xinu43'
mt Xinu MORE/bsd. Contributed by Jan-Simon Pendry
<jspATdoc.uk>
File: amdref.info, Node: Supported Machine Architectures, Prev: Supported Operating Systems, Up: Supported Platforms
2.2 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
File: amdref.info, Node: Mount Maps, Next: Amd Command Line Options, Prev: Supported Platforms, Up: Top
3 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 (*note fs
Option::). A location may also contain "selectors" (*note Selectors::).
* Menu:
* Map Types::
* Key Lookup::
* Location Format::
File: amdref.info, Node: Map Types, Next: Key Lookup, Prev: Mount Maps, Up: Mount Maps
3.1 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, 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 (*note 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.
* Menu:
* File maps::
* NIS maps::
* Hesiod maps::
* Password maps::
* Union maps::
File: amdref.info, Node: File maps, Next: NIS maps, Prev: Map Types, Up: Map Types
3.1.1 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.
When caching is enabled, file maps have a default cache mode of
`all' (*note Automount Filesystem::).
File: amdref.info, Node: NIS maps, Next: Hesiod maps, Prev: File maps, Up: Map Types
3.1.2 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' (*note 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.
File: amdref.info, Node: Hesiod maps, Next: Password maps, Prev: NIS maps, Up: Map Types
3.1.3 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 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' (*note 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"
File: amdref.info, Node: Password maps, Next: Union maps, Prev: Hesiod maps, Up: Map Types
3.1.4 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
File: amdref.info, Node: Union maps, Prev: Password maps, Up: Map Types
3.1.5 Union maps
----------------
The union map support is provided specifically for use with the union
filesystem, *note 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.
File: amdref.info, Node: Key Lookup, Next: Location Format, Prev: Map Types, Up: Mount Maps
3.2 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 (*note 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.
(*note Filesystem Types::).
File: amdref.info, Node: Location Format, Prev: Key Lookup, Up: Mount Maps
3.3 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 (*note 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
(*note Program Filesystem::).
* Menu:
* Map Defaults::
* Variable Expansion::
* Selectors::
* Map Options::
File: amdref.info, Node: Map Defaults, Next: Variable Expansion, Prev: Location Format, Up: Location Format
3.3.1 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').
File: amdref.info, Node: Variable Expansion, Next: Selectors, Prev: Map Defaults, Up: Location Format
3.3.2 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.
File: amdref.info, Node: Selectors, Next: Map Options, Prev: Variable Expansion, Up: Location Format
3.3.3 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 (*note 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'. *Note 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 (*note rwho servers::).
`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'. *Note
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.
File: amdref.info, Node: Map Options, Prev: Selectors, Up: Location Format
3.3.4 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. *Note
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.
* Menu:
* delay Option::
* fs Option::
* opts Option::
* remopts Option::
* sublink Option::
* type Option::
File: amdref.info, Node: delay Option, Next: fs Option, Prev: Map Options, Up: Map Options
3.3.4.1 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.
File: amdref.info, Node: fs Option, Next: opts Option, Prev: delay Option, Up: Map Options
3.3.4.2 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 (*note 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 `/'.
File: amdref.info, Node: opts Option, Next: remopts Option, Prev: fs Option, Up: Map Options
3.3.4.3 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.
`nolooklease'
When nqnfs is selected, disable the automatic acquiring of leases
on lookups.
`nosuid'
Don't allow set-uid or set-gid executables on this filesystem.
`nqnfs'
Enable leasing extensions to the NFS protocol know as Not Quite
NFS. Only supported by the 4.4BSD NFS implementation.
`quota'
Enable quota checking on this mount.
`resvport'
Use a reserved port number (one less than 1024). Some NFS servers
require this.
`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.
File: amdref.info, Node: remopts Option, Next: sublink Option, Prev: opts Option, Up: Map Options
3.3.4.4 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}'.
File: amdref.info, Node: sublink Option, Next: type Option, Prev: remopts Option, Up: Map Options
3.3.4.5 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.
File: amdref.info, Node: type Option, Prev: sublink Option, Up: Map Options
3.3.4.6 type Option
...................
The filesystem type to be used. *Note Filesystem Types::, for a full
description of each type.
File: amdref.info, Node: Amd Command Line Options, Next: Filesystem Types, Prev: Mount Maps, Up: Top
4 Amd Command Line Options
**************************
Many of Amd's parameters can be set from the command line. The command
line is also used to specify automount points and maps.
The general format of a command line is
amd [options] { directory map-name [-map-options] } ...
For each directory and map-name given, Amd establishes an automount
point. The "map-options" may be any sequence of options or
selectors--*note Location Format::. The "map-options" apply only to
Amd's mount point.
`type:=toplvl;cache:=mapdefault;fs:=${map}' is the default value for
the map options. Default options for a map are read from a special
entry in the map whose key is the string `/defaults'. When default
options are given they are prepended to any options specified in the
mount-map locations as explained in. *Note Map Defaults::, for more
details.
The "options" are any combination of those listed below.
Once the command line has been parsed, the automount points are
mounted. The mount points are created if they do not already exist, in
which case they will be removed when Amd exits. Finally, Amd
disassociates itself from its controlling terminal and forks into the
background.
Note: Even if Amd has been built with `-DDEBUG' it will still
background itself and disassociate itself from the controlling terminal.
To use a debugger it is necessary to specify `-D nodaemon' on the
command line.
* Menu:
* -a Option:: Automount directory.
* -c Option:: Cache timeout interval.
* -d Option:: Domain name.
* -k Option:: Kernel architecture.
* -l Option:: Log file.
* -n Option:: Hostname normalisation.
* -p Option:: Output process id.
* -r Option:: Restart existing mounts.
* -t Option:: Kernel RPC timeout.
* -v Option:: Version information.
* -w Option:: Wait interval after failed unmount.
* -x Option:: Log options.
* -y Option:: NIS domain.
* -C-Option:: Cluster name.
* -D-Option:: Debug flags.
File: amdref.info, Node: -a Option, Next: -c Option, Prev: Amd Command Line Options, Up: Amd Command Line Options
4.1 `-a' DIRECTORY
==================
Specifies the default mount directory. This option changes the variable
`${autodir}' which otherwise defaults to `/a'. For example, some sites
prefer `/amd'.
amd -a /amd ...
File: amdref.info, Node: -c Option, Next: -d Option, Prev: -a Option, Up: Amd Command Line Options
4.2 `-c' CACHE-INTERVAL
=======================
Selects the period, in seconds, for which a name is cached by Amd. If
no reference is made to the volume in this period, Amd discards the
volume name to filesystem mapping.
Once the last reference to a filesystem has been removed, Amd
attempts to unmount the filesystem. If the unmount fails the interval
is extended by a further period as specified by the `-w' command line
option or by the `utimeout' mount option.
The default "cache-interval" is 300 seconds (five minutes).
File: amdref.info, Node: -d Option, Next: -k Option, Prev: -c Option, Up: Amd Command Line Options
4.3 `-d' DOMAIN
===============
Specifies the host's domain. This sets the internal variable
`${domain}' and affects the `${hostd}' variable.
If this option is not specified and the hostname already contains the
local domain then that is used, otherwise the default value of
`${domain}' is `unknown.domain'.
For example, if the local domain was `doc.ic.ac.uk', Amd could be
started as follows:
amd -d doc.ic.ac.uk ...
File: amdref.info, Node: -k Option, Next: -l Option, Prev: -d Option, Up: Amd Command Line Options
4.4 `-k' KERNEL-ARCHITECTURE
============================
Specifies the kernel architecture of the system. This is usually the
output of `arch -k' and its only effect is to set the variable
`${karch}'. If this option is not given, `${karch}' has the same value
as `${arch}'.
This would be used as follows:
amd -k `arch -k` ...
File: amdref.info, Node: -l Option, Next: -n Option, Prev: -k Option, Up: Amd Command Line Options
4.5 `-l' LOG-OPTION
===================
Selects the form of logging to be made. Two special "log-options" are
recognised.
1. If "log-option" is the string `syslog', Amd will use the syslog(3)
mechanism.
2. If "log-option" is the string `/dev/stderr', Amd will use standard
error, which is also the default target for log messages. To
implement this, Amd simulates the effect of the `/dev/fd' driver.
Any other string is taken as a filename to use for logging. Log
messages are appended to the file if it already exists, otherwise a new
file is created. The file is opened once and then held open, rather
than being re-opened for each message.
If the `syslog' option is specified but the system does not support
syslog or if the named file cannot be opened or created, Amd will use
standard error. Error messages generated before Amd has finished
parsing the command line are printed on standard error.
Using `syslog' is usually best, in which case Amd would be started
as follows:
amd -l syslog ...
File: amdref.info, Node: -n Option, Next: -p Option, Prev: -l Option, Up: Amd Command Line Options
4.6 `-n'
========
Normalises the remote hostname before using it. Normalisation is done
by replacing the value of `${rhost}' with the primary name returned by
a hostname lookup.
This option should be used if several names are used to refer to a
single host in a mount map.
File: amdref.info, Node: -p Option, Next: -r Option, Prev: -n Option, Up: Amd Command Line Options
4.7 `-p'
========
Causes Amd's process id to be printed on standard output. This can be
redirected to a suitable file for use with kill:
amd -p > /var/run/amd.pid ...
This option only has an affect if Amd is running in daemon mode. If
Amd is started with the `-D nodaemon' debug flag, this option is
ignored.
File: amdref.info, Node: -r Option, Next: -t Option, Prev: -p Option, Up: Amd Command Line Options
4.8 `-r'
========
Tells Amd to restart existing mounts (*note Inheritance Filesystem::).
File: amdref.info, Node: -t Option, Next: -v Option, Prev: -r Option, Up: Amd Command Line Options
4.9 `-t' TIMEOUT.RETRANSMIT
===========================
Specifies the RPC "timeout" and "retransmit" intervals used by the
kernel to communicate to Amd. These are used to set the `timeo' and
`retrans' mount options.
Amd relies on the kernel RPC retransmit mechanism to trigger mount
retries. The value of this parameter changes the retry interval. Too
long an interval gives poor interactive response, too short an interval
causes excessive retries.
File: amdref.info, Node: -v Option, Next: -w Option, Prev: -t Option, Up: Amd Command Line Options
4.10 `-v'
=========
Print version information on standard error and then exit. The output
is of the form:
amd 5.2.1.11 of 91/03/17 18:04:05 5.3Alpha11 #0: Sun Mar 17 18:07:28 GMT 1991
Built by pendryATvangogh.EDU for a hp300 running bsd44 (big-endian).
Map support for: root, passwd, union, file, error.
FS: ufs, nfs, nfsx, host, link, program, union, auto, direct, toplvl, error.
Primary network is 128.32.130.0.
The information includes the version number, release date and name of
the release. The architecture (*note Supported Machine
Architectures::), operating system (*note Supported Operating Systems::)
and byte ordering are also printed as they appear in the `${os}',
`${arch}' and `${byte}' variables.
File: amdref.info, Node: -w Option, Next: -x Option, Prev: -v Option, Up: Amd Command Line Options
4.11 `-w' WAIT-TIMEOUT
======================
Selects the interval in seconds between unmount attempts after the
initial time-to-live has expired.
This defaults to 120 seconds (two minutes).
File: amdref.info, Node: -x Option, Next: -y Option, Prev: -w Option, Up: Amd Command Line Options
4.12 `-x' OPTS
==============
Specifies the type and verbosity of log messages. "opts" is a comma
separated list selected from the following options:
`fatal'
Fatal errors
`error'
Non-fatal errors
`user'
Non-fatal user errors
`warn'
Recoverable errors
`warning'
Alias for `warn'
`info'
Information messages
`map'
Mount map usage
`stats'
Additional statistics
`all'
All of the above
Initially a set of default logging flags is enabled. This is as if
`-x all,nomap,nostats' had been selected. The command line is parsed
and logging is controlled by the "-x" option. The very first set of
logging flags is saved and can not be subsequently disabled using Amq.
This default set of options is useful for general production use.
The `info' messages include details of what is mounted and unmounted
and when filesystems have timed out. If you want to have the default
set of messages without the `info' messages then you simply need `-x
noinfo'. The messages given by `user' relate to errors in the mount
maps, so these are useful when new maps are installed. The following
table lists the syslog priorites used for each of the message types.
`fatal'
LOG_CRIT
`error'
LOG_ERR
`user'
LOG_WARNING
`warning'
LOG_WARNING
`info'
LOG_INFO
`debug'
LOG_DEBUG
`map'
LOG_DEBUG
`stats'
LOG_INFO
The options can be prefixed by the string `no' to indicate that this
option should be turned off. For example, to obtain all but `info'
messages the option `-x all,noinfo' would be used.
If Amd was built with debugging enabled the `debug' option is
automatically enabled regardless of the command line options.
File: amdref.info, Node: -y Option, Next: -C-Option, Prev: -x Option, Up: Amd Command Line Options
4.13 `-y' NIS-DOMAIN
====================
Selects an alternate NIS domain. This is useful for debugging and
cross-domain shared mounting. If this flag is specified, Amd
immediately attempts to bind to a server for this domain.
File: amdref.info, Node: -C-Option, Next: -D-Option, Prev: -y Option, Up: Amd Command Line Options
4.14 `-C' CLUSTER-NAME
======================
Specifies the name of the cluster of which the local machine is a
member. The only effect is to set the variable `${cluster}'. The
"cluster-name" is will usually obtained by running another command
which uses a database to map the local hostname into a cluster name.
`${cluster}' can then be used as a selector to restrict mounting of
replicated data. If this option is not given, `${cluster}' has the
same value as `${domain}'. This would be used as follows:
amd -C `clustername` ...
File: amdref.info, Node: -D-Option, Prev: -C-Option, Up: Amd Command Line Options
4.15 `-D' OPTS
==============
Controls the verbosity and coverage of the debugging trace; "opts" is a
comma separated list of debugging options. The "-D" option is only
available if Amd was compiled with `-DDEBUG'. The memory debugging
facilities are only available if Amd was compiled with `-DDEBUG_MEM'
(in addition to `-DDEBUG').
The most common options to use are `-D trace' and `-D test' (which
turns on all the useful debug options). See the program source for a
more detailed explanation of the available options.
File: amdref.info, Node: Filesystem Types, Next: Run-time Administration, Prev: Amd Command Line Options, Up: Top
5 Filesystem Types
******************
To mount a volume, Amd must be told the type of filesystem to be used.
Each filesystem type typically requires additional information such as
the fileserver name for NFS.
From the point of view of Amd, a "filesystem" is anything that can
resolve an incoming name lookup. An important feature is support for
multiple filesystem types. Some of these filesystems are implemented
in the local kernel and some on remote fileservers, whilst the others
are implemented internally by Amd.
The two common filesystem types are UFS and NFS. Four other user
accessible filesystems (`link', `program', `auto' and `direct') are
also implemented internally by Amd and these are described below.
There are two additional filesystem types internal to Amd which are not
directly accessible to the user (`inherit' and `error'). Their use is
described since they may still have an effect visible to the user.
* Menu:
* Network Filesystem:: A single NFS filesystem.
* Network Host Filesystem:: NFS mount a host's entire export tree.
* Network Filesystem Group:: An atomic group of NFS filesystems.
* Unix Filesystem:: Native disk filesystem.
* Program Filesystem:: Generic Program mounts.
* Symbolic Link Filesystem:: Local link referencing existing filesystem.
* Automount Filesystem::
* Direct Automount Filesystem::
* Union Filesystem::
* Error Filesystem::
* Top-level Filesystem::
* Root Filesystem::
* Inheritance Filesystem::
File: amdref.info, Node: Network Filesystem, Next: Network Host Filesystem, Prev: Filesystem Types, Up: Filesystem Types
5.1 Network Filesystem (`type:=nfs')
====================================
The "nfs" filesystem type provides access to Sun's NFS.
The following options must be specified:
`rhost'
the remote fileserver. This must be an entry in the hosts
database. IP addresses are not accepted. The default value is
taken from the local host name (`${host}') if no other value is
specified.
`rfs'
the remote filesystem. If no value is specified for this option,
an internal default of `${path}' is used.
NFS mounts require a two stage process. First, the "file handle" of
the remote file system must be obtained from the server. Then a mount
system call must be done on the local system. Amd keeps a cache of
file handles for remote file systems. The cache entries have a
lifetime of a few minutes.
If a required file handle is not in the cache, Amd sends a request
to the remote server to obtain it. Amd "does not" wait for a response;
it notes that one of the locations needs retrying, but continues with
any remaining locations. When the file handle becomes available, and
assuming none of the other locations was successfully mounted, Amd will
retry the mount. This mechanism allows several NFS filesystems to be
mounted in parallel. The first one which responds with a valid file
handle will be used.
An NFS entry might be:
jsp host!=charm;type:=nfs;rhost:=charm;rfs:=/home/charm;sublink:=jsp
The mount system call and any unmount attempts are always done in a
new task to avoid the possibilty of blocking Amd.
File: amdref.info, Node: Network Host Filesystem, Next: Network Filesystem Group, Prev: Network Filesystem, Up: Filesystem Types
5.2 Network Host Filesystem (`type:=host')
==========================================
The "host" filesystem allows access to the entire export tree of an NFS
server. The implementation is layered above the `nfs' implementation
so keep-alives work in the same way. The only option which needs to
specified is `rhost' which is the name of the fileserver to mount.
The `host' filesystem type works by querying the mount daemon on the
given fileserver to obtain its export list. Amd then obtains
filehandles for each of the exported filesystems. Any errors at this
stage cause that particular filesystem to be ignored. Finally each
filesystem is mounted. Again, errors are logged but ignored. One
common reason for mounts to fail is that the mount point does not exist.
Although Amd attempts to automatically create the mount point, it may
be on a remote filesystem to which Amd does not have write permission.
When an attempt to unmount a `host' filesystem mount fails, Amd
remounts any filesystems which had successfully been unmounted. To do
this Amd queries the mount daemon again and obtains a fresh copy of the
export list. Amd then tries to mount any exported filesystems which
are not currently mounted.
Sun's automounter provides a special `-hosts' map. To achieve the
same effect with Amd requires two steps. First a mount map must be
created as follows:
/defaults type:=host;fs:=${autodir}/${rhost}/root;rhost:=${key}
* opts:=rw,nosuid,grpid
and then start Amd with the following command
amd /n net.map
where `net.map' is the name of map described above. Note that the
value of `${fs}' is overridden in the map. This is done to avoid a
clash between the mount tree and any other filesystem already mounted
from the same fileserver.
If different mount options are needed for different hosts then
additional entries can be added to the map, for example
host2 opts:=ro,nosuid,soft
would soft mount `host2' read-only.
File: amdref.info, Node: Network Filesystem Group, Next: Unix Filesystem, Prev: Network Host Filesystem, Up: Filesystem Types
5.3 Network Filesystem Group (`type:=nfsx')
===========================================
The "nfsx" filesystem allows a group of filesystems to be mounted from
a single NFS server. The implementation is layered above the `nfs'
implementation so keep-alives work in the same way.
The options are the same as for the `nfs' filesystem with one
difference.
The following options must be specified:
`rhost'
the remote fileserver. This must be an entry in the hosts
database. IP addresses are not accepted. The default value is
taken from the local host name (`${host}') if no other value is
specified.
`rfs'
as a list of filesystems to mount. The list is in the form of a
comma separated strings.
For example:
pub type:=nfsx;rhost:=gould;\
rfs:=/public,/,graphics,usenet;fs:=${autodir}/${rhost}/root
The first string defines the root of the tree, and is applied as a
prefix to the remaining members of the list which define the individual
filesystems. The first string is _not_ used as a filesystem name. A
parallel operation is used to determine the local mount points to
ensure a consistent layout of a tree of mounts.
Here, the _three_ filesystems, `/public', `/public/graphics' and
`/public/usenet', would be mounted.
A local mount point, `${fs}', _must_ be specified. The default
local mount point will not work correctly in the general case. A
suggestion is to use `fs:=${autodir}/${rhost}/root'.
File: amdref.info, Node: Unix Filesystem, Next: Program Filesystem, Prev: Network Filesystem Group, Up: Filesystem Types
5.4 Unix Filesystem (`type:=ufs')
=================================
The "ufs" filesystem type provides access to the system's standard disk
filesystem--usually a derivative of the Berkeley Fast Filesystem.
The following option must be specified:
`dev'
the block special device to be mounted.
A UFS entry might be:
jsp host==charm;type:=ufs;dev:=/dev/xd0g;sublink:=jsp
File: amdref.info, Node: Program Filesystem, Next: Symbolic Link Filesystem, Prev: Unix Filesystem, Up: Filesystem Types
5.5 Program Filesystem (`type:=program')
========================================
The "program" filesystem type allows a program to be run whenever a
mount or unmount is required. This allows easy addition of support for
other filesystem types, such as MIT's Remote Virtual Disk (RVD) which
has a programmatic interface via the commands `rvdmount' and
`rvdunmount'.
The following options must be specified:
`mount'
the program which will perform the mount.
`unmount'
the program which will perform the unmount.
The exit code from these two programs is interpreted as a Unix error
code. As usual, exit code zero indicates success. To execute the
program Amd splits the string on whitespace to create an array of
substrings. Single quotes `'' can be used to quote whitespace if that
is required in an argument. There is no way to escape or change the
quote character.
To run the program `rvdmount' with a host name and filesystem as
arguments would be specified by `mount:="/etc/rvdmount rvdmount fserver
${path}"'.
The first element in the array is taken as the pathname of the
program to execute. The other members of the array form the argument
vector to be passed to the program, "including argument zero". This
means that the split string must have at least two elements. The
program is directly executed by Amd, not via a shell. This means that
scripts must begin with a `#!' interpreter specification.
If a filesystem type is to be heavily used, it may be worthwhile
adding a new filesystem type into Amd, but for most uses the program
filesystem should suffice.
When the program is run, standard input and standard error are
inherited from the current values used by Amd. Standard output is a
duplicate of standard error. The value specified with the "-l" command
line option has no effect on standard error.
File: amdref.info, Node: Symbolic Link Filesystem, Next: Symbolic Link Filesystem II, Prev: Program Filesystem, Up: Filesystem Types
5.6 Symbolic Link Filesystem (`type:=link')
===========================================
Each filesystem type creates a symbolic link to point from the volume
name to the physical mount point. The `link' filesystem does the same
without any other side effects. This allows any part of the machines
name space to be accessed via Amd.
One common use for the symlink filesystem is `/homes' which can be
made to contain an entry for each user which points to their
(auto-mounted) home directory. Although this may seem rather expensive,
it provides a great deal of administrative flexibility.
The following option must be defined:
`fs'
The value of FS option specifies the destination of the link, as
modified by the SUBLINK option. If SUBLINK is non-null, it is
appended to `${fs}'`/' and the resulting string is used as the
target.
The `link' filesystem can be though of as identical to the `ufs'
filesystem but without actually mounting anything.
An example entry might be:
jsp host==charm;type:=link;fs:=/home/charm;sublink:=jsp
which would return a symbolic link pointing to `/home/charm/jsp'.
File: amdref.info, Node: Automount Filesystem, Next: Direct Automount Filesystem, Prev: Symbolic Link Filesystem II, Up: Filesystem Types
5.8 Automount Filesystem (`type:=auto')
=======================================
The "auto" filesystem type creates a new automount point below an
existing automount point. Top-level automount points appear as system
mount points. An automount mount point can also appear as a
sub-directory of an existing automount point. This allows some
additional structure to be added, for example to mimic the mount tree of
another machine.
The following options may be specified:
`cache'
specifies whether the data in this mount-map should be cached.
The default value is `none', in which case no caching is done in
order to conserve memory. However, better performance and
reliability can be obtained by caching some or all of a mount-map.
If the cache option specifies `all', the entire map is enumerated
when the mount point is created.
If the cache option specifies `inc', caching is done incrementally
as and when data is required. Some map types do not support cache
mode `all', in which case `inc' is used whenever `all' is
requested.
Caching can be entirely disabled by using cache mode `none'.
If the cache option specifies `regexp' then the entire map will be
enumerated and each key will be treated as an egrep-style regular
expression. The order in which a cached map is searched does not
correspond to the ordering in the source map so the regular
expressions should be mutually exclusive to avoid confusion.
Each mount map type has a default cache type, usually `inc', which
can be selected by specifying `mapdefault'.
The cache mode for a mount map can only be selected on the command
line. Starting Amd with the command:
amd /homes hesiod.homes -cache:=inc
will cause `/homes' to be automounted using the "Hesiod" name
server with local incremental caching of all successfully resolved
names.
All cached data is forgotten whenever Amd receives a `SIGHUP'
signal and, if cache `all' mode was selected, the cache will be
reloaded. This can be used to inform Amd that a map has been
updated. In addition, whenever a cache lookup fails and Amd needs
to examine a map, the map's modify time is examined. If the cache
is out of date with respect to the map then it is flushed as if a
`SIGHUP' had been received.
An additional option (`sync') may be specified to force Amd to
check the map's modify time whenever a cached entry is being used.
For example, an incremental, synchronised cache would be created
by the following command:
amd /homes hesiod.homes -cache:=inc,sync
`fs'
specifies the name of the mount map to use for the new mount point.
Arguably this should have been specified with the `${rfs}' option
but we are now stuck with it due to historical accident.
`pref'
alters the name that is looked up in the mount map. If `${pref}',
the "prefix", is non-null then it is prepended to the name
requested by the kernel "before" the map is searched.
The server `dylan.doc.ic.ac.uk' has two user disks: `/dev/dsk/2s0'
and `/dev/dsk/5s0'. These are accessed as `/home/dylan/dk2' and
`/home/dylan/dk5' respectively. Since `/home' is already an automount
point, this naming is achieved with the following map entries:
dylan type:=auto;fs:=${map};pref:=${key}/
dylan/dk2 type:=ufs;dev:=/dev/dsk/2s0
dylan/dk5 type:=ufs;dev:=/dev/dsk/5s0
File: amdref.info, Node: Direct Automount Filesystem, Next: Union Filesystem, Prev: Automount Filesystem, Up: Filesystem Types
5.9 Direct Automount Filesystem (`type:=direct')
================================================
The "direct" filesystem is almost identical to the automount
filesystem. Instead of appearing to be a directory of mount points, it
appears as a symbolic link to a mounted filesystem. The mount is done
at the time the link is accessed. *Note Automount Filesystem::, for a
list of required options.
Direct automount points are created by specifying the `direct'
filesystem type on the command line:
amd ... /usr/man auto.direct -type:=direct
where `auto.direct' would contain an entry such as:
usr/man -type:=nfs;rfs:=/usr/man \
rhost:=man-server1 rhost:=man-server2
In this example, `man-server1' and `man-server2' are file servers
which export copies of the manual pages. Note that the key which is
looked up is the name of the automount point without the leading `/'.
File: amdref.info, Node: Union Filesystem, Next: Error Filesystem, Prev: Direct Automount Filesystem, Up: Filesystem Types
5.10 Union Filesystem (`type:=union')
=====================================
The "union" filesystem type allows the contents of several directories
to be merged and made visible in a single directory. This can be used
to overcome one of the major limitations of the Unix mount mechanism
which only allows complete directories to be mounted.
For example, supposing `/tmp' and `/var/tmp' were to be merged into
a new directory called `/mtmp', with files in `/var/tmp' taking
precedence. The following command could be used to achieve this effect:
amd ... /mtmp union:/tmp:/var/tmp -type:=union
Currently, the unioned directories must _not_ be automounted. That
would cause a deadlock. This seriously limits the current usefulness of
this filesystem type and the problem will be addressed in a future
release of Amd.
Files created in the union directory are actually created in the last
named directory. This is done by creating a wildcard entry which points
to the correct directory. The wildcard entry is visible if the union
directory is listed, so allowing you to see which directory has
priority.
The files visible in the union directory are computed at the time
Amd is started, and are not kept uptodate with respect to the
underlying directories. Similarly, if a link is removed, for example
with the `rm' command, it will be lost forever.
File: amdref.info, Node: Error Filesystem, Next: Top-level Filesystem, Prev: Union Filesystem, Up: Filesystem Types
5.11 Error Filesystem (`type:=error')
=====================================
The "error" filesystem type is used internally as a catch-all in the
case where none of the other filesystems was selected, or some other
error occurred. Lookups and mounts always fail with "No such file or
directory". All other operations trivially succeed.
The error filesystem is not directly accessible.
File: amdref.info, Node: Top-level Filesystem, Next: Root Filesystem, Prev: Error Filesystem, Up: Filesystem Types
5.12 Top-level Filesystem (`type:=toplvl')
==========================================
The "toplvl" filesystems is derived from the `auto' filesystem and is
used to mount the top-level automount nodes. Requests of this type are
automatically generated from the command line arguments and can also be
passed in by using the "-M" option of the "Amq" command.
File: amdref.info, Node: Root Filesystem, Next: Inheritance Filesystem, Prev: Top-level Filesystem, Up: Filesystem Types
5.13 Root Filesystem
====================
The "root" (`type:=root') filesystem type acts as an internal
placeholder onto which Amd can pin `toplvl' mounts. Only one node of
this type need ever exist and one is created automatically during
startup. The effect of creating a second root node is undefined.
File: amdref.info, Node: Inheritance Filesystem, Prev: Root Filesystem, Up: Filesystem Types
5.14 Inheritance Filesystem
===========================
The "inheritance" (`type:=inherit') filesystem is not directly
accessible. Instead, internal mount nodes of this type are
automatically generated when Amd is started with the "-r" option. At
this time the system mount table is scanned to locate any filesystems
which are already mounted. If any reference to these filesystems is
made through Amd then instead of attempting to mount it, Amd simulates
the mount and "inherits" the filesystem. This allows a new version of
Amd to be installed on a live system simply by killing the old daemon
with `SIGTERM' and starting the new one.
This filesystem type is not generally visible externally, but it is
possible that the output from `amq -m' may list `inherit' as the
filesystem type. This happens when an inherit operation cannot be
completed for some reason, usually because a fileserver is down.
File: amdref.info, Node: Run-time Administration, Next: Examples, Prev: Filesystem Types, Up: Top
6 Run-time Administration
*************************
* Menu:
* Starting Amd::
* Stopping Amd::
* Controlling Amd::
File: amdref.info, Node: Starting Amd, Next: Stopping Amd, Prev: Run-time Administration, Up: Run-time Administration
6.1 Starting Amd
================
Amd is best started from `/etc/rc.local':
if [ -f /etc/amd.start ]; then
sh /etc/amd.start; (echo -n ' amd') >/dev/console
fi
The shell script, `amd.start', contains:
#!/bin/sh -
PATH=/etc:/bin:/usr/bin:/usr/ucb:$PATH export PATH
#
# Either name of logfile or "syslog"
#
LOGFILE=syslog
#LOGFILE=/var/log/amd
#
# Figure out whether domain name is in host name
# If the hostname is just the machine name then
# pass in the name of the local domain so that the
# hostnames in the map are domain stripped correctly.
#
case `hostname` in
*.*) dmn= ;;
*) dmn='-d doc.ic.ac.uk'
esac
#
# Zap earlier log file
#
case "$LOGFILE" in
*/*)
mv "$LOGFILE" "$LOGFILE"-
> "$LOGFILE"
;;
syslog)
: nothing
;;
esac
cd /usr/sbin
#
# -r restart
# -d dmn local domain
# -w wait wait between unmount attempts
# -l log logfile or "syslog"
#
eval ./amd -r $dmn -w 240 -l "$LOGFILE" \
/homes amd.homes -cache:=inc \
/home amd.home -cache:=inc \
/vol amd.vol -cache:=inc \
/n amd.net -cache:=inc
If the list of automount points and maps is contained in a file or
NIS map it is easily incorporated onto the command line:
...
eval ./amd -r $dmn -w 240 -l "$LOGFILE" `ypcat -k auto.master`
File: amdref.info, Node: Stopping Amd, Next: Controlling Amd, Prev: Starting Amd, Up: Run-time Administration
6.2 Stopping Amd
================
Amd stops in response to two signals.
`SIGTERM'
causes the top-level automount points to be unmounted and then Amd
to exit. Any automounted filesystems are left mounted. They can
be recovered by restarting Amd with the "-r" command line option.
`SIGINT'
causes Amd to attempt to unmount any filesystems which it has
automounted, in addition to the actions of `SIGTERM'. This signal
is primarly used for debugging.
Actions taken for other signals are undefined.
File: amdref.info, Node: Controlling Amd, Prev: Stopping Amd, Up: Run-time Administration
6.3 Controlling Amd
===================
It is sometimes desirable or necessary to exercise external control
over some of Amd's internal state. To support this requirement, Amd
implements an RPC interface which is used by the "Amq" program. A
variety of information is available.
Amq generally applies an operation, specified by a single letter
option, to a list of mount points. The default operation is to obtain
statistics about each mount point. This is similar to the output shown
above but includes information about the number and type of accesses to
each mount point.
* Menu:
* Amq default:: Default command behaviour.
* Amq -f option:: Flushing the map cache.
* Amq -h option:: Controlling a non-local host.
* Amq -m option:: Obtaining mount statistics.
* Amq -M-option:: Mounting a volume.
* Amq -s option:: Obtaining global statistics.
* Amq -u option:: Forcing volumes to time out.
* Amq -v option:: Version information.
* Other Amq options:: Three other special options.
File: amdref.info, Node: Amq default, Next: Amq -f option, Prev: Controlling Amd, Up: Controlling Amd
6.3.1 Amq default information
-----------------------------
With no arguments, "Amq" obtains a brief list of all existing mounts
created by Amd. This is different from the list displayed by df(1)
since the latter only includes system mount points.
The output from this option includes the following information:
* the automount point,
* the filesystem type,
* the mount map or mount information,
* the internal, or system mount point.
For example:
/ root "root" sky:(pid75)
/homes toplvl /usr/local/etc/amd.homes /homes
/home toplvl /usr/local/etc/amd.home /home
/homes/jsp nfs charm:/home/charm /a/charm/home/charm/jsp
/homes/phjk nfs toytown:/home/toytown /a/toytown/home/toytown/ai/phjk
If an argument is given then statistics for that volume name will be
output. For example:
What Uid Getattr Lookup RdDir RdLnk Statfs Mounted@
/homes 0 1196 512 22 0 30 90/09/14 12:32:55
/homes/jsp 0 0 0 0 1180 0 90/10/13 12:56:58
`What'
the volume name.
`Uid'
ignored.
`Getattr'
the count of NFS "getattr" requests on this node. This should
only be non-zero for directory nodes.
`Lookup'
the count of NFS "lookup" requests on this node. This should only
be non-zero for directory nodes.
`RdDir'
the count of NFS "readdir" requests on this node. This should only
be non-zero for directory nodes.
`RdLnk'
the count of NFS "readlink" requests on this node. This should be
zero for directory nodes.
`Statfs'
the could of NFS "statfs" requests on this node. This should only
be non-zero for top-level automount points.
`Mounted@'
the date and time the volume name was first referenced.
File: amdref.info, Node: Amq -f option, Next: Amq -h option, Prev: Amq default, Up: Controlling Amd
6.3.2 Amq -f option
-------------------
The "-f" option causes Amd to flush the internal mount map cache. This
is useful for Hesiod maps since Amd will not automatically notice when
they have been updated. The map cache can also be synchronised with
the map source by using the `sync' option (*note Automount
Filesystem::).
File: amdref.info, Node: Amq -h option, Next: Amq -m option, Prev: Amq -f option, Up: Controlling Amd
6.3.3 Amq -h option
-------------------
By default the local host is used. In an HP-UX cluster the root server
is used since that is the only place in the cluster where Amd will be
running. To query Amd on another host the "-h" option should be used.
File: amdref.info, Node: Amq -m option, Next: Amq -M-option, Prev: Amq -h option, Up: Controlling Amd
6.3.4 Amq -m option
-------------------
The "-m" option displays similar information about mounted filesystems,
rather than automount points. The output includes the following
information:
* the mount information,
* the mount point,
* the filesystem type,
* the number of references to this filesystem,
* the server hostname,
* the state of the file server,
* any error which has occured.
For example:
"root" truth:(pid602) root 1 localhost is up
hesiod.home /home toplvl 1 localhost is up
hesiod.vol /vol toplvl 1 localhost is up
hesiod.homes /homes toplvl 1 localhost is up
amy:/home/amy /a/amy/home/amy nfs 5 amy is up
swan:/home/swan /a/swan/home/swan nfs 0 swan is up (Permission denied)
ex:/home/ex /a/ex/home/ex nfs 0 ex is down
When the reference count is zero the filesystem is not mounted but
the mount point and server information is still being maintained by Amd.
File: amdref.info, Node: Amq -M-option, Next: Amq -s option, Prev: Amq -m option, Up: Controlling Amd
6.3.5 Amq -M option
-------------------
The "-M" option passes a new map entry to Amd and waits for it to be
evaluated, possibly causing a mount. For example, the following
command would cause `/home/toytown' on host `toytown' to be mounted
locally on `/mnt/toytown'.
amq -M '/mnt/toytown type:=nfs;rfs:=/home/toytown;rhost:=toytown;fs:=${key}'
Amd applies some simple security checks before allowing this
operation. The check tests whether the incoming request is from a
privileged UDP port on the local machine. "Permission denied" is
returned if the check fails.
A future release of Amd will include code to allow the mount(8)
command to mount automount points:
mount -t amd /vol hesiod.vol
This will then allow Amd to be controlled from the standard system
filesystem mount list.
File: amdref.info, Node: Amq -s option, Next: Amq -u option, Prev: Amq -M-option, Up: Controlling Amd
6.3.6 Amq -s option
-------------------
The "-s" option displays global statistics. If any other options are
specified or any filesystems named then this option is ignored. For
example:
requests stale mount mount unmount
deferred fhandles ok failed failed
1054 1 487 290 7017
`Deferred requests'
are those for which an immediate reply could not be constructed.
For example, this would happen if a background mount was required.
`Stale filehandles'
counts the number of times the kernel passes a stale filehandle to
Amd. Large numbers indicate problems.
`Mount ok'
counts the number of automounts which were successful.
`Mount failed'
counts the number of automounts which failed.
`Unmount failed'
counts the number of times a filesystem could not be unmounted.
Very large numbers here indicate that the time between unmount
attempts should be increased.
File: amdref.info, Node: Amq -u option, Next: Amq -v option, Prev: Amq -s option, Up: Controlling Amd
6.3.7 Amq -u option
-------------------
The "-u" option causes the time-to-live interval of the named mount
points to be expired, thus causing an unmount attempt. This is the only
safe way to unmount an automounted filesystem. It is not possible to
unmount a filesystem which has been mounted with the `nounmount' flag.
File: amdref.info, Node: Amq -v option, Next: Other Amq options, Prev: Amq -u option, Up: Controlling Amd
6.3.8 Amq -v option
-------------------
The "-v" option displays the version of Amd in a similar way to Amd's
"-v" option.
File: amdref.info, Node: Other Amq options, Prev: Amq -v option, Up: Controlling Amd
6.3.9 Other Amq options
-----------------------
Three other operations are implemented. These modify the state of Amd
as a whole, rather than any particular filesystem. The "-l", "-x" and
"-D" options have exactly the same effect as Amd's corresponding
command line options. The "-l" option is rejected by Amd in the
current version for obvious security reasons. When Amd receives a
"-x"flag it limits the log options being modified to those which were
not enabled at startup. This prevents a user turning _off_ any logging
option which was specified at startup, though any which have been
turned off since then can still be turned off. The "-D" option has a
similar behaviour.
File: amdref.info, Node: Examples, Next: Internals, Prev: Run-time Administration, Up: Top
7 Examples
**********
* Menu:
* User Filesystems::
* Home Directories::
* Architecture Sharing::
* Wildcard Names::
* rwho servers::
* /vol::
File: amdref.info, Node: User Filesystems, Next: Home Directories, Prev: Examples, Up: Examples
7.1 User Filesystems
====================
With more than one fileserver, the directories most frequently
cross-mounted are those containing user home directories. A common
convention used at Imperial College is to mount the user disks under
/home/machine.
Typically, the `/etc/fstab' file contained a long list of entries
such as:
machine:/home/machine /home/machine nfs ...
for each fileserver on the network.
There are numerous problems with this system. The mount list can
become quite large and some of the machines may be down when a system is
booted. When a new fileserver is installed, `/etc/fstab' must be
updated on every machine, the mount directory created and the filesystem
mounted.
In many environments most people use the same few workstations, but
it is convenient to go to a colleague's machine and access your own
files. When a server goes down, it can cause a process on a client
machine to hang. By minimising the mounted filesystems to only include
those actively being used, there is less chance that a filesystem will
be mounted when a server goes down.
The following is a short extract from a map taken from a research
fileserver at Imperial College.
Note the entry for `localhost' which is used for users such as the
operator (`opr') who have a home directory on most machine as
`/home/localhost/opr'.
/defaults opts:=rw,intr,grpid,nosuid
charm host!=${key};type:=nfs;rhost:=${key};rfs:=/home/${key} \
host==${key};type:=ufs;dev:=/dev/xd0g
#
...
#
localhost type:=link;fs:=${host}
...
#
# dylan has two user disks so have a
# top directory in which to mount them.
#
dylan type:=auto;fs:=${map};pref:=${key}/
#
dylan/dk2 host!=dylan;type:=nfs;rhost:=dylan;rfs:=/home/${key} \
host==dylan;type:=ufs;dev:=/dev/dsk/2s0
#
dylan/dk5 host!=dylan;type:=nfs;rhost:=dylan;rfs:=/home/${key} \
host==dylan;type:=ufs;dev:=/dev/dsk/5s0
...
#
toytown host!=${key};type:=nfs;rhost:=${key};rfs:=/home/${key} \
host==${key};type:=ufs;dev:=/dev/xy1g
...
#
zebedee host!=${key};type:=nfs;rhost:=${key};rfs:=/home/${key} \
host==${key};type:=ufs;dev:=/dev/dsk/1s0
#
# Just for access...
#
gould type:=auto;fs:=${map};pref:=${key}/
gould/staff host!=gould;type:=nfs;rhost:=gould;rfs:=/home/${key}
#
gummo host!=${key};type:=nfs;rhost:=${key};rfs:=/home/${key}
...
This map is shared by most of the machines listed so on those
systems any of the user disks is accessible via a consistent name. Amd
is started with the following command
amd /home amd.home
Note that when mounting a remote filesystem, the "automounted" mount
point is referenced, so that the filesystem will be mounted if it is
not yet (at the time the remote `mountd' obtains the file handle).
File: amdref.info, Node: Home Directories, Next: Architecture Sharing, Prev: User Filesystems, Up: Examples
7.2 Home Directories
====================
One convention for home directories is to locate them in `/homes' so
user `jsp''s home directory is `/homes/jsp'. With more than a single
fileserver it is convenient to spread user files across several
machines. All that is required is a mount-map which converts login
names to an automounted directory.
Such a map might be started by the command:
amd /homes amd.homes
where the map `amd.homes' contained the entries:
/defaults type:=link # All the entries are of type:=link
jsp fs:=/home/charm/jsp
njw fs:=/home/dylan/dk5/njw
...
phjk fs:=/home/toytown/ai/phjk
sjv fs:=/home/ganymede/sjv
Whenever a login name is accessed in `/homes' a symbolic link
appears pointing to the real location of that user's home directory. In
this example, `/homes/jsp' would appear to be a symbolic link pointing
to `/home/charm/jsp'. Of course, `/home' would also be an automount
point.
This system causes an extra level of symbolic links to be used.
Although that turns out to be relatively inexpensive, an alternative is
to directly mount the required filesystems in the `/homes' map. The
required map is simple, but long, and its creation is best automated.
The entry for `jsp' could be:
jsp -sublink:=${key};rfs:=/home/charm \
host==charm;type:=ufs;dev:=/dev/xd0g \
host!=charm;type:=nfs;rhost:=charm
This map can become quite big if it contains a large number of
entries. By combining two other features of Amd it can be greatly
simplified.
First the UFS partitions should be mounted under the control of
`/etc/fstab', taking care that they are mounted in the same place that
Amd would have automounted them. In most cases this would be something
like `/a/"host"/home/"host"' and `/etc/fstab' on host `charm' would
have a line:
/dev/xy0g /a/charm/home/charm 4.2 rw,nosuid,grpid 1 5
The map can then be changed to:
/defaults type:=nfs;sublink:=${key};opts:=rw,intr,nosuid,grpid
jsp rhost:=charm;rfs:=/home/charm
njw rhost:=dylan;rfs:=/home/dylan/dk5
...
phjk rhost:=toytown;rfs:=/home/toytown;sublink:=ai/${key}
sjv rhost:=ganymede;rfs:=/home/ganymede
This map operates as usual on a remote machine (ie `${host}' not
equal to `${rhost}'). On the machine where the filesystem is stored
(ie `${host}' equal to `${rhost}'), Amd will construct a local
filesystem mount point which corresponds to the name of the locally
mounted UFS partition. If Amd is started with the "-r" option then
instead of attempting an NFS mount, Amd will simply inherit the UFS
mount (*note Inheritance Filesystem::). If "-r" is not used then a
loopback NFS mount will be made. This type of mount is known to cause
a deadlock on many systems.
File: amdref.info, Node: Architecture Sharing, Next: Wildcard Names, Prev: Home Directories, Up: Examples
7.3 Architecture Sharing
========================
Often a filesystem will be shared by machines of different
architectures. Separate trees can be maintained for the executable
images for each architecture, but it may be more convenient to have a
shared tree, with distinct subdirectories.
A shared tree might have the following structure on the fileserver
(called `fserver' in the example):
local/tex
local/tex/fonts
local/tex/lib
local/tex/bin
local/tex/bin/sun3
local/tex/bin/sun4
local/tex/bin/hp9000
...
In this example, the subdirectories of `local/tex/bin' should be
hidden when accessed via the automount point (conventionally `/vol').
A mount-map for `/vol' to achieve this would look like:
/defaults sublink:=${/key};rhost:=fserver;type:=link
tex type:=auto;fs:=${map};pref:=${key}/
tex/fonts host!=fserver;type:=nfs;rfs:=/vol/tex \
host==fserver;fs:=/usr/local/tex
tex/lib host!=fserver;type:=nfs;rfs:=/vol/tex \
host==fserver;fs:=/usr/local/tex
tex/bin -sublink:=${/key}/${arch} host!=fserver;type:=nfs;rfs:=/vol/tex \
host:=fserver;fs:=/usr/local/tex
When `/vol/tex/bin' is referenced, the current machine architecture
is automatically appended to the path by the `${sublink}' variable.
This means that users can have `/vol/tex/bin' in their `PATH' without
concern for architecture dependencies.
File: amdref.info, Node: Wildcard Names, Next: rwho servers, Prev: Architecture Sharing, Up: Examples
7.4 Wildcard names & Replicated Servers
=======================================
By using the wildcard facility, Amd can "overlay" an existing directory
with additional entries. The system files are usually mounted under
`/usr'. If instead Amd is mounted on `/usr', additional names can be
overlayed to augment or replace names in the "master" `/usr'. A map to
do this would have the form:
local type:=auto;fs:=local-map
share type:=auto;fs:=share-map
* -type:=nfs;rfs:=/export/exec/${arch};sublink:="${key}" \
rhost:=fserv1 rhost:=fserv2 rhost:=fserv3
Note that the assignment to `${sublink}' is surrounded by double
quotes to prevent the incoming key from causing the map to be
misinterpreted. This map has the effect of directing any access to
`/usr/local' or `/usr/share' to another automount point.
In this example, it is assumed that the `/usr' files are replicated
on three fileservers: `fserv1', `fserv2' and `fserv3'. For any
references other than to `local' and `share' one of the servers is used
and a symbolic link to ${autodir}/${rhost}/export/exec/${arch}/whatever
is returned once an appropriate filesystem has been mounted.
File: amdref.info, Node: rwho servers, Next: /vol, Prev: Wildcard Names, Up: Examples
7.5 `rwho' servers
==================
The `/usr/spool/rwho' directory is a good candidate for automounting.
For efficiency reasons it is best to capture the rwho data on a small
number of machines and then mount that information onto a large number
of clients. The data written into the rwho files is byte order
dependent so only servers with the correct byte ordering can be used by
a client:
/defaults type:=nfs
usr/spool/rwho -byte==little;rfs:=/usr/spool/rwho \
rhost:=vaxA rhost:=vaxB \
|| -rfs:=/usr/spool/rwho \
rhost:=sun4 rhost:=hp300
File: amdref.info, Node: /vol, Prev: rwho servers, Up: Examples
7.6 `/vol'
==========
`/vol' is used as a catch-all for volumes which do not have other
conventional names.
Below is part of the `/vol' map for the domain `doc.ic.ac.uk'. The
`r+d' tree is used for new or experimental software that needs to be
available everywhere without installing it on all the fileservers.
Users wishing to try out the new software then simply include
`/vol/r+d/{bin,ucb}' in their path.
The main tree resides on one host `gould.doc.ic.ac.uk', which has
different `bin', `etc', `lib' and `ucb' sub-directories for each
machine architecture. For example, `/vol/r+d/bin' for a Sun-4 would be
stored in the sub-directory `bin/sun4' of the filesystem `/usr/r+d'.
When it was accessed a symbolic link pointing to
`/a/gould/usr/r+d/bin/sun4' would be returned.
/defaults type:=nfs;opts:=rw,grpid,nosuid,intr,soft
wp -opts:=rw,grpid,nosuid;rhost:=charm \
host==charm;type:=link;fs:=/usr/local/wp \
host!=charm;type:=nfs;rfs:=/vol/wp
...
#
src -opts:=rw,grpid,nosuid;rhost:=charm \
host==charm;type:=link;fs:=/usr/src \
host!=charm;type:=nfs;rfs:=/vol/src
#
r+d type:=auto;fs:=${map};pref:=r+d/
# per architecture bin,etc,lib&ucb...
r+d/bin rhost:=gould.doc.ic.ac.uk;rfs:=/usr/r+d;sublink:=${/key}/${arch}
r+d/etc rhost:=gould.doc.ic.ac.uk;rfs:=/usr/r+d;sublink:=${/key}/${arch}
r+d/include rhost:=gould.doc.ic.ac.uk;rfs:=/usr/r+d;sublink:=${/key}
r+d/lib rhost:=gould.doc.ic.ac.uk;rfs:=/usr/r+d;sublink:=${/key}/${arch}
r+d/man rhost:=gould.doc.ic.ac.uk;rfs:=/usr/r+d;sublink:=${/key}
r+d/src rhost:=gould.doc.ic.ac.uk;rfs:=/usr/r+d;sublink:=${/key}
r+d/ucb rhost:=gould.doc.ic.ac.uk;rfs:=/usr/r+d;sublink:=${/key}/${arch}
# hades pictures
pictures -opts:=rw,grpid,nosuid;rhost:=thpfs \
host==thpfs;type:=link;fs:=/nbsd/pictures \
host!=thpfs;type:=nfs;rfs:=/nbsd;sublink:=pictures
# hades tools
hades -opts:=rw,grpid,nosuid;rhost:=thpfs \
host==thpfs;type:=link;fs:=/nbsd/hades \
host!=thpfs;type:=nfs;rfs:=/nbsd;sublink:=hades
# bsd tools for hp.
bsd -opts:=rw,grpid,nosuid;arch==hp9000;rhost:=thpfs \
host==thpfs;type:=link;fs:=/nbsd/bsd \
host!=thpfs;type:=nfs;rfs:=/nbsd;sublink:=bsd
File: amdref.info, Node: Internals, Next: Acknowledgements & Trademarks, Prev: Examples, Up: Top
8 Internals
***********
* Menu:
* Log Messages::
File: amdref.info, Node: Log Messages, Prev: Internals, Up: Internals
8.1 Log Messages
================
In the following sections a brief explanation is given of some of the
log messages made by Amd. Where the message is in `typewriter' font,
it corresponds exactly to the message produced by Amd. Words in
"italic" are replaced by an appropriate string. Variables, `${var}',
indicate that the value of the appropriate variable is output.
Log messages are either sent direct to a file, or logged via the
syslog(3) mechanism. Messages are logged with facility `LOG_DAEMON'
when using syslog(3). In either case, entries in the file are of the
form:
date-string hostname amd[pid] message
* Menu:
* Fatal errors::
* Info messages::
File: amdref.info, Node: Fatal errors, Next: Info messages, Prev: Log Messages, Up: Log Messages
8.1.1 Fatal errors
------------------
Amd attempts to deal with unusual events. Whenever it is not possible
to deal with such an error, Amd will log an appropriate message and, if
it cannot possibly continue, will either exit or abort. These messages
are selected by `-x fatal' on the command line. When syslog(3) is
being used, they are logged with level `LOG_FATAL'. Even if Amd
continues to operate it is likely to remain in a precarious state and
should be restarted at the earliest opportunity.
Attempting to inherit not-a-filesystem
The prototype mount point created during a filesystem restart did
not contain a reference to the restarted filesystem. This erorr
"should never happen".
Can't bind to domain "NIS-domain"
A specific NIS domain was requested on the command line, but no
server for that domain is available on the local net.
Can't determine IP address of this host (hostname)
When Amd starts it determines its own IP address. If this lookup
fails then Amd cannot continue. The hostname it looks up is that
obtained returned by gethostname(2) system call.
Can't find root file handle for automount point
Amd creates its own file handles for the automount points. When it
mounts itself as a server, it must pass these file handles to the
local kernel. If the filehandle is not obtainable the mount point
is ignored. This error "should never happen".
Must be root to mount filesystems (euid = euid)
To prevent embarrassment, Amd makes sure it has appropriate system
privileges. This amounts to having an euid of 0. The check is
made after argument processing complete to give non-root users a
chance to access the "-v" option.
No work to do - quitting
No automount points were given on the command line and so there is
no work to do.
Out of memory in realloc
While attempting to realloc some memory, the memory space
available to Amd was exhausted. This is an unrecoverable error.
Out of memory
While attempting to malloc some memory, the memory space available
to Amd was exhausted. This is an unrecoverable error.
cannot create rpc/udp service
Either the NFS or AMQ endpoint could not be created.
gethostname: description
The gethostname(2) system call failed during startup.
host name is not set
The gethostname(2) system call returned a zero length host name.
This can happen if Amd is started in single user mode just after
booting the system.
ifs_match called!
An internal error occurred while restarting a pre-mounted
filesystem. This error "should never happen".
mount_afs: description
An error occured while Amd was mounting itself.
run_rpc failed
Somehow the main NFS server loop failed. This error "should never
happen".
unable to free rpc arguments in amqprog_1
The incoming arguments to the AMQ server could not be free'ed.
unable to free rpc arguments in nfs_program_1
The incoming arguments to the NFS server could not be free'ed.
unable to register (AMQ_PROGRAM, AMQ_VERSION, udp)
The AMQ server could not be registered with the local portmapper
or the internal RPC dispatcher.
unable to register (NFS_PROGRAM, NFS_VERSION, 0)
The NFS server could not be registered with the internal RPC
dispatcher.
File: amdref.info, Node: Info messages, Prev: Fatal errors, Up: Log Messages
8.1.2 Info messages
-------------------
Amd generates information messages to record state changes. These
messages are selected by `-x info' on the command line. When syslog(3)
is being used, they are logged with level `LOG_INFO'.
The messages listed below can be generated and are in a format
suitable for simple statistical analysis. "mount-info" is the string
that is displayed by "Amq" in its mount information column and placed
in the system mount table.
mount of "${path}" on ${fs} timed out
Attempts to mount a filesystem for the given automount point have
failed to complete within 30 seconds.
"${path}" forcibly timed out
An automount point has been timed out by the Amq command.
restarting mount-info on ${fs}
A pre-mounted file system has been noted.
"${path}" has timed out
No access to the automount point has been made within the timeout
period.
file server ${rhost} is down - timeout of "${path}" ignored
An automount point has timed out, but the corresponding file
server is known to be down. This message is only produced once
for each mount point for which the server is down.
Re-synchronizing cache for map ${map}
The named map has been modified and the internal cache is being
re-synchronized.
Filehandle denied for "${rhost}:${rfs}"
The mount daemon refused to return a file handle for the requested
filesystem.
Filehandle error for "${rhost}:${rfs}": description
The mount daemon gave some other error for the requested
filesystem.
file server ${rhost} type nfs starts up
A new NFS file server has been referenced and is known to be up.
file server ${rhost} type nfs starts down
A new NFS file server has been referenced and is known to be down.
file server ${rhost} type nfs is up
An NFS file server that was previously down is now up.
file server ${rhost} type nfs is down
An NFS file server that was previously up is now down.
Finishing with status exit-status
Amd is about to exit with the given exit status.
mount-info mounted fstype ${type} on ${fs}
A new file system has been mounted.
mount-info restarted fstype ${type} on ${fs}
Amd is using a pre-mounted filesystem to satisfy a mount request.
mount-info unmounted fstype ${type} from ${fs}
A file system has been unmounted.
mount-info unmounted fstype ${type} from ${fs} link ${fs}/${sublink}
A file system of which only a sub-directory was in use has been
unmounted.
File: amdref.info, Node: Acknowledgements & Trademarks, Next: Index, Prev: Internals, Up: Top
Acknowledgements & Trademarks
*****************************
Thanks to the Formal Methods Group at Imperial College for suffering
patiently while Amd was being developed on their machines.
Thanks to the many people who have helped with the development of
Amd, especially Piete Brooks at the Cambridge University Computing Lab
for many hours of testing, experimentation and discussion.
* DEC, VAX and Ultrix are registered trademarks of Digital Equipment
Corporation.
* AIX and IBM are registered trademarks of International Business
Machines Corporation.
* Sun, NFS and SunOS are registered trademarks of Sun Microsystems,
Inc.
* Unix is a registered trademark of AT&T Unix Systems Laboratories
in the USA and other countries.
File: amdref.info, Node: Index, Next: Intro, Prev: Acknowledgements & Trademarks, Up: Top
Index
*****
[index]
* Menu:
* /etc/amd.start: Starting Amd. (line 6)
* /etc/passwd maps: Password maps. (line 6)
* /etc/rc.local additions: Starting Amd. (line 6)
* /vol: /vol. (line 6)
* Additions to /etc/rc.local: Starting Amd. (line 6)
* Aliased hostnames: -n Option. (line 6)
* Alternate locations: Mounting a Volume. (line 6)
* Amd command line options: Amd Command Line Options.
(line 6)
* Amq command: Run-time Administration.
(line 6)
* arch, mount selector: Selectors. (line 21)
* Architecture dependent volumes: Architecture Sharing. (line 6)
* Architecture sharing: Architecture Sharing. (line 6)
* Architecture specific mounts: rwho servers. (line 6)
* Atomic NFS mounts: Network Filesystem Group.
(line 6)
* auto, filesystem type: Automount Filesystem. (line 6)
* autodir, mount selector: Selectors. (line 27)
* Automatic generation of user maps: Password maps. (line 6)
* Automount directory: -a Option. (line 6)
* Automount filesystem: Automount Filesystem. (line 6)
* Automounter configuration maps: Mount Maps. (line 6)
* Automounter fundamentals: Fundamentals. (line 6)
* Background mounts: Mounting a Volume. (line 6)
* Binding names to filesystems: Volume Binding. (line 6)
* Bug reports: Distrib. (line 26)
* byte, mount selector: Selectors. (line 31)
* Cache interval: -c Option. (line 6)
* cache, mount option: Automount Filesystem. (line 15)
* Catch-all mount point: /vol. (line 6)
* Changing the interval before a filesystem times out: -c Option.
(line 6)
* Cluster names: -C-Option. (line 6)
* cluster, mount selector: Selectors. (line 36)
* Command line options, Amd: Amd Command Line Options.
(line 6)
* Configuration map types: Map Types. (line 6)
* Controlling Amd: Controlling Amd. (line 6)
* Creating a pid file: -p Option. (line 6)
* Debug options: -D-Option. (line 6)
* delay, mount option: delay Option. (line 6)
* Delaying mounts from specific locations: delay Option. (line 6)
* Determining the map type: Map Types. (line 6)
* dev, mount option: Unix Filesystem. (line 11)
* Direct automount filesystem: Direct Automount Filesystem.
(line 6)
* direct, filesystem type: Direct Automount Filesystem.
(line 6)
* Discovering version information: -v Option. (line 6)
* Discovering what is going on at run-time: Controlling Amd. (line 6)
* Disk filesystems: Unix Filesystem. (line 6)
* Displaying the process id: -p Option. (line 6)
* Domain name: -d Option. (line 6)
* Domain stripping: Variable Expansion. (line 6)
* domain, mount selector: Selectors. (line 42)
* Domainname operators: Variable Expansion. (line 6)
* Duplicated volumes: Volume Naming. (line 6)
* Environment variables: Variable Expansion. (line 6)
* Error filesystem: Error Filesystem. (line 6)
* error, filesystem type: Error Filesystem. (line 6)
* Example of architecture specific mounts: rwho servers. (line 6)
* Example of mounting home directories: Home Directories. (line 6)
* File map syntactic conventions: File maps. (line 6)
* File maps: File maps. (line 6)
* Fileserver: Filesystems and Volumes.
(line 6)
* Filesystem: Filesystems and Volumes.
(line 6)
* Filesystem type; auto: Automount Filesystem. (line 6)
* Filesystem type; direct: Direct Automount Filesystem.
(line 6)
* Filesystem type; error: Error Filesystem. (line 6)
* Filesystem type; host: Network Host Filesystem.
(line 6)
* Filesystem type; inherit: Inheritance Filesystem.
(line 6)
* Filesystem type; link: Symbolic Link Filesystem.
(line 6)
* Filesystem type; linkx: Symbolic Link Filesystem II.
(line 6)
* Filesystem type; nfs: Network Filesystem. (line 6)
* Filesystem type; nfsx: Network Filesystem Group.
(line 6)
* Filesystem type; program: Program Filesystem. (line 6)
* Filesystem type; root: Root Filesystem. (line 6)
* Filesystem type; toplvl: Top-level Filesystem. (line 6)
* Filesystem type; ufs: Unix Filesystem. (line 6)
* Filesystem type; union: Union Filesystem. (line 6)
* Filesystem types: Filesystem Types. (line 6)
* Flat file maps: File maps. (line 6)
* Flushing the map cache: Amq -f option. (line 6)
* Forcing filesystem to time out: Amq -u option. (line 6)
* fs, mount option: fs Option. (line 6)
* Generic volume name: /vol. (line 6)
* Global statistics: Amq -s option. (line 6)
* Hesiod maps: Hesiod maps. (line 6)
* Home directories: Home Directories. (line 6)
* host, filesystem type: Network Host Filesystem.
(line 6)
* host, mount selector: Selectors. (line 46)
* hostd, mount selector: Selectors. (line 55)
* Hostname normalisation: -n Option. (line 6)
* How keys are looked up: Key Lookup. (line 6)
* How locations are parsed: Location Format. (line 6)
* How to access environment variables in maps: Variable Expansion.
(line 6)
* How to discover your version of Amd: -v Option. (line 6)
* How to mount a local disk: Unix Filesystem. (line 6)
* How to mount a UFS filesystems: Unix Filesystem. (line 6)
* How to mount all NFS exported filesystems: Network Host Filesystem.
(line 6)
* How to mount an atomic group of NFS filesystems: Network Filesystem Group.
(line 6)
* How to mount and NFS filesystem: Network Filesystem. (line 6)
* How to reference an existing part of the local name space: Symbolic Link Filesystem II.
(line 6)
* How to reference part of the local name space: Symbolic Link Filesystem.
(line 6)
* How to select log messages: -x Option. (line 6)
* How to set default map parameters: Map Defaults. (line 6)
* How to set map cache parameters: Automount Filesystem. (line 6)
* How to start a direct automount point: Direct Automount Filesystem.
(line 6)
* How to start an indirect automount point: Automount Filesystem.
(line 6)
* How variables are expanded: Variable Expansion. (line 6)
* inherit, filesystem type: Inheritance Filesystem.
(line 6)
* Inheritance filesystem: Inheritance Filesystem.
(line 6)
* Interval before a filesystem times out: -c Option. (line 6)
* Introduction: Intro. (line 6)
* karch, mount selector: Selectors. (line 60)
* Keep-alives: Keep-alives. (line 6)
* Key lookup: Key Lookup. (line 6)
* key, mount selector: Selectors. (line 78)
* License Information: License. (line 6)
* link, filesystem type: Symbolic Link Filesystem.
(line 6)
* linkx, filesystem type: Symbolic Link Filesystem II.
(line 6)
* Listing currently mounted filesystems: Controlling Amd. (line 6)
* Location format: Location Format. (line 6)
* Location lists: Mounting a Volume. (line 6)
* Log filename: -l Option. (line 6)
* Log message selection: -x Option. (line 6)
* Looking up keys: Key Lookup. (line 6)
* Machine architecture names: Supported Machine Architectures.
(line 6)
* Machine architectures supported by Amd: Supported Machine Architectures.
(line 6)
* Mailing list: Distrib. (line 33)
* Map cache options: Automount Filesystem. (line 6)
* Map cache synchronising: Automount Filesystem. (line 6)
* Map cache types: Automount Filesystem. (line 6)
* Map cache, flushing: Amq -f option. (line 6)
* Map defaults: Map Defaults. (line 6)
* Map entry format: Location Format. (line 6)
* Map lookup: Key Lookup. (line 6)
* Map options: Map Options. (line 6)
* Map types: Map Types. (line 6)
* map, mount selector: Selectors. (line 85)
* Mount a filesystem under program control: Program Filesystem.
(line 6)
* Mount home directories: Home Directories. (line 6)
* Mount information: Mount Maps. (line 6)
* Mount map types: Map Types. (line 6)
* Mount maps: Mount Maps. (line 6)
* Mount option; cache: Automount Filesystem. (line 15)
* Mount option; delay: delay Option. (line 6)
* Mount option; dev: Unix Filesystem. (line 11)
* Mount option; fs: fs Option. (line 6)
* Mount option; mount: Program Filesystem. (line 14)
* Mount option; opts: opts Option. (line 6)
* Mount option; remopts: remopts Option. (line 6)
* Mount option; rfs: Network Filesystem. (line 16)
* Mount option; rhost: Network Filesystem. (line 10)
* Mount option; sublink: sublink Option. (line 6)
* Mount option; type: type Option. (line 6)
* Mount option; unmount: Program Filesystem. (line 17)
* Mount retries: Mounting a Volume. (line 6)
* Mount selector; arch: Selectors. (line 21)
* Mount selector; autodir: Selectors. (line 27)
* Mount selector; byte: Selectors. (line 31)
* Mount selector; cluster: Selectors. (line 36)
* Mount selector; domain: Selectors. (line 42)
* Mount selector; host: Selectors. (line 46)
* Mount selector; hostd: Selectors. (line 55)
* Mount selector; karch: Selectors. (line 60)
* Mount selector; key: Selectors. (line 78)
* Mount selector; map: Selectors. (line 85)
* Mount selector; os: Selectors. (line 66)
* Mount selector; path: Selectors. (line 88)
* Mount selector; wire: Selectors. (line 92)
* mount system call: opts Option. (line 6)
* mount system call flags: opts Option. (line 6)
* Mount types: Filesystem Types. (line 6)
* mount, mount option: Program Filesystem. (line 14)
* Mounting a local disk: Unix Filesystem. (line 6)
* Mounting a UFS filesystem: Unix Filesystem. (line 6)
* Mounting a volume: Mounting a Volume. (line 6)
* Mounting an atomic group of NFS filesystems: Network Filesystem Group.
(line 6)
* Mounting an existing part of the local name space: Symbolic Link Filesystem II.
(line 6)
* Mounting an NFS filesystem: Network Filesystem. (line 6)
* Mounting entire export trees: Network Host Filesystem.
(line 6)
* Mounting part of the local name space: Symbolic Link Filesystem.
(line 6)
* Mounting user filesystems: User Filesystems. (line 6)
* Multiple-threaded server: Non-blocking Operation.
(line 6)
* Namespace: Volume Binding. (line 6)
* Network filesystem group: Network Filesystem Group.
(line 6)
* Network host filesystem: Network Host Filesystem.
(line 6)
* Network-wide naming |
