callback_xdr.c File Reference

#include "nfs41_callback.h"
#include "nfs41_ops.h"
#include "util.h"
#include "daemon_debug.h"

Include dependency graph for callback_xdr.c:

Go to the source code of this file.

Macros
#define	CBXLVL   2 /* dprintf level for callback xdr logging */
#define	CBX_ERR(msg)   dprintf((CBXLVL), __FUNCTION__ ": failed at " msg "\n")

Functions
bool_t	xdr_bitmap4 (XDR *xdr, bitmap4 *bitmap)
bool_t	xdr_fattr4 (XDR *xdr, fattr4 *fattr)
static bool_t	common_stateid (XDR *xdr, stateid4 *stateid)
static bool_t	common_fh (XDR *xdr, nfs41_fh *fh)
static bool_t	common_fsid (XDR *xdr, nfs41_fsid *fsid)
static bool_t	common_notify4 (XDR *xdr, struct notify4 *notify)
static bool_t	op_cb_layoutrecall_file (XDR *xdr, struct cb_recall_file *args)
static bool_t	op_cb_layoutrecall_fsid (XDR *xdr, union cb_recall_file_args *args)
static bool_t	op_cb_layoutrecall_args (XDR *xdr, struct cb_layoutrecall_args *args)
static bool_t	op_cb_layoutrecall_res (XDR *xdr, struct cb_layoutrecall_res *res)
static bool_t	op_cb_recall_slot_args (XDR *xdr, struct cb_recall_slot_args *res)
static bool_t	op_cb_recall_slot_res (XDR *xdr, struct cb_recall_slot_res *res)
static bool_t	op_cb_sequence_ref (XDR *xdr, struct cb_sequence_ref *args)
static bool_t	op_cb_sequence_ref_list (XDR *xdr, struct cb_sequence_ref_list *args)
static bool_t	op_cb_sequence_args (XDR *xdr, struct cb_sequence_args *args)
static bool_t	op_cb_sequence_res_ok (XDR *xdr, struct cb_sequence_res_ok *res)
static bool_t	op_cb_sequence_res (XDR *xdr, struct cb_sequence_res *res)
static bool_t	op_cb_getattr_args (XDR *xdr, struct cb_getattr_args *args)
static bool_t	info_to_fattr4 (nfs41_file_info *info, fattr4 *fattr)
static bool_t	op_cb_getattr_res (XDR *xdr, struct cb_getattr_res *res)
static bool_t	op_cb_recall_args (XDR *xdr, struct cb_recall_args *args)
static bool_t	op_cb_recall_res (XDR *xdr, struct cb_recall_res *res)
static bool_t	op_cb_notify_args (XDR *xdr, struct cb_notify_args *res)
static bool_t	op_cb_notify_res (XDR *xdr, struct cb_notify_res *res)
static bool_t	op_cb_push_deleg_args (XDR *xdr, struct cb_push_deleg_args *res)
static bool_t	op_cb_push_deleg_res (XDR *xdr, struct cb_push_deleg_res *res)
static bool_t	op_cb_recall_any_args (XDR *xdr, struct cb_recall_any_args *res)
static bool_t	op_cb_recall_any_res (XDR *xdr, struct cb_recall_any_res *res)
static bool_t	op_cb_recallable_obj_avail_args (XDR *xdr, struct cb_recallable_obj_avail_args *res)
static bool_t	op_cb_recallable_obj_avail_res (XDR *xdr, struct cb_recallable_obj_avail_res *res)
static bool_t	op_cb_wants_cancelled_args (XDR *xdr, struct cb_wants_cancelled_args *res)
static bool_t	op_cb_wants_cancelled_res (XDR *xdr, struct cb_wants_cancelled_res *res)
static bool_t	op_cb_notify_lock_args (XDR *xdr, struct cb_notify_lock_args *res)
static bool_t	op_cb_notify_lock_res (XDR *xdr, struct cb_notify_lock_res *res)
static bool_t	cb_notify_deviceid_change (XDR *xdr, struct notify_deviceid4 *change)
static bool_t	cb_notify_deviceid_delete (XDR *xdr, struct notify_deviceid4 *change)
static bool_t	op_cb_notify_deviceid_args (XDR *xdr, struct cb_notify_deviceid_args *args)
static bool_t	op_cb_notify_deviceid_res (XDR *xdr, struct cb_notify_deviceid_res *res)
static bool_t	cb_compound_tag (XDR *xdr, struct cb_compound_tag *args)
static bool_t	cb_compound_argop (XDR *xdr, struct cb_argop *args)
bool_t	proc_cb_compound_args (XDR *xdr, struct cb_compound_args *args)
static bool_t	cb_compound_resop (XDR *xdr, struct cb_resop *res)
bool_t	proc_cb_compound_res (XDR *xdr, struct cb_compound_res *res)

