/* $NetBSD: ops_nfs.c,v 1.1.1.3 2015/01/17 16:34:15 christos Exp $ */
/*
* Copyright (c) 1997-2014 Erez Zadok
* Copyright (c) 1990 Jan-Simon Pendry
* Copyright (c) 1990 Imperial College of Science, Technology & Medicine
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Jan-Simon Pendry at Imperial College, London.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. 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 BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*
* File: am-utils/amd/ops_nfs.c
*
*/
/*
* Network file system
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif /* HAVE_CONFIG_H */
#include <am_defs.h>
#include <amd.h>
/*
* Convert from nfsstat to UN*X error code
*/
#define unx_error(e) ((int)(e))
/*
* FH_TTL is the time a file handle will remain in the cache since
* last being used. If the file handle becomes invalid, then it
* will be flushed anyway.
*/
#define FH_TTL (5 * 60) /* five minutes */
#define FH_TTL_ERROR (30) /* 30 seconds */
#define FHID_ALLOC() (++fh_id)
/*
* The NFS layer maintains a cache of file handles.
* This is *fundamental* to the implementation and
* also allows quick remounting when a filesystem
* is accessed soon after timing out.
*
* The NFS server layer knows to flush this cache
* when a server goes down so avoiding stale handles.
*
* Each cache entry keeps a hard reference to
* the corresponding server. This ensures that
* the server keepalive information is maintained.
*
* The copy of the sockaddr_in here is taken so
* that the port can be twiddled to talk to mountd
* instead of portmap or the NFS server as used
* elsewhere.
* The port# is flushed if a server goes down.
* The IP address is never flushed - we assume
* that the address of a mounted machine never
* changes. If it does, then you have other
* problems...
*/
typedef struct fh_cache fh_cache;
struct fh_cache {
qelem fh_q; /* List header */
wchan_t fh_wchan; /* Wait channel */
int fh_error; /* Valid data? */
int fh_id; /* Unique id */
int fh_cid; /* Callout id */
u_long fh_nfs_version; /* highest NFS version on host */
am_nfs_handle_t fh_nfs_handle; /* Handle on filesystem */
int fh_status; /* Status of last rpc */
struct sockaddr_in fh_sin; /* Address of mountd */
fserver *fh_fs; /* Server holding filesystem */
char *fh_path; /* Filesystem on host */
};
/* forward definitions */
static int nfs_init(mntfs *mf);
static char *nfs_match(am_opts *fo);
static int nfs_mount(am_node *am, mntfs *mf);
static int nfs_umount(am_node *am, mntfs *mf);
static void nfs_umounted(mntfs *mf);
static int call_mountd(fh_cache *fp, u_long proc, fwd_fun f, wchan_t wchan);
static int webnfs_lookup(fh_cache *fp, fwd_fun f, wchan_t wchan);
static int fh_id = 0;
/*
* clamp the filehandle version to 3, so that we can fail back to nfsv3
* since nfsv4 does not have file handles
*/
#define SET_FH_VERSION(fs) \
(fs)->fs_version > NFS_VERSION3 ? NFS_VERSION3 : (fs)->fs_version;
/* globals */
AUTH *nfs_auth;
qelem fh_head = {&fh_head, &fh_head};
/*
* Network file system operations
*/
am_ops nfs_ops =
{
"nfs",
nfs_match,
nfs_init,
nfs_mount,
nfs_umount,
amfs_error_lookup_child,
amfs_error_mount_child,
amfs_error_readdir,
0, /* nfs_readlink */
0, /* nfs_mounted */
nfs_umounted,
find_nfs_srvr,
0, /* nfs_get_wchan */
FS_MKMNT | FS_BACKGROUND | FS_AMQINFO, /* nfs_fs_flags */
#ifdef HAVE_FS_AUTOFS
AUTOFS_NFS_FS_FLAGS,
#endif /* HAVE_FS_AUTOFS */
};
static fh_cache *
find_nfs_fhandle_cache(opaque_t arg, int done)
{
fh_cache *fp, *fp2 = NULL;
int id = (long) arg; /* for 64-bit archs */
ITER(fp, fh_cache, &fh_head) {
if (fp->fh_id == id) {
fp2 = fp;
break;
}
}
if (fp2) {
dlog("fh cache gives fp %#lx, fs %s", (unsigned long) fp2, fp2->fh_path);
} else {
dlog("fh cache search failed");
}
if (fp2 && !done) {
fp2->fh_error = ETIMEDOUT;
return 0;
}
return fp2;
}
/*
* Called when a filehandle appears via the mount protocol
*/
static void
got_nfs_fh_mount(voidp pkt, int len, struct sockaddr_in *sa, struct sockaddr_in *ia, opaque_t arg, int done)
{
fh_cache *fp;
struct fhstatus res;
#ifdef HAVE_FS_NFS3
struct am_mountres3 res3;
#endif /* HAVE_FS_NFS3 */
fp = find_nfs_fhandle_cache(arg, done);
if (!fp)
return;
/*
* retrieve the correct RPC reply for the file handle, based on the
* NFS protocol version.
*/
#ifdef HAVE_FS_NFS3
if (fp->fh_nfs_version == NFS_VERSION3) {
memset(&res3, 0, sizeof(res3));
fp->fh_error = pickup_rpc_reply(pkt, len, (voidp) &res3,
(XDRPROC_T_TYPE) xdr_am_mountres3);
fp->fh_status = unx_error(res3.fhs_status);
memset(&fp->fh_nfs_handle.v3, 0, sizeof(am_nfs_fh3));
fp->fh_nfs_handle.v3.am_fh3_length = res3.mountres3_u.mountinfo.fhandle.fhandle3_len;
memmove(fp->fh_nfs_handle.v3.am_fh3_data,
res3.mountres3_u.mountinfo.fhandle.fhandle3_val,
fp->fh_nfs_handle.v3.am_fh3_length);
XFREE(res3.mountres3_u.mountinfo.fhandle.fhandle3_val);
if (res3.mountres3_u.mountinfo.auth_flavors.auth_flavors_val)
XFREE(res3.mountres3_u.mountinfo.auth_flavors.auth_flavors_val);
} else {
#endif /* HAVE_FS_NFS3 */
memset(&res, 0, sizeof(res));
fp->fh_error = pickup_rpc_reply(pkt, len, (voidp) &res,
(XDRPROC_T_TYPE) xdr_fhstatus);
fp->fh_status = unx_error(res.fhs_status);
memmove(&fp->fh_nfs_handle.v2, &res.fhs_fh, NFS_FHSIZE);
#ifdef HAVE_FS_NFS3
}
#endif /* HAVE_FS_NFS3 */
if (!fp->fh_error) {
dlog("got filehandle for %s:%s", fp->fh_fs->fs_host, fp->fh_path);
} else {
plog(XLOG_USER, "filehandle denied for %s:%s", fp->fh_fs->fs_host, fp->fh_path);
/*
* Force the error to be EACCES. It's debatable whether it should be
* ENOENT instead, but the server really doesn't give us any clues, and
* EACCES is more in line with the "filehandle denied" message.
*/
fp->fh_error = EACCES;
}
/*
* Wakeup anything sleeping on this filehandle
*/
if (fp->fh_wchan) {
dlog("Calling wakeup on %#lx", (unsigned long) fp->fh_wchan);
wakeup(fp->fh_wchan);
}
}
/*
* Called when a filehandle appears via WebNFS
*/
static void
got_nfs_fh_webnfs(voidp pkt, int len, struct sockaddr_in *sa, struct sockaddr_in *ia, opaque_t arg, int done)
{
fh_cache *fp;
nfsdiropres res;
#ifdef HAVE_FS_NFS3
am_LOOKUP3res res3;
#endif /* HAVE_FS_NFS3 */
fp = find_nfs_fhandle_cache(arg, done);
if (!fp)
return;
/*
* retrieve the correct RPC reply for the file handle, based on the
* NFS protocol version.
*/
#ifdef HAVE_FS_NFS3
if (fp->fh_nfs_version == NFS_VERSION3) {
memset(&res3, 0, sizeof(res3));
fp->fh_error = pickup_rpc_reply(pkt, len, (voidp) &res3,
(XDRPROC_T_TYPE) xdr_am_LOOKUP3res);
fp->fh_status = unx_error(res3.status);
memset(&fp->fh_nfs_handle.v3, 0, sizeof(am_nfs_fh3));
fp->fh_nfs_handle.v3.am_fh3_length = res3.res_u.ok.object.am_fh3_length;
memmove(fp->fh_nfs_handle.v3.am_fh3_data,
res3.res_u.ok.object.am_fh3_data,
fp->fh_nfs_handle.v3.am_fh3_length);
} else {
#endif /* HAVE_FS_NFS3 */
memset(&res, 0, sizeof(res));
fp->fh_error = pickup_rpc_reply(pkt, len, (voidp) &res,
(XDRPROC_T_TYPE) xdr_diropres);
fp->fh_status = unx_error(res.dr_status);
memmove(&fp->fh_nfs_handle.v2, &res.dr_u.dr_drok_u.drok_fhandle, NFS_FHSIZE);
#ifdef HAVE_FS_NFS3
}
#endif /* HAVE_FS_NFS3 */
if (!fp->fh_error) {
dlog("got filehandle for %s:%s", fp->fh_fs->fs_host, fp->fh_path);
} else {
plog(XLOG_USER, "filehandle denied for %s:%s", fp->fh_fs->fs_host, fp->fh_path);
/*
* Force the error to be EACCES. It's debatable whether it should be
* ENOENT instead, but the server really doesn't give us any clues, and
* EACCES is more in line with the "filehandle denied" message.
*/
fp->fh_error = EACCES;
}
/*
* Wakeup anything sleeping on this filehandle
*/
if (fp->fh_wchan) {
dlog("Calling wakeup on %#lx", (unsigned long) fp->fh_wchan);
wakeup(fp->fh_wchan);
}
}
void
flush_nfs_fhandle_cache(fserver *fs)
{
fh_cache *fp;
ITER(fp, fh_cache, &fh_head) {
if (fp->fh_fs == fs || fs == NULL) {
/*
* Only invalidate port info for non-WebNFS servers
*/
if (!(fp->fh_fs->fs_flags & FSF_WEBNFS))
fp->fh_sin.sin_port = (u_short) 0;
fp->fh_error = -1;
}
}
}
static void
discard_fh(opaque_t arg)
{
fh_cache *fp = (fh_cache *) arg;
rem_que(&fp->fh_q);
if (fp->fh_fs) {
dlog("Discarding filehandle for %s:%s", fp->fh_fs->fs_host, fp->fh_path);
free_srvr(fp->fh_fs);
}
XFREE(fp->fh_path);
XFREE(fp);
}
/*
* Determine the file handle for a node
*/
static int
prime_nfs_fhandle_cache(char *path, fserver *fs, am_nfs_handle_t *fhbuf, mntfs *mf)
{
fh_cache *fp, *fp_save = NULL;
int error;
int reuse_id = FALSE;
dlog("Searching cache for %s:%s", fs->fs_host, path);
/*
* First search the cache
*/
ITER(fp, fh_cache, &fh_head) {
if (fs != fp->fh_fs || !STREQ(path, fp->fh_path))
continue; /* skip to next ITER item */
/* else we got a match */
switch (fp->fh_error) {
case 0:
plog(XLOG_INFO, "prime_nfs_fhandle_cache: NFS version %d", (int) fp->fh_nfs_version);
error = fp->fh_error = fp->fh_status;
if (error == 0) {
if (mf->mf_flags & MFF_NFS_SCALEDOWN) {
fp_save = fp;
/* XXX: why reuse the ID? */
reuse_id = TRUE;
break;
}
if (fhbuf) {
#ifdef HAVE_FS_NFS3
if (fp->fh_nfs_version == NFS_VERSION3) {
memmove((voidp) &(fhbuf->v3), (voidp) &(fp->fh_nfs_handle.v3),
sizeof(fp->fh_nfs_handle.v3));
} else
#endif /* HAVE_FS_NFS3 */
{
memmove((voidp) &(fhbuf->v2), (voidp) &(fp->fh_nfs_handle.v2),
sizeof(fp->fh_nfs_handle.v2));
}
}
if (fp->fh_cid)
untimeout(fp->fh_cid);
fp->fh_cid = timeout(FH_TTL, discard_fh, (opaque_t) fp);
} else if (error == EACCES) {
/*
* Now decode the file handle return code.
*/
plog(XLOG_INFO, "Filehandle denied for \"%s:%s\"",
fs->fs_host, path);
} else {
errno = error; /* XXX */
plog(XLOG_INFO, "Filehandle error for \"%s:%s\": %m",
fs->fs_host, path);
}
/*
* The error was returned from the remote mount daemon.
* Policy: this error will be cached for now...
*/
return error;
case -1:
/*
* Still thinking about it, but we can re-use.
*/
fp_save = fp;
reuse_id = TRUE;
break;
default:
/*
* Return the error.
* Policy: make sure we recompute if required again
* in case this was caused by a network failure.
* This can thrash mountd's though... If you find
* your mountd going slowly then:
* 1. Add a fork() loop to main.
* 2. Remove the call to innetgr() and don't use
* netgroups, especially if you don't use YP.
*/
error = fp->fh_error;
fp->fh_error = -1;
return error;
} /* end of switch statement */
} /* end of ITER loop */
/*
* Not in cache
*/
if (fp_save) {
fp = fp_save;
/*
* Re-use existing slot
*/
untimeout(fp->fh_cid);
free_srvr(fp->fh_fs);
XFREE(fp->fh_path);
} else {
fp = ALLOC(struct fh_cache);
memset((voidp) fp, 0, sizeof(struct fh_cache));
ins_que(&fp->fh_q, &fh_head);
}
if (!reuse_id)
fp->fh_id = FHID_ALLOC();
fp->fh_wchan = get_mntfs_wchan(mf);
fp->fh_error = -1;
fp->fh_cid = timeout(FH_TTL, discard_fh, (opaque_t) fp);
/*
* If fs->fs_ip is null, remote server is probably down.
*/
if (!fs->fs_ip) {
/* Mark the fileserver down and invalid again */
fs->fs_flags &= ~FSF_VALID;
fs->fs_flags |= FSF_DOWN;
error = AM_ERRNO_HOST_DOWN;
return error;
}
/*
* Either fp has been freshly allocated or the address has changed.
* Initialize address and nfs version. Don't try to re-use the port
* information unless using WebNFS where the port is fixed either by
* the spec or the "port" mount option.
*/
if (fp->fh_sin.sin_addr.s_addr != fs->fs_ip->sin_addr.s_addr) {
fp->fh_sin = *fs->fs_ip;
if (!(mf->mf_flags & MFF_WEBNFS))
fp->fh_sin.sin_port = 0;
fp->fh_nfs_version = SET_FH_VERSION(fs);
}
fp->fh_fs = dup_srvr(fs);
fp->fh_path = xstrdup(path);
if (mf->mf_flags & MFF_WEBNFS)
error = webnfs_lookup(fp, got_nfs_fh_webnfs, get_mntfs_wchan(mf));
else
error = call_mountd(fp, MOUNTPROC_MNT, got_nfs_fh_mount, get_mntfs_wchan(mf));
if (error) {
/*
* Local error - cache for a short period
* just to prevent thrashing.
*/
untimeout(fp->fh_cid);
fp->fh_cid = timeout(error < 0 ? 2 * ALLOWED_MOUNT_TIME : FH_TTL_ERROR,
discard_fh, (opaque_t) fp);
fp->fh_error = error;
} else {
error = fp->fh_error;
}
return error;
}
int
make_nfs_auth(void)
{
AUTH_CREATE_GIDLIST_TYPE group_wheel = 0;
/* Some NFS mounts (particularly cross-domain) require FQDNs to succeed */
#ifdef HAVE_TRANSPORT_TYPE_TLI
if (gopt.flags & CFM_FULLY_QUALIFIED_HOSTS) {
plog(XLOG_INFO, "Using NFS auth for FQHN \"%s\"", hostd);
nfs_auth = authsys_create(hostd, 0, 0, 1, &group_wheel);
} else {
nfs_auth = authsys_create_default();
}
#else /* not HAVE_TRANSPORT_TYPE_TLI */
if (gopt.flags & CFM_FULLY_QUALIFIED_HOSTS) {
plog(XLOG_INFO, "Using NFS auth for FQHN \"%s\"", hostd);
nfs_auth = authunix_create(hostd, 0, 0, 1, &group_wheel);
} else {
nfs_auth = authunix_create_default();
}
#endif /* not HAVE_TRANSPORT_TYPE_TLI */
if (!nfs_auth)
return ENOBUFS;
return 0;
}
static int
call_mountd(fh_cache *fp, u_long proc, fwd_fun fun, wchan_t wchan)
{
struct rpc_msg mnt_msg;
int len;
char iobuf[UDPMSGSIZE];
int error;
u_long mnt_version;
if (!nfs_auth) {
error = make_nfs_auth();
if (error)
return error;
}
if (fp->fh_sin.sin_port == 0) {
u_short mountd_port;
error = get_mountd_port(fp->fh_fs, &mountd_port, wchan);
if (error)
return error;
fp->fh_sin.sin_port = mountd_port;
dlog("%s: New %d mountd port", __func__, fp->fh_sin.sin_port);
} else
dlog("%s: Already had %d mountd port", __func__, fp->fh_sin.sin_port);
/* find the right version of the mount protocol */
#ifdef HAVE_FS_NFS3
if (fp->fh_nfs_version == NFS_VERSION3)
mnt_version = AM_MOUNTVERS3;
else
#endif /* HAVE_FS_NFS3 */
mnt_version = MOUNTVERS;
plog(XLOG_INFO, "call_mountd: NFS version %d, mount version %d",
(int) fp->fh_nfs_version, (int) mnt_version);
rpc_msg_init(&mnt_msg, MOUNTPROG, mnt_version, MOUNTPROC_NULL);
len = make_rpc_packet(iobuf,
sizeof(iobuf),
proc,
&mnt_msg,
(voidp) &fp->fh_path,
(XDRPROC_T_TYPE) xdr_nfspath,
nfs_auth);
if (len > 0) {
error = fwd_packet(MK_RPC_XID(RPC_XID_MOUNTD, fp->fh_id),
iobuf,
len,
&fp->fh_sin,
&fp->fh_sin,
(opaque_t) ((long) fp->fh_id), /* cast to long needed for 64-bit archs */
fun);
} else {
error = -len;
}
/*
* It may be the case that we're sending to the wrong MOUNTD port. This
* occurs if mountd is restarted on the server after the port has been
* looked up and stored in the filehandle cache somewhere. The correct
* solution, if we're going to cache port numbers is to catch the ICMP
* port unreachable reply from the server and cause the portmap request
* to be redone. The quick solution here is to invalidate the MOUNTD
* port.
*/
fp->fh_sin.sin_port = 0;
return error;
}
static int
webnfs_lookup(fh_cache *fp, fwd_fun fun, wchan_t wchan)
{
struct rpc_msg wnfs_msg;
int len;
char iobuf[UDPMSGSIZE];
int error;
u_long proc;
XDRPROC_T_TYPE xdr_fn;
voidp argp;
nfsdiropargs args;
#ifdef HAVE_FS_NFS3
am_LOOKUP3args args3;
#endif /* HAVE_FS_NFS3 */
char *wnfs_path;
size_t l;
if (!nfs_auth) {
error = make_nfs_auth();
if (error)
return error;
}
if (fp->fh_sin.sin_port == 0) {
/* FIXME: wrong, don't discard sin_port in the first place for WebNFS. */
plog(XLOG_WARNING, "webnfs_lookup: port == 0 for nfs on %s, fixed",
fp->fh_fs->fs_host);
fp->fh_sin.sin_port = htons(NFS_PORT);
}
/*
* Use native path like the rest of amd (cf. RFC 2054, 6.1).
*/
l = strlen(fp->fh_path) + 2;
wnfs_path = (char *) xmalloc(l);
wnfs_path[0] = 0x80;
xstrlcpy(wnfs_path + 1, fp->fh_path, l - 1);
/* find the right program and lookup procedure */
#ifdef HAVE_FS_NFS3
if (fp->fh_nfs_version == NFS_VERSION3) {
proc = AM_NFSPROC3_LOOKUP;
xdr_fn = (XDRPROC_T_TYPE) xdr_am_LOOKUP3args;
argp = &args3;
/* WebNFS public file handle */
args3.what.dir.am_fh3_length = 0;
args3.what.name = wnfs_path;
} else {
#endif /* HAVE_FS_NFS3 */
proc = NFSPROC_LOOKUP;
xdr_fn = (XDRPROC_T_TYPE) xdr_diropargs;
argp = &args;
/* WebNFS public file handle */
memset(&args.da_fhandle, 0, NFS_FHSIZE);
args.da_name = wnfs_path;
#ifdef HAVE_FS_NFS3
}
#endif /* HAVE_FS_NFS3 */
plog(XLOG_INFO, "webnfs_lookup: NFS version %d", (int) fp->fh_nfs_version);
rpc_msg_init(&wnfs_msg, NFS_PROGRAM, fp->fh_nfs_version, proc);
len = make_rpc_packet(iobuf,
sizeof(iobuf),
proc,
&wnfs_msg,
argp,
(XDRPROC_T_TYPE) xdr_fn,
nfs_auth);
if (len > 0) {
error = fwd_packet(MK_RPC_XID(RPC_XID_WEBNFS, fp->fh_id),
iobuf,
len,
&fp->fh_sin,
&fp->fh_sin,
(opaque_t) ((long) fp->fh_id), /* cast to long needed for 64-bit archs */
fun);
} else {
error = -len;
}
XFREE(wnfs_path);
return error;
}
/*
* NFS needs the local filesystem, remote filesystem
* remote hostname.
* Local filesystem defaults to remote and vice-versa.
*/
static char *
nfs_match(am_opts *fo)
{
char *xmtab;
size_t l;
if (fo->opt_fs && !fo->opt_rfs)
fo->opt_rfs = fo->opt_fs;
if (!fo->opt_rfs) {
plog(XLOG_USER, "nfs: no remote filesystem specified");
return NULL;
}
if (!fo->opt_rhost) {
plog(XLOG_USER, "nfs: no remote host specified");
return NULL;
}
/*
* Determine magic cookie to put in mtab
*/
l = strlen(fo->opt_rhost) + strlen(fo->opt_rfs) + 2;
xmtab = (char *) xmalloc(l);
xsnprintf(xmtab, l, "%s:%s", fo->opt_rhost, fo->opt_rfs);
dlog("NFS: mounting remote server \"%s\", remote fs \"%s\" on \"%s\"",
fo->opt_rhost, fo->opt_rfs, fo->opt_fs);
return xmtab;
}
/*
* Initialize am structure for nfs
*/
static int
nfs_init(mntfs *mf)
{
int error;
am_nfs_handle_t fhs;
char *colon;
#ifdef NO_FALLBACK
/*
* We don't need file handles for NFS version 4, but we can fall back to
* version 3, so we allocate anyway
*/
#ifdef HAVE_FS_NFS4
if (mf->mf_server->fs_version == NFS_VERSION4)
return 0;
#endif /* HAVE_FS_NFS4 */
#endif /* NO_FALLBACK */
if (mf->mf_private) {
if (mf->mf_flags & MFF_NFS_SCALEDOWN) {
fserver *fs;
/* tell remote mountd that we're done with this filehandle */
mf->mf_ops->umounted(mf);
mf->mf_prfree(mf->mf_private);
mf->mf_private = NULL;
mf->mf_prfree = NULL;
fs = mf->mf_ops->ffserver(mf);
free_srvr(mf->mf_server);
mf->mf_server = fs;
} else
return 0;
}
colon = strchr(mf->mf_info, ':');
if (colon == 0)
return ENOENT;
error = prime_nfs_fhandle_cache(colon + 1, mf->mf_server, &fhs, mf);
if (!error) {
mf->mf_private = (opaque_t) ALLOC(am_nfs_handle_t);
mf->mf_prfree = (void (*)(opaque_t)) free;
memmove(mf->mf_private, (voidp) &fhs, sizeof(fhs));
}
return error;
}
int
mount_nfs_fh(am_nfs_handle_t *fhp, char *mntdir, char *fs_name, mntfs *mf)
{
MTYPE_TYPE type;
char *colon;
char *xopts=NULL, transp_timeo_opts[40], transp_retrans_opts[40];
char host[MAXHOSTNAMELEN + MAXPATHLEN + 2];
fserver *fs = mf->mf_server;
u_long nfs_version = fs->fs_version;
char *nfs_proto = fs->fs_proto; /* "tcp" or "udp" */
int on_autofs = mf->mf_flags & MFF_ON_AUTOFS;
int error;
int genflags;
int retry;
int proto = AMU_TYPE_NONE;
mntent_t mnt;
void *argsp;
nfs_args_t nfs_args;
#ifdef HAVE_FS_NFS4
nfs4_args_t nfs4_args;
#endif /* HAVE_FS_NFS4 */
/*
* Extract HOST name to give to kernel.
* Some systems like osf1/aix3/bsd44 variants may need old code
* for NFS_ARGS_NEEDS_PATH.
*/
if (!(colon = strchr(fs_name, ':')))
return ENOENT;
#ifdef MOUNT_TABLE_ON_FILE
*colon = '\0';
#endif /* MOUNT_TABLE_ON_FILE */
xstrlcpy(host, fs_name, sizeof(host));
#ifdef MOUNT_TABLE_ON_FILE
*colon = ':';
#endif /* MOUNT_TABLE_ON_FILE */
#ifdef MAXHOSTNAMELEN
/* most kernels have a name length restriction */
if (strlen(host) >= MAXHOSTNAMELEN)
xstrlcpy(host + MAXHOSTNAMELEN - 3, "..",
sizeof(host) - MAXHOSTNAMELEN + 3);
#endif /* MAXHOSTNAMELEN */
/*
* Create option=VAL for udp/tcp specific timeouts and retrans values, but
* only if these options were specified.
*/
transp_timeo_opts[0] = transp_retrans_opts[0] = '\0'; /* initialize */
if (STREQ(nfs_proto, "udp"))
proto = AMU_TYPE_UDP;
else if (STREQ(nfs_proto, "tcp"))
proto = AMU_TYPE_TCP;
if (proto != AMU_TYPE_NONE) {
if (gopt.amfs_auto_timeo[proto] > 0)
xsnprintf(transp_timeo_opts, sizeof(transp_timeo_opts), "%s=%d,",
MNTTAB_OPT_TIMEO, gopt.amfs_auto_timeo[proto]);
if (gopt.amfs_auto_retrans[proto] > 0)
xsnprintf(transp_retrans_opts, sizeof(transp_retrans_opts), "%s=%d,",
MNTTAB_OPT_RETRANS, gopt.amfs_auto_retrans[proto]);
}
if (mf->mf_remopts && *mf->mf_remopts &&
!islocalnet(fs->fs_ip->sin_addr.s_addr)) {
plog(XLOG_INFO, "Using remopts=\"%s\"", mf->mf_remopts);
/* use transp_opts first, so map-specific opts will override */
xopts = str3cat(xopts, transp_timeo_opts, transp_retrans_opts, mf->mf_remopts);
} else {
/* use transp_opts first, so map-specific opts will override */
xopts = str3cat(xopts, transp_timeo_opts, transp_retrans_opts, mf->mf_mopts);
}
memset((voidp) &mnt, 0, sizeof(mnt));
mnt.mnt_dir = mntdir;
mnt.mnt_fsname = fs_name;
mnt.mnt_opts = xopts;
/*
* Set mount types accordingly
*/
#ifdef HAVE_FS_NFS3
if (nfs_version == NFS_VERSION3) {
type = MOUNT_TYPE_NFS3;
/*
* Systems that include the mount table "vers" option generally do not
* set the mnttab entry to "nfs3", but to "nfs" and then they set
* "vers=3". Setting it to "nfs3" works, but it may break some things
* like "df -t nfs" and the "quota" program (esp. on Solaris and Irix).
* So on those systems, set it to "nfs".
* Note: MNTTAB_OPT_VERS is always set for NFS3 (see am_compat.h).
*/
argsp = &nfs_args;
# if defined(MNTTAB_OPT_VERS) && defined(MOUNT_TABLE_ON_FILE)
mnt.mnt_type = MNTTAB_TYPE_NFS;
# else /* defined(MNTTAB_OPT_VERS) && defined(MOUNT_TABLE_ON_FILE) */
mnt.mnt_type = MNTTAB_TYPE_NFS3;
# endif /* defined(MNTTAB_OPT_VERS) && defined(MOUNT_TABLE_ON_FILE) */
# ifdef HAVE_FS_NFS4
} else if (nfs_version == NFS_VERSION4) {
argsp = &nfs4_args;
type = MOUNT_TYPE_NFS4;
mnt.mnt_type = MNTTAB_TYPE_NFS4;
# endif /* HAVE_FS_NFS4 */
} else
#endif /* HAVE_FS_NFS3 */
{
argsp = &nfs_args;
type = MOUNT_TYPE_NFS;
mnt.mnt_type = MNTTAB_TYPE_NFS;
}
plog(XLOG_INFO, "mount_nfs_fh: NFS version %d", (int) nfs_version);
plog(XLOG_INFO, "mount_nfs_fh: using NFS transport %s", nfs_proto);
retry = hasmntval(&mnt, MNTTAB_OPT_RETRY);
if (retry <= 0)
retry = 1; /* XXX */
genflags = compute_mount_flags(&mnt);
#ifdef HAVE_FS_AUTOFS
if (on_autofs)
genflags |= autofs_compute_mount_flags(&mnt);
#endif /* HAVE_FS_AUTOFS */
/* setup the many fields and flags within nfs_args */
compute_nfs_args(argsp,
&mnt,
genflags,
NULL, /* struct netconfig *nfsncp */
fs->fs_ip,
nfs_version,
nfs_proto,
fhp,
host,
fs_name);
/* finally call the mounting function */
if (amuDebug(D_TRACE)) {
print_nfs_args(argsp, nfs_version);
plog(XLOG_DEBUG, "Generic mount flags 0x%x used for NFS mount", genflags);
}
error = mount_fs(&mnt, genflags, argsp, retry, type,
nfs_version, nfs_proto, mnttab_file_name, on_autofs);
XFREE(mnt.mnt_opts);
discard_nfs_args(argsp, nfs_version);
#ifdef HAVE_FS_NFS4
# ifndef NO_FALLBACK
/*
* If we are using a v4 file handle, we try a v3 if we get back:
* ENOENT: NFS v4 has a different export list than v3
* EPERM: Kernels <= 2.6.18 return that, instead of ENOENT
*/
if ((error == ENOENT || error == EPERM) && nfs_version == NFS_VERSION4) {
plog(XLOG_DEBUG, "Could not find NFS 4 mount, trying again with NFS 3");
fs->fs_version = NFS_VERSION3;
error = mount_nfs_fh(fhp, mntdir, fs_name, mf);
if (error)
fs->fs_version = NFS_VERSION4;
}
# endif /* NO_FALLBACK */
#endif /* HAVE_FS_NFS4 */
return error;
}
static int
nfs_mount(am_node *am, mntfs *mf)
{
int error = 0;
mntent_t mnt;
if (!mf->mf_private && mf->mf_server->fs_version != 4) {
plog(XLOG_ERROR, "Missing filehandle for %s", mf->mf_info);
return EINVAL;
}
if (mf->mf_mopts == NULL) {
plog(XLOG_ERROR, "Missing mount options for %s", mf->mf_info);
return EINVAL;
}
mnt.mnt_opts = mf->mf_mopts;
if (amu_hasmntopt(&mnt, "softlookup") ||
(amu_hasmntopt(&mnt, "soft") && !amu_hasmntopt(&mnt, "nosoftlookup")))
am->am_flags |= AMF_SOFTLOOKUP;
error = mount_nfs_fh((am_nfs_handle_t *) mf->mf_private,
mf->mf_mount,
mf->mf_info,
mf);
if (error) {
errno = error;
dlog("mount_nfs: %m");
}
return error;
}
static int
nfs_umount(am_node *am, mntfs *mf)
{
int unmount_flags, new_unmount_flags, error;
dlog("attempting nfs umount");
unmount_flags = (mf->mf_flags & MFF_ON_AUTOFS) ? AMU_UMOUNT_AUTOFS : 0;
error = UMOUNT_FS(mf->mf_mount, mnttab_file_name, unmount_flags);
#if defined(HAVE_UMOUNT2) && (defined(MNT2_GEN_OPT_FORCE) || defined(MNT2_GEN_OPT_DETACH))
/*
* If the attempt to unmount failed with EBUSY, and this fserver was
* marked for forced unmounts, then use forced/lazy unmounts.
*/
if (error == EBUSY &&
gopt.flags & CFM_FORCED_UNMOUNTS &&
mf->mf_server->fs_flags & FSF_FORCE_UNMOUNT) {
plog(XLOG_INFO, "EZK: nfs_umount: trying forced/lazy unmounts");
/*
* XXX: turning off the FSF_FORCE_UNMOUNT may not be perfectly
* incorrect. Multiple nodes may need to be timed out and restarted for
* a single hung fserver.
*/
mf->mf_server->fs_flags &= ~FSF_FORCE_UNMOUNT;
new_unmount_flags = unmount_flags | AMU_UMOUNT_FORCE | AMU_UMOUNT_DETACH;
error = UMOUNT_FS(mf->mf_mount, mnttab_file_name, new_unmount_flags);
}
#endif /* HAVE_UMOUNT2 && (MNT2_GEN_OPT_FORCE || MNT2_GEN_OPT_DETACH) */
/*
* Here is some code to unmount 'restarted' file systems.
* The restarted file systems are marked as 'nfs', not
* 'host', so we only have the map information for the
* the top-level mount. The unmount will fail (EBUSY)
* if there are anything else from the NFS server mounted
* below the mount-point. This code checks to see if there
* is anything mounted with the same prefix as the
* file system to be unmounted ("/a/b/c" when unmounting "/a/b").
* If there is, and it is a 'restarted' file system, we unmount
* it.
* Added by Mike Mitchell,
[email protected], 09/08/93
*/
if (error == EBUSY) {
mntfs *new_mf;
int len = strlen(mf->mf_mount);
int didsome = 0;
ITER(new_mf, mntfs, &mfhead) {
if (new_mf->mf_ops != mf->mf_ops ||
new_mf->mf_refc > 1 ||
mf == new_mf ||
((new_mf->mf_flags & (MFF_MOUNTED | MFF_UNMOUNTING | MFF_RESTART)) == (MFF_MOUNTED | MFF_RESTART)))
continue;
if (NSTREQ(mf->mf_mount, new_mf->mf_mount, len) &&
new_mf->mf_mount[len] == '/') {
new_unmount_flags =
(new_mf->mf_flags & MFF_ON_AUTOFS) ? AMU_UMOUNT_AUTOFS : 0;
UMOUNT_FS(new_mf->mf_mount, mnttab_file_name, new_unmount_flags);
didsome = 1;
}
}
if (didsome)
error = UMOUNT_FS(mf->mf_mount, mnttab_file_name, unmount_flags);
}
if (error)
return error;
return 0;
}
static void
nfs_umounted(mntfs *mf)
{
fserver *fs;
char *colon, *path;
if (mf->mf_error || mf->mf_refc > 1)
return;
/*
* No need to inform mountd when WebNFS is in use.
*/
if (mf->mf_flags & MFF_WEBNFS)
return;
/*
* Call the mount daemon on the server to announce that we are not using
* the fs any more.
*
* XXX: This is *wrong*. The mountd should be called when the fhandle is
* flushed from the cache, and a reference held to the cached entry while
* the fs is mounted...
*/
fs = mf->mf_server;
colon = path = strchr(mf->mf_info, ':');
if (fs && colon) {
fh_cache f;
dlog("calling mountd for %s", mf->mf_info);
*path++ = '\0';
f.fh_path = path;
f.fh_sin = *fs->fs_ip;
f.fh_sin.sin_port = (u_short) 0;
f.fh_nfs_version = SET_FH_VERSION(fs);
f.fh_fs = fs;
f.fh_id = 0;
f.fh_error = 0;
prime_nfs_fhandle_cache(colon + 1, mf->mf_server, (am_nfs_handle_t *) NULL, mf);
call_mountd(&f, MOUNTPROC_UMNT, (fwd_fun *) NULL, (wchan_t) NULL);
*colon = ':';
}
}
