fs/nfs/nfs_common.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
 * Copyright 2013 Joyent, Inc. All rights reserved.
 */

/*
 *  Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T
 *      All rights reserved.
 */

#include <sys/errno.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/user.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/utsname.h>
#include <sys/vfs.h>
#include <sys/vfs_opreg.h>
#include <sys/vnode.h>
#include <sys/pathname.h>
#include <sys/bootconf.h>
#include <fs/fs_subr.h>
#include <rpc/types.h>
#include <nfs/nfs.h>
#include <nfs/nfs4.h>
#include <nfs/nfs_clnt.h>
#include <nfs/rnode.h>
#include <nfs/mount.h>
#include <nfs/nfssys.h>
#include <sys/debug.h>
#include <sys/cmn_err.h>
#include <sys/file.h>
#include <sys/fcntl.h>
#include <sys/zone.h>

/*
 * This is the loadable module wrapper.
 */
#include <sys/systm.h>
#include <sys/modctl.h>
#include <sys/syscall.h>
#include <sys/ddi.h>

#include <rpc/types.h>
#include <rpc/auth.h>
#include <rpc/clnt.h>
#include <rpc/svc.h>

/*
 * The pseudo NFS filesystem to allow diskless booting to dynamically
 * mount either a NFS V2, NFS V3, or NFS V4 filesystem.  This only implements
 * the VFS_MOUNTROOT op and is only intended to be used by the
 * diskless booting code until the real root filesystem is mounted.
 * Nothing else should ever call this!
 *
 * The strategy is that if the initial rootfs type is set to "nfsdyn"
 * by loadrootmodules() this filesystem is called to mount the
 * root filesystem.  It first attempts to mount a V4 filesystem, and if that
 * fails due to an RPC version mismatch it tries V3 and finally V2.
 * Once the real mount succeeds the vfsops and rootfs name are changed
 * to reflect the real filesystem type.
 */
static int nfsdyninit(int, char *);
static int nfsdyn_mountroot(vfs_t *, whymountroot_t);

vfsops_t *nfsdyn_vfsops;

/*
 * The following data structures are used to configure the NFS
 * system call, the NFS Version 2 client VFS, and the NFS Version
 * 3 client VFS into the system.  The NFS Version 4 structures are defined in
 * nfs4_common.c
 */

/*
 * The NFS system call.
 */
static struct sysent nfssysent = {
    2,
    SE_32RVAL1 | SE_ARGC | SE_NOUNLOAD,
    nfssys
};

static struct modlsys modlsys = {
    &mod_syscallops,
    "NFS syscall, client, and common",
    &nfssysent
};

#ifdef _SYSCALL32_IMPL
static struct modlsys modlsys32 = {
    &mod_syscallops32,
    "NFS syscall, client, and common (32-bit)",
    &nfssysent
};
#endif /* _SYSCALL32_IMPL */

/*
 * The NFS Dynamic client VFS.
 */
static vfsdef_t vfw = {
    VFSDEF_VERSION,
    "nfsdyn",
    nfsdyninit,
    0,
    NULL
};

static struct modlfs modlfs = {
    &mod_fsops,
    "network filesystem",
    &vfw
};

/*
 * The NFS Version 2 client VFS.
 */
static vfsdef_t vfw2 = {
    VFSDEF_VERSION,
    "nfs",
    nfsinit,
    VSW_CANREMOUNT|VSW_NOTZONESAFE|VSW_STATS,
    NULL
};

static struct modlfs modlfs2 = {
    &mod_fsops,
    "network filesystem version 2",
    &vfw2
};

/*
 * The NFS Version 3 client VFS.
 */
static vfsdef_t vfw3 = {
    VFSDEF_VERSION,
    "nfs3",
    nfs3init,
    VSW_CANREMOUNT|VSW_NOTZONESAFE|VSW_STATS,
    NULL
};

static struct modlfs modlfs3 = {
    &mod_fsops,
    "network filesystem version 3",
    &vfw3
};

extern struct modlfs modlfs4;

/*
 * We have too many linkage structures so we define our own XXX
 */
struct modlinkage_big {
    int     ml_rev;     /* rev of loadable modules system */
    void        *ml_linkage[7]; /* NULL terminated list of */
                    /* linkage structures */
};

/*
 * All of the module configuration linkages required to configure
 * the system call and client VFS's into the system.
 */
static struct modlinkage_big modlinkage = {
    MODREV_1,
    &modlsys,
#ifdef _SYSCALL32_IMPL
    &modlsys32,
#endif
    &modlfs,
    &modlfs2,
    &modlfs3,
    &modlfs4,
    NULL
};