Variables
static const struct xdr_discrim	cb_layoutrecall_discrim []
static const struct xdr_discrim	cb_sequence_res_discrim []
static const struct xdr_discrim	cb_argop_discrim []
static const struct xdr_discrim	cb_resop_discrim []

Macro Definition Documentation

CBX_ERR

#define CBX_ERR

(

msg

)

dprintf((CBXLVL), __FUNCTION__ ": failed at " msg "\n")

Definition at line 32 of file callback_xdr.c.

CBXLVL

#define CBXLVL   2 /* dprintf level for callback xdr logging */

Definition at line 28 of file callback_xdr.c.

Function Documentation

cb_compound_argop()

static bool_t cb_compound_argop ( XDR *  xdr, struct cb_argop *  args  )

static

Definition at line 579 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_union(xdr, &args->opnum, (char*)&args->args,
        cb_argop_discrim, NULL_xdrproc_t);
    if (!result) { CBX_ERR("cmb:argop.args"); goto out; }
out:
    return result;
}

Referenced by proc_cb_compound_args().

cb_compound_resop()

static bool_t cb_compound_resop ( XDR *  xdr, struct cb_resop *  res  )

static

Definition at line 628 of file callback_xdr.c.

{
    /* save xdr encode/decode status to see which operation failed */
    res->xdr_ok = xdr_union(xdr, &res->opnum, (char*)&res->res,
        cb_resop_discrim, NULL_xdrproc_t);
    if (!res->xdr_ok) { CBX_ERR("resop.res"); goto out; }
out:
    return res->xdr_ok;
}

Referenced by proc_cb_compound_res().

cb_compound_tag()

static bool_t cb_compound_tag ( XDR *  xdr, struct cb_compound_tag *  args  )

static

Definition at line 556 of file callback_xdr.c.

{
    return xdr_u_int32_t(xdr, &args->len)
        && args->len <= CB_COMPOUND_MAX_TAG
        && xdr_opaque(xdr, args->str, args->len);
}

cb_notify_deviceid_change()

static bool_t cb_notify_deviceid_change ( XDR *  xdr, struct notify_deviceid4 *  change  )

static

Definition at line 461 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_u_int32_t(xdr, (uint32_t*)&change->layouttype);
    if (!result) { CBX_ERR("notify_deviceid.change.layouttype"); goto out; }
 
    result = xdr_opaque(xdr, (char*)change->deviceid, PNFS_DEVICEID_SIZE);
    if (!result) { CBX_ERR("notify_deviceid.change.deviceid"); goto out; }
 
    result = xdr_bool(xdr, &change->immediate);
    if (!result) { CBX_ERR("notify_deviceid.change.immediate"); goto out; }
out:
    return result;
}

Referenced by op_cb_notify_deviceid_args().

cb_notify_deviceid_delete()

static bool_t cb_notify_deviceid_delete ( XDR *  xdr, struct notify_deviceid4 *  change  )

static

Definition at line 477 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_u_int32_t(xdr, (uint32_t*)&change->layouttype);
    if (!result) { CBX_ERR("notify_deviceid.delete.layouttype"); goto out; }
 
    result = xdr_opaque(xdr, (char*)change->deviceid, PNFS_DEVICEID_SIZE);
    if (!result) { CBX_ERR("notify_deviceid.delete.deviceid"); goto out; }
out:
    return result;
}

Referenced by op_cb_notify_deviceid_args().

common_fh()

static bool_t common_fh ( XDR *  xdr, nfs41_fh *  fh  )

static

Definition at line 45 of file callback_xdr.c.

{
    return xdr_u_int32_t(xdr, &fh->len)
        && fh->len <= NFS4_FHSIZE
        && xdr_opaque(xdr, (char*)fh->fh, fh->len);
}

Referenced by op_cb_getattr_args(), op_cb_layoutrecall_file(), and op_cb_recall_args().

