/*
 * 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 2009 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 */

#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/sdt.h>

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

#include <nfs/nfs.h>

#include <vm/hat.h>
#include <vm/as.h>
#include <vm/seg.h>
#include <vm/seg_map.h>
#include <vm/seg_kmem.h>

static bool_t xdr_fastshorten(XDR *, uint_t);

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

/*
 * File access handle
 * The fhandle struct is treated a opaque data on the wire
 */
bool_t
xdr_fhandle(XDR *xdrs, fhandle_t *fh)
{
        int32_t *ptr;
        int32_t *fhp;

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

        ptr = XDR_INLINE(xdrs, RNDUP(sizeof (fhandle_t)));
        if (ptr != NULL) {
                fhp = (int32_t *)fh;
                if (xdrs->x_op == XDR_DECODE) {
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp = *ptr;
                } else {
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr = *fhp;
                }
                return (TRUE);
        }

        return (xdr_opaque(xdrs, (caddr_t)fh, NFS_FHSIZE));
}

bool_t
xdr_fastfhandle(XDR *xdrs, fhandle_t **fh)
{
        int32_t *ptr;

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

        ptr = XDR_INLINE(xdrs, RNDUP(sizeof (fhandle_t)));
        if (ptr != NULL) {
                *fh = (fhandle_t *)ptr;
                return (TRUE);
        }

        return (FALSE);
}

/*
 * Arguments to remote write and writecache
 */
bool_t
xdr_writeargs(XDR *xdrs, struct nfswriteargs *wa)
{
        int32_t *ptr;
        int32_t *fhp;

        switch (xdrs->x_op) {
        case XDR_DECODE:
                wa->wa_args = &wa->wa_args_buf;
                ptr = XDR_INLINE(xdrs, RNDUP(sizeof (fhandle_t)) +
                    3 * BYTES_PER_XDR_UNIT);
                if (ptr != NULL) {
                        fhp = (int32_t *)&wa->wa_fhandle;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp = *ptr++;
                        wa->wa_begoff = IXDR_GET_U_INT32(ptr);
                        wa->wa_offset = IXDR_GET_U_INT32(ptr);
                        wa->wa_totcount = IXDR_GET_U_INT32(ptr);
                        wa->wa_mblk = NULL;
                        wa->wa_data = NULL;
                        wa->wa_rlist = NULL;
                        wa->wa_conn = NULL;
                        if (xdrs->x_ops == &xdrmblk_ops) {
                                return (xdrmblk_getmblk(xdrs, &wa->wa_mblk,
                                    &wa->wa_count));
                        } else {
                                if (xdrs->x_ops == &xdrrdmablk_ops) {
                                        if (xdrrdma_getrdmablk(xdrs,
                                            &wa->wa_rlist,
                                            &wa->wa_count,
                                            &wa->wa_conn,
                                            NFS_MAXDATA) == TRUE)
                                        return (xdrrdma_read_from_client(
                                            wa->wa_rlist,
                                            &wa->wa_conn,
                                            wa->wa_count));

                                        wa->wa_rlist = NULL;
                                        wa->wa_conn = NULL;
                                }
                        }

                        /*
                         * It is just as efficient to xdr_bytes
                         * an array of unknown length as to inline copy it.
                         */
                        return (xdr_bytes(xdrs, &wa->wa_data,
                            &wa->wa_count, NFS_MAXDATA));
                }
                if (xdr_fhandle(xdrs, &wa->wa_fhandle) &&
                    xdr_u_int(xdrs, &wa->wa_begoff) &&
                    xdr_u_int(xdrs, &wa->wa_offset) &&
                    xdr_u_int(xdrs, &wa->wa_totcount)) {
                        /* deal with the variety of data transfer types */

                        wa->wa_mblk = NULL;
                        wa->wa_data = NULL;
                        wa->wa_rlist = NULL;
                        wa->wa_conn = NULL;

                        if (xdrs->x_ops == &xdrmblk_ops) {
                                if (xdrmblk_getmblk(xdrs, &wa->wa_mblk,
                                    &wa->wa_count) == TRUE)
                                        return (TRUE);
                        } else {
                                if (xdrs->x_ops == &xdrrdmablk_ops) {
                                        if (xdrrdma_getrdmablk(xdrs,
                                            &wa->wa_rlist,
                                            &wa->wa_count,
                                            &wa->wa_conn,
                                            NFS_MAXDATA) == TRUE)
                                        return (xdrrdma_read_from_client(
                                            wa->wa_rlist,
                                            &wa->wa_conn,
                                            wa->wa_count));

                                        wa->wa_rlist = NULL;
                                        wa->wa_conn = NULL;
                                }
                        }
                        return (xdr_bytes(xdrs, &wa->wa_data,
                            &wa->wa_count, NFS_MAXDATA));
                }
                return (FALSE);
        case XDR_ENCODE:
                ptr = XDR_INLINE(xdrs, RNDUP(sizeof (fhandle_t)) +
                    3 * BYTES_PER_XDR_UNIT);
                if (ptr != NULL) {
                        fhp = (int32_t *)&wa->wa_fhandle;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp;
                        IXDR_PUT_U_INT32(ptr, wa->wa_begoff);
                        IXDR_PUT_U_INT32(ptr, wa->wa_offset);
                        IXDR_PUT_U_INT32(ptr, wa->wa_totcount);
                } else {
                        if (!(xdr_fhandle(xdrs, &wa->wa_fhandle) &&
                            xdr_u_int(xdrs, &wa->wa_begoff) &&
                            xdr_u_int(xdrs, &wa->wa_offset) &&
                            xdr_u_int(xdrs, &wa->wa_totcount)))
                                return (FALSE);
                }

                return (xdr_bytes(xdrs, &wa->wa_data, &wa->wa_count,
                    NFS_MAXDATA));
        case XDR_FREE:
                if (wa->wa_rlist) {
                        (void) xdrrdma_free_clist(wa->wa_conn, wa->wa_rlist);
                        wa->wa_rlist = NULL;
                }

                if (wa->wa_data != NULL) {
                        kmem_free(wa->wa_data, wa->wa_count);
                        wa->wa_data = NULL;
                }
                return (TRUE);
        }
        return (FALSE);
}