/*
 * This routine is invoked automatically when the kernel module
 * containing this routine is loaded.  This allows module specific
 * initialization to be done when the module is loaded.
 */
int
_init(void)
{
    int status;

    if ((status = nfs_clntinit()) != 0) {
        cmn_err(CE_WARN, "_init: nfs_clntinit failed");
        return (status);
    }

    /*
     * Create the version specific kstats.
     *
     * PSARC 2001/697 Contract Private Interface
     * All nfs kstats are under SunMC contract
     * Please refer to the PSARC listed above and contact
     * SunMC before making any changes!
     *
     * Changes must be reviewed by Solaris File Sharing
     * Changes must be communicated to contract-2001-697@sun.com
     *
     */

    zone_key_create(&nfsstat_zone_key, nfsstat_zone_init, NULL,
        nfsstat_zone_fini);
    status = mod_install((struct modlinkage *)&modlinkage);

    if (status)  {
        (void) zone_key_delete(nfsstat_zone_key);

        /*
         * Failed to install module, cleanup previous
         * initialization work.
         */
        nfs_clntfini();

        /*
         * Clean up work performed indirectly by mod_installfs()
         * as a result of our call to mod_install().
         */
        nfs4fini();
        nfs3fini();
        nfsfini();
    }
    return (status);
}

int
_fini(void)
{
    /* Don't allow module to be unloaded */
    return (EBUSY);
}

int
_info(struct modinfo *modinfop)
{
    return (mod_info((struct modlinkage *)&modlinkage, modinfop));
}

/*
 * General utilities
 */

/*
 * Returns the preferred transfer size in bytes based on
 * what network interfaces are available.
 */
int
nfstsize(void)
{
    /*
     * For the moment, just return NFS_MAXDATA until we can query the
     * appropriate transport.
     */
    return (NFS_MAXDATA);
}

/*
 * Returns the preferred transfer size in bytes based on
 * what network interfaces are available.
 */

/* this should reflect the largest transfer size possible */
static int nfs3_max_transfer_size = 1024 * 1024;

int
nfs3tsize(void)
{
    /*
     * For the moment, just return nfs3_max_transfer_size until we
     * can query the appropriate transport.
     */
    return (nfs3_max_transfer_size);
}

static uint_t nfs3_max_transfer_size_clts = 32 * 1024;
static uint_t nfs3_max_transfer_size_cots = 1024 * 1024;
static uint_t nfs3_max_transfer_size_rdma = 1024 * 1024;

uint_t
nfs3_tsize(struct knetconfig *knp)
{

    if (knp->knc_semantics == NC_TPI_COTS_ORD ||
        knp->knc_semantics == NC_TPI_COTS)
        return (nfs3_max_transfer_size_cots);
    if (knp->knc_semantics == NC_TPI_RDMA)
        return (nfs3_max_transfer_size_rdma);
    return (nfs3_max_transfer_size_clts);
}

uint_t
rfs3_tsize(struct svc_req *req)
{

    if (req->rq_xprt->xp_type == T_COTS_ORD ||
        req->rq_xprt->xp_type == T_COTS)
        return (nfs3_max_transfer_size_cots);
    if (req->rq_xprt->xp_type == T_RDMA)
        return (nfs3_max_transfer_size_rdma);
    return (nfs3_max_transfer_size_clts);
}

/* ARGSUSED */
static int
nfsdyninit(int fstyp, char *name)
{
    static const fs_operation_def_t nfsdyn_vfsops_template[] = {
        VFSNAME_MOUNTROOT, { .vfs_mountroot = nfsdyn_mountroot },
        NULL, NULL
    };
    int error;

    error = vfs_setfsops(fstyp, nfsdyn_vfsops_template, &nfsdyn_vfsops);
    if (error != 0)
        return (error);

    return (0);
}

