pnfs_osd_xdr_cli.c

Go to the documentation of this file.

/*
 *  Object-Based pNFS Layout XDR layer
 *
 *  Copyright (C) 2007 Panasas Inc. [year of first publication]
 *  All rights reserved.
 *
 *  Benny Halevy <[email protected]>
 *  Boaz Harrosh <[email protected]>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  See the file COPYING included with this distribution for more details.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the Panasas company nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <linux/pnfs_osd_xdr.h>

#define NFSDBG_FACILITY         NFSDBG_PNFS_LD

/*
 * The following implementation is based on RFC5664
 */

/*
 * struct pnfs_osd_objid {
 *  struct nfs4_deviceid    oid_device_id;
 *  u64         oid_partition_id;
 *  u64         oid_object_id;
 * }; // xdr size 32 bytes
 */
static __be32 *
_osd_xdr_decode_objid(__be32 *p, struct pnfs_osd_objid *objid)
{
    p = xdr_decode_opaque_fixed(p, objid->oid_device_id.data,
                    sizeof(objid->oid_device_id.data));

    p = xdr_decode_hyper(p, &objid->oid_partition_id);
    p = xdr_decode_hyper(p, &objid->oid_object_id);
    return p;
}
/*
 * struct pnfs_osd_opaque_cred {
 *  u32 cred_len;
 *  void *cred;
 * }; // xdr size [variable]
 * The return pointers are from the xdr buffer
 */
static int
_osd_xdr_decode_opaque_cred(struct pnfs_osd_opaque_cred *opaque_cred,
                struct xdr_stream *xdr)
{
    __be32 *p = xdr_inline_decode(xdr, 1);

    if (!p)
        return -EINVAL;

    opaque_cred->cred_len = be32_to_cpu(*p++);

    p = xdr_inline_decode(xdr, opaque_cred->cred_len);
    if (!p)
        return -EINVAL;

    opaque_cred->cred = p;
    return 0;
}

/*
 * struct pnfs_osd_object_cred {
 *  struct pnfs_osd_objid       oc_object_id;
 *  u32             oc_osd_version;
 *  u32             oc_cap_key_sec;
 *  struct pnfs_osd_opaque_cred oc_cap_key
 *  struct pnfs_osd_opaque_cred oc_cap;
 * }; // xdr size 32 + 4 + 4 + [variable] + [variable]
 */
static int
_osd_xdr_decode_object_cred(struct pnfs_osd_object_cred *comp,
                struct xdr_stream *xdr)
{
    __be32 *p = xdr_inline_decode(xdr, 32 + 4 + 4);
    int ret;

    if (!p)
        return -EIO;

    p = _osd_xdr_decode_objid(p, &comp->oc_object_id);
    comp->oc_osd_version = be32_to_cpup(p++);
    comp->oc_cap_key_sec = be32_to_cpup(p);

    ret = _osd_xdr_decode_opaque_cred(&comp->oc_cap_key, xdr);
    if (unlikely(ret))
        return ret;

    ret = _osd_xdr_decode_opaque_cred(&comp->oc_cap, xdr);
    return ret;
}

/*
 * struct pnfs_osd_data_map {
 *  u32 odm_num_comps;
 *  u64 odm_stripe_unit;
 *  u32 odm_group_width;
 *  u32 odm_group_depth;
 *  u32 odm_mirror_cnt;
 *  u32 odm_raid_algorithm;
 * }; // xdr size 4 + 8 + 4 + 4 + 4 + 4
 */
static inline int
_osd_data_map_xdr_sz(void)
{
    return 4 + 8 + 4 + 4 + 4 + 4;
}

static __be32 *
_osd_xdr_decode_data_map(__be32 *p, struct pnfs_osd_data_map *data_map)
{
    data_map->odm_num_comps = be32_to_cpup(p++);
    p = xdr_decode_hyper(p, &data_map->odm_stripe_unit);
    data_map->odm_group_width = be32_to_cpup(p++);
    data_map->odm_group_depth = be32_to_cpup(p++);
    data_map->odm_mirror_cnt = be32_to_cpup(p++);
    data_map->odm_raid_algorithm = be32_to_cpup(p++);
    dprintk("%s: odm_num_comps=%u odm_stripe_unit=%llu odm_group_width=%u "
        "odm_group_depth=%u odm_mirror_cnt=%u odm_raid_algorithm=%u\n",
        __func__,
        data_map->odm_num_comps,
        (unsigned long long)data_map->odm_stripe_unit,
        data_map->odm_group_width,
        data_map->odm_group_depth,
        data_map->odm_mirror_cnt,
        data_map->odm_raid_algorithm);
    return p;
}