/*
 * File attributes
 */
bool_t
xdr_fattr(XDR *xdrs, struct nfsfattr *na)
{
        int32_t *ptr;

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

        ptr = XDR_INLINE(xdrs, 17 * BYTES_PER_XDR_UNIT);
        if (ptr != NULL) {
                if (xdrs->x_op == XDR_DECODE) {
                        na->na_type = IXDR_GET_ENUM(ptr, enum nfsftype);
                        na->na_mode = IXDR_GET_U_INT32(ptr);
                        na->na_nlink = IXDR_GET_U_INT32(ptr);
                        na->na_uid = IXDR_GET_U_INT32(ptr);
                        na->na_gid = IXDR_GET_U_INT32(ptr);
                        na->na_size = IXDR_GET_U_INT32(ptr);
                        na->na_blocksize = IXDR_GET_U_INT32(ptr);
                        na->na_rdev = IXDR_GET_U_INT32(ptr);
                        na->na_blocks = IXDR_GET_U_INT32(ptr);
                        na->na_fsid = IXDR_GET_U_INT32(ptr);
                        na->na_nodeid = IXDR_GET_U_INT32(ptr);
                        na->na_atime.tv_sec = IXDR_GET_U_INT32(ptr);
                        na->na_atime.tv_usec = IXDR_GET_U_INT32(ptr);
                        na->na_mtime.tv_sec = IXDR_GET_U_INT32(ptr);
                        na->na_mtime.tv_usec = IXDR_GET_U_INT32(ptr);
                        na->na_ctime.tv_sec = IXDR_GET_U_INT32(ptr);
                        na->na_ctime.tv_usec = IXDR_GET_U_INT32(ptr);
                } else {
                        IXDR_PUT_ENUM(ptr, na->na_type);
                        IXDR_PUT_U_INT32(ptr, na->na_mode);
                        IXDR_PUT_U_INT32(ptr, na->na_nlink);
                        IXDR_PUT_U_INT32(ptr, na->na_uid);
                        IXDR_PUT_U_INT32(ptr, na->na_gid);
                        IXDR_PUT_U_INT32(ptr, na->na_size);
                        IXDR_PUT_U_INT32(ptr, na->na_blocksize);
                        IXDR_PUT_U_INT32(ptr, na->na_rdev);
                        IXDR_PUT_U_INT32(ptr, na->na_blocks);
                        IXDR_PUT_U_INT32(ptr, na->na_fsid);
                        IXDR_PUT_U_INT32(ptr, na->na_nodeid);
                        IXDR_PUT_U_INT32(ptr, na->na_atime.tv_sec);
                        IXDR_PUT_U_INT32(ptr, na->na_atime.tv_usec);
                        IXDR_PUT_U_INT32(ptr, na->na_mtime.tv_sec);
                        IXDR_PUT_U_INT32(ptr, na->na_mtime.tv_usec);
                        IXDR_PUT_U_INT32(ptr, na->na_ctime.tv_sec);
                        IXDR_PUT_U_INT32(ptr, na->na_ctime.tv_usec);
                }
                return (TRUE);
        }

        if (xdr_enum(xdrs, (enum_t *)&na->na_type) &&
            xdr_u_int(xdrs, &na->na_mode) &&
            xdr_u_int(xdrs, &na->na_nlink) &&
            xdr_u_int(xdrs, &na->na_uid) &&
            xdr_u_int(xdrs, &na->na_gid) &&
            xdr_u_int(xdrs, &na->na_size) &&
            xdr_u_int(xdrs, &na->na_blocksize) &&
            xdr_u_int(xdrs, &na->na_rdev) &&
            xdr_u_int(xdrs, &na->na_blocks) &&
            xdr_u_int(xdrs, &na->na_fsid) &&
            xdr_u_int(xdrs, &na->na_nodeid) &&
            xdr_nfs2_timeval(xdrs, &na->na_atime) &&
            xdr_nfs2_timeval(xdrs, &na->na_mtime) &&
            xdr_nfs2_timeval(xdrs, &na->na_ctime)) {
                return (TRUE);
        }
        return (FALSE);
}

#ifdef _LITTLE_ENDIAN
bool_t
xdr_fastfattr(XDR *xdrs, struct nfsfattr *na)
{
        if (xdrs->x_op == XDR_FREE)
                return (TRUE);
        if (xdrs->x_op == XDR_DECODE)
                return (FALSE);

        na->na_type = htonl(na->na_type);
        na->na_mode = htonl(na->na_mode);
        na->na_nlink = htonl(na->na_nlink);
        na->na_uid = htonl(na->na_uid);
        na->na_gid = htonl(na->na_gid);
        na->na_size = htonl(na->na_size);
        na->na_blocksize = htonl(na->na_blocksize);
        na->na_rdev = htonl(na->na_rdev);
        na->na_blocks = htonl(na->na_blocks);
        na->na_fsid = htonl(na->na_fsid);
        na->na_nodeid = htonl(na->na_nodeid);
        na->na_atime.tv_sec = htonl(na->na_atime.tv_sec);
        na->na_atime.tv_usec = htonl(na->na_atime.tv_usec);
        na->na_mtime.tv_sec = htonl(na->na_mtime.tv_sec);
        na->na_mtime.tv_usec = htonl(na->na_mtime.tv_usec);
        na->na_ctime.tv_sec = htonl(na->na_ctime.tv_sec);
        na->na_ctime.tv_usec = htonl(na->na_ctime.tv_usec);
        return (TRUE);
}
#endif

bool_t
xdr_readlink(XDR *xdrs, fhandle_t *fh)
{
        rdma_chunkinfo_t rci;
        struct xdr_ops *xops = xdrrdma_xops();

        if (xdr_fhandle(xdrs, fh)) {
                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);
                }

                return (TRUE);
        }
        return (FALSE);
}

/*
 * Arguments to remote read
 */
