fs/nfs/nfs3_xdr.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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */

/*
 * Copyright (c) 2013 by Delphix. All rights reserved.
 */

#include <sys/param.h>
#include <sys/types.h>
#include <sys/systm.h>
#include <sys/user.h>
#include <sys/vnode.h>
#include <sys/file.h>
#include <sys/dirent.h>
#include <sys/vfs.h>
#include <sys/stream.h>
#include <sys/strsubr.h>
#include <sys/debug.h>
#include <sys/t_lock.h>
#include <sys/cmn_err.h>
#include <sys/dnlc.h>
#include <sys/cred.h>
#include <sys/time.h>
#include <sys/sdt.h>

#include <rpc/types.h>
#include <rpc/xdr.h>

#include <nfs/nfs.h>
#include <nfs/rnode.h>
#include <rpc/rpc_rdma.h>

/*
 * These are the XDR routines used to serialize and deserialize
 * the various structures passed as parameters across the network
 * between NFS clients and servers.
 */

/*
 * XDR null terminated ASCII strings
 * xdr_string3 deals with "C strings" - arrays of bytes that are
 * terminated by a NULL character.  The parameter cpp references a
 * pointer to storage; If the pointer is null, then the necessary
 * storage is allocated.  The last parameter is the max allowed length
 * of the string as allowed by the system.  The NFS Version 3 protocol
 * does not place limits on strings, but the implementation needs to
 * place a reasonable limit to avoid problems.
 */
bool_t
xdr_string3(XDR *xdrs, char **cpp, uint_t maxsize)
{
    char *sp;
    uint_t size;
    uint_t nodesize;
    bool_t mem_alloced = FALSE;

    /*
     * first deal with the length since xdr strings are counted-strings
     */
    sp = *cpp;
    switch (xdrs->x_op) {
    case XDR_FREE:
        if (sp == NULL || sp == nfs3nametoolong)
            return (TRUE);  /* already free */
        /* FALLTHROUGH */

    case XDR_ENCODE:
        size = (uint_t)strlen(sp);
        break;

    case XDR_DECODE:
        break;
    }

    if (!xdr_u_int(xdrs, &size))
        return (FALSE);

    /*
     * now deal with the actual bytes
     */
    switch (xdrs->x_op) {
    case XDR_DECODE:
        if (size >= maxsize) {
            *cpp = nfs3nametoolong;
            if (!XDR_CONTROL(xdrs, XDR_SKIPBYTES, &size))
                return (FALSE);
            return (TRUE);
        }
        nodesize = size + 1;
        if (nodesize == 0)
            return (TRUE);
        if (sp == NULL) {
            sp = kmem_alloc(nodesize, KM_NOSLEEP);
            *cpp = sp;
            if (sp == NULL)
                return (FALSE);
            mem_alloced = TRUE;
        }
        sp[size] = 0;

        if (xdr_opaque(xdrs, sp, size)) {
            if (strlen(sp) != size) {
                if (mem_alloced)
                    kmem_free(sp, nodesize);
                *cpp = NULL;
                return (FALSE);
            }
        } else {
            if (mem_alloced)
                kmem_free(sp, nodesize);
            *cpp = NULL;
            return (FALSE);
        }
        return (TRUE);

    case XDR_ENCODE:
        return (xdr_opaque(xdrs, sp, size));

    case XDR_FREE:
        nodesize = size + 1;
        kmem_free(sp, nodesize);
        *cpp = NULL;
        return (TRUE);
    }

    return (FALSE);
}

/*
 * XDR_INLINE decode a filehandle.
 */
bool_t
xdr_inline_decode_nfs_fh3(uint32_t *ptr, nfs_fh3 *fhp, uint32_t fhsize)
{
    uchar_t *bp = (uchar_t *)ptr;
    uchar_t *cp;
    uint32_t dsize;
    uintptr_t resid;

    /*
     * Check to see if what the client sent us is bigger or smaller
     * than what we can ever possibly send out. NFS_FHMAXDATA is
     * unfortunately badly named as it is no longer the max and is
     * really the min of what is sent over the wire.
     */
    if (fhsize > sizeof (fhandle3_t) || fhsize < (sizeof (fsid_t) +
        sizeof (ushort_t) + NFS_FHMAXDATA +
        sizeof (ushort_t) + NFS_FHMAXDATA)) {
        return (FALSE);
    }

    /*
     * All internal parts of a filehandle are in native byte order.
     *
     * Decode what should be fh3_fsid, it is aligned.
     */
    fhp->fh3_fsid.val[0] = *(uint32_t *)bp;
    bp += BYTES_PER_XDR_UNIT;
    fhp->fh3_fsid.val[1] = *(uint32_t *)bp;
    bp += BYTES_PER_XDR_UNIT;

    /*
     * Decode what should be fh3_len.  fh3_len is two bytes, so we're
     * unaligned now.
     */
    cp = (uchar_t *)&fhp->fh3_len;
    *cp++ = *bp++;
    *cp++ = *bp++;
    fhsize -= 2 * BYTES_PER_XDR_UNIT + sizeof (ushort_t);

    /*
     * For backwards compatability, the fid length may be less than
     * NFS_FHMAXDATA, but it was always encoded as NFS_FHMAXDATA bytes.
     */
    dsize = fhp->fh3_len < NFS_FHMAXDATA ? NFS_FHMAXDATA : fhp->fh3_len;

    /*
     * Make sure the client isn't sending us a bogus length for fh3x_data.
     */
    if (fhsize < dsize)
        return (FALSE);
    bcopy(bp, fhp->fh3_data, dsize);
    bp += dsize;
    fhsize -= dsize;

    if (fhsize < sizeof (ushort_t))
        return (FALSE);
    cp = (uchar_t *)&fhp->fh3_xlen;
    *cp++ = *bp++;
    *cp++ = *bp++;
    fhsize -= sizeof (ushort_t);

    dsize = fhp->fh3_xlen < NFS_FHMAXDATA ? NFS_FHMAXDATA : fhp->fh3_xlen;

    /*
     * Make sure the client isn't sending us a bogus length for fh3x_xdata.
     */
    if (fhsize < dsize)
        return (FALSE);
    bcopy(bp, fhp->fh3_xdata, dsize);
    fhsize -= dsize;
    bp += dsize;

    /*
     * We realign things on purpose, so skip any padding
     */
    resid = (uintptr_t)bp % BYTES_PER_XDR_UNIT;
    if (resid != 0) {
        if (fhsize < (BYTES_PER_XDR_UNIT - resid))
            return (FALSE);
        bp += BYTES_PER_XDR_UNIT - resid;
        fhsize -= BYTES_PER_XDR_UNIT - resid;
    }

    /*
     * Make sure client didn't send extra bytes
     */
    if (fhsize != 0)
        return (FALSE);
    return (TRUE);
}

static bool_t
xdr_decode_nfs_fh3(XDR *xdrs, nfs_fh3 *objp)
{
    uint32_t fhsize;        /* filehandle size */
    uint32_t bufsize;
    rpc_inline_t *ptr;
    uchar_t *bp;

    ASSERT(xdrs->x_op == XDR_DECODE);

    /*
     * Retrieve the filehandle length.
     */
    if (!XDR_GETINT32(xdrs, (int32_t *)&fhsize))
        return (FALSE);

    bzero(objp->fh3_u.data, sizeof (objp->fh3_u.data));
    objp->fh3_length = 0;

    /*
     * Check to see if what the client sent us is bigger or smaller
     * than what we can ever possibly send out. NFS_FHMAXDATA is
     * unfortunately badly named as it is no longer the max and is
     * really the min of what is sent over the wire.
     */
    if (fhsize > sizeof (fhandle3_t) || fhsize < (sizeof (fsid_t) +
        sizeof (ushort_t) + NFS_FHMAXDATA +
        sizeof (ushort_t) + NFS_FHMAXDATA)) {
        if (!XDR_CONTROL(xdrs, XDR_SKIPBYTES, &fhsize))
            return (FALSE);
        return (TRUE);
    }

    /*
     * bring in fhsize plus any padding
     */
    bufsize = RNDUP(fhsize);
    ptr = XDR_INLINE(xdrs, bufsize);
    bp = (uchar_t *)ptr;
    if (ptr == NULL) {
        bp = kmem_alloc(bufsize, KM_SLEEP);
        if (!xdr_opaque(xdrs, (char *)bp, bufsize)) {
            kmem_free(bp, bufsize);
            return (FALSE);
        }
    }

    objp->fh3_length = sizeof (fhandle3_t);

    if (xdr_inline_decode_nfs_fh3((uint32_t *)bp, objp, fhsize) == FALSE) {
        /*
         * If in the process of decoding we find the file handle
         * is not correctly formed, we need to continue decoding
         * and trigger an NFS layer error. Set the nfs_fh3_len to
         * zero so it gets caught as a bad length.
         */
        bzero(objp->fh3_u.data, sizeof (objp->fh3_u.data));
        objp->fh3_length = 0;
    }

    if (ptr == NULL)
        kmem_free(bp, bufsize);
    return (TRUE);
}

/*
 * XDR_INLINE encode a filehandle.
 */
bool_t
xdr_inline_encode_nfs_fh3(uint32_t **ptrp, uint32_t *ptr_redzone,
    nfs_fh3 *fhp)
{
    uint32_t *ptr = *ptrp;
    uchar_t *cp;
    uint_t otw_len, fsize, xsize;   /* otw, file, and export sizes */
    uint32_t padword;

    fsize = fhp->fh3_len < NFS_FHMAXDATA ? NFS_FHMAXDATA : fhp->fh3_len;
    xsize = fhp->fh3_xlen < NFS_FHMAXDATA ? NFS_FHMAXDATA : fhp->fh3_xlen;

    /*
     * First get the initial and variable sized part of the filehandle.
     */
    otw_len = sizeof (fhp->fh3_fsid) +
        sizeof (fhp->fh3_len) + fsize +
        sizeof (fhp->fh3_xlen) + xsize;

    /*
     * Round out to a full word.
     */
    otw_len = RNDUP(otw_len);
    padword = (otw_len / BYTES_PER_XDR_UNIT);   /* includes fhlen */

    /*
     * Make sure we don't exceed our buffer.
     */
    if ((ptr + (otw_len / BYTES_PER_XDR_UNIT) + 1) > ptr_redzone)
        return (FALSE);

    /*
     * Zero out the pading.
     */
    ptr[padword] = 0;

    IXDR_PUT_U_INT32(ptr, otw_len);

    /*
     * The rest of the filehandle is in native byteorder
     */
    /* fh3_fsid */
    *ptr++ = (uint32_t)fhp->fh3_fsid.val[0];
    *ptr++ = (uint32_t)fhp->fh3_fsid.val[1];

    /*
     * Since the next pieces are unaligned, we need to
     * do bytewise copies.
     */
    cp = (uchar_t *)ptr;

    /* fh3_len + fh3_data */
    bcopy(&fhp->fh3_len, cp, sizeof (fhp->fh3_len) + fsize);
    cp += sizeof (fhp->fh3_len) + fsize;

    /* fh3_xlen + fh3_xdata */
    bcopy(&fhp->fh3_xlen, cp, sizeof (fhp->fh3_xlen) + xsize);
    cp += sizeof (fhp->fh3_xlen) + xsize;

    /* do necessary rounding/padding */
    cp = (uchar_t *)RNDUP((uintptr_t)cp);
    ptr = (uint32_t *)cp;

    /*
     * With the above padding, we're word aligned again.
     */
    ASSERT(((uintptr_t)ptr % BYTES_PER_XDR_UNIT) == 0);

    *ptrp = ptr;

    return (TRUE);
}