common_fsid()

static bool_t common_fsid ( XDR *  xdr, nfs41_fsid *  fsid  )

static

Definition at line 52 of file callback_xdr.c.

{
    return xdr_u_int64_t(xdr, &fsid->major)
        && xdr_u_int64_t(xdr, &fsid->minor);
}

Referenced by op_cb_layoutrecall_fsid().

common_notify4()

static bool_t common_notify4 ( XDR *  xdr, struct notify4 *  notify  )

static

Definition at line 58 of file callback_xdr.c.

{
    return xdr_bitmap4(xdr, &notify->mask)
        && xdr_bytes(xdr, &notify->list, &notify->len, NFS4_OPAQUE_LIMIT);
}

Referenced by op_cb_notify_deviceid_args().

common_stateid()

static bool_t common_stateid ( XDR *  xdr, stateid4 *  stateid  )

static

Definition at line 39 of file callback_xdr.c.

{
    return xdr_u_int32_t(xdr, &stateid->seqid)
        && xdr_opaque(xdr, (char*)stateid->other, NFS4_STATEID_OTHER);
}

Referenced by op_cb_layoutrecall_file(), and op_cb_recall_args().

info_to_fattr4()

static bool_t info_to_fattr4 ( nfs41_file_info *  info, fattr4 *  fattr  )

static

Definition at line 261 of file callback_xdr.c.

{
    XDR fattr_xdr;
    bool_t result = TRUE;
 
    /* encode nfs41_file_info into fattr4 */
    xdrmem_create(&fattr_xdr, (char*)fattr->attr_vals,
        NFS4_OPAQUE_LIMIT, XDR_ENCODE);
    
    /* The only attributes that the server can reliably
     * query via CB_GETATTR are size and change. */
    if (bitmap_isset(&info->attrmask, 0, FATTR4_WORD0_CHANGE)) {
        result = xdr_u_hyper(&fattr_xdr, &info->change);
        if (!result) { CBX_ERR("getattr.info.change"); goto out; }
        bitmap_set(&fattr->attrmask, 0, FATTR4_WORD0_CHANGE);
    }
    if (bitmap_isset(&info->attrmask, 0, FATTR4_WORD0_SIZE)) {
        result = xdr_u_hyper(&fattr_xdr, &info->size);
        if (!result) { CBX_ERR("getattr.info.size"); goto out; }
        bitmap_set(&fattr->attrmask, 0, FATTR4_WORD0_SIZE);
    }
    fattr->attr_vals_len = xdr_getpos(&fattr_xdr);
out:
    return result;
}

Referenced by op_cb_getattr_res().

op_cb_getattr_args()

static bool_t op_cb_getattr_args ( XDR *  xdr, struct cb_getattr_args *  args  )

static

Definition at line 248 of file callback_xdr.c.

{
    bool_t result;
 
    result = common_fh(xdr, &args->fh);
    if (!result) { CBX_ERR("getattr.fh"); goto out; }
 
    result = xdr_bitmap4(xdr, &args->attr_request);
    if (!result) { CBX_ERR("getattr.attr_request"); goto out; }
out:
    return result;
}

op_cb_getattr_res()

static bool_t op_cb_getattr_res ( XDR *  xdr, struct cb_getattr_res *  res  )

static

Definition at line 287 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("getattr.status"); goto out; }
 
    if (res->status == NFS4_OK) {
        fattr4 fattr = { 0 };
 
        result = info_to_fattr4(&res->info, &fattr);
        if (!result) { goto out; }
 
        result = xdr_fattr4(xdr, &fattr);
        if (!result) { CBX_ERR("getattr.obj_attributes"); goto out; }
    }
out:
    return result;
}

op_cb_layoutrecall_args()

static bool_t op_cb_layoutrecall_args ( XDR *  xdr, struct cb_layoutrecall_args *  args  )

static

Definition at line 101 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, (enum_t*)&args->type);
    if (!result) { CBX_ERR("layoutrecall_args.type"); goto out; }
 
    result = xdr_enum(xdr, (enum_t*)&args->iomode);
    if (!result) { CBX_ERR("layoutrecall_args.iomode"); goto out; }
 
    result = xdr_bool(xdr, &args->changed);
    if (!result) { CBX_ERR("layoutrecall_args.changed"); goto out; }
 
    result = xdr_union(xdr, (enum_t*)&args->recall.type,
        (char*)&args->recall.args, cb_layoutrecall_discrim, NULL_xdrproc_t);
    if (!result) { CBX_ERR("layoutrecall_args.recall"); goto out; }