int pnfs_osd_xdr_decode_layout_map(struct pnfs_osd_layout *layout,
    struct pnfs_osd_xdr_decode_layout_iter *iter, struct xdr_stream *xdr)
{
    __be32 *p;

    memset(iter, 0, sizeof(*iter));

    p = xdr_inline_decode(xdr, _osd_data_map_xdr_sz() + 4 + 4);
    if (unlikely(!p))
        return -EINVAL;

    p = _osd_xdr_decode_data_map(p, &layout->olo_map);
    layout->olo_comps_index = be32_to_cpup(p++);
    layout->olo_num_comps = be32_to_cpup(p++);
    dprintk("%s: olo_comps_index=%d olo_num_comps=%d\n", __func__,
        layout->olo_comps_index, layout->olo_num_comps);

    iter->total_comps = layout->olo_num_comps;
    return 0;
}

bool pnfs_osd_xdr_decode_layout_comp(struct pnfs_osd_object_cred *comp,
    struct pnfs_osd_xdr_decode_layout_iter *iter, struct xdr_stream *xdr,
    int *err)
{
    BUG_ON(iter->decoded_comps > iter->total_comps);
    if (iter->decoded_comps == iter->total_comps)
        return false;

    *err = _osd_xdr_decode_object_cred(comp, xdr);
    if (unlikely(*err)) {
        dprintk("%s: _osd_xdr_decode_object_cred=>%d decoded_comps=%d "
            "total_comps=%d\n", __func__, *err,
            iter->decoded_comps, iter->total_comps);
        return false; /* stop the loop */
    }
    dprintk("%s: dev(%llx:%llx) par=0x%llx obj=0x%llx "
        "key_len=%u cap_len=%u\n",
        __func__,
        _DEVID_LO(&comp->oc_object_id.oid_device_id),
        _DEVID_HI(&comp->oc_object_id.oid_device_id),
        comp->oc_object_id.oid_partition_id,
        comp->oc_object_id.oid_object_id,
        comp->oc_cap_key.cred_len, comp->oc_cap.cred_len);

    iter->decoded_comps++;
    return true;
}

/*
 * Get Device Information Decoding
 *
 * Note: since Device Information is currently done synchronously, all
 *       variable strings fields are left inside the rpc buffer and are only
 *       pointed to by the pnfs_osd_deviceaddr members. So the read buffer
 *       should not be freed while the returned information is in use.
 */
/*
 *struct nfs4_string {
 *  unsigned int len;
 *  char *data;
 *}; // size [variable]
 * NOTE: Returned string points to inside the XDR buffer
 */
static __be32 *
__read_u8_opaque(__be32 *p, struct nfs4_string *str)
{
    str->len = be32_to_cpup(p++);
    str->data = (char *)p;

    p += XDR_QUADLEN(str->len);
    return p;
}

/*
 * struct pnfs_osd_targetid {
 *  u32         oti_type;
 *  struct nfs4_string  oti_scsi_device_id;
 * };// size 4 + [variable]
 */
static __be32 *
__read_targetid(__be32 *p, struct pnfs_osd_targetid* targetid)
{
    u32 oti_type;

    oti_type = be32_to_cpup(p++);
    targetid->oti_type = oti_type;

    switch (oti_type) {
    case OBJ_TARGET_SCSI_NAME:
    case OBJ_TARGET_SCSI_DEVICE_ID:
        p = __read_u8_opaque(p, &targetid->oti_scsi_device_id);
    }

    return p;
}

/*
 * struct pnfs_osd_net_addr {
 *  struct nfs4_string  r_netid;
 *  struct nfs4_string  r_addr;
 * };
 */
static __be32 *
__read_net_addr(__be32 *p, struct pnfs_osd_net_addr* netaddr)
{
    p = __read_u8_opaque(p, &netaddr->r_netid);
    p = __read_u8_opaque(p, &netaddr->r_addr);

    return p;
}

/*
 * struct pnfs_osd_targetaddr {
 *  u32             ota_available;
 *  struct pnfs_osd_net_addr    ota_netaddr;
 * };
 */
static __be32 *
__read_targetaddr(__be32 *p, struct pnfs_osd_targetaddr *targetaddr)
{
    u32 ota_available;

    ota_available = be32_to_cpup(p++);
    targetaddr->ota_available = ota_available;

    if (ota_available)
        p = __read_net_addr(p, &targetaddr->ota_netaddr);


    return p;
}