static bool_t
xdr_encode_nfs_fh3(XDR *xdrs, nfs_fh3 *objp)
{
    uint_t otw_len, fsize, xsize;   /* otw, file, and export sizes */
    bool_t ret;
    rpc_inline_t *ptr;
    rpc_inline_t *buf = NULL;
    uint32_t *ptr_redzone;

    ASSERT(xdrs->x_op == XDR_ENCODE);

    fsize = objp->fh3_len < NFS_FHMAXDATA ? NFS_FHMAXDATA : objp->fh3_len;
    xsize = objp->fh3_xlen < NFS_FHMAXDATA ? NFS_FHMAXDATA : objp->fh3_xlen;

    /*
     * First get the over the wire size, it is the 4 bytes
     * for the length, plus the combined size of the
     * file handle components.
     */
    otw_len = BYTES_PER_XDR_UNIT + sizeof (objp->fh3_fsid) +
        sizeof (objp->fh3_len) + fsize +
        sizeof (objp->fh3_xlen) + xsize;
    /*
     * Round out to a full word.
     */
    otw_len = RNDUP(otw_len);

    /*
     * Next try to inline the XDR stream, if that fails (rare)
     * allocate a buffer to encode the file handle and then
     * copy it using xdr_opaque and free the buffer.
     */
    ptr = XDR_INLINE(xdrs, otw_len);
    if (ptr == NULL)
        ptr = buf = kmem_alloc(otw_len, KM_SLEEP);

    ptr_redzone = (uint32_t *)(ptr + (otw_len / BYTES_PER_XDR_UNIT));
    ret = xdr_inline_encode_nfs_fh3((uint32_t **)&ptr, ptr_redzone, objp);

    if (buf != NULL) {
        if (ret == TRUE)
            ret = xdr_opaque(xdrs, (char *)buf, otw_len);
        kmem_free(buf, otw_len);
    }
    return (ret);
}

/*
 * XDR a NFSv3 filehandle the naive way.
 */
bool_t
xdr_nfs_fh3(XDR *xdrs, nfs_fh3 *objp)
{
    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    if (!xdr_u_int(xdrs, &objp->fh3_length))
        return (FALSE);

    if (objp->fh3_length > NFS3_FHSIZE)
        return (FALSE);

    return (xdr_opaque(xdrs, objp->fh3_u.data, objp->fh3_length));
}

/*
 * XDR a NFSv3 filehandle with intelligence on the server.
 * Encoding goes from our in-memory structure to wire format.
 * Decoding goes from wire format to our in-memory structure.
 */
bool_t
xdr_nfs_fh3_server(XDR *xdrs, nfs_fh3 *objp)
{
    switch (xdrs->x_op) {
    case XDR_ENCODE:
        if (objp->fh3_flags & FH_WEBNFS)
            return (xdr_nfs_fh3(xdrs, objp));
        else
            return (xdr_encode_nfs_fh3(xdrs, objp));
    case XDR_DECODE:
        return (xdr_decode_nfs_fh3(xdrs, objp));
    case XDR_FREE:
        if (objp->fh3_u.data != NULL)
            bzero(objp->fh3_u.data, sizeof (objp->fh3_u.data));
        return (TRUE);
    }
    return (FALSE);
}

bool_t
xdr_diropargs3(XDR *xdrs, diropargs3 *objp)
{
    switch (xdrs->x_op) {
    case XDR_FREE:
    case XDR_ENCODE:
        if (!xdr_nfs_fh3(xdrs, objp->dirp))
            return (FALSE);
        break;
    case XDR_DECODE:
        if (!xdr_nfs_fh3_server(xdrs, &objp->dir))
            return (FALSE);
        break;
    }
    return (xdr_string3(xdrs, &objp->name, MAXNAMELEN));
}

static bool_t
xdr_fattr3(XDR *xdrs, fattr3 *na)
{
    int32_t *ptr;

    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    ptr = XDR_INLINE(xdrs, NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT);
    if (ptr != NULL) {
        if (xdrs->x_op == XDR_DECODE) {
            na->type = IXDR_GET_ENUM(ptr, enum ftype3);
            na->mode = IXDR_GET_U_INT32(ptr);
            na->nlink = IXDR_GET_U_INT32(ptr);
            na->uid = IXDR_GET_U_INT32(ptr);
            na->gid = IXDR_GET_U_INT32(ptr);
            IXDR_GET_U_HYPER(ptr, na->size);
            IXDR_GET_U_HYPER(ptr, na->used);
            na->rdev.specdata1 = IXDR_GET_U_INT32(ptr);
            na->rdev.specdata2 = IXDR_GET_U_INT32(ptr);
            IXDR_GET_U_HYPER(ptr, na->fsid);
            IXDR_GET_U_HYPER(ptr, na->fileid);
            na->atime.seconds = IXDR_GET_U_INT32(ptr);
            na->atime.nseconds = IXDR_GET_U_INT32(ptr);
            na->mtime.seconds = IXDR_GET_U_INT32(ptr);
            na->mtime.nseconds = IXDR_GET_U_INT32(ptr);
            na->ctime.seconds = IXDR_GET_U_INT32(ptr);
            na->ctime.nseconds = IXDR_GET_U_INT32(ptr);
        } else {
            IXDR_PUT_ENUM(ptr, na->type);
            IXDR_PUT_U_INT32(ptr, na->mode);
            IXDR_PUT_U_INT32(ptr, na->nlink);
            IXDR_PUT_U_INT32(ptr, na->uid);
            IXDR_PUT_U_INT32(ptr, na->gid);
            IXDR_PUT_U_HYPER(ptr, na->size);
            IXDR_PUT_U_HYPER(ptr, na->used);
            IXDR_PUT_U_INT32(ptr, na->rdev.specdata1);
            IXDR_PUT_U_INT32(ptr, na->rdev.specdata2);
            IXDR_PUT_U_HYPER(ptr, na->fsid);
            IXDR_PUT_U_HYPER(ptr, na->fileid);
            IXDR_PUT_U_INT32(ptr, na->atime.seconds);
            IXDR_PUT_U_INT32(ptr, na->atime.nseconds);
            IXDR_PUT_U_INT32(ptr, na->mtime.seconds);
            IXDR_PUT_U_INT32(ptr, na->mtime.nseconds);
            IXDR_PUT_U_INT32(ptr, na->ctime.seconds);
            IXDR_PUT_U_INT32(ptr, na->ctime.nseconds);
        }
        return (TRUE);
    }
    if (!(xdr_enum(xdrs, (enum_t *)&na->type) &&
        xdr_u_int(xdrs, &na->mode) &&
        xdr_u_int(xdrs, &na->nlink) &&
        xdr_u_int(xdrs, &na->uid) &&
        xdr_u_int(xdrs, &na->gid) &&
        xdr_u_longlong_t(xdrs, &na->size) &&
        xdr_u_longlong_t(xdrs, &na->used) &&
        xdr_u_int(xdrs, &na->rdev.specdata1) &&
        xdr_u_int(xdrs, &na->rdev.specdata2) &&
        xdr_u_longlong_t(xdrs, &na->fsid) &&
        xdr_u_longlong_t(xdrs, &na->fileid) &&
        xdr_u_int(xdrs, &na->atime.seconds) &&
        xdr_u_int(xdrs, &na->atime.nseconds) &&
        xdr_u_int(xdrs, &na->mtime.seconds) &&
        xdr_u_int(xdrs, &na->mtime.nseconds) &&
        xdr_u_int(xdrs, &na->ctime.seconds) &&
        xdr_u_int(xdrs, &na->ctime.nseconds)))
            return (FALSE);
    return (TRUE);
}

/*
 * Fast decode of an fattr3 to a vattr
 * Only return FALSE on decode error, all other fattr to vattr translation
 * failures set status.
 *
 * Callers must catch the following errors:
 *  EFBIG - file size will not fit in va_size
 *  EOVERFLOW - time will not fit in va_*time
 */