out:
    return result;
}

op_cb_layoutrecall_file()

static bool_t op_cb_layoutrecall_file ( XDR *  xdr, struct cb_recall_file *  args  )

static

Definition at line 65 of file callback_xdr.c.

{
    bool_t result;
 
    result = common_fh(xdr, &args->fh);
    if (!result) { CBX_ERR("layoutrecall_file.fh"); goto out; }
 
    result = xdr_u_int64_t(xdr, &args->offset);
    if (!result) { CBX_ERR("layoutrecall_file.offset"); goto out; }
 
    result = xdr_u_int64_t(xdr, &args->length);
    if (!result) { CBX_ERR("layoutrecall_file.length"); goto out; }
 
    result = common_stateid(xdr, &args->stateid);
    if (!result) { CBX_ERR("layoutrecall_file.stateid"); goto out; }
out:
    return result;
}

op_cb_layoutrecall_fsid()

static bool_t op_cb_layoutrecall_fsid ( XDR *  xdr, union cb_recall_file_args *  args  )

static

Definition at line 84 of file callback_xdr.c.

{
    bool_t result;
 
    result = common_fsid(xdr, &args->fsid);
    if (!result) { CBX_ERR("layoutrecall_fsid.fsid"); goto out; }
out:
    return result;
}

op_cb_layoutrecall_res()

static bool_t op_cb_layoutrecall_res ( XDR *  xdr, struct cb_layoutrecall_res *  res  )

static

Definition at line 121 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("layoutrecall_res.status"); goto out; }
out:
    return result;
}

op_cb_notify_args()

static bool_t op_cb_notify_args ( XDR *  xdr, struct cb_notify_args *  res  )

static

Definition at line 335 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_u_int32_t(xdr, &res->target_highest_slotid);
    if (!result) { CBX_ERR("notify.target_highest_slotid"); goto out; }
out:
    return result;
}

op_cb_notify_deviceid_args()

static bool_t op_cb_notify_deviceid_args ( XDR *  xdr, struct cb_notify_deviceid_args *  args  )

static

Definition at line 490 of file callback_xdr.c.

{
    XDR notify_xdr;
    uint32_t i, j, c;
    bool_t result;
 
    /* decode the generic notify4 list */
    result = xdr_array(xdr, (char**)&args->notify_list,
        &args->notify_count, CB_COMPOUND_MAX_OPERATIONS,
        sizeof(struct notify4), (xdrproc_t)common_notify4);
    if (!result) { CBX_ERR("notify_deviceid.notify_list"); goto out; }
 
    switch (xdr->x_op) {
    case XDR_FREE:
        free(args->change_list);
    case XDR_ENCODE:
        return TRUE;
    }
 
    /* count the number of device changes */
    args->change_count = 0;
    for (i = 0; i < args->notify_count; i++)
        args->change_count += args->notify_list[i].mask.count;
 
    args->change_list = calloc(args->change_count, sizeof(struct notify_deviceid4));
    if (args->change_list == NULL)
        return FALSE;
 
    c = 0;
    for (i = 0; i < args->notify_count; i++) {
        struct notify4 *notify = &args->notify_list[i];
 
        /* decode the device notifications out of the opaque buffer */
        xdrmem_create(&notify_xdr, notify->list, notify->len, XDR_DECODE);
 
        for (j = 0; j < notify->mask.count; j++) {
            struct notify_deviceid4 *change = &args->change_list[c++];
            change->type = notify->mask.arr[j];
 
            switch (change->type) {
            case NOTIFY_DEVICEID4_CHANGE:
                result = cb_notify_deviceid_change(&notify_xdr, change);
                if (!result) { CBX_ERR("notify_deviceid.change"); goto out; }
                break;
            case NOTIFY_DEVICEID4_DELETE:
                result = cb_notify_deviceid_delete(&notify_xdr, change);
                if (!result) { CBX_ERR("notify_deviceid.delete"); goto out; }
                break;
            }
        }
    }
out:
    return result;
}

op_cb_notify_deviceid_res()

static bool_t op_cb_notify_deviceid_res ( XDR *  xdr, struct cb_notify_deviceid_res *  res  )

