pnfs-obj: decode layout, alloc/free lseg

objlayout_alloc_lseg prepares an xdr_stream and calls the
raid engins objio_alloc_lseg() to allocate a private
pnfs_layout_segment.

objio_osd.c::objio_alloc_lseg() uses passed xdr_stream to
decode and store the layout_segment information in an
objio_segment struct, using the pnfs_osd_xdr.h API for
the actual parsing the layout xdr.

objlayout_free_lseg calls objio_free_lseg() to free the
allocated space.

Signed-off-by: Boaz Harrosh <bharrosh@panasas.com>
[gfp_flags]
[removed "extern" from function definitions]
Signed-off-by: Benny Halevy <bhalevy@panasas.com>

1 files changed, 169 insertions, 1 deletions

diff --git a/fs/nfs/objlayout/objio_osd.c b/fs/nfs/objlayout/objio_osd.c
index 379595f2d1cc..08f1d90b4ce7 100644
--- a/fs/nfs/objlayout/objio_osd.c
+++ b/fs/nfs/objlayout/objio_osd.c
@@ -38,11 +38,179 @@
  */
 
 #include <linux/module.h>
-#include "../pnfs.h"
+#include <scsi/osd_initiator.h>
+
+#include "objlayout.h"
+
+#define NFSDBG_FACILITY         NFSDBG_PNFS_LD
+
+#define _LLU(x) ((unsigned long long)x)
+
+struct caps_buffers {
+        u8 caps_key[OSD_CRYPTO_KEYID_SIZE];
+        u8 creds[OSD_CAP_LEN];
+};
+
+struct objio_segment {
+        struct pnfs_layout_segment lseg;
+
+        struct pnfs_osd_object_cred *comps;
+
+        unsigned mirrors_p1;
+        unsigned stripe_unit;
+        unsigned group_width;   /* Data stripe_units without integrity comps */
+        u64 group_depth;
+        unsigned group_count;
+
+        unsigned comps_index;
+        unsigned num_comps;
+        /* variable length */
+        struct objio_dev_ent *ods[];
+};
+
+static inline struct objio_segment *
+OBJIO_LSEG(struct pnfs_layout_segment *lseg)
+{
+        return container_of(lseg, struct objio_segment, lseg);
+}
+
+static int _verify_data_map(struct pnfs_osd_layout *layout)
+{
+        struct pnfs_osd_data_map *data_map = &layout->olo_map;
+        u64 stripe_length;
+        u32 group_width;
+
+/* FIXME: Only raid0 for now. if not go through MDS */
+        if (data_map->odm_raid_algorithm != PNFS_OSD_RAID_0) {
+                printk(KERN_ERR "Only RAID_0 for now\n");
+                return -ENOTSUPP;
+        }
+        if (0 != (data_map->odm_num_comps % (data_map->odm_mirror_cnt + 1))) {
+                printk(KERN_ERR "Data Map wrong, num_comps=%u mirrors=%u\n",
+                          data_map->odm_num_comps, data_map->odm_mirror_cnt);
+                return -EINVAL;
+        }
+
+        if (data_map->odm_group_width)
+                group_width = data_map->odm_group_width;
+        else
+                group_width = data_map->odm_num_comps /
+                                                (data_map->odm_mirror_cnt + 1);
+
+        stripe_length = (u64)data_map->odm_stripe_unit * group_width;
+        if (stripe_length >= (1ULL << 32)) {
+                printk(KERN_ERR "Total Stripe length(0x%llx)"
+                          " >= 32bit is not supported\n", _LLU(stripe_length));
+                return -ENOTSUPP;
+        }
+
+        if (0 != (data_map->odm_stripe_unit & ~PAGE_MASK)) {
+                printk(KERN_ERR "Stripe Unit(0x%llx)"
+                          " must be Multples of PAGE_SIZE(0x%lx)\n",
+                          _LLU(data_map->odm_stripe_unit), PAGE_SIZE);
+                return -ENOTSUPP;
+        }
+
+        return 0;
+}
+
+static void copy_single_comp(struct pnfs_osd_object_cred *cur_comp,
+                             struct pnfs_osd_object_cred *src_comp,
+                             struct caps_buffers *caps_p)
+{
+        WARN_ON(src_comp->oc_cap_key.cred_len > sizeof(caps_p->caps_key));
+        WARN_ON(src_comp->oc_cap.cred_len > sizeof(caps_p->creds));
+
+        *cur_comp = *src_comp;
+
+        memcpy(caps_p->caps_key, src_comp->oc_cap_key.cred,
+               sizeof(caps_p->caps_key));
+        cur_comp->oc_cap_key.cred = caps_p->caps_key;
+
+        memcpy(caps_p->creds, src_comp->oc_cap.cred,
+               sizeof(caps_p->creds));
+        cur_comp->oc_cap.cred = caps_p->creds;
+}
+
+int objio_alloc_lseg(struct pnfs_layout_segment **outp,
+        struct pnfs_layout_hdr *pnfslay,
+        struct pnfs_layout_range *range,
+        struct xdr_stream *xdr,
+        gfp_t gfp_flags)
+{
+        struct objio_segment *objio_seg;
+        struct pnfs_osd_xdr_decode_layout_iter iter;
+        struct pnfs_osd_layout layout;
+        struct pnfs_osd_object_cred *cur_comp, src_comp;
+        struct caps_buffers *caps_p;
+        int err;
+
+        err = pnfs_osd_xdr_decode_layout_map(&layout, &iter, xdr);
+        if (unlikely(err))
+                return err;
+
+        err = _verify_data_map(&layout);
+        if (unlikely(err))
+                return err;
+
+        objio_seg = kzalloc(sizeof(*objio_seg) +
+                            sizeof(objio_seg->ods[0]) * layout.olo_num_comps +
+                            sizeof(*objio_seg->comps) * layout.olo_num_comps +
+                            sizeof(struct caps_buffers) * layout.olo_num_comps,
+                            gfp_flags);
+        if (!objio_seg)
+                return -ENOMEM;
+
+        objio_seg->comps = (void *)(objio_seg->ods + layout.olo_num_comps);
+        cur_comp = objio_seg->comps;
+        caps_p = (void *)(cur_comp + layout.olo_num_comps);
+        while (pnfs_osd_xdr_decode_layout_comp(&src_comp, &iter, xdr, &err))
+                copy_single_comp(cur_comp++, &src_comp, caps_p++);
+        if (unlikely(err))
+                goto err;
+
+        objio_seg->num_comps = layout.olo_num_comps;
+        objio_seg->comps_index = layout.olo_comps_index;
+
+        objio_seg->mirrors_p1 = layout.olo_map.odm_mirror_cnt + 1;
+        objio_seg->stripe_unit = layout.olo_map.odm_stripe_unit;
+        if (layout.olo_map.odm_group_width) {
+                objio_seg->group_width = layout.olo_map.odm_group_width;
+                objio_seg->group_depth = layout.olo_map.odm_group_depth;
+                objio_seg->group_count = layout.olo_map.odm_num_comps /
+                                                objio_seg->mirrors_p1 /
+                                                objio_seg->group_width;
+        } else {
+                objio_seg->group_width = layout.olo_map.odm_num_comps /
+                                                objio_seg->mirrors_p1;
+                objio_seg->group_depth = -1;
+                objio_seg->group_count = 1;
+        }
+
+        *outp = &objio_seg->lseg;
+        return 0;
+
+err:
+        kfree(objio_seg);
+        dprintk("%s: Error: return %d\n", __func__, err);
+        *outp = NULL;
+        return err;
+}
+
+void objio_free_lseg(struct pnfs_layout_segment *lseg)
+{
+        struct objio_segment *objio_seg = OBJIO_LSEG(lseg);
+
+        kfree(objio_seg);
+}
+
 
 static struct pnfs_layoutdriver_type objlayout_type = {
         .id = LAYOUT_OSD2_OBJECTS,
         .name = "LAYOUT_OSD2_OBJECTS",
+
+        .alloc_lseg              = objlayout_alloc_lseg,
+        .free_lseg               = objlayout_free_lseg,
 };
 
 MODULE_DESCRIPTION("pNFS Layout Driver for OSD2 objects");