static bool_t
xdr_fattr3_to_vattr(XDR *xdrs, fattr3_res *objp)
{
    int32_t *ptr;
    size3 used;
    specdata3 rdev;
    uint32_t ntime;
    vattr_t *vap = objp->vap;

    /*
     * DECODE only
     */
    ASSERT(xdrs->x_op == XDR_DECODE);

    /* On success, all attributes will be decoded */
    vap->va_mask = AT_ALL;

    objp->status = 0;
    ptr = XDR_INLINE(xdrs, NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT);
    if (ptr != NULL) {
        /*
         * Common case
         */
        vap->va_type = IXDR_GET_ENUM(ptr, enum vtype);
        if ((ftype3)vap->va_type < NF3REG ||
            (ftype3)vap->va_type > NF3FIFO)
            vap->va_type = VBAD;
        else
            vap->va_type = nf3_to_vt[vap->va_type];
        vap->va_mode = IXDR_GET_U_INT32(ptr);
        vap->va_nlink = IXDR_GET_U_INT32(ptr);
        vap->va_uid = (uid_t)IXDR_GET_U_INT32(ptr);
        if (vap->va_uid == NFS_UID_NOBODY)
            vap->va_uid = UID_NOBODY;
        vap->va_gid = (gid_t)IXDR_GET_U_INT32(ptr);
        if (vap->va_gid == NFS_GID_NOBODY)
            vap->va_gid = GID_NOBODY;
        IXDR_GET_U_HYPER(ptr, vap->va_size);
        /*
         * If invalid size, stop decode, set status, and
         * return TRUE, x_handy will be correct, caller must ignore vap.
         */
        if (!NFS3_SIZE_OK(vap->va_size)) {
            objp->status = EFBIG;
            return (TRUE);
        }
        IXDR_GET_U_HYPER(ptr, used);
        rdev.specdata1 = IXDR_GET_U_INT32(ptr);
        rdev.specdata2 = IXDR_GET_U_INT32(ptr);
        /* fsid is ignored */
        ptr += 2;
        IXDR_GET_U_HYPER(ptr, vap->va_nodeid);

        /*
         * nfs protocol defines times as unsigned so don't
         * extend sign, unless sysadmin set nfs_allow_preepoch_time.
         * The inline macros do the equivilant of NFS_TIME_T_CONVERT
         */
        if (nfs_allow_preepoch_time) {
            vap->va_atime.tv_sec = IXDR_GET_INT32(ptr);
            vap->va_atime.tv_nsec = IXDR_GET_U_INT32(ptr);
            vap->va_mtime.tv_sec = IXDR_GET_INT32(ptr);
            vap->va_mtime.tv_nsec = IXDR_GET_U_INT32(ptr);
            vap->va_ctime.tv_sec = IXDR_GET_INT32(ptr);
            vap->va_ctime.tv_nsec = IXDR_GET_U_INT32(ptr);
        } else {
            /*
             * Check if the time would overflow on 32-bit
             */
            ntime = IXDR_GET_U_INT32(ptr);
            /*CONSTCOND*/
            if (NFS3_TIME_OVERFLOW(ntime)) {
                objp->status = EOVERFLOW;
                return (TRUE);
            }
            vap->va_atime.tv_sec = ntime;
            vap->va_atime.tv_nsec = IXDR_GET_U_INT32(ptr);

            ntime = IXDR_GET_U_INT32(ptr);
            /*CONSTCOND*/
            if (NFS3_TIME_OVERFLOW(ntime)) {
                objp->status = EOVERFLOW;
                return (TRUE);
            }
            vap->va_mtime.tv_sec = ntime;
            vap->va_mtime.tv_nsec = IXDR_GET_U_INT32(ptr);

            ntime = IXDR_GET_U_INT32(ptr);
            /*CONSTCOND*/
            if (NFS3_TIME_OVERFLOW(ntime)) {
                objp->status = EOVERFLOW;
                return (TRUE);
            }
            vap->va_ctime.tv_sec = ntime;
            vap->va_ctime.tv_nsec = IXDR_GET_U_INT32(ptr);
        }

    } else {
        uint64 fsid;

        /*
         * Slow path
         */
        if (!(xdr_enum(xdrs, (enum_t *)&vap->va_type) &&
            xdr_u_int(xdrs, &vap->va_mode) &&
            xdr_u_int(xdrs, &vap->va_nlink) &&
            xdr_u_int(xdrs, (uint_t *)&vap->va_uid) &&
            xdr_u_int(xdrs, (uint_t *)&vap->va_gid) &&
            xdr_u_longlong_t(xdrs, &vap->va_size) &&
            xdr_u_longlong_t(xdrs, &used) &&
            xdr_u_int(xdrs, &rdev.specdata1) &&
            xdr_u_int(xdrs, &rdev.specdata2) &&
            xdr_u_longlong_t(xdrs, &fsid) &&    /* ignored */
            xdr_u_longlong_t(xdrs, &vap->va_nodeid)))
                return (FALSE);

        if (nfs_allow_preepoch_time) {
            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            vap->va_atime.tv_sec = (int32_t)ntime;
            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            vap->va_atime.tv_nsec = ntime;

            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            vap->va_mtime.tv_sec = (int32_t)ntime;
            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            vap->va_mtime.tv_nsec = ntime;

            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            vap->va_ctime.tv_sec = (int32_t)ntime;
            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            vap->va_ctime.tv_nsec = ntime;
        } else {
            /*
             * Check if the time would overflow on 32-bit
             * Set status and keep decoding stream.
             */
            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            /*CONSTCOND*/
            if (NFS3_TIME_OVERFLOW(ntime)) {
                objp->status = EOVERFLOW;
            }
            vap->va_atime.tv_sec = ntime;
            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            vap->va_atime.tv_nsec = ntime;

            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            /*CONSTCOND*/
            if (NFS3_TIME_OVERFLOW(ntime)) {
                objp->status = EOVERFLOW;
            }
            vap->va_mtime.tv_sec = ntime;
            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            vap->va_mtime.tv_nsec = ntime;

            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            /*CONSTCOND*/
            if (NFS3_TIME_OVERFLOW(ntime)) {
                objp->status = EOVERFLOW;
            }
            vap->va_ctime.tv_sec = ntime;
            if (!xdr_u_int(xdrs, &ntime))
                return (FALSE);
            vap->va_ctime.tv_nsec = ntime;
        }

        /*
         * Fixup as needed
         */
        if ((ftype3)vap->va_type < NF3REG ||
            (ftype3)vap->va_type > NF3FIFO)
            vap->va_type = VBAD;
        else
            vap->va_type = nf3_to_vt[vap->va_type];
        if (vap->va_uid == NFS_UID_NOBODY)
            vap->va_uid = UID_NOBODY;
        if (vap->va_gid == NFS_GID_NOBODY)
            vap->va_gid = GID_NOBODY;
        /*
         * If invalid size, set status, and
         * return TRUE, caller must ignore vap.
         */
        if (!NFS3_SIZE_OK(vap->va_size)) {
            objp->status = EFBIG;
            return (TRUE);
        }
    }

    /*
     * Fill in derived fields
     */
    vap->va_fsid = objp->vp->v_vfsp->vfs_dev;
    vap->va_seq = 0;

    /*
     * Common case values
     */
    vap->va_rdev = 0;
    vap->va_blksize = MAXBSIZE;
    vap->va_nblocks = 0;

    switch (vap->va_type) {
    case VREG:
    case VDIR:
    case VLNK:
        vap->va_nblocks = (u_longlong_t)
            ((used + (size3)DEV_BSIZE - (size3)1) /
            (size3)DEV_BSIZE);
        break;
    case VBLK:
        vap->va_blksize = DEV_BSIZE;
        /* FALLTHRU */
    case VCHR:
        vap->va_rdev = makedevice(rdev.specdata1, rdev.specdata2);
        break;
    case VSOCK:
    case VFIFO:
    default:
        break;
    }

    return (TRUE);
}

static bool_t
xdr_post_op_vattr(XDR *xdrs, post_op_vattr *objp)
{
    /*
     * DECODE only
     */
    ASSERT(xdrs->x_op == XDR_DECODE);

    if (!xdr_bool(xdrs, &objp->attributes))
        return (FALSE);

    if (objp->attributes == FALSE)
        return (TRUE);

    if (objp->attributes != TRUE)
        return (FALSE);

    if (!xdr_fattr3_to_vattr(xdrs, &objp->fres))
        return (FALSE);

    /*
     * The file size may cause an EFBIG or the time values
     * may cause EOVERFLOW, if so simply drop the attributes.
     */
    if (objp->fres.status != NFS3_OK)
        objp->attributes = FALSE;

    return (TRUE);
}

bool_t
xdr_post_op_attr(XDR *xdrs, post_op_attr *objp)
{
    if (!xdr_bool(xdrs, &objp->attributes))
        return (FALSE);

    if (objp->attributes == FALSE)
        return (TRUE);

    if (objp->attributes != TRUE)
        return (FALSE);

    if (!xdr_fattr3(xdrs, &objp->attr))
        return (FALSE);

    /*
     * Check that we don't get a file we can't handle through
     *  existing interfaces (especially stat64()).
     * Decode only check since on encode the data has
     * been dealt with in the above call to xdr_fattr3().
     */
    if (xdrs->x_op == XDR_DECODE) {
        /* Set attrs to false if invalid size or time */
        if (!NFS3_SIZE_OK(objp->attr.size)) {
            objp->attributes = FALSE;
            return (TRUE);
        }
#ifndef _LP64
        if (!NFS3_FATTR_TIME_OK(&objp->attr))
            objp->attributes = FALSE;
#endif
    }
    return (TRUE);
}

static bool_t
xdr_wcc_data(XDR *xdrs, wcc_data *objp)
{
    int32_t *ptr;
    wcc_attr *attrp;

    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    if (xdrs->x_op == XDR_DECODE) {
        /* pre_op_attr */
        if (!xdr_bool(xdrs, &objp->before.attributes))
            return (FALSE);

        switch (objp->before.attributes) {
        case TRUE:
            attrp = &objp->before.attr;
            ptr = XDR_INLINE(xdrs, 6 * BYTES_PER_XDR_UNIT);
            if (ptr != NULL) {
                IXDR_GET_U_HYPER(ptr, attrp->size);
                attrp->mtime.seconds = IXDR_GET_U_INT32(ptr);
                attrp->mtime.nseconds = IXDR_GET_U_INT32(ptr);
                attrp->ctime.seconds = IXDR_GET_U_INT32(ptr);
                attrp->ctime.nseconds = IXDR_GET_U_INT32(ptr);
            } else {
                if (!xdr_u_longlong_t(xdrs, &attrp->size))
                    return (FALSE);
                if (!xdr_u_int(xdrs, &attrp->mtime.seconds))
                    return (FALSE);
                if (!xdr_u_int(xdrs, &attrp->mtime.nseconds))
                    return (FALSE);
                if (!xdr_u_int(xdrs, &attrp->ctime.seconds))
                    return (FALSE);
                if (!xdr_u_int(xdrs, &attrp->ctime.nseconds))
                    return (FALSE);
            }

#ifndef _LP64
            /*
             * check time overflow.
             */
            if (!NFS3_TIME_OK(attrp->mtime.seconds) ||
                !NFS3_TIME_OK(attrp->ctime.seconds))
                objp->before.attributes = FALSE;
#endif
            break;
        case FALSE:
            break;
        default:
            return (FALSE);
        }
    }

    if (xdrs->x_op == XDR_ENCODE) {
        /* pre_op_attr */
        if (!xdr_bool(xdrs, &objp->before.attributes))
            return (FALSE);

        switch (objp->before.attributes) {
        case TRUE:
            attrp = &objp->before.attr;

            ptr = XDR_INLINE(xdrs, 6 * BYTES_PER_XDR_UNIT);
            if (ptr != NULL) {
                IXDR_PUT_U_HYPER(ptr, attrp->size);
                IXDR_PUT_U_INT32(ptr, attrp->mtime.seconds);
                IXDR_PUT_U_INT32(ptr, attrp->mtime.nseconds);
                IXDR_PUT_U_INT32(ptr, attrp->ctime.seconds);
                IXDR_PUT_U_INT32(ptr, attrp->ctime.nseconds);
            } else {
                if (!xdr_u_longlong_t(xdrs, &attrp->size))
                    return (FALSE);
                if (!xdr_u_int(xdrs, &attrp->mtime.seconds))
                    return (FALSE);
                if (!xdr_u_int(xdrs, &attrp->mtime.nseconds))
                    return (FALSE);
                if (!xdr_u_int(xdrs, &attrp->ctime.seconds))
                    return (FALSE);
                if (!xdr_u_int(xdrs, &attrp->ctime.nseconds))
                    return (FALSE);
            }
            break;
        case FALSE:
            break;
        default:
            return (FALSE);
        }
    }
    return (xdr_post_op_attr(xdrs, &objp->after));
}