static

Definition at line 545 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("notify_deviceid.status"); goto out; }
out:
    return result;
}

op_cb_notify_lock_args()

static bool_t op_cb_notify_lock_args ( XDR *  xdr, struct cb_notify_lock_args *  res  )

static

Definition at line 440 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_u_int32_t(xdr, &res->target_highest_slotid);
    if (!result) { CBX_ERR("notify_lock.target_highest_slotid"); goto out; }
out:
    return result;
}

op_cb_notify_lock_res()

static bool_t op_cb_notify_lock_res ( XDR *  xdr, struct cb_notify_lock_res *  res  )

static

Definition at line 450 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("notify_lock.status"); goto out; }
out:
    return result;
}

op_cb_notify_res()

static bool_t op_cb_notify_res ( XDR *  xdr, struct cb_notify_res *  res  )

static

Definition at line 345 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("notify.status"); goto out; }
out:
    return result;
}

op_cb_push_deleg_args()

static bool_t op_cb_push_deleg_args ( XDR *  xdr, struct cb_push_deleg_args *  res  )

static

Definition at line 356 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_u_int32_t(xdr, &res->target_highest_slotid);
    if (!result) { CBX_ERR("push_deleg.target_highest_slotid"); goto out; }
out:
    return result;
}

op_cb_push_deleg_res()

static bool_t op_cb_push_deleg_res ( XDR *  xdr, struct cb_push_deleg_res *  res  )

static

Definition at line 366 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("push_deleg.status"); goto out; }
out:
    return result;
}

op_cb_recall_any_args()

static bool_t op_cb_recall_any_args ( XDR *  xdr, struct cb_recall_any_args *  res  )

static

Definition at line 377 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_u_int32_t(xdr, &res->target_highest_slotid);
    if (!result) { CBX_ERR("recall_any.target_highest_slotid"); goto out; }
out:
    return result;
}

op_cb_recall_any_res()

static bool_t op_cb_recall_any_res ( XDR *  xdr, struct cb_recall_any_res *  res  )

static

Definition at line 387 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("recall_any.status"); goto out; }
out:
    return result;
}

op_cb_recall_args()

static bool_t op_cb_recall_args ( XDR *  xdr, struct cb_recall_args *  args  )

static

Definition at line 308 of file callback_xdr.c.

{
    bool_t result;
 
    result = common_stateid(xdr, &args->stateid);
    if (!result) { CBX_ERR("recall.stateid"); goto out; }
 
    result = xdr_bool(xdr, &args->truncate);
    if (!result) { CBX_ERR("recall.truncate"); goto out; }
 
    result = common_fh(xdr, &args->fh);
    if (!result) { CBX_ERR("recall.fh"); goto out; }
out:
    return result;
}

op_cb_recall_res()

static bool_t op_cb_recall_res ( XDR *  xdr, struct cb_recall_res *  res  )

static

Definition at line 324 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("recall.status"); goto out; }
out:
    return result;
}

op_cb_recall_slot_args()

static bool_t op_cb_recall_slot_args ( XDR *  xdr, struct cb_recall_slot_args *  res  )

static

Definition at line 133 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_u_int32_t(xdr, &res->target_highest_slotid);
    if (!result) { CBX_ERR("recall_slot.target_highest_slotid"); goto out; }
out:
    return result;
}

op_cb_recall_slot_res()

static bool_t op_cb_recall_slot_res ( XDR *  xdr, struct cb_recall_slot_res *  res  )

static

Definition at line 143 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("recall_slot.status"); goto out; }
out:
    return result;
}

op_cb_recallable_obj_avail_args()

static bool_t op_cb_recallable_obj_avail_args ( XDR *  xdr, struct cb_recallable_obj_avail_args *  res  )

static

Definition at line 398 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_u_int32_t(xdr, &res->target_highest_slotid);
    if (!result) { CBX_ERR("recallable_obj_avail.target_highest_slotid"); goto out; }
out:
    return result;
}

op_cb_recallable_obj_avail_res()

static bool_t op_cb_recallable_obj_avail_res ( XDR *  xdr, struct cb_recallable_obj_avail_res *  res  )

static

Definition at line 408 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("recallable_obj_avail.status"); goto out; }
out:
    return result;
}

op_cb_sequence_args()

static bool_t op_cb_sequence_args ( XDR *  xdr, struct cb_sequence_args *  args  )