/*
 * struct pnfs_osd_deviceaddr {
 *  struct pnfs_osd_targetid    oda_targetid;
 *  struct pnfs_osd_targetaddr  oda_targetaddr;
 *  u8              oda_lun[8];
 *  struct nfs4_string      oda_systemid;
 *  struct pnfs_osd_object_cred oda_root_obj_cred;
 *  struct nfs4_string      oda_osdname;
 * };
 */

/* We need this version for the pnfs_osd_xdr_decode_deviceaddr which does
 * not have an xdr_stream
 */
static __be32 *
__read_opaque_cred(__be32 *p,
                  struct pnfs_osd_opaque_cred *opaque_cred)
{
    opaque_cred->cred_len = be32_to_cpu(*p++);
    opaque_cred->cred = p;
    return p + XDR_QUADLEN(opaque_cred->cred_len);
}

static __be32 *
__read_object_cred(__be32 *p, struct pnfs_osd_object_cred *comp)
{
    p = _osd_xdr_decode_objid(p, &comp->oc_object_id);
    comp->oc_osd_version = be32_to_cpup(p++);
    comp->oc_cap_key_sec = be32_to_cpup(p++);

    p = __read_opaque_cred(p, &comp->oc_cap_key);
    p = __read_opaque_cred(p, &comp->oc_cap);
    return p;
}

void pnfs_osd_xdr_decode_deviceaddr(
    struct pnfs_osd_deviceaddr *deviceaddr, __be32 *p)
{
    p = __read_targetid(p, &deviceaddr->oda_targetid);

    p = __read_targetaddr(p, &deviceaddr->oda_targetaddr);

    p = xdr_decode_opaque_fixed(p, deviceaddr->oda_lun,
                    sizeof(deviceaddr->oda_lun));

    p = __read_u8_opaque(p, &deviceaddr->oda_systemid);

    p = __read_object_cred(p, &deviceaddr->oda_root_obj_cred);

    p = __read_u8_opaque(p, &deviceaddr->oda_osdname);

    /* libosd likes this terminated in dbg. It's last, so no problems */
    deviceaddr->oda_osdname.data[deviceaddr->oda_osdname.len] = 0;
}

/*
 * struct pnfs_osd_layoutupdate {
 *  u32 dsu_valid;
 *  s64 dsu_delta;
 *  u32 olu_ioerr_flag;
 * }; xdr size 4 + 8 + 4
 */
int
pnfs_osd_xdr_encode_layoutupdate(struct xdr_stream *xdr,
                 struct pnfs_osd_layoutupdate *lou)
{
    __be32 *p = xdr_reserve_space(xdr,  4 + 8 + 4);

    if (!p)
        return -E2BIG;

    *p++ = cpu_to_be32(lou->dsu_valid);
    if (lou->dsu_valid)
        p = xdr_encode_hyper(p, lou->dsu_delta);
    *p++ = cpu_to_be32(lou->olu_ioerr_flag);
    return 0;
}

/*
 * struct pnfs_osd_objid {
 *  struct nfs4_deviceid    oid_device_id;
 *  u64         oid_partition_id;
 *  u64         oid_object_id;
 * }; // xdr size 32 bytes
 */
static inline __be32 *
pnfs_osd_xdr_encode_objid(__be32 *p, struct pnfs_osd_objid *object_id)
{
    p = xdr_encode_opaque_fixed(p, &object_id->oid_device_id.data,
                    sizeof(object_id->oid_device_id.data));
    p = xdr_encode_hyper(p, object_id->oid_partition_id);
    p = xdr_encode_hyper(p, object_id->oid_object_id);

    return p;
}

/*
 * struct pnfs_osd_ioerr {
 *  struct pnfs_osd_objid   oer_component;
 *  u64         oer_comp_offset;
 *  u64         oer_comp_length;
 *  u32         oer_iswrite;
 *  u32         oer_errno;
 * }; // xdr size 32 + 24 bytes
 */
void pnfs_osd_xdr_encode_ioerr(__be32 *p, struct pnfs_osd_ioerr *ioerr)
{
    p = pnfs_osd_xdr_encode_objid(p, &ioerr->oer_component);
    p = xdr_encode_hyper(p, ioerr->oer_comp_offset);
    p = xdr_encode_hyper(p, ioerr->oer_comp_length);
    *p++ = cpu_to_be32(ioerr->oer_iswrite);
    *p   = cpu_to_be32(ioerr->oer_errno);
}

__be32 *pnfs_osd_xdr_ioerr_reserve_space(struct xdr_stream *xdr)
{
    __be32 *p;

    p = xdr_reserve_space(xdr, 32 + 24);
    if (unlikely(!p))
        dprintk("%s: out of xdr space\n", __func__);

    return p;
}