bool_t
xdr_post_op_fh3(XDR *xdrs, post_op_fh3 *objp)
{
    if (!xdr_bool(xdrs, &objp->handle_follows))
        return (FALSE);
    switch (objp->handle_follows) {
    case TRUE:
        switch (xdrs->x_op) {
        case XDR_ENCODE:
            if (!xdr_nfs_fh3_server(xdrs, &objp->handle))
                return (FALSE);
            break;
        case XDR_FREE:
        case XDR_DECODE:
            if (!xdr_nfs_fh3(xdrs, &objp->handle))
                return (FALSE);
            break;
        }
        return (TRUE);
    case FALSE:
        return (TRUE);
    default:
        return (FALSE);
    }
}

static bool_t
xdr_sattr3(XDR *xdrs, sattr3 *objp)
{
    /* set_mode3 */
    if (!xdr_bool(xdrs, &objp->mode.set_it))
        return (FALSE);
    if (objp->mode.set_it)
        if (!xdr_u_int(xdrs, &objp->mode.mode))
            return (FALSE);
    /* set_uid3 */
    if (!xdr_bool(xdrs, &objp->uid.set_it))
        return (FALSE);
    if (objp->uid.set_it)
        if (!xdr_u_int(xdrs, &objp->uid.uid))
            return (FALSE);
    /* set_gid3 */
    if (!xdr_bool(xdrs, &objp->gid.set_it))
        return (FALSE);
    if (objp->gid.set_it)
        if (!xdr_u_int(xdrs, &objp->gid.gid))
            return (FALSE);

    /* set_size3 */
    if (!xdr_bool(xdrs, &objp->size.set_it))
        return (FALSE);
    if (objp->size.set_it)
        if (!xdr_u_longlong_t(xdrs, &objp->size.size))
            return (FALSE);

    /* set_atime */
    if (!xdr_enum(xdrs, (enum_t *)&objp->atime.set_it))
        return (FALSE);
    if (objp->atime.set_it == SET_TO_CLIENT_TIME) {
        if (!xdr_u_int(xdrs, &objp->atime.atime.seconds))
            return (FALSE);
        if (!xdr_u_int(xdrs, &objp->atime.atime.nseconds))
            return (FALSE);
    }

    /* set_mtime */
    if (!xdr_enum(xdrs, (enum_t *)&objp->mtime.set_it))
        return (FALSE);
    if (objp->mtime.set_it == SET_TO_CLIENT_TIME) {
        if (!xdr_u_int(xdrs, &objp->mtime.mtime.seconds))
            return (FALSE);
        if (!xdr_u_int(xdrs, &objp->mtime.mtime.nseconds))
            return (FALSE);
    }

    return (TRUE);
}

bool_t
xdr_GETATTR3res(XDR *xdrs, GETATTR3res *objp)
{
    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    if (objp->status != NFS3_OK)
        return (TRUE);
    /* xdr_GETATTR3resok */
    return (xdr_fattr3(xdrs, &objp->resok.obj_attributes));
}

bool_t
xdr_GETATTR3vres(XDR *xdrs, GETATTR3vres *objp)
{
    /*
     * DECODE or FREE only
     */
    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    if (xdrs->x_op != XDR_DECODE)
        return (FALSE);

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);

    if (objp->status != NFS3_OK)
        return (TRUE);

    return (xdr_fattr3_to_vattr(xdrs, &objp->fres));
}


bool_t
xdr_SETATTR3args(XDR *xdrs, SETATTR3args *objp)
{
    switch (xdrs->x_op) {
    case XDR_FREE:
    case XDR_ENCODE:
        if (!xdr_nfs_fh3(xdrs, &objp->object))
            return (FALSE);
        break;
    case XDR_DECODE:
        if (!xdr_nfs_fh3_server(xdrs, &objp->object))
            return (FALSE);
        break;
    }
    if (!xdr_sattr3(xdrs, &objp->new_attributes))
        return (FALSE);

    /* sattrguard3 */
    if (!xdr_bool(xdrs, &objp->guard.check))
        return (FALSE);
    switch (objp->guard.check) {
    case TRUE:
        if (!xdr_u_int(xdrs, &objp->guard.obj_ctime.seconds))
            return (FALSE);
        return (xdr_u_int(xdrs, &objp->guard.obj_ctime.nseconds));
    case FALSE:
        return (TRUE);
    default:
        return (FALSE);
    }
}

bool_t
xdr_SETATTR3res(XDR *xdrs, SETATTR3res *objp)
{
    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    switch (objp->status) {
    case NFS3_OK:
        return (xdr_wcc_data(xdrs, &objp->resok.obj_wcc));
    default:
        return (xdr_wcc_data(xdrs, &objp->resfail.obj_wcc));
    }
}

bool_t
xdr_LOOKUP3res(XDR *xdrs, LOOKUP3res *objp)
{
    LOOKUP3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);

    if (objp->status != NFS3_OK)
        return (xdr_post_op_attr(xdrs, &objp->resfail.dir_attributes));

    /* xdr_LOOKUP3resok */
    resokp = &objp->resok;
    switch (xdrs->x_op) {
    case XDR_ENCODE:
        if (!xdr_nfs_fh3_server(xdrs, &resokp->object))
            return (FALSE);
        break;
    case XDR_FREE:
    case XDR_DECODE:
        if (!xdr_nfs_fh3(xdrs, &resokp->object))
            return (FALSE);
        break;
    }
    if (!xdr_post_op_attr(xdrs, &resokp->obj_attributes))
        return (FALSE);
    return (xdr_post_op_attr(xdrs, &resokp->dir_attributes));
}

bool_t
xdr_LOOKUP3vres(XDR *xdrs, LOOKUP3vres *objp)
{
    /*
     * DECODE or FREE only
     */
    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    if (xdrs->x_op != XDR_DECODE)
        return (FALSE);

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);

    if (objp->status != NFS3_OK)
        return (xdr_post_op_vattr(xdrs, &objp->dir_attributes));

    if (!xdr_nfs_fh3(xdrs, &objp->object))
        return (FALSE);
    if (!xdr_post_op_vattr(xdrs, &objp->obj_attributes))
        return (FALSE);
    return (xdr_post_op_vattr(xdrs, &objp->dir_attributes));
}

bool_t
xdr_ACCESS3args(XDR *xdrs, ACCESS3args *objp)
{
    switch (xdrs->x_op) {
    case XDR_FREE:
    case XDR_ENCODE:
        if (!xdr_nfs_fh3(xdrs, &objp->object))
            return (FALSE);
        break;
    case XDR_DECODE:
        if (!xdr_nfs_fh3_server(xdrs, &objp->object))
            return (FALSE);
        break;
    }
    return (xdr_u_int(xdrs, &objp->access));
}


bool_t
xdr_ACCESS3res(XDR *xdrs, ACCESS3res *objp)
{
    ACCESS3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    if (objp->status != NFS3_OK)
        return (xdr_post_op_attr(xdrs, &objp->resfail.obj_attributes));

    /* xdr_ACCESS3resok */
    resokp = &objp->resok;
    if (!xdr_post_op_attr(xdrs, &resokp->obj_attributes))
        return (FALSE);
    return (xdr_u_int(xdrs, &resokp->access));
}

bool_t
xdr_READLINK3args(XDR *xdrs,  READLINK3args *objp)
{
    rdma_chunkinfo_t rci;
    struct xdr_ops *xops = xdrrdma_xops();

    if ((xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) &&
        xdrs->x_op == XDR_ENCODE) {
        rci.rci_type = RCI_REPLY_CHUNK;
        rci.rci_len = MAXPATHLEN;
        XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
    }
    if (!xdr_nfs_fh3(xdrs, (nfs_fh3 *)objp))
        return (FALSE);
    return (TRUE);
}

bool_t
xdr_READLINK3res(XDR *xdrs, READLINK3res *objp)
{

    READLINK3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    if (objp->status != NFS3_OK)
        return (xdr_post_op_attr(xdrs,
            &objp->resfail.symlink_attributes));

    /* xdr_READLINK3resok */
    resokp = &objp->resok;
    if (!xdr_post_op_attr(xdrs, &resokp->symlink_attributes))
        return (FALSE);
    return (xdr_string3(xdrs, &resokp->data, MAXPATHLEN));
}