static

Definition at line 182 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_opaque(xdr, args->sessionid, NFS4_SESSIONID_SIZE);
    if (!result) { CBX_ERR("sequence_args.sessionid"); goto out; }
 
    result = xdr_u_int32_t(xdr, &args->sequenceid);
    if (!result) { CBX_ERR("sequence_args.sequenceid"); goto out; }
 
    result = xdr_u_int32_t(xdr, &args->slotid);
    if (!result) { CBX_ERR("sequence_args.slotid"); goto out; }
 
    result = xdr_u_int32_t(xdr, &args->highest_slotid);
    if (!result) { CBX_ERR("sequence_args.highest_slotid"); goto out; }
 
    result = xdr_bool(xdr, &args->cachethis);
    if (!result) { CBX_ERR("sequence_args.cachethis"); goto out; }
 
    result = xdr_array(xdr, (char**)&args->ref_lists,
        &args->ref_list_count, 64, sizeof(struct cb_sequence_ref_list),
        (xdrproc_t)op_cb_sequence_ref_list);
    if (!result) { CBX_ERR("sequence_args.ref_lists"); goto out; }
out:
    return result;
}

op_cb_sequence_ref()

static bool_t op_cb_sequence_ref ( XDR *  xdr, struct cb_sequence_ref *  args  )

static

Definition at line 155 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_u_int32_t(xdr, &args->sequenceid);
    if (!result) { CBX_ERR("sequence_ref.sequenceid"); goto out; }
 
    result = xdr_u_int32_t(xdr, &args->slotid);
    if (!result) { CBX_ERR("sequence_ref.slotid"); goto out; }
out:
    return result;
}

Referenced by op_cb_sequence_ref_list().

op_cb_sequence_ref_list()

static bool_t op_cb_sequence_ref_list ( XDR *  xdr, struct cb_sequence_ref_list *  args  )

static

Definition at line 168 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_opaque(xdr, args->sessionid, NFS4_SESSIONID_SIZE);
    if (!result) { CBX_ERR("sequence_ref_list.sessionid"); goto out; }
 
    result = xdr_array(xdr, (char**)&args->calls, &args->call_count,
        64, sizeof(struct cb_sequence_ref), (xdrproc_t)op_cb_sequence_ref);
    if (!result) { CBX_ERR("sequence_ref_list.calls"); goto out; }
out:
    return result;
}

Referenced by op_cb_sequence_args().

op_cb_sequence_res()

static bool_t op_cb_sequence_res ( XDR *  xdr, struct cb_sequence_res *  res  )

static

Definition at line 236 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_union(xdr, &res->status, (char*)&res->ok,
        cb_sequence_res_discrim, (xdrproc_t)xdr_void);
    if (!result) { CBX_ERR("seq:argop.args"); goto out; }
out:
    return result;
}

op_cb_sequence_res_ok()

static bool_t op_cb_sequence_res_ok ( XDR *  xdr, struct cb_sequence_res_ok *  res  )

static

Definition at line 209 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_opaque(xdr, res->sessionid, NFS4_SESSIONID_SIZE);
    if (!result) { CBX_ERR("sequence_res.sessionid"); goto out; }
 
    result = xdr_u_int32_t(xdr, &res->sequenceid);
    if (!result) { CBX_ERR("sequence_res.sequenceid"); goto out; }
 
    result = xdr_u_int32_t(xdr, &res->slotid);
    if (!result) { CBX_ERR("sequence_res.slotid"); goto out; }
 
    result = xdr_u_int32_t(xdr, &res->highest_slotid);
    if (!result) { CBX_ERR("sequence_res.highest_slotid"); goto out; }
 
    result = xdr_u_int32_t(xdr, &res->target_highest_slotid);
    if (!result) { CBX_ERR("sequence_res.target_highest_slotid"); goto out; }
out:
    return result;
}

op_cb_wants_cancelled_args()

static bool_t op_cb_wants_cancelled_args ( XDR *  xdr, struct cb_wants_cancelled_args *  res  )

static

Definition at line 419 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_u_int32_t(xdr, &res->target_highest_slotid);
    if (!result) { CBX_ERR("wants_cancelled.target_highest_slotid"); goto out; }
out:
    return result;
}

op_cb_wants_cancelled_res()