bool_t
xdr_readargs(XDR *xdrs, struct nfsreadargs *ra)
{
        int32_t *ptr;
        int32_t *fhp;
        rdma_chunkinfo_t rci;
        rdma_wlist_conn_info_t rwci;
        struct xdr_ops *xops = xdrrdma_xops();

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

        ptr = XDR_INLINE(xdrs,
            RNDUP(sizeof (fhandle_t)) + 3 * BYTES_PER_XDR_UNIT);
        if (ptr != NULL) {
                if (xdrs->x_op == XDR_DECODE) {
                        fhp = (int32_t *)&ra->ra_fhandle;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp = *ptr++;
                        ra->ra_offset = IXDR_GET_INT32(ptr);
                        ra->ra_count = IXDR_GET_INT32(ptr);
                        ra->ra_totcount = IXDR_GET_INT32(ptr);
                } else {
                        fhp = (int32_t *)&ra->ra_fhandle;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp;
                        IXDR_PUT_INT32(ptr, ra->ra_offset);
                        IXDR_PUT_INT32(ptr, ra->ra_count);
                        IXDR_PUT_INT32(ptr, ra->ra_totcount);
                }
        } else {
                if (!xdr_fhandle(xdrs, &ra->ra_fhandle) ||
                    !xdr_u_int(xdrs, &ra->ra_offset) ||
                    !xdr_u_int(xdrs, &ra->ra_count) ||
                    !xdr_u_int(xdrs, &ra->ra_totcount)) {
                        return (FALSE);
                }
        }

        if (ra->ra_count > NFS_MAXDATA)
                return (FALSE);

        ra->ra_wlist = NULL;
        ra->ra_conn = NULL;

        /* If this is xdrrdma_sizeof, record the expect response size */
        if (xdrs->x_ops == xops && xdrs->x_op == XDR_ENCODE) {
                rci.rci_type = RCI_WRITE_ADDR_CHUNK;
                rci.rci_len = ra->ra_count;
                (void) XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
        }
        /* Nothing special to do, return */
        if (xdrs->x_ops != &xdrrdma_ops || xdrs->x_op == XDR_FREE)
                return (TRUE);

        if (xdrs->x_op == XDR_ENCODE) {
                /* Place the target data location into the RDMA header */
                rci.rci_type = RCI_WRITE_ADDR_CHUNK;
                rci.rci_a.rci_addr = ra->ra_data;
                rci.rci_len = ra->ra_count;
                rci.rci_clpp = &ra->ra_wlist;

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

        /* XDR_DECODE case */
        (void) XDR_CONTROL(xdrs, XDR_RDMA_GET_WCINFO, &rwci);
        ra->ra_wlist = rwci.rwci_wlist;
        ra->ra_conn = rwci.rwci_conn;

        return (TRUE);
}


/*
 * Status OK portion of remote read reply
 */
bool_t
xdr_rrok(XDR *xdrs, struct nfsrrok *rrok)
{
        bool_t ret;
        mblk_t *mp;
        struct xdr_ops *xops = xdrrdma_xops();

        if (xdr_fattr(xdrs, &rrok->rrok_attr) == FALSE)
                return (FALSE);

        /* deal with RDMA separately */
        if (xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) {
                if (xdrs->x_op == XDR_ENCODE &&
                    rrok->rrok_mp != NULL) {
                        ret = xdr_bytes(xdrs, (char **)&rrok->rrok_data,
                            &rrok->rrok_count, NFS_MAXDATA);
                        return (ret);
                }

                if (xdrs->x_op == XDR_ENCODE) {
                        if (xdr_u_int(xdrs, &rrok->rrok_count) == FALSE) {
                                return (FALSE);
                        }
                        /*
                         * If read data sent by wlist (RDMA_WRITE), don't do
                         * xdr_bytes() below.   RDMA_WRITE transfers the data.
                         */
                        if (rrok->rrok_wlist) {
                                if (rrok->rrok_count != 0) {
                                        return (xdrrdma_send_read_data(
                                            xdrs, rrok->rrok_count,
                                            rrok->rrok_wlist));
                                }
                                return (TRUE);
                        }
                        if (rrok->rrok_count == 0) {
                                return (TRUE);
                        }
                } else {
                        struct clist *cl;
                        uint32_t count;

                        XDR_CONTROL(xdrs, XDR_RDMA_GET_WLIST, &cl);

                        if (cl) {
                                if (!xdr_u_int(xdrs, &count))
                                        return (FALSE);
                                if (count == 0) {
                                        rrok->rrok_wlist_len = 0;
                                        rrok->rrok_count = 0;
                                } else {
                                        rrok->rrok_wlist_len = clist_len(cl);
                                        if (rrok->rrok_wlist_len !=
                                            roundup(count,
                                            BYTES_PER_XDR_UNIT)) {
                                                rrok->rrok_wlist_len = 0;
                                                rrok->rrok_count = 0;
                                                return (FALSE);
                                        }
                                        rrok->rrok_count = count;
                                }
                                return (TRUE);
                        }
                }
                ret = xdr_bytes(xdrs, (char **)&rrok->rrok_data,
                    &rrok->rrok_count, NFS_MAXDATA);

                return (ret);
        }

        if (xdrs->x_op == XDR_ENCODE) {
                int i, rndup;

                mp = rrok->rrok_mp;
                if (mp != NULL && xdrs->x_ops == &xdrmblk_ops) {
                        mp->b_wptr += rrok->rrok_count;
                        rndup = BYTES_PER_XDR_UNIT -
                            (rrok->rrok_count % BYTES_PER_XDR_UNIT);
                        if (rndup != BYTES_PER_XDR_UNIT)
                                for (i = 0; i < rndup; i++)
                                        *mp->b_wptr++ = '\0';
                        if (xdrmblk_putmblk(xdrs, mp,
                            rrok->rrok_count) == TRUE) {
                                rrok->rrok_mp = NULL;
                                return (TRUE);
                        }
                }

                /*
                 * Fall thru for the xdr_bytes()
                 *
                 * Note: the mblk mp will be freed in rfs_rdfree
                 */
        }

        ret = xdr_bytes(xdrs, (char **)&rrok->rrok_data,
            &rrok->rrok_count, NFS_MAXDATA);

        return (ret);
}

static struct xdr_discrim rdres_discrim[2] = {
        { NFS_OK, xdr_rrok },
        { __dontcare__, NULL_xdrproc_t }
};

/*
 * Reply from remote read
 */
bool_t
xdr_rdresult(XDR *xdrs, struct nfsrdresult *rr)
{
        return (xdr_union(xdrs, (enum_t *)&(rr->rr_status),
            (caddr_t)&(rr->rr_ok), rdres_discrim, xdr_void));
}

/*
 * File attributes which can be set
 */
bool_t
xdr_sattr(XDR *xdrs, struct nfssattr *sa)
{
        if (xdr_u_int(xdrs, &sa->sa_mode) &&
            xdr_u_int(xdrs, &sa->sa_uid) &&
            xdr_u_int(xdrs, &sa->sa_gid) &&
            xdr_u_int(xdrs, &sa->sa_size) &&
            xdr_nfs2_timeval(xdrs, &sa->sa_atime) &&
            xdr_nfs2_timeval(xdrs, &sa->sa_mtime)) {
                return (TRUE);
        }
        return (FALSE);
}

static struct xdr_discrim attrstat_discrim[2] = {
        { (int)NFS_OK, xdr_fattr },
        { __dontcare__, NULL_xdrproc_t }
};

/*
 * Reply status with file attributes
 */
bool_t
xdr_attrstat(XDR *xdrs, struct nfsattrstat *ns)
{
        return (xdr_union(xdrs, (enum_t *)&(ns->ns_status),
            (caddr_t)&(ns->ns_attr), attrstat_discrim, xdr_void));
}

/*
 * Fast reply status with file attributes
 */
bool_t
xdr_fastattrstat(XDR *xdrs, struct nfsattrstat *ns)
{
#if defined(_LITTLE_ENDIAN)
        /*
         * we deal with the discriminator;  it's an enum
         */
        if (!xdr_fastenum(xdrs, (enum_t *)&ns->ns_status))
                return (FALSE);

        if (ns->ns_status == NFS_OK)
                return (xdr_fastfattr(xdrs, &ns->ns_attr));
#elif defined(_BIG_ENDIAN)
        if (ns->ns_status == NFS_OK)
                return (TRUE);
#endif
        return (xdr_fastshorten(xdrs, sizeof (*ns)));
}

/*
 * NFS_OK part of read sym link reply union
 */
bool_t
xdr_srok(XDR *xdrs, struct nfssrok *srok)
{
        /*
         * It is just as efficient to xdr_bytes
         * an array of unknown length as to inline copy it.
         */
        return (xdr_bytes(xdrs, &srok->srok_data, &srok->srok_count,
            NFS_MAXPATHLEN));
}

static struct xdr_discrim rdlnres_discrim[2] = {
        { (int)NFS_OK, xdr_srok },
        { __dontcare__, NULL_xdrproc_t }
};

/*
 * Result of reading symbolic link
 */
bool_t
xdr_rdlnres(XDR *xdrs, struct nfsrdlnres *rl)
{
        return (xdr_union(xdrs, (enum_t *)&(rl->rl_status),
            (caddr_t)&(rl->rl_srok), rdlnres_discrim, xdr_void));
}

/*
 * Arguments to readdir
 */
bool_t
xdr_rddirargs(XDR *xdrs, struct nfsrddirargs *rda)
{
        int32_t *ptr;
        int32_t *fhp;
        rdma_chunkinfo_t rci;
        struct xdr_ops *xops = xdrrdma_xops();

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

        ptr = XDR_INLINE(xdrs,
            RNDUP(sizeof (fhandle_t)) + 2 * BYTES_PER_XDR_UNIT);

        if ((xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) &&
            xdrs->x_op == XDR_ENCODE) {
                rci.rci_type = RCI_REPLY_CHUNK;
                rci.rci_len = rda->rda_count;
                XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
        }

        if (ptr != NULL) {
                if (xdrs->x_op == XDR_DECODE) {
                        fhp = (int32_t *)&rda->rda_fh;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp = *ptr++;
                        rda->rda_offset = IXDR_GET_U_INT32(ptr);
                        rda->rda_count = IXDR_GET_U_INT32(ptr);
                } else {
                        fhp = (int32_t *)&rda->rda_fh;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp;
                        IXDR_PUT_U_INT32(ptr, rda->rda_offset);
                        IXDR_PUT_U_INT32(ptr, rda->rda_count);
                }
                return (TRUE);
        }

        if (xdr_fhandle(xdrs, &rda->rda_fh) &&
            xdr_u_int(xdrs, &rda->rda_offset) &&
            xdr_u_int(xdrs, &rda->rda_count)) {
                return (TRUE);
        }
        return (FALSE);
}


/*
 * Directory read reply:
 * union (enum status) {
 *      NFS_OK: entlist;
 *              boolean eof;
 *      default:
 * }
 *
 * Directory entries
 *      struct  direct {
 *              off_t   d_off;                  * offset of next entry *
 *              u_int   d_fileno;               * inode number of entry *
 *              u_short d_reclen;               * length of this record *
 *              u_short d_namlen;               * length of string in d_name *
 *              char    d_name[MAXNAMLEN + 1];  * name no longer than this *
 *      };
 * are on the wire as:
 * union entlist (boolean valid) {
 *      TRUE:   struct otw_dirent;
 *              u_int nxtoffset;
 *              union entlist;
 *      FALSE:
 * }
 * where otw_dirent is:
 *      struct dirent {
 *              u_int   de_fid;
 *              string  de_name<NFS_MAXNAMELEN>;
 *      }
 */

#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
 */
bool_t
xdr_putrddirres(XDR *xdrs, struct nfsrddirres *rd)
{
        struct dirent64 *dp;
        char *name;
        int size;
        uint_t namlen;
        bool_t true = TRUE;
        bool_t false = FALSE;
        int entrysz;
        int tofit;
        int bufsize;
        uint32_t ino, off;

        if (xdrs->x_op != XDR_ENCODE)
                return (FALSE);
        if (!xdr_enum(xdrs, (enum_t *)&rd->rd_status))
                return (FALSE);
        if (rd->rd_status != NFS_OK)
                return (TRUE);

        bufsize = 1 * BYTES_PER_XDR_UNIT;
        for (size = rd->rd_size, dp = rd->rd_entries;
            size > 0;
            size -= dp->d_reclen, dp = nextdp(dp)) {
                if (dp->d_reclen == 0 /* || DIRSIZ(dp) > dp->d_reclen */)
                        return (FALSE);
                if (dp->d_ino == 0)
                        continue;
                ino = (uint32_t)dp->d_ino; /* for LP64 we clip the bits */
                if (dp->d_ino != (ino64_t)ino)  /* and they better be zeros */
                        return (FALSE);
                off = (uint32_t)dp->d_off;
                name = dp->d_name;
                namlen = (uint_t)strlen(name);
                entrysz = (1 + 1 + 1 + 1) * BYTES_PER_XDR_UNIT +
                    roundup(namlen, BYTES_PER_XDR_UNIT);
                tofit = entrysz + 2 * BYTES_PER_XDR_UNIT;
                if (bufsize + tofit > rd->rd_bufsize) {
                        rd->rd_eof = FALSE;
                        break;
                }
                if (!xdr_bool(xdrs, &true) ||
                    !xdr_u_int(xdrs, &ino) ||
                    !xdr_bytes(xdrs, &name, &namlen, NFS_MAXNAMLEN) ||
                    !xdr_u_int(xdrs, &off)) {
                        return (FALSE);
                }
                bufsize += entrysz;
        }
        if (!xdr_bool(xdrs, &false))
                return (FALSE);
        if (!xdr_bool(xdrs, &rd->rd_eof))
                return (FALSE);
        return (TRUE);
}

/*
 * DECODE ONLY
 */
bool_t
xdr_getrddirres(XDR *xdrs, struct nfsrddirres *rd)
{
        struct dirent64 *dp;
        uint_t namlen;
        int size;
        bool_t valid;
        uint32_t offset;
        uint_t fileid, this_reclen;

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

        if (!xdr_enum(xdrs, (enum_t *)&rd->rd_status))
                return (FALSE);
        if (rd->rd_status != NFS_OK)
                return (TRUE);

        size = rd->rd_size;
        dp = rd->rd_entries;
        offset = rd->rd_offset;
        for (;;) {
                if (!xdr_bool(xdrs, &valid))
                        return (FALSE);
                if (!valid)
                        break;
                if (!xdr_u_int(xdrs, &fileid) ||
                    !xdr_u_int(xdrs, &namlen))
                        return (FALSE);
                this_reclen = DIRENT64_RECLEN(namlen);
                if (this_reclen > size) {
                        rd->rd_eof = FALSE;
                        goto bufovflw;
                }
                if (!xdr_opaque(xdrs, dp->d_name, namlen)||
                    !xdr_u_int(xdrs, &offset)) {
                        return (FALSE);
                }
                bzero(&dp->d_name[namlen],
                    DIRENT64_NAMELEN(this_reclen) - namlen);
                dp->d_ino = (ino64_t)fileid;
                dp->d_reclen = this_reclen;
                dp->d_off = (off64_t)offset;
                size -= dp->d_reclen;
                dp = nextdp(dp);
        }
        if (!xdr_bool(xdrs, &rd->rd_eof))
                return (FALSE);
bufovflw:
        rd->rd_size = (uint32_t)((char *)dp - (char *)(rd->rd_entries));
        rd->rd_offset = offset;
        return (TRUE);
}

/*
 * Arguments for directory operations
 */
bool_t
xdr_diropargs(XDR *xdrs, struct nfsdiropargs *da)
{
        int32_t *ptr;
        int32_t *fhp;
        uint32_t size;
        uint32_t nodesize;
        int i;
        int rndup;
        char *cptr;

        if (xdrs->x_op == XDR_DECODE) {
                da->da_fhandle = &da->da_fhandle_buf;
                ptr = XDR_INLINE(xdrs, RNDUP(sizeof (fhandle_t)) +
                    1 * BYTES_PER_XDR_UNIT);
                if (ptr != NULL) {
                        fhp = (int32_t *)da->da_fhandle;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp = *ptr++;
                        size = IXDR_GET_U_INT32(ptr);
                        if (size > NFS_MAXNAMLEN)
                                return (FALSE);
                        nodesize = size + 1;
                        if (nodesize == 0)
                                return (TRUE);
                        if (da->da_name == NULL) {
                                da->da_name = kmem_alloc(nodesize, KM_NOSLEEP);
                                if (da->da_name == NULL)
                                        return (FALSE);
                                da->da_flags |= DA_FREENAME;
                        }
                        ptr = XDR_INLINE(xdrs, RNDUP(size));
                        if (ptr == NULL) {
                                if (!xdr_opaque(xdrs, da->da_name, size)) {
                                        if (da->da_flags & DA_FREENAME) {
                                                kmem_free(da->da_name,
                                                    nodesize);
                                                da->da_name = NULL;
                                        }
                                        return (FALSE);
                                }
                                da->da_name[size] = '\0';
                                if (strlen(da->da_name) != size) {
                                        if (da->da_flags & DA_FREENAME) {
                                                kmem_free(da->da_name,
                                                    nodesize);
                                                da->da_name = NULL;
                                        }
                                        return (FALSE);
                                }
                                return (TRUE);
                        }
                        bcopy(ptr, da->da_name, size);
                        da->da_name[size] = '\0';
                        if (strlen(da->da_name) != size) {
                                if (da->da_flags & DA_FREENAME) {
                                        kmem_free(da->da_name, nodesize);
                                        da->da_name = NULL;
                                }
                                return (FALSE);
                        }
                        return (TRUE);
                }
                if (da->da_name == NULL)
                        da->da_flags |= DA_FREENAME;
        }

        if (xdrs->x_op == XDR_ENCODE) {
                size = (uint32_t)strlen(da->da_name);
                if (size > NFS_MAXNAMLEN)
                        return (FALSE);
                ptr = XDR_INLINE(xdrs, (int)(RNDUP(sizeof (fhandle_t)) +
                    1 * BYTES_PER_XDR_UNIT + RNDUP(size)));
                if (ptr != NULL) {
                        fhp = (int32_t *)da->da_fhandle;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp;
                        IXDR_PUT_U_INT32(ptr, (uint32_t)size);
                        bcopy(da->da_name, ptr, size);
                        rndup = BYTES_PER_XDR_UNIT -
                            (size % BYTES_PER_XDR_UNIT);
                        if (rndup != BYTES_PER_XDR_UNIT) {
                                cptr = (char *)ptr + size;
                                for (i = 0; i < rndup; i++)
                                        *cptr++ = '\0';
                        }
                        return (TRUE);
                }
        }

        if (xdrs->x_op == XDR_FREE) {
                if (da->da_name == NULL)
                        return (TRUE);
                size = (uint32_t)strlen(da->da_name);
                if (size > NFS_MAXNAMLEN)
                        return (FALSE);
                if (da->da_flags & DA_FREENAME)
                        kmem_free(da->da_name, size + 1);
                da->da_name = NULL;
                return (TRUE);
        }

        if (xdr_fhandle(xdrs, da->da_fhandle) &&
            xdr_string(xdrs, &da->da_name, NFS_MAXNAMLEN)) {
                return (TRUE);
        }
        return (FALSE);
}

/*
 * NFS_OK part of directory operation result
 */
bool_t
xdr_drok(XDR *xdrs, struct nfsdrok *drok)
{
        int32_t *ptr;
        int32_t *fhp;
        struct nfsfattr *na;

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

        ptr = XDR_INLINE(xdrs,
            RNDUP(sizeof (fhandle_t)) + 17 * BYTES_PER_XDR_UNIT);
        if (ptr != NULL) {
                if (xdrs->x_op == XDR_DECODE) {
                        fhp = (int32_t *)&drok->drok_fhandle;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp++ = *ptr++;
                        *fhp = *ptr++;
                        na = &drok->drok_attr;
                        na->na_type = IXDR_GET_ENUM(ptr, enum nfsftype);
                        na->na_mode = IXDR_GET_U_INT32(ptr);
                        na->na_nlink = IXDR_GET_U_INT32(ptr);
                        na->na_uid = IXDR_GET_U_INT32(ptr);
                        na->na_gid = IXDR_GET_U_INT32(ptr);
                        na->na_size = IXDR_GET_U_INT32(ptr);
                        na->na_blocksize = IXDR_GET_U_INT32(ptr);
                        na->na_rdev = IXDR_GET_U_INT32(ptr);
                        na->na_blocks = IXDR_GET_U_INT32(ptr);
                        na->na_fsid = IXDR_GET_U_INT32(ptr);
                        na->na_nodeid = IXDR_GET_U_INT32(ptr);
                        na->na_atime.tv_sec = IXDR_GET_U_INT32(ptr);
                        na->na_atime.tv_usec = IXDR_GET_U_INT32(ptr);
                        na->na_mtime.tv_sec = IXDR_GET_U_INT32(ptr);
                        na->na_mtime.tv_usec = IXDR_GET_U_INT32(ptr);
                        na->na_ctime.tv_sec = IXDR_GET_U_INT32(ptr);
                        na->na_ctime.tv_usec = IXDR_GET_U_INT32(ptr);
                } else {
                        fhp = (int32_t *)&drok->drok_fhandle;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp++;
                        *ptr++ = *fhp;
                        na = &drok->drok_attr;
                        IXDR_PUT_ENUM(ptr, na->na_type);
                        IXDR_PUT_U_INT32(ptr, na->na_mode);
                        IXDR_PUT_U_INT32(ptr, na->na_nlink);
                        IXDR_PUT_U_INT32(ptr, na->na_uid);
                        IXDR_PUT_U_INT32(ptr, na->na_gid);
                        IXDR_PUT_U_INT32(ptr, na->na_size);
                        IXDR_PUT_U_INT32(ptr, na->na_blocksize);
                        IXDR_PUT_U_INT32(ptr, na->na_rdev);
                        IXDR_PUT_U_INT32(ptr, na->na_blocks);
                        IXDR_PUT_U_INT32(ptr, na->na_fsid);
                        IXDR_PUT_U_INT32(ptr, na->na_nodeid);
                        IXDR_PUT_U_INT32(ptr, na->na_atime.tv_sec);
                        IXDR_PUT_U_INT32(ptr, na->na_atime.tv_usec);
                        IXDR_PUT_U_INT32(ptr, na->na_mtime.tv_sec);
                        IXDR_PUT_U_INT32(ptr, na->na_mtime.tv_usec);
                        IXDR_PUT_U_INT32(ptr, na->na_ctime.tv_sec);
                        IXDR_PUT_U_INT32(ptr, na->na_ctime.tv_usec);
                }
                return (TRUE);
        }

        if (xdr_fhandle(xdrs, &drok->drok_fhandle) &&
            xdr_fattr(xdrs, &drok->drok_attr)) {
                return (TRUE);
        }
        return (FALSE);
}

#ifdef _LITTLE_ENDIAN
bool_t
xdr_fastdrok(XDR *xdrs, struct nfsdrok *drok)
{
        struct nfsfattr *na;

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

        na = &drok->drok_attr;
        na->na_type = (enum nfsftype)htonl(na->na_type);
        na->na_mode = (uint32_t)htonl(na->na_mode);
        na->na_nlink = (uint32_t)htonl(na->na_nlink);
        na->na_uid = (uint32_t)htonl(na->na_uid);
        na->na_gid = (uint32_t)htonl(na->na_gid);
        na->na_size = (uint32_t)htonl(na->na_size);
        na->na_blocksize = (uint32_t)htonl(na->na_blocksize);
        na->na_rdev = (uint32_t)htonl(na->na_rdev);
        na->na_blocks = (uint32_t)htonl(na->na_blocks);
        na->na_fsid = (uint32_t)htonl(na->na_fsid);
        na->na_nodeid = (uint32_t)htonl(na->na_nodeid);
        na->na_atime.tv_sec = htonl(na->na_atime.tv_sec);
        na->na_atime.tv_usec = htonl(na->na_atime.tv_usec);
        na->na_mtime.tv_sec = htonl(na->na_mtime.tv_sec);
        na->na_mtime.tv_usec = htonl(na->na_mtime.tv_usec);
        na->na_ctime.tv_sec = htonl(na->na_ctime.tv_sec);
        na->na_ctime.tv_usec = htonl(na->na_ctime.tv_usec);
        return (TRUE);
}
#endif

static struct xdr_discrim diropres_discrim[2] = {
        { NFS_OK, xdr_drok },
        { __dontcare__, NULL_xdrproc_t }
};

/*
 * Results from directory operation
 */
bool_t
xdr_diropres(XDR *xdrs, struct nfsdiropres *dr)
{
        return (xdr_union(xdrs, (enum_t *)&(dr->dr_status),
            (caddr_t)&(dr->dr_drok), diropres_discrim, xdr_void));
}

/*
 * Results from directory operation
 */
bool_t
xdr_fastdiropres(XDR *xdrs, struct nfsdiropres *dr)
{
#if defined(_LITTLE_ENDIAN)
        /*
         * we deal with the discriminator;  it's an enum
         */
        if (!xdr_fastenum(xdrs, (enum_t *)&dr->dr_status))
                return (FALSE);

        if (dr->dr_status == NFS_OK)
                return (xdr_fastdrok(xdrs, &dr->dr_drok));
#elif defined(_BIG_ENDIAN)
        if (dr->dr_status == NFS_OK)
                return (TRUE);
#endif
        return (xdr_fastshorten(xdrs, sizeof (*dr)));
}

/*
 * Time Structure, unsigned
 */
bool_t
xdr_nfs2_timeval(XDR *xdrs, struct nfs2_timeval *tv)
{
        if (xdr_u_int(xdrs, &tv->tv_sec) &&
            xdr_u_int(xdrs, &tv->tv_usec))
                return (TRUE);
        return (FALSE);
}

/*
 * arguments to setattr
 */
bool_t
xdr_saargs(XDR *xdrs, struct nfssaargs *argp)
{
        int32_t *ptr;
        int32_t *arg;
        struct nfssattr *sa;

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

        ptr = XDR_INLINE(xdrs,
            RNDUP(sizeof (fhandle_t)) + 8 * BYTES_PER_XDR_UNIT);
        if (ptr != NULL) {
                if (xdrs->x_op == XDR_DECODE) {
                        arg = (int32_t *)&argp->saa_fh;
                        *arg++ = *ptr++;
                        *arg++ = *ptr++;
                        *arg++ = *ptr++;
                        *arg++ = *ptr++;
                        *arg++ = *ptr++;
                        *arg++ = *ptr++;
                        *arg++ = *ptr++;
                        *arg = *ptr++;
                        sa = &argp->saa_sa;
                        sa->sa_mode = IXDR_GET_U_INT32(ptr);
                        sa->sa_uid = IXDR_GET_U_INT32(ptr);
                        sa->sa_gid = IXDR_GET_U_INT32(ptr);
                        sa->sa_size = IXDR_GET_U_INT32(ptr);
                        sa->sa_atime.tv_sec = IXDR_GET_U_INT32(ptr);
                        sa->sa_atime.tv_usec = IXDR_GET_U_INT32(ptr);
                        sa->sa_mtime.tv_sec = IXDR_GET_U_INT32(ptr);
                        sa->sa_mtime.tv_usec = IXDR_GET_U_INT32(ptr);
                } else {
                        arg = (int32_t *)&argp->saa_fh;
                        *ptr++ = *arg++;
                        *ptr++ = *arg++;
                        *ptr++ = *arg++;
                        *ptr++ = *arg++;
                        *ptr++ = *arg++;
                        *ptr++ = *arg++;
                        *ptr++ = *arg++;
                        *ptr++ = *arg;
                        sa = &argp->saa_sa;
                        IXDR_PUT_U_INT32(ptr, sa->sa_mode);
                        IXDR_PUT_U_INT32(ptr, sa->sa_uid);
                        IXDR_PUT_U_INT32(ptr, sa->sa_gid);
                        IXDR_PUT_U_INT32(ptr, sa->sa_size);
                        IXDR_PUT_U_INT32(ptr, sa->sa_atime.tv_sec);
                        IXDR_PUT_U_INT32(ptr, sa->sa_atime.tv_usec);
                        IXDR_PUT_U_INT32(ptr, sa->sa_mtime.tv_sec);
                        IXDR_PUT_U_INT32(ptr, sa->sa_mtime.tv_usec);
                }
                return (TRUE);
        }

        if (xdr_fhandle(xdrs, &argp->saa_fh) &&
            xdr_sattr(xdrs, &argp->saa_sa)) {
                return (TRUE);
        }
        return (FALSE);
}


/*
 * arguments to create and mkdir
 */
bool_t
xdr_creatargs(XDR *xdrs, struct nfscreatargs *argp)
{
        argp->ca_sa = &argp->ca_sa_buf;

        if (xdrs->x_op == XDR_DECODE)
                argp->ca_sa = &argp->ca_sa_buf;
        if (xdr_diropargs(xdrs, &argp->ca_da) &&
            xdr_sattr(xdrs, argp->ca_sa)) {
                return (TRUE);
        }
        return (FALSE);
}

/*
 * arguments to link
 */
bool_t
xdr_linkargs(XDR *xdrs, struct nfslinkargs *argp)
{
        if (xdrs->x_op == XDR_DECODE)
                argp->la_from = &argp->la_from_buf;
        if (xdr_fhandle(xdrs, argp->la_from) &&
            xdr_diropargs(xdrs, &argp->la_to)) {
                return (TRUE);
        }
        return (FALSE);
}

/*
 * arguments to rename
 */
bool_t
xdr_rnmargs(XDR *xdrs, struct nfsrnmargs *argp)
{
        if (xdr_diropargs(xdrs, &argp->rna_from) &&
            xdr_diropargs(xdrs, &argp->rna_to))
                return (TRUE);
        return (FALSE);
}


/*
 * arguments to symlink
 */
bool_t
xdr_slargs(XDR *xdrs, struct nfsslargs *argp)
{
        if (xdrs->x_op == XDR_FREE) {
                if (!xdr_diropargs(xdrs, &argp->sla_from))
                        return (FALSE);
                if ((argp->sla_tnm_flags & SLA_FREETNM) &&
                    !xdr_string(xdrs, &argp->sla_tnm, (uint_t)NFS_MAXPATHLEN))
                        return (FALSE);
                return (TRUE);
        }

        if (xdrs->x_op == XDR_DECODE) {
                argp->sla_sa = &argp->sla_sa_buf;
                if (argp->sla_tnm == NULL)
                        argp->sla_tnm_flags |= SLA_FREETNM;
        }

        if (xdr_diropargs(xdrs, &argp->sla_from) &&
            xdr_string(xdrs, &argp->sla_tnm, (uint_t)NFS_MAXPATHLEN) &&
            xdr_sattr(xdrs, argp->sla_sa)) {
                return (TRUE);
        }
        return (FALSE);
}


/*
 * NFS_OK part of statfs operation
 */
bool_t
xdr_fsok(XDR *xdrs, struct nfsstatfsok *fsok)
{
        int32_t *ptr;

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

        ptr = XDR_INLINE(xdrs, 5 * BYTES_PER_XDR_UNIT);
        if (ptr != NULL) {
                if (xdrs->x_op == XDR_DECODE) {
                        fsok->fsok_tsize = IXDR_GET_INT32(ptr);
                        fsok->fsok_bsize = IXDR_GET_INT32(ptr);
                        fsok->fsok_blocks = IXDR_GET_INT32(ptr);
                        fsok->fsok_bfree = IXDR_GET_INT32(ptr);
                        fsok->fsok_bavail = IXDR_GET_INT32(ptr);
                } else {
                        IXDR_PUT_INT32(ptr, fsok->fsok_tsize);
                        IXDR_PUT_INT32(ptr, fsok->fsok_bsize);
                        IXDR_PUT_INT32(ptr, fsok->fsok_blocks);
                        IXDR_PUT_INT32(ptr, fsok->fsok_bfree);
                        IXDR_PUT_INT32(ptr, fsok->fsok_bavail);
                }
                return (TRUE);
        }

        if (xdr_u_int(xdrs, &fsok->fsok_tsize) &&
            xdr_u_int(xdrs, &fsok->fsok_bsize) &&
            xdr_u_int(xdrs, &fsok->fsok_blocks) &&
            xdr_u_int(xdrs, &fsok->fsok_bfree) &&
            xdr_u_int(xdrs, &fsok->fsok_bavail)) {
                return (TRUE);
        }
        return (FALSE);
}

#ifdef _LITTLE_ENDIAN
bool_t
xdr_fastfsok(XDR *xdrs, struct nfsstatfsok *fsok)
{

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

        fsok->fsok_tsize = htonl(fsok->fsok_tsize);
        fsok->fsok_bsize = htonl(fsok->fsok_bsize);
        fsok->fsok_blocks = htonl(fsok->fsok_blocks);
        fsok->fsok_bfree = htonl(fsok->fsok_bfree);
        fsok->fsok_bavail = htonl(fsok->fsok_bavail);
        return (TRUE);
}
#endif

static struct xdr_discrim statfs_discrim[2] = {
        { NFS_OK, xdr_fsok },
        { __dontcare__, NULL_xdrproc_t }
};

/*
 * Results of statfs operation
 */
bool_t
xdr_statfs(XDR *xdrs, struct nfsstatfs *fs)
{
        return (xdr_union(xdrs, (enum_t *)&(fs->fs_status),
            (caddr_t)&(fs->fs_fsok), statfs_discrim, xdr_void));
}

/*
 * Results of statfs operation
 */
bool_t
xdr_faststatfs(XDR *xdrs, struct nfsstatfs *fs)
{
#if defined(_LITTLE_ENDIAN)
        /*
         * we deal with the discriminator;  it's an enum
         */
        if (!xdr_fastenum(xdrs, (enum_t *)&fs->fs_status))
                return (FALSE);

        if (fs->fs_status == NFS_OK)
                return (xdr_fastfsok(xdrs, &fs->fs_fsok));
#elif defined(_BIG_ENDIAN)
        if (fs->fs_status == NFS_OK)
                return (TRUE);
#endif
        return (xdr_fastshorten(xdrs, sizeof (*fs)));
}

#ifdef _LITTLE_ENDIAN
/*
 * XDR enumerations
 */
#ifndef lint
static enum sizecheck { SIZEVAL } sizecheckvar; /* used to find the size of */
                                                /* an enum */
#endif
bool_t
xdr_fastenum(XDR *xdrs, enum_t *ep)
{
        if (xdrs->x_op == XDR_FREE)
                return (TRUE);
        if (xdrs->x_op == XDR_DECODE)
                return (FALSE);

#ifndef lint
        /*
         * enums are treated as ints
         */
        if (sizeof (sizecheckvar) == sizeof (int32_t)) {
                *ep = (enum_t)htonl((int32_t)(*ep));
        } else if (sizeof (sizecheckvar) == sizeof (short)) {
                *ep = (enum_t)htons((short)(*ep));
        } else {
                return (FALSE);
        }
        return (TRUE);
#else
        (void) (xdr_short(xdrs, (short *)ep));
        return (xdr_int(xdrs, (int *)ep));
#endif
}
#endif

static bool_t
xdr_fastshorten(XDR *xdrs, uint_t ressize)
{
        uint_t curpos;

        curpos = XDR_GETPOS(xdrs);
        ressize -= BYTES_PER_XDR_UNIT;
        curpos -= ressize;
        return (XDR_SETPOS(xdrs, curpos));
}