bool_t
xdr_READ3args(XDR *xdrs, READ3args *objp)
{
    rdma_chunkinfo_t rci;
    rdma_wlist_conn_info_t rwci;
    struct xdr_ops *xops = xdrrdma_xops();

    switch (xdrs->x_op) {
    case XDR_FREE:
    case XDR_ENCODE:
        if (!xdr_nfs_fh3(xdrs, &objp->file))
            return (FALSE);
        break;
    case XDR_DECODE:
        if (!xdr_nfs_fh3_server(xdrs, &objp->file))
            return (FALSE);
        break;
    }
    if (!xdr_u_longlong_t(xdrs, &objp->offset))
        return (FALSE);
    if (!xdr_u_int(xdrs, &objp->count))
        return (FALSE);

    DTRACE_PROBE1(xdr__i__read3_buf_len, int, objp->count);

    objp->wlist = NULL;

    /* if xdrrdma_sizeof in progress, then store the size */
    if (xdrs->x_ops == xops && xdrs->x_op == XDR_ENCODE) {
        rci.rci_type = RCI_WRITE_ADDR_CHUNK;
        rci.rci_len = objp->count;
        (void) XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
    }

    if (xdrs->x_ops != &xdrrdma_ops || xdrs->x_op == XDR_FREE)
        return (TRUE);

    if (xdrs->x_op == XDR_ENCODE) {

        if (objp->res_uiop != NULL) {
            rci.rci_type = RCI_WRITE_UIO_CHUNK;
            rci.rci_a.rci_uiop = objp->res_uiop;
            rci.rci_len = objp->count;
            rci.rci_clpp = &objp->wlist;
        } else {
            rci.rci_type = RCI_WRITE_ADDR_CHUNK;
            rci.rci_a.rci_addr = objp->res_data_val_alt;
            rci.rci_len = objp->count;
            rci.rci_clpp = &objp->wlist;
        }

        return (XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci));
    }

    /* XDR_DECODE case */
    (void) XDR_CONTROL(xdrs, XDR_RDMA_GET_WCINFO, &rwci);
    objp->wlist = rwci.rwci_wlist;
    objp->conn = rwci.rwci_conn;

    return (TRUE);
}

bool_t
xdr_READ3res(XDR *xdrs, READ3res *objp)
{
    READ3resok *resokp;
    bool_t ret;
    mblk_t *mp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);

    if (objp->status != NFS3_OK)
        return (xdr_post_op_attr(xdrs, &objp->resfail.file_attributes));

    resokp = &objp->resok;

    if (xdr_post_op_attr(xdrs, &resokp->file_attributes) == FALSE ||
        xdr_u_int(xdrs, &resokp->count) == FALSE ||
        xdr_bool(xdrs, &resokp->eof) == FALSE) {
        return (FALSE);
    }

    if (xdrs->x_op == XDR_ENCODE) {

        mp = resokp->data.mp;
        if (mp != NULL) {
            if (xdrs->x_ops == &xdrmblk_ops) {
                if (xdrmblk_putmblk(xdrs, mp, resokp->count)) {
                    resokp->data.mp = NULL;
                    return (TRUE);
                } else {
                    return (FALSE);
                }
            } else if (mp->b_cont != NULL) {
                /*
                 * We have read results in an mblk chain, but
                 * the encoding operations don't handle mblks
                 * (they'll operate on data.data_val rather
                 * than data.mp).  Because data_val can only
                 * point at a single data buffer, we need to
                 * pullup the read results into a single data
                 * block and reset data_val to point to it.
                 *
                 * This happens with RPC GSS where the wrapping
                 * function does XDR serialization into a
                 * temporary buffer prior to applying GSS.
                 * Because we're not in a performance sensitive
                 * path, the pullupmsg() here shouldn't hurt us
                 * too badly.
                 */
                if (pullupmsg(mp, -1) == 0)
                    return (FALSE);
                resokp->data.data_val = (caddr_t)mp->b_rptr;
            }
        } else {
            if (xdr_u_int(xdrs, &resokp->count) == FALSE) {
                return (FALSE);
            }
            /*
             * If read data sent by wlist (RDMA_WRITE), don't do
             * xdr_bytes() below.   RDMA_WRITE transfers the data.
             * Note: this is encode-only because the client code
             * uses xdr_READ3vres/xdr_READ3uiores to decode results.
             */
            if (resokp->wlist) {
                if (resokp->count != 0) {
                    return (xdrrdma_send_read_data(
                        xdrs, resokp->count,
                        resokp->wlist));
                }
                return (TRUE);
            }
        }
        /*
         * Fall thru for the xdr_bytes()
         *
         * note: the mblk will be freed in
         * rfs3_read_free.
         */
    }

    /* no RDMA_WRITE transfer -- send data inline */

    ret = xdr_bytes(xdrs, (char **)&resokp->data.data_val,
        &resokp->data.data_len, nfs3tsize());

    return (ret);
}

bool_t
xdr_READ3vres(XDR *xdrs, READ3vres *objp)
{
    count3 ocount;
    /*
     * DECODE or FREE only
     */
    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    if (xdrs->x_op != XDR_DECODE)
        return (FALSE);

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);

    if (!xdr_post_op_vattr(xdrs, &objp->pov))
        return (FALSE);

    if (objp->status != NFS3_OK)
        return (TRUE);

    if (!xdr_u_int(xdrs, &objp->count))
        return (FALSE);

    if (!xdr_bool(xdrs, &objp->eof))
        return (FALSE);

    /*
     * If read data received via RDMA_WRITE, don't do xdr_bytes().
     * RDMA_WRITE already moved the data so decode length of RDMA_WRITE.
     */
    if (xdrs->x_ops == &xdrrdma_ops) {
        struct clist *cl;

        XDR_CONTROL(xdrs, XDR_RDMA_GET_WLIST, &cl);

        if (cl) {
            if (!xdr_u_int(xdrs, &ocount)) {
                return (FALSE);
            }
            if (ocount != objp->count) {
                DTRACE_PROBE2(xdr__e__read3vres_fail,
                    int, ocount, int, objp->count);
                objp->wlist = NULL;
                return (FALSE);
            }

            objp->wlist_len = clist_len(cl);
            objp->data.data_len = ocount;

            if (objp->wlist_len !=
                roundup(objp->data.data_len, BYTES_PER_XDR_UNIT)) {
                DTRACE_PROBE2(
                    xdr__e__read3vres_fail,
                    int, ocount,
                    int, objp->data.data_len);
                objp->wlist = NULL;
                return (FALSE);
            }
            return (TRUE);
        }
    }

    return (xdr_bytes(xdrs, (char **)&objp->data.data_val,
        &objp->data.data_len, nfs3tsize()));
}

bool_t
xdr_READ3uiores(XDR *xdrs, READ3uiores *objp)
{
    count3 ocount;
    bool_t attributes;
    mblk_t *mp;
    size_t n;
    int error;
    int size = (int)objp->size;
    struct uio *uiop = objp->uiop;
    int32_t fattr3_len = NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT;
    int32_t *ptr;

    /*
     * DECODE or FREE only
     */
    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    if (xdrs->x_op != XDR_DECODE)
        return (FALSE);

    if (!XDR_GETINT32(xdrs, (int32_t *)&objp->status))
        return (FALSE);

    if (!XDR_GETINT32(xdrs, (int32_t *)&attributes))
        return (FALSE);

    /*
     * For directio we just skip over attributes if present
     */
    switch (attributes) {
    case TRUE:
        if (!XDR_CONTROL(xdrs, XDR_SKIPBYTES, &fattr3_len))
            return (FALSE);
        break;
    case FALSE:
        break;
    default:
        return (FALSE);
    }

    if (objp->status != NFS3_OK)
        return (TRUE);

    if (!XDR_GETINT32(xdrs, (int32_t *)&objp->count))
        return (FALSE);

    if (!XDR_GETINT32(xdrs, (int32_t *)&objp->eof))
        return (FALSE);

    if (xdrs->x_ops == &xdrmblk_ops) {
        if (!xdrmblk_getmblk(xdrs, &mp, &objp->size))
            return (FALSE);

        if (objp->size == 0)
            return (TRUE);

        if (objp->size > size)
            return (FALSE);

        size = (int)objp->size;
        do {
            n = MIN(size, mp->b_wptr - mp->b_rptr);
            if ((n = MIN(uiop->uio_resid, n)) != 0) {

                error = uiomove((char *)mp->b_rptr, n, UIO_READ,
                    uiop);
                if (error)
                    return (FALSE);
                mp->b_rptr += n;
                size -= n;
            }

            while (mp && (mp->b_rptr >= mp->b_wptr))
                mp = mp->b_cont;
        } while (mp && size > 0 && uiop->uio_resid > 0);

        return (TRUE);
    }

    if (xdrs->x_ops == &xdrrdma_ops) {
        struct clist *cl;

        XDR_CONTROL(xdrs, XDR_RDMA_GET_WLIST, &cl);

        objp->wlist = cl;

        if (objp->wlist) {
            if (!xdr_u_int(xdrs, &ocount)) {
                objp->wlist = NULL;
                return (FALSE);
            }

            if (ocount != objp->count) {
                DTRACE_PROBE2(xdr__e__read3uiores_fail,
                    int, ocount, int, objp->count);
                objp->wlist = NULL;
                return (FALSE);
            }

            objp->wlist_len = clist_len(cl);

            uiop->uio_resid -= objp->count;
            uiop->uio_iov->iov_len -= objp->count;
            uiop->uio_iov->iov_base += objp->count;
            uiop->uio_loffset += objp->count;

            /*
             * XXX: Assume 1 iov, needs to be changed.
             */
            objp->size = objp->count;

            return (TRUE);
        }
    }

    /*
     * This isn't an xdrmblk stream nor RDMA.
     * Handle the likely case that it can be
     * inlined (ex. xdrmem).
     */
    if (!XDR_GETINT32(xdrs, (int32_t *)&objp->size))
        return (FALSE);

    if (objp->size == 0)
        return (TRUE);

    if (objp->size > size)
        return (FALSE);

    size = (int)objp->size;
    if ((ptr = XDR_INLINE(xdrs, size)) != NULL)
        return (uiomove(ptr, size, UIO_READ, uiop) ? FALSE : TRUE);

    /*
     * Handle some other (unlikely) stream type that will need a copy.
     */
    if ((ptr = kmem_alloc(size, KM_NOSLEEP)) == NULL)
        return (FALSE);

    if (!XDR_GETBYTES(xdrs, (caddr_t)ptr, size)) {
        kmem_free(ptr, size);
        return (FALSE);
    }
    error = uiomove(ptr, size, UIO_READ, uiop);
    kmem_free(ptr, size);

    return (error ? FALSE : TRUE);
}