static bool_t op_cb_wants_cancelled_res ( XDR *  xdr, struct cb_wants_cancelled_res *  res  )

static

Definition at line 429 of file callback_xdr.c.

{
    bool_t result;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("wants_cancelled.status"); goto out; }
out:
    return result;
}

proc_cb_compound_args()

bool_t proc_cb_compound_args	(	XDR *	xdr,
		struct cb_compound_args *	args
	)

Definition at line 590 of file callback_xdr.c.

{
    bool_t result;
 
    result = cb_compound_tag(xdr, &args->tag);
    if (!result) { CBX_ERR("compound.tag"); goto out; }
 
    result = xdr_u_int32_t(xdr, &args->minorversion);
    if (!result) { CBX_ERR("compound.minorversion"); goto out; }
 
    /* "superfluous in NFSv4.1 and MUST be ignored by the client" */
    result = xdr_u_int32_t(xdr, &args->callback_ident);
    if (!result) { CBX_ERR("compound.callback_ident"); goto out; }
 
    result = xdr_array(xdr, (char**)&args->argarray,
        &args->argarray_count, CB_COMPOUND_MAX_OPERATIONS,
        sizeof(struct cb_argop), (xdrproc_t)cb_compound_argop);
    if (!result) { CBX_ERR("compound.argarray"); goto out; }
out:
    return result;
}

Referenced by handle_cb_compound(), replay_cache_write(), and replay_validate_args().

proc_cb_compound_res()

bool_t proc_cb_compound_res	(	XDR *	xdr,
		struct cb_compound_res *	res
	)

Definition at line 638 of file callback_xdr.c.

{
    bool_t result;
 
    if (res == NULL)
        return TRUE;
 
    result = xdr_enum(xdr, &res->status);
    if (!result) { CBX_ERR("compound_res.status"); goto out; }
 
    result = cb_compound_tag(xdr, &res->tag);
    if (!result) { CBX_ERR("compound_res.tag"); goto out; }
 
    result = xdr_array(xdr, (char**)&res->resarray,
        &res->resarray_count, CB_COMPOUND_MAX_OPERATIONS,
        sizeof(struct cb_resop), (xdrproc_t)cb_compound_resop);
    if (!result) { CBX_ERR("compound_res.resarray"); goto out; }
out:
    if (xdr->x_op == XDR_FREE)
        free(res);
    return result;
}

Referenced by get_client_for_netaddr(), replay_cache_read(), and replay_cache_write().

xdr_bitmap4()

bool_t xdr_bitmap4	(	XDR *	xdr,
		bitmap4 *	bitmap
	)

Definition at line 48 of file nfs41_xdr.c.

{
    uint32_t i;
 
    if (xdr->x_op == XDR_ENCODE) {
        if (bitmap->count > 3) {
            eprintf("encode_bitmap4: count (%d) must be <= 3\n",
                bitmap->count);
            return FALSE;
        }
        if (!xdr_u_int32_t(xdr, &bitmap->count))
            return FALSE;
 
        for (i = 0; i < bitmap->count; i++)
            if (!xdr_u_int32_t(xdr, &bitmap->arr[i]))
                return FALSE;
 
    } else if (xdr->x_op == XDR_DECODE) {
        if (!xdr_u_int32_t(xdr, &bitmap->count))
            return FALSE;
        if (bitmap->count > 3) {
            eprintf("decode_bitmap4: count (%d) must be <= 3\n",
                bitmap->count);
            return FALSE;
        }
 
        for (i = 0; i < bitmap->count; i++)
            if (!xdr_u_int32_t(xdr, &bitmap->arr[i]))
                return FALSE;
    } else 
        return FALSE;
 
    return TRUE;
}

Referenced by common_notify4(), decode_file_attrs(), decode_getdeviceinfo_ok(), decode_op_create(), decode_op_setattr(), decode_open_res_ok(), encode_op_getattr(), encode_op_getdeviceinfo(), encode_op_readdir(), op_cb_getattr_args(), xdr_fattr4(), and xdr_threshold_item().

xdr_fattr4()

bool_t xdr_fattr4	(	XDR *	xdr,
		fattr4 *	fattr
	)

Definition at line 144 of file nfs41_xdr.c.

{
    unsigned char *attr_vals = fattr->attr_vals;
 
    if (!xdr_bitmap4(xdr, &fattr->attrmask))
        return FALSE;
 
    return xdr_bytes(xdr, (char **)&attr_vals, &fattr->attr_vals_len, NFS4_OPAQUE_LIMIT);
}