/* ARGSUSED */
static int
nfsdyn_mountroot(vfs_t *vfsp, whymountroot_t why)
{
    char root_hostname[SYS_NMLN+1];
    struct servinfo *svp;
    int error;
    int vfsflags;
    char *root_path;
    struct pathname pn;
    char *name;
    static char token[10];
    struct nfs_args args;       /* nfs mount arguments */

    bzero(&args, sizeof (args));

    /* do this BEFORE getfile which causes xid stamps to be initialized */
    clkset(-1L);        /* hack for now - until we get time svc? */

    if (why == ROOT_REMOUNT) {
        /*
         * Shouldn't happen.
         */
        panic("nfs3_mountroot: why == ROOT_REMOUNT\n");
    }

    if (why == ROOT_UNMOUNT) {
        /*
         * Nothing to do for NFS.
         */
        return (0);
    }

    /*
     * why == ROOT_INIT
     */

    name = token;
    *name = 0;
    getfsname("root", name, sizeof (token));

    pn_alloc(&pn);
    root_path = pn.pn_path;

    svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
    mutex_init(&svp->sv_lock, NULL, MUTEX_DEFAULT, NULL);
    svp->sv_knconf = kmem_zalloc(sizeof (*svp->sv_knconf), KM_SLEEP);
    svp->sv_knconf->knc_protofmly = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
    svp->sv_knconf->knc_proto = kmem_alloc(KNC_STRSIZE, KM_SLEEP);

    /*
     * First try version 4
     */
    vfs_setops(vfsp, nfs4_vfsops);
    args.addr = &svp->sv_addr;
    args.fh = (char *)&svp->sv_fhandle;
    args.knconf = svp->sv_knconf;
    args.hostname = root_hostname;
    vfsflags = 0;

    if (error = mount_root(*name ? name : "root", root_path, NFS_V4,
        &args, &vfsflags)) {
        if (error != EPROTONOSUPPORT) {
            nfs_cmn_err(error, CE_WARN,
                "Unable to mount NFS root filesystem: %m");
            sv_free(svp);
            pn_free(&pn);
            vfs_setops(vfsp, nfsdyn_vfsops);
            return (error);
        }

        /*
         * Then try version 3
         */
        bzero(&args, sizeof (args));
        vfs_setops(vfsp, nfs3_vfsops);
        args.addr = &svp->sv_addr;
        args.fh = (char *)&svp->sv_fhandle;
        args.knconf = svp->sv_knconf;
        args.hostname = root_hostname;
        vfsflags = 0;

        if (error = mount_root(*name ? name : "root", root_path,
            NFS_V3, &args, &vfsflags)) {
            if (error != EPROTONOSUPPORT) {
                nfs_cmn_err(error, CE_WARN,
                    "Unable to mount NFS root filesystem: %m");
                sv_free(svp);
                pn_free(&pn);
                vfs_setops(vfsp, nfsdyn_vfsops);
                return (error);
            }

            /*
             * Finally, try version 2
             */
            bzero(&args, sizeof (args));
            args.addr = &svp->sv_addr;
            args.fh = (char *)&svp->sv_fhandle.fh_buf;
            args.knconf = svp->sv_knconf;
            args.hostname = root_hostname;
            vfsflags = 0;

            vfs_setops(vfsp, nfs_vfsops);

            if (error = mount_root(*name ? name : "root",
                root_path, NFS_VERSION, &args, &vfsflags)) {
                nfs_cmn_err(error, CE_WARN,
                    "Unable to mount NFS root filesystem: %m");
                sv_free(svp);
                pn_free(&pn);
                vfs_setops(vfsp, nfsdyn_vfsops);
                return (error);
            }
        }
    }

    sv_free(svp);
    pn_free(&pn);
    return (VFS_MOUNTROOT(vfsp, why));
}