bool_t
xdr_WRITE3args(XDR *xdrs, WRITE3args *objp)
{
    switch (xdrs->x_op) {
    case XDR_FREE:
    case XDR_ENCODE:
        if (!xdr_nfs_fh3(xdrs, &objp->file))
            return (FALSE);
        break;
    case XDR_DECODE:
        if (!xdr_nfs_fh3_server(xdrs, &objp->file))
            return (FALSE);
        break;
    }
    if (!xdr_u_longlong_t(xdrs, &objp->offset))
        return (FALSE);
    if (!xdr_u_int(xdrs, &objp->count))
        return (FALSE);
    if (!xdr_enum(xdrs, (enum_t *)&objp->stable))
        return (FALSE);

    if (xdrs->x_op == XDR_DECODE) {
        if (xdrs->x_ops == &xdrmblk_ops) {
            if (xdrmblk_getmblk(xdrs, &objp->mblk,
                &objp->data.data_len) == TRUE) {
                objp->data.data_val = NULL;
                return (TRUE);
            }
        }
        objp->mblk = NULL;

        if (xdrs->x_ops == &xdrrdmablk_ops) {
            if (xdrrdma_getrdmablk(xdrs, &objp->rlist,
                &objp->data.data_len,
                &objp->conn, nfs3tsize()) == TRUE) {
                objp->data.data_val = NULL;
                if (xdrrdma_read_from_client(
                    objp->rlist,
                    &objp->conn,
                    objp->count) == FALSE) {
                    return (FALSE);
                }
                return (TRUE);
            }
        }
        objp->rlist = NULL;

        /* Else fall thru for the xdr_bytes(). */
    }

    if (xdrs->x_op == XDR_FREE) {
        if (objp->rlist != NULL) {
            (void) xdrrdma_free_clist(objp->conn, objp->rlist);
            objp->rlist = NULL;
            objp->data.data_val = NULL;
            return (TRUE);
        }
    }

    DTRACE_PROBE1(xdr__i__write3_buf_len,
        int, objp->data.data_len);

    return (xdr_bytes(xdrs, (char **)&objp->data.data_val,
        &objp->data.data_len, nfs3tsize()));
}

bool_t
xdr_WRITE3res(XDR *xdrs, WRITE3res *objp)
{
    WRITE3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    if (objp->status != NFS3_OK) /* xdr_WRITE3resfail */
        return (xdr_wcc_data(xdrs, &objp->resfail.file_wcc));

    /* xdr_WRITE3resok */
    resokp = &objp->resok;
    if (!xdr_wcc_data(xdrs, &resokp->file_wcc))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->count))
        return (FALSE);
    if (!xdr_enum(xdrs, (enum_t *)&resokp->committed))
        return (FALSE);
    /*
     * writeverf3 is really an opaque 8 byte
     * quantity, but we will treat it as a
     * hyper for efficiency, the cost of
     * a byteswap here saves bcopys elsewhere
     */
    return (xdr_u_longlong_t(xdrs, &resokp->verf));
}

bool_t
xdr_CREATE3args(XDR *xdrs, CREATE3args *objp)
{
    createhow3 *howp;

    if (!xdr_diropargs3(xdrs, &objp->where))
        return (FALSE);

    /* xdr_createhow3 */
    howp = &objp->how;

    if (!xdr_enum(xdrs, (enum_t *)&howp->mode))
        return (FALSE);
    switch (howp->mode) {
    case UNCHECKED:
    case GUARDED:
        return (xdr_sattr3(xdrs, &howp->createhow3_u.obj_attributes));
    case EXCLUSIVE:
        /*
         * createverf3 is really an opaque 8 byte
         * quantity, but we will treat it as a
         * hyper for efficiency, the cost of
         * a byteswap here saves bcopys elsewhere
         */
        return (xdr_u_longlong_t(xdrs, &howp->createhow3_u.verf));
    default:
        return (FALSE);
    }
}

bool_t
xdr_CREATE3res(XDR *xdrs, CREATE3res *objp)
{
    CREATE3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    switch (objp->status) {
    case NFS3_OK:
        /* xdr_CREATE3resok */
        resokp = &objp->resok;

        if (!xdr_post_op_fh3(xdrs, &resokp->obj))
            return (FALSE);
        if (!xdr_post_op_attr(xdrs, &resokp->obj_attributes))
            return (FALSE);
        return (xdr_wcc_data(xdrs, &resokp->dir_wcc));
    default:
        /* xdr_CREATE3resfail */
        return (xdr_wcc_data(xdrs, &objp->resfail.dir_wcc));
    }
}

bool_t
xdr_MKDIR3args(XDR *xdrs, MKDIR3args *objp)
{
    if (!xdr_diropargs3(xdrs, &objp->where))
        return (FALSE);
    return (xdr_sattr3(xdrs, &objp->attributes));
}

bool_t
xdr_MKDIR3res(XDR *xdrs, MKDIR3res *objp)
{
    MKDIR3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    switch (objp->status) {
    case NFS3_OK:
        /* xdr_MKDIR3resok */
        resokp = &objp->resok;

        if (!xdr_post_op_fh3(xdrs, &resokp->obj))
            return (FALSE);
        if (!xdr_post_op_attr(xdrs, &resokp->obj_attributes))
            return (FALSE);
        return (xdr_wcc_data(xdrs, &resokp->dir_wcc));
    default:
        return (xdr_wcc_data(xdrs, &objp->resfail.dir_wcc));
    }
}

bool_t
xdr_SYMLINK3args(XDR *xdrs, SYMLINK3args *objp)
{
    if (!xdr_diropargs3(xdrs, &objp->where))
        return (FALSE);
    if (!xdr_sattr3(xdrs, &objp->symlink.symlink_attributes))
        return (FALSE);
    return (xdr_string3(xdrs, &objp->symlink.symlink_data, MAXPATHLEN));
}

bool_t
xdr_SYMLINK3res(XDR *xdrs, SYMLINK3res *objp)
{
    SYMLINK3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    switch (objp->status) {
    case NFS3_OK:
        resokp = &objp->resok;
        /* xdr_SYMLINK3resok */
        if (!xdr_post_op_fh3(xdrs, &resokp->obj))
            return (FALSE);
        if (!xdr_post_op_attr(xdrs, &resokp->obj_attributes))
            return (FALSE);
        return (xdr_wcc_data(xdrs, &resokp->dir_wcc));
    default:
        return (xdr_wcc_data(xdrs, &objp->resfail.dir_wcc));
    }
}

bool_t
xdr_MKNOD3args(XDR *xdrs, MKNOD3args *objp)
{
    mknoddata3 *whatp;
    devicedata3 *nod_objp;

    if (!xdr_diropargs3(xdrs, &objp->where))
        return (FALSE);

    whatp = &objp->what;
    if (!xdr_enum(xdrs, (enum_t *)&whatp->type))
        return (FALSE);
    switch (whatp->type) {
    case NF3CHR:
    case NF3BLK:
        /* xdr_devicedata3 */
        nod_objp = &whatp->mknoddata3_u.device;
        if (!xdr_sattr3(xdrs, &nod_objp->dev_attributes))
            return (FALSE);
        if (!xdr_u_int(xdrs, &nod_objp->spec.specdata1))
            return (FALSE);
        return (xdr_u_int(xdrs, &nod_objp->spec.specdata2));
    case NF3SOCK:
    case NF3FIFO:
        return (xdr_sattr3(xdrs, &whatp->mknoddata3_u.pipe_attributes));
    default:
        break;
    }
    return (TRUE);
}

bool_t
xdr_MKNOD3res(XDR *xdrs, MKNOD3res *objp)
{
    MKNOD3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    switch (objp->status) {
    case NFS3_OK:
        /* xdr_MKNOD3resok */
        resokp = &objp->resok;
        if (!xdr_post_op_fh3(xdrs, &resokp->obj))
            return (FALSE);
        if (!xdr_post_op_attr(xdrs, &resokp->obj_attributes))
            return (FALSE);
        return (xdr_wcc_data(xdrs, &resokp->dir_wcc));
    default:
        return (xdr_wcc_data(xdrs, &objp->resfail.dir_wcc));
    }
}

bool_t
xdr_REMOVE3res(XDR *xdrs, REMOVE3res *objp)
{
    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    switch (objp->status) {
    case NFS3_OK:
        return (xdr_wcc_data(xdrs, &objp->resok.dir_wcc));
    default:
        return (xdr_wcc_data(xdrs, &objp->resfail.dir_wcc));
    }
}

bool_t
xdr_RMDIR3res(XDR *xdrs, RMDIR3res *objp)
{
    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    switch (objp->status) {
    case NFS3_OK:
        return (xdr_wcc_data(xdrs, &objp->resok.dir_wcc));
    default:
        return (xdr_wcc_data(xdrs, &objp->resfail.dir_wcc));
    }
}

bool_t
xdr_RENAME3args(XDR *xdrs, RENAME3args *objp)
{
    if (!xdr_diropargs3(xdrs, &objp->from))
        return (FALSE);
    return (xdr_diropargs3(xdrs, &objp->to));
}

bool_t
xdr_RENAME3res(XDR *xdrs, RENAME3res *objp)
{
    RENAME3resok *resokp;
    RENAME3resfail *resfailp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    switch (objp->status) {
    case NFS3_OK:
        /* xdr_RENAME3resok */
        resokp = &objp->resok;

        if (!xdr_wcc_data(xdrs, &resokp->fromdir_wcc))
            return (FALSE);
        return (xdr_wcc_data(xdrs, &resokp->todir_wcc));
    default:
        /* xdr_RENAME3resfail */
        resfailp = &objp->resfail;
        if (!xdr_wcc_data(xdrs, &resfailp->fromdir_wcc))
            return (FALSE);
        return (xdr_wcc_data(xdrs, &resfailp->todir_wcc));
    }
}

bool_t
xdr_LINK3args(XDR *xdrs, LINK3args *objp)
{
    switch (xdrs->x_op) {
    case XDR_FREE:
    case XDR_ENCODE:
        if (!xdr_nfs_fh3(xdrs, &objp->file))
            return (FALSE);
        break;
    case XDR_DECODE:
        if (!xdr_nfs_fh3_server(xdrs, &objp->file))
            return (FALSE);
        break;
    }
    return (xdr_diropargs3(xdrs, &objp->link));
}

bool_t
xdr_LINK3res(XDR *xdrs, LINK3res *objp)
{
    LINK3resok *resokp;
    LINK3resfail *resfailp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    switch (objp->status) {
    case NFS3_OK:
        /* xdr_LINK3resok */
        resokp = &objp->resok;
        if (!xdr_post_op_attr(xdrs, &resokp->file_attributes))
            return (FALSE);
        return (xdr_wcc_data(xdrs, &resokp->linkdir_wcc));
    default:
        /* xdr_LINK3resfail */
        resfailp = &objp->resfail;
        if (!xdr_post_op_attr(xdrs, &resfailp->file_attributes))
            return (FALSE);
        return (xdr_wcc_data(xdrs, &resfailp->linkdir_wcc));
    }
}