Referenced by decode_op_getattr(), decode_readdir_entry(), encode_createattrs4(), encode_op_setattr(), and op_cb_getattr_res().

Variable Documentation

cb_argop_discrim

const struct xdr_discrim cb_argop_discrim[]

static

Initial value:

= {
    { OP_CB_LAYOUTRECALL,   (xdrproc_t)op_cb_layoutrecall_args },
    { OP_CB_RECALL_SLOT,    (xdrproc_t)op_cb_recall_slot_args },
    { OP_CB_SEQUENCE,       (xdrproc_t)op_cb_sequence_args },
    { OP_CB_GETATTR,        (xdrproc_t)op_cb_getattr_args },
    { OP_CB_RECALL,         (xdrproc_t)op_cb_recall_args },
    { OP_CB_NOTIFY,         (xdrproc_t)op_cb_notify_args },
    { OP_CB_PUSH_DELEG,     (xdrproc_t)op_cb_push_deleg_args },
    { OP_CB_RECALL_ANY,     (xdrproc_t)op_cb_recall_any_args },
    { OP_CB_RECALLABLE_OBJ_AVAIL, (xdrproc_t)op_cb_recallable_obj_avail_args },
    { OP_CB_WANTS_CANCELLED, (xdrproc_t)op_cb_wants_cancelled_args },
    { OP_CB_NOTIFY_LOCK,     (xdrproc_t)op_cb_notify_lock_args },
    { OP_CB_NOTIFY_DEVICEID, (xdrproc_t)op_cb_notify_deviceid_args },
    { OP_CB_ILLEGAL,         NULL_xdrproc_t },
}

Definition at line 563 of file callback_xdr.c.

Referenced by cb_compound_argop().

cb_layoutrecall_discrim

const struct xdr_discrim cb_layoutrecall_discrim[]

static

Initial value:

= {
    { PNFS_RETURN_FILE,     (xdrproc_t)op_cb_layoutrecall_file },
    { PNFS_RETURN_FSID,     (xdrproc_t)op_cb_layoutrecall_fsid },
    { PNFS_RETURN_ALL,      (xdrproc_t)xdr_void },
    { 0,                    NULL_xdrproc_t }
}

Definition at line 94 of file callback_xdr.c.

Referenced by op_cb_layoutrecall_args().

cb_resop_discrim

const struct xdr_discrim cb_resop_discrim[]

static

Initial value:

= {
    { OP_CB_LAYOUTRECALL,   (xdrproc_t)op_cb_layoutrecall_res },
    { OP_CB_RECALL_SLOT,    (xdrproc_t)op_cb_recall_slot_res },
    { OP_CB_SEQUENCE,       (xdrproc_t)op_cb_sequence_res },
    { OP_CB_GETATTR,        (xdrproc_t)op_cb_getattr_res },
    { OP_CB_RECALL,         (xdrproc_t)op_cb_recall_res },
    { OP_CB_NOTIFY,         (xdrproc_t)op_cb_notify_res },
    { OP_CB_PUSH_DELEG,     (xdrproc_t)op_cb_push_deleg_res },
    { OP_CB_RECALL_ANY,     (xdrproc_t)op_cb_recall_any_res },
    { OP_CB_RECALLABLE_OBJ_AVAIL, (xdrproc_t)op_cb_recallable_obj_avail_res },
    { OP_CB_WANTS_CANCELLED, (xdrproc_t)op_cb_wants_cancelled_res },
    { OP_CB_NOTIFY_LOCK,     (xdrproc_t)op_cb_notify_lock_res },
    { OP_CB_NOTIFY_DEVICEID, (xdrproc_t)op_cb_notify_deviceid_res },
    { OP_CB_ILLEGAL,         NULL_xdrproc_t },
}

Definition at line 612 of file callback_xdr.c.

Referenced by cb_compound_resop().

cb_sequence_res_discrim

const struct xdr_discrim cb_sequence_res_discrim[]

static

Initial value:

= {
    { NFS4_OK,              (xdrproc_t)op_cb_sequence_res_ok },
    { 0,                    NULL_xdrproc_t }
}

Definition at line 231 of file callback_xdr.c.

Referenced by op_cb_sequence_res().