int
nfs_setopts(vnode_t *vp, model_t model, struct nfs_args *buf)
{
    mntinfo_t *mi;          /* mount info, pointed at by vfs */
    STRUCT_HANDLE(nfs_args, args);
    int flags;

#ifdef lint
    model = model;
#endif

    STRUCT_SET_HANDLE(args, model, buf);

    flags = STRUCT_FGET(args, flags);

    /*
     * Set option fields in mount info record
     */
    mi = VTOMI(vp);

    if (flags & NFSMNT_NOAC) {
        mi->mi_flags |= MI_NOAC;
        PURGE_ATTRCACHE(vp);
    }
    if (flags & NFSMNT_NOCTO)
        mi->mi_flags |= MI_NOCTO;
    if (flags & NFSMNT_LLOCK)
        mi->mi_flags |= MI_LLOCK;
    if (flags & NFSMNT_GRPID)
        mi->mi_flags |= MI_GRPID;
    if (flags & NFSMNT_RETRANS) {
        if (STRUCT_FGET(args, retrans) < 0)
            return (EINVAL);
        mi->mi_retrans = STRUCT_FGET(args, retrans);
    }
    if (flags & NFSMNT_TIMEO) {
        if (STRUCT_FGET(args, timeo) <= 0)
            return (EINVAL);
        mi->mi_timeo = STRUCT_FGET(args, timeo);
        /*
         * The following scales the standard deviation and
         * and current retransmission timer to match the
         * initial value for the timeout specified.
         */
        mi->mi_timers[NFS_CALLTYPES].rt_deviate =
            (mi->mi_timeo * hz * 2) / 5;
        mi->mi_timers[NFS_CALLTYPES].rt_rtxcur =
            mi->mi_timeo * hz / 10;
    }
    if (flags & NFSMNT_RSIZE) {
        if (STRUCT_FGET(args, rsize) <= 0)
            return (EINVAL);
        mi->mi_tsize = MIN(mi->mi_tsize, STRUCT_FGET(args, rsize));
        mi->mi_curread = MIN(mi->mi_curread, mi->mi_tsize);
    }
    if (flags & NFSMNT_WSIZE) {
        if (STRUCT_FGET(args, wsize) <= 0)
            return (EINVAL);
        mi->mi_stsize = MIN(mi->mi_stsize, STRUCT_FGET(args, wsize));
        mi->mi_curwrite = MIN(mi->mi_curwrite, mi->mi_stsize);
    }
    if (flags & NFSMNT_ACREGMIN) {
        if (STRUCT_FGET(args, acregmin) < 0)
            mi->mi_acregmin = ACMINMAX;
        else
            mi->mi_acregmin = MIN(STRUCT_FGET(args, acregmin),
                ACMINMAX);
        mi->mi_acregmin = SEC2HR(mi->mi_acregmin);
    }
    if (flags & NFSMNT_ACREGMAX) {
        if (STRUCT_FGET(args, acregmax) < 0)
            mi->mi_acregmax = ACMAXMAX;
        else
            mi->mi_acregmax = MIN(STRUCT_FGET(args, acregmax),
                ACMAXMAX);
        mi->mi_acregmax = SEC2HR(mi->mi_acregmax);
    }
    if (flags & NFSMNT_ACDIRMIN) {
        if (STRUCT_FGET(args, acdirmin) < 0)
            mi->mi_acdirmin = ACMINMAX;
        else
            mi->mi_acdirmin = MIN(STRUCT_FGET(args, acdirmin),
                ACMINMAX);
        mi->mi_acdirmin = SEC2HR(mi->mi_acdirmin);
    }
    if (flags & NFSMNT_ACDIRMAX) {
        if (STRUCT_FGET(args, acdirmax) < 0)
            mi->mi_acdirmax = ACMAXMAX;
        else
            mi->mi_acdirmax = MIN(STRUCT_FGET(args, acdirmax),
                ACMAXMAX);
        mi->mi_acdirmax = SEC2HR(mi->mi_acdirmax);
    }

    if (flags & NFSMNT_LOOPBACK)
        mi->mi_flags |= MI_LOOPBACK;

    return (0);
}

/*
 * Set or Clear direct I/O flag
 * VOP_RWLOCK() is held for write access to prevent a race condition
 * which would occur if a process is in the middle of a write when
 * directio flag gets set. It is possible that all pages may not get flushed.
 */

/* ARGSUSED */
int
nfs_directio(vnode_t *vp, int cmd, cred_t *cr)
{
    int error = 0;
    rnode_t *rp;

    rp = VTOR(vp);

    if (cmd == DIRECTIO_ON) {

        if (rp->r_flags & RDIRECTIO)
            return (0);

        /*
         * Flush the page cache.
         */

        (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL);

        if (rp->r_flags & RDIRECTIO) {
            VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL);
            return (0);
        }

        if (vn_has_cached_data(vp) &&
            ((rp->r_flags & RDIRTY) || rp->r_awcount > 0)) {
            error = VOP_PUTPAGE(vp, (offset_t)0, (uint_t)0,
                B_INVAL, cr, NULL);
            if (error) {
                if (error == ENOSPC || error == EDQUOT) {
                    mutex_enter(&rp->r_statelock);
                    if (!rp->r_error)
                        rp->r_error = error;
                    mutex_exit(&rp->r_statelock);
                }
                VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL);
                return (error);
            }
        }

        mutex_enter(&rp->r_statelock);
        rp->r_flags |= RDIRECTIO;
        mutex_exit(&rp->r_statelock);
        VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL);
        return (0);
    }

    if (cmd == DIRECTIO_OFF) {
        mutex_enter(&rp->r_statelock);
        rp->r_flags &= ~RDIRECTIO;  /* disable direct mode */
        mutex_exit(&rp->r_statelock);
        return (0);
    }

    return (EINVAL);
}