bool_t
xdr_READDIR3args(XDR *xdrs, READDIR3args *objp)
{
    rdma_chunkinfo_t rci;
    struct xdr_ops *xops = xdrrdma_xops();

    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    switch (xdrs->x_op) {
    case XDR_FREE:
    case XDR_ENCODE:
        if (!xdr_nfs_fh3(xdrs, &objp->dir))
            return (FALSE);
        break;
    case XDR_DECODE:
        if (!xdr_nfs_fh3_server(xdrs, &objp->dir))
            return (FALSE);
        break;
    }
    if ((xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) &&
        xdrs->x_op == XDR_ENCODE) {
        rci.rci_type = RCI_REPLY_CHUNK;
        rci.rci_len = objp->count;
        XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
    }

    if (!xdr_u_longlong_t(xdrs, &objp->cookie))
        return (FALSE);
    /*
     * cookieverf is really an opaque 8 byte
     * quantity, but we will treat it as a
     * hyper for efficiency, the cost of
     * a byteswap here saves bcopys elsewhere
     */
    if (!xdr_u_longlong_t(xdrs, &objp->cookieverf))
        return (FALSE);
    return (xdr_u_int(xdrs, &objp->count));
}

#ifdef  nextdp
#undef  nextdp
#endif
#define nextdp(dp)  ((struct dirent64 *)((char *)(dp) + (dp)->d_reclen))
#ifdef  roundup
#undef  roundup
#endif
#define roundup(x, y)   ((((x) + ((y) - 1)) / (y)) * (y))

/*
 * ENCODE ONLY
 */
static bool_t
xdr_putdirlist(XDR *xdrs, READDIR3resok *objp)
{
    struct dirent64 *dp;
    char *name;
    int size;
    int bufsize;
    uint_t namlen;
    bool_t true = TRUE;
    bool_t false = FALSE;
    int entrysz;
    int tofit;
    fileid3 fileid;
    cookie3 cookie;

    if (xdrs->x_op != XDR_ENCODE)
        return (FALSE);

    /*
     * bufsize is used to keep track of the size of the response.
     * It is primed with:
     *  1 for the status +
     *  1 for the dir_attributes.attributes boolean +
     *  2 for the cookie verifier
     * all times BYTES_PER_XDR_UNIT to convert from XDR units
     * to bytes.  If there are directory attributes to be
     * returned, then:
     *  NFS3_SIZEOF_FATTR3 for the dir_attributes.attr fattr3
     * time BYTES_PER_XDR_UNIT is added to account for them.
     */
    bufsize = (1 + 1 + 2) * BYTES_PER_XDR_UNIT;
    if (objp->dir_attributes.attributes)
        bufsize += NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT;
    for (size = objp->size, dp = (struct dirent64 *)objp->reply.entries;
        size > 0;
        size -= dp->d_reclen, dp = nextdp(dp)) {
        if (dp->d_reclen == 0)
            return (FALSE);
        if (dp->d_ino == 0)
            continue;
        name = dp->d_name;
        namlen = (uint_t)strlen(dp->d_name);
        /*
         * An entry is composed of:
         *  1 for the true/false list indicator +
         *  2 for the fileid +
         *  1 for the length of the name +
         *  2 for the cookie +
         * all times BYTES_PER_XDR_UNIT to convert from
         * XDR units to bytes, plus the length of the name
         * rounded up to the nearest BYTES_PER_XDR_UNIT.
         */
        entrysz = (1 + 2 + 1 + 2) * BYTES_PER_XDR_UNIT +
            roundup(namlen, BYTES_PER_XDR_UNIT);
        /*
         * We need to check to see if the number of bytes left
         * to go into the buffer will actually fit into the
         * buffer.  This is calculated as the size of this
         * entry plus:
         *  1 for the true/false list indicator +
         *  1 for the eof indicator
         * times BYTES_PER_XDR_UNIT to convert from from
         * XDR units to bytes.
         */
        tofit = entrysz + (1 + 1) * BYTES_PER_XDR_UNIT;
        if (bufsize + tofit > objp->count) {
            objp->reply.eof = FALSE;
            break;
        }
        fileid = (fileid3)(dp->d_ino);
        cookie = (cookie3)(dp->d_off);
        if (!xdr_bool(xdrs, &true) ||
            !xdr_u_longlong_t(xdrs, &fileid) ||
            !xdr_bytes(xdrs, &name, &namlen, ~0) ||
            !xdr_u_longlong_t(xdrs, &cookie)) {
            return (FALSE);
        }
        bufsize += entrysz;
    }
    if (!xdr_bool(xdrs, &false))
        return (FALSE);
    if (!xdr_bool(xdrs, &objp->reply.eof))
        return (FALSE);
    return (TRUE);
}

bool_t
xdr_READDIR3res(XDR *xdrs, READDIR3res *objp)
{
    READDIR3resok *resokp;

    /*
     * ENCODE or FREE only
     */
    if (xdrs->x_op == XDR_DECODE)
        return (FALSE);

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    if (objp->status != NFS3_OK)
        return (xdr_post_op_attr(xdrs, &objp->resfail.dir_attributes));

    /* xdr_READDIR3resok */
    resokp = &objp->resok;
    if (!xdr_post_op_attr(xdrs, &resokp->dir_attributes))
        return (FALSE);
    if (xdrs->x_op != XDR_ENCODE)
        return (TRUE);
    /*
     * cookieverf is really an opaque 8 byte
     * quantity, but we will treat it as a
     * hyper for efficiency, the cost of
     * a byteswap here saves bcopys elsewhere
     */
    if (!xdr_u_longlong_t(xdrs, &resokp->cookieverf))
        return (FALSE);
    return (xdr_putdirlist(xdrs, resokp));
}

bool_t
xdr_READDIR3vres(XDR *xdrs, READDIR3vres *objp)
{
    dirent64_t *dp;
    uint_t entries_size;
    int outcount = 0;

    /*
     * DECODE or FREE only
     */
    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    if (xdrs->x_op != XDR_DECODE)
        return (FALSE);

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);

    if (!xdr_post_op_vattr(xdrs, &objp->dir_attributes))
        return (FALSE);

    if (objp->status != NFS3_OK)
        return (TRUE);

    /*
     * cookieverf is really an opaque 8 byte
     * quantity, but we will treat it as a
     * hyper for efficiency, the cost of
     * a byteswap here saves bcopys elsewhere
     */
    if (!xdr_u_longlong_t(xdrs, &objp->cookieverf))
        return (FALSE);

    entries_size = objp->entries_size;
    dp = objp->entries;

    for (;;) {
        uint_t this_reclen;
        bool_t valid;
        uint_t namlen;
        ino64_t fileid;

        if (!XDR_GETINT32(xdrs, (int32_t *)&valid))
            return (FALSE);
        if (!valid) {
            /*
             * We have run out of entries, decode eof.
             */
            if (!XDR_GETINT32(xdrs, (int32_t *)&objp->eof))
                return (FALSE);

            break;
        }

        /*
         * fileid3 fileid
         */
        if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&fileid))
            return (FALSE);

        /*
         * filename3 name
         */
        if (!XDR_GETINT32(xdrs, (int32_t *)&namlen))
            return (FALSE);
        this_reclen = DIRENT64_RECLEN(namlen);

        /*
         * If this will overflow buffer, stop decoding
         */
        if ((outcount + this_reclen) > entries_size) {
            objp->eof = FALSE;
            break;
        }
        dp->d_reclen = this_reclen;
        dp->d_ino = fileid;

        if (!xdr_opaque(xdrs, dp->d_name, namlen))
            return (FALSE);
        bzero(&dp->d_name[namlen],
            DIRENT64_NAMELEN(this_reclen) - namlen);

        /*
         * cookie3 cookie
         */
        if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&dp->d_off))
            return (FALSE);
        objp->loff = dp->d_off;

        outcount += this_reclen;
        dp = (dirent64_t *)((intptr_t)dp + this_reclen);
    }

    objp->size = outcount;
    return (TRUE);
}

bool_t
xdr_READDIRPLUS3args(XDR *xdrs, READDIRPLUS3args *objp)
{
    rdma_chunkinfo_t rci;
    struct xdr_ops *xops = xdrrdma_xops();

    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    switch (xdrs->x_op) {
    case XDR_FREE:
    case XDR_ENCODE:
        if (!xdr_nfs_fh3(xdrs, &objp->dir))
            return (FALSE);
        break;
    case XDR_DECODE:
        if (!xdr_nfs_fh3_server(xdrs, &objp->dir))
            return (FALSE);
        break;
    }
    if ((xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) &&
        xdrs->x_op == XDR_ENCODE) {
        rci.rci_type = RCI_REPLY_CHUNK;
        rci.rci_len = objp->maxcount;
        XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
    }

    if (!xdr_u_longlong_t(xdrs, &objp->cookie))
        return (FALSE);
    /*
     * cookieverf is really an opaque 8 byte
     * quantity, but we will treat it as a
     * hyper for efficiency, the cost of
     * a byteswap here saves bcopys elsewhere
     */
    if (!xdr_u_longlong_t(xdrs, &objp->cookieverf))
        return (FALSE);
    if (!xdr_u_int(xdrs, &objp->dircount))
        return (FALSE);
    return (xdr_u_int(xdrs, &objp->maxcount));
}

/*
 * ENCODE ONLY
 */
static bool_t
xdr_putdirpluslist(XDR *xdrs, READDIRPLUS3resok *objp)
{
    struct dirent64 *dp;
    char *name;
    int nents;
    bool_t true = TRUE;
    bool_t false = FALSE;
    fileid3 fileid;
    cookie3 cookie;
    entryplus3_info *infop;

    if (xdrs->x_op != XDR_ENCODE)
        return (FALSE);

    dp = (struct dirent64 *)objp->reply.entries;
    nents = objp->size;
    infop = objp->infop;

    while (nents > 0) {
        if (dp->d_reclen == 0)
            return (FALSE);
        if (dp->d_ino != 0) {
            name = dp->d_name;
            fileid = (fileid3)(dp->d_ino);
            cookie = (cookie3)(dp->d_off);
            if (!xdr_bool(xdrs, &true) ||
                !xdr_u_longlong_t(xdrs, &fileid) ||
                !xdr_bytes(xdrs, &name, &infop->namelen, ~0) ||
                !xdr_u_longlong_t(xdrs, &cookie) ||
                !xdr_post_op_attr(xdrs, &infop->attr) ||
                !xdr_post_op_fh3(xdrs, &infop->fh)) {
                return (FALSE);
            }
        }
        dp = nextdp(dp);
        infop++;
        nents--;
    }

    if (!xdr_bool(xdrs, &false))
        return (FALSE);
    if (!xdr_bool(xdrs, &objp->reply.eof))
        return (FALSE);
    return (TRUE);
}

