bool_t
xdr_fhstatus(XDR *xdrs, struct fhstatus *fhsp)
{
if (!xdr_int(xdrs, (int *)&fhsp->fhs_status))
return (FALSE);
if (fhsp->fhs_status == 0) {
return (xdr_fhandle(xdrs, fhsp->fhstatus_u.fhs_fhandle));
}
return (TRUE);
}
bool_t
xdr_nfsreadargs(XDR *xdrs, struct nfsreadargs *ra)
{
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 (TRUE);
}
return (FALSE);
}
bool_t
xdr_fhstatus(XDR *xdrs, fhstatus *objp)
{
if (amuDebug(D_XDRTRACE))
plog(XLOG_DEBUG, "xdr_fhstatus:");
if (!xdr_u_int(xdrs, &objp->fhs_status)) {
return (FALSE);
}
if (objp->fhs_status == 0 && !xdr_fhandle(xdrs, objp->fhs_fh)) {
return (FALSE);
}
return (TRUE);
}
static bool_t xdr_fhstatus(XDR *xdrs, fhstatus *objp)
{
if (!xdr_u_int(xdrs, &objp->fhs_status))
return FALSE;
switch (objp->fhs_status) {
case 0:
if (!xdr_fhandle(xdrs, objp->fhstatus_u.fhs_fhandle))
return FALSE;
break;
default:
break;
}
return TRUE;
}
bool_t
xdr_fhstatus(register XDR *xdrs, fhstatus *objp)
{
if (!xdr_u_int(xdrs, &objp->fhs_status))
return (FALSE);
switch (objp->fhs_status) {
case 0:
if (!xdr_fhandle(xdrs, objp->fhstatus_u.fhs_fhandle))
return (FALSE);
break;
default:
break;
}
return (TRUE);
}
static int
nd_send_data(TIUSER *tiptr, caddr_t addr, int offset, XDR *xdrp, uint32_t *xidp)
{
static struct rpc_msg call_msg;
static uchar_t header[HDR_SIZE];
static struct t_kunitdata sudata;
static uchar_t *dumpbuf;
int procnum;
stable_how stable = FILE_SYNC;
mblk_t *mblk_p;
int error;
int tsize = ptob(1);
uint64 offset3;
if (!dumpbuf) {
call_msg.rm_direction = CALL;
call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
call_msg.rm_call.cb_prog = NFS_PROGRAM;
call_msg.rm_call.cb_vers = nfsdump_version;
if (!(dumpbuf = kmem_alloc(ptob(1), KM_NOSLEEP))) {
cmn_err(CE_WARN, "\tnfs_dump: cannot allocate dump buffer");
return (ENOMEM);
}
}
nd_log("nfs_dump: calling esballoc for header\n");
if (!(mblk_p = esballoc(header, HDR_SIZE, BPRI_HI, &frnop))) {
cmn_err(CE_WARN, "\tnfs_dump: out of mblks");
return (ENOBUFS);
}
xdrmem_create(xdrp, (caddr_t)header, HDR_SIZE, XDR_ENCODE);
call_msg.rm_xid = alloc_xid();
*xidp = call_msg.rm_xid;
if (!xdr_callhdr(xdrp, &call_msg)) {
cmn_err(CE_WARN, "\tnfs_dump: cannot serialize header");
return (EIO);
}
if (nfsdump_maxcount) {
/*
* Do not extend the dump file if it is also
* the swap file.
*/
if (offset >= nfsdump_maxcount) {
cmn_err(CE_WARN, "\tnfs_dump: end of file");
return (EIO);
}
if (offset + tsize > nfsdump_maxcount)
tsize = nfsdump_maxcount - offset;
}
switch (nfsdump_version) {
case NFS_VERSION:
procnum = RFS_WRITE;
if (!XDR_PUTINT32(xdrp, (int32_t *)&procnum) ||
!nd_auth_marshall(xdrp) ||
!xdr_fhandle(xdrp, &nfsdump_fhandle2) ||
/*
* Following four values are:
* beginoffset
* offset
* length
* bytes array length
*/
!XDR_PUTINT32(xdrp, (int32_t *)&offset) ||
!XDR_PUTINT32(xdrp, (int32_t *)&offset) ||
!XDR_PUTINT32(xdrp, (int32_t *)&tsize) ||
!XDR_PUTINT32(xdrp, (int32_t *)&tsize)) {
cmn_err(CE_WARN, "\tnfs_dump: serialization failed");
return (EIO);
}
break;
case NFS_V3:
procnum = NFSPROC3_WRITE;
offset3 = offset;
if (!XDR_PUTINT32(xdrp, (int32_t *)&procnum) ||
!nd_auth_marshall(xdrp) ||
!xdr_nfs_fh3(xdrp, &nfsdump_fhandle3) ||
/*
* Following four values are:
* offset
* count
* stable
* bytes array length
*/
!xdr_u_longlong_t(xdrp, &offset3) ||
!XDR_PUTINT32(xdrp, (int32_t *)&tsize) ||
!XDR_PUTINT32(xdrp, (int32_t *)&stable) ||
!XDR_PUTINT32(xdrp, (int32_t *)&tsize)) {
cmn_err(CE_WARN, "\tnfs_dump: serialization failed");
return (EIO);
}
break;
default:
return (EIO);
}
bcopy(addr, (caddr_t)dumpbuf, tsize);
mblk_p->b_wptr += (int)XDR_GETPOS(xdrp);
mblk_p->b_cont = esballoc((uchar_t *)dumpbuf, ptob(1), BPRI_HI, &frnop);
if (!mblk_p->b_cont) {
cmn_err(CE_WARN, "\tnfs_dump: out of mblks");
return (ENOBUFS);
}
mblk_p->b_cont->b_wptr += ptob(1);
sudata.addr = nfsdump_addr; /* structure copy */
sudata.udata.buf = (char *)NULL;
sudata.udata.maxlen = 0;
sudata.udata.len = 1; /* needed for t_ksndudata */
sudata.udata.udata_mp = mblk_p;
nd_log("nfs_dump: calling t_ksndudata\n");
if (error = t_ksndudata(tiptr, &sudata, (frtn_t *)NULL)) {
nfs_perror(error, "\nnfs_dump: t_ksndudata failed: %m\n");
return (error);
}
return (0);
}
/*
* 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);
}