bool_t
xdr_READDIRPLUS3res(XDR *xdrs, READDIRPLUS3res *objp)
{
    READDIRPLUS3resok *resokp;

    /*
     * ENCODE or FREE only
     */
    if (xdrs->x_op == XDR_DECODE)
        return (FALSE);

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    switch (objp->status) {
    case NFS3_OK:
        /* xdr_READDIRPLUS3resok */
        resokp = &objp->resok;
        if (!xdr_post_op_attr(xdrs, &resokp->dir_attributes))
            return (FALSE);
        /*
         * cookieverf is really an opaque 8 byte
         * quantity, but we will treat it as a
         * hyper for efficiency, the cost of
         * a byteswap here saves bcopys elsewhere
         */
        if (!xdr_u_longlong_t(xdrs, &resokp->cookieverf))
            return (FALSE);
        if (xdrs->x_op == XDR_ENCODE) {
            if (!xdr_putdirpluslist(xdrs, resokp))
                return (FALSE);
        }
        break;
    default:
        return (xdr_post_op_attr(xdrs, &objp->resfail.dir_attributes));
    }
    return (TRUE);
}

/*
 * Decode readdirplus directly into a dirent64_t and do the DNLC caching.
 */
bool_t
xdr_READDIRPLUS3vres(XDR *xdrs, READDIRPLUS3vres *objp)
{
    dirent64_t *dp;
    vnode_t *dvp;
    uint_t entries_size;
    int outcount = 0;
    vnode_t *nvp;
    rnode_t *rp;
    post_op_vattr pov;
    vattr_t va;

    /*
     * DECODE or FREE only
     */
    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    if (xdrs->x_op != XDR_DECODE)
        return (FALSE);

    if (!XDR_GETINT32(xdrs, (int32_t *)&objp->status))
        return (FALSE);

    if (!xdr_post_op_vattr(xdrs, &objp->dir_attributes))
        return (FALSE);

    if (objp->status != NFS3_OK)
        return (TRUE);

    /*
     * cookieverf is really an opaque 8 byte
     * quantity, but we will treat it as a
     * hyper for efficiency, the cost of
     * a byteswap here saves bcopys elsewhere
     */
    if (!xdr_u_longlong_t(xdrs, &objp->cookieverf))
        return (FALSE);

    dvp = objp->dir_attributes.fres.vp;
    rp = VTOR(dvp);

    pov.fres.vap = &va;
    pov.fres.vp = dvp;

    entries_size = objp->entries_size;
    dp = objp->entries;

    for (;;) {
        uint_t this_reclen;
        bool_t valid;
        uint_t namlen;
        nfs_fh3 fh;
        int va_valid;
        int fh_valid;
        ino64_t fileid;

        if (!XDR_GETINT32(xdrs, (int32_t *)&valid))
            return (FALSE);
        if (!valid) {
            /*
             * We have run out of entries, decode eof.
             */
            if (!XDR_GETINT32(xdrs, (int32_t *)&objp->eof))
                return (FALSE);

            break;
        }

        /*
         * fileid3 fileid
         */
        if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&fileid))
            return (FALSE);

        /*
         * filename3 name
         */
        if (!XDR_GETINT32(xdrs, (int32_t *)&namlen))
            return (FALSE);
        this_reclen = DIRENT64_RECLEN(namlen);

        /*
         * If this will overflow buffer, stop decoding
         */
        if ((outcount + this_reclen) > entries_size) {
            objp->eof = FALSE;
            break;
        }
        dp->d_reclen = this_reclen;
        dp->d_ino = fileid;

        if (!xdr_opaque(xdrs, dp->d_name, namlen))
            return (FALSE);
        bzero(&dp->d_name[namlen],
            DIRENT64_NAMELEN(this_reclen) - namlen);

        /*
         * cookie3 cookie
         */
        if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&dp->d_off))
            return (FALSE);
        objp->loff = dp->d_off;

        /*
         * post_op_attr name_attributes
         */
        if (!xdr_post_op_vattr(xdrs, &pov))
            return (FALSE);

        if (pov.attributes == TRUE &&
            pov.fres.status == NFS3_OK)
            va_valid = TRUE;
        else
            va_valid = FALSE;

        /*
         * post_op_fh3 name_handle
         */
        if (!XDR_GETINT32(xdrs, (int32_t *)&fh_valid))
            return (FALSE);

        /*
         * By definition of the standard fh_valid can be 0 (FALSE) or
         * 1 (TRUE), but we have to account for it being anything else
         * in case some other system didn't follow the standard.  Note
         * that this is why the else checks if the fh_valid variable
         * is != FALSE.
         */
        if (fh_valid == TRUE) {
            if (!xdr_nfs_fh3(xdrs, &fh))
                return (FALSE);
        } else {
            if (fh_valid != FALSE)
                return (FALSE);
        }

        /*
         * If the name is "." or there are no attributes,
         * don't polute the DNLC with "." entries or files
         * we cannot determine the type for.
         */
        if (!(namlen == 1 && dp->d_name[0] == '.') &&
            va_valid && fh_valid) {

            /*
             * Do the DNLC caching
             */
            nvp = makenfs3node_va(&fh, &va, dvp->v_vfsp,
                objp->time, objp->credentials,
                rp->r_path, dp->d_name);
            dnlc_update(dvp, dp->d_name, nvp);
            VN_RELE(nvp);
        }

        outcount += this_reclen;
        dp = (dirent64_t *)((intptr_t)dp + this_reclen);
    }

    objp->size = outcount;
    return (TRUE);
}

bool_t
xdr_FSSTAT3res(XDR *xdrs, FSSTAT3res *objp)
{
    FSSTAT3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    if (objp->status != NFS3_OK)
        return (xdr_post_op_attr(xdrs, &objp->resfail.obj_attributes));

    /* xdr_FSSTAT3resok */
    resokp = &objp->resok;
    if (!xdr_post_op_attr(xdrs, &resokp->obj_attributes))
        return (FALSE);
    if (!xdr_u_longlong_t(xdrs, &resokp->tbytes))
        return (FALSE);
    if (!xdr_u_longlong_t(xdrs, &resokp->fbytes))
        return (FALSE);
    if (!xdr_u_longlong_t(xdrs, &resokp->abytes))
        return (FALSE);
    if (!xdr_u_longlong_t(xdrs, &resokp->tfiles))
        return (FALSE);
    if (!xdr_u_longlong_t(xdrs, &resokp->ffiles))
        return (FALSE);
    if (!xdr_u_longlong_t(xdrs, &resokp->afiles))
        return (FALSE);
    return (xdr_u_int(xdrs, &resokp->invarsec));
}

bool_t
xdr_FSINFO3res(XDR *xdrs, FSINFO3res *objp)
{
    FSINFO3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    if (objp->status != NFS3_OK) /* xdr_FSSTAT3resfail */
        return (xdr_post_op_attr(xdrs, &objp->resfail.obj_attributes));

    /* xdr_FSINFO3resok */
    resokp = &objp->resok;
    if (!xdr_post_op_attr(xdrs, &resokp->obj_attributes))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->rtmax))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->rtpref))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->rtmult))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->wtmax))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->wtpref))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->wtmult))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->dtpref))
        return (FALSE);
    if (!xdr_u_longlong_t(xdrs, &resokp->maxfilesize))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->time_delta.seconds))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->time_delta.nseconds))
        return (FALSE);
    return (xdr_u_int(xdrs, &resokp->properties));
}

bool_t
xdr_PATHCONF3res(XDR *xdrs, PATHCONF3res *objp)
{
    PATHCONF3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    if (objp->status != NFS3_OK)
        return (xdr_post_op_attr(xdrs, &objp->resfail.obj_attributes));

    /* xdr_PATHCONF3resok */
    resokp = &objp->resok;
    if (!xdr_post_op_attr(xdrs, &resokp->obj_attributes))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->info.link_max))
        return (FALSE);
    if (!xdr_u_int(xdrs, &resokp->info.name_max))
        return (FALSE);
    if (!xdr_bool(xdrs, &resokp->info.no_trunc))
        return (FALSE);
    if (!xdr_bool(xdrs, &resokp->info.chown_restricted))
        return (FALSE);
    if (!xdr_bool(xdrs, &resokp->info.case_insensitive))
        return (FALSE);
    return (xdr_bool(xdrs, &resokp->info.case_preserving));
}

bool_t
xdr_COMMIT3args(XDR *xdrs, COMMIT3args *objp)
{
    if (xdrs->x_op == XDR_FREE)
        return (TRUE);

    switch (xdrs->x_op) {
    case XDR_FREE:
    case XDR_ENCODE:
        if (!xdr_nfs_fh3(xdrs, &objp->file))
            return (FALSE);
        break;
    case XDR_DECODE:
        if (!xdr_nfs_fh3_server(xdrs, &objp->file))
            return (FALSE);
        break;
    }
    if (!xdr_u_longlong_t(xdrs, &objp->offset))
        return (FALSE);
    return (xdr_u_int(xdrs, &objp->count));
}

bool_t
xdr_COMMIT3res(XDR *xdrs, COMMIT3res *objp)
{
    COMMIT3resok *resokp;

    if (!xdr_enum(xdrs, (enum_t *)&objp->status))
        return (FALSE);
    if (objp->status != NFS3_OK)
        return (xdr_wcc_data(xdrs, &objp->resfail.file_wcc));

    /* xdr_COMMIT3resok */
    resokp = &objp->resok;
    if (!xdr_wcc_data(xdrs, &resokp->file_wcc))
        return (FALSE);
    /*
     * writeverf3 is really an opaque 8 byte
     * quantity, but we will treat it as a
     * hyper for efficiency, the cost of
     * a byteswap here saves bcopys elsewhere
     */
    return (xdr_u_longlong_t(xdrs, &resokp->verf));
}