LU-3162 lov: Get the correct address of lmm_objects

[fs/lustre-release.git] / lustre / lov / lov_pack.c

diff --git a/lustre/lov/lov_pack.c b/lustre/lov/lov_pack.c
index 47e0127..bc1e489 100644 (file)
--- a/lustre/lov/lov_pack.c
+++ b/lustre/lov/lov_pack.c
@@ -106,26 +106,24 @@ void lov_dump_lmm_v3(int level, struct lov_mds_md_v3 *lmm)
 
 void lov_dump_lmm(int level, void *lmm)
 {
-        int magic;
-
-        magic = ((struct lov_mds_md_v1 *)(lmm))->lmm_magic;
-        switch (magic) {
-        case LOV_MAGIC_V1:
-                return lov_dump_lmm_v1(level, (struct lov_mds_md_v1 *)(lmm));
-        case LOV_MAGIC_V3:
-                return lov_dump_lmm_v3(level, (struct lov_mds_md_v3 *)(lmm));
-        default:
-                CERROR("Cannot recognize lmm_magic %x", magic);
-        }
-        return;
+       int magic;
+
+       magic = le32_to_cpu(((struct lov_mds_md *)lmm)->lmm_magic);
+       switch (magic) {
+       case LOV_MAGIC_V1:
+               lov_dump_lmm_v1(level, (struct lov_mds_md_v1 *)lmm);
+               break;
+       case LOV_MAGIC_V3:
+               lov_dump_lmm_v3(level, (struct lov_mds_md_v3 *)lmm);
+               break;
+       default:
+               CDEBUG(level, "unrecognized lmm_magic %x, assuming %x\n",
+                      magic, LOV_MAGIC_V1);
+               lov_dump_lmm_common(level, lmm);
+               break;
+       }
 }
 
-#define LMM_ASSERT(test)                                                \
-do {                                                                    \
-        if (!(test)) lov_dump_lmm(D_ERROR, lmm);                        \
-        LASSERT(test); /* so we know what assertion failed */           \
-} while(0)
-
 /* Pack LOV object metadata for disk storage.  It is packed in LE byte
  * order and is opaque to the networking layer.
  *
@@ -169,13 +167,15 @@ int lov_packmd(struct obd_export *exp, struct lov_mds_md **lmmp,
         if (lsm) {
                 /* If we are just sizing the EA, limit the stripe count
                  * to the actual number of OSTs in this filesystem. */
-                if (!lmmp) {
-                        stripe_count = lov_get_stripecnt(lov, lmm_magic,
-                                                         lsm->lsm_stripe_count);
-                        lsm->lsm_stripe_count = stripe_count;
-                } else {
-                        stripe_count = lsm->lsm_stripe_count;
-                }
+               if (!lmmp) {
+                       stripe_count = lov_get_stripecnt(lov, lmm_magic,
+                                                       lsm->lsm_stripe_count);
+                       lsm->lsm_stripe_count = stripe_count;
+               } else if (!lsm_is_released(lsm)) {
+                       stripe_count = lsm->lsm_stripe_count;
+               } else {
+                       stripe_count = 0;
+               }
         } else {
                 /* No need to allocate more than maximum supported stripes.
                  * Anyway, this is pretty inaccurate since ld_tgt_count now
@@ -328,7 +328,8 @@ int lov_alloc_memmd(struct lov_stripe_md **lsmp, __u16 stripe_count,
         (*lsmp)->lsm_pattern = pattern;
         (*lsmp)->lsm_pool_name[0] = '\0';
         (*lsmp)->lsm_layout_gen = 0;
-        (*lsmp)->lsm_oinfo[0]->loi_ost_idx = ~0;
+       if (stripe_count > 0)
+               (*lsmp)->lsm_oinfo[0]->loi_ost_idx = ~0;
 
         for (i = 0; i < stripe_count; i++)
                 loi_init((*lsmp)->lsm_oinfo[i]);
@@ -362,6 +363,7 @@ int lov_unpackmd(struct obd_export *exp,  struct lov_stripe_md **lsmp,
         int rc = 0, lsm_size;
         __u16 stripe_count;
         __u32 magic;
+       __u32 pattern;
         ENTRY;
 
         /* If passed an MDS struct use values from there, otherwise defaults */
@@ -387,8 +389,8 @@ int lov_unpackmd(struct obd_export *exp,  struct lov_stripe_md **lsmp,
                 RETURN(0);
         }
 
-        lsm_size = lov_alloc_memmd(lsmp, stripe_count, LOV_PATTERN_RAID0,
-                                   magic);
+       pattern = le32_to_cpu(lmm->lmm_pattern);
+        lsm_size = lov_alloc_memmd(lsmp, stripe_count, pattern, magic);
         if (lsm_size < 0)
                 RETURN(lsm_size);
 
@@ -433,7 +435,7 @@ static int __lov_setstripe(struct obd_export *exp, int max_lmm_size,
                         lov->desc.ld_pattern : LOV_PATTERN_RAID0;
         }
 
-        if (lumv1->lmm_pattern != LOV_PATTERN_RAID0) {
+        if (lov_pattern(lumv1->lmm_pattern) != LOV_PATTERN_RAID0) {
                 CDEBUG(D_IOCTL, "bad userland stripe pattern: %#x\n",
                        lumv1->lmm_pattern);
                 RETURN(-EINVAL);
@@ -493,6 +495,9 @@ static int __lov_setstripe(struct obd_export *exp, int max_lmm_size,
                 }
         }
 
+       if (lumv1->lmm_pattern & LOV_PATTERN_F_RELEASED)
+               stripe_count = 0;
+
         rc = lov_alloc_memmd(lsmp, stripe_count, lumv1->lmm_pattern, lmm_magic);
 
         if (rc >= 0) {
@@ -595,23 +600,15 @@ int lov_getstripe(struct obd_export *exp, struct lov_stripe_md *lsm,
         struct lov_mds_md *lmmk = NULL;
         int rc, lmm_size;
         int lum_size;
-        mm_segment_t seg;
         ENTRY;
 
         if (!lsm)
                 RETURN(-ENODATA);
 
-        /*
-         * "Switch to kernel segment" to allow copying from kernel space by
-         * copy_{to,from}_user().
-         */
-        seg = get_fs();
-        set_fs(KERNEL_DS);
-
         /* we only need the header part from user space to get lmm_magic and
          * lmm_stripe_count, (the header part is common to v1 and v3) */
         lum_size = sizeof(struct lov_user_md_v1);
-        if (cfs_copy_from_user(&lum, lump, lum_size))
+       if (copy_from_user(&lum, lump, lum_size))
                 GOTO(out_set, rc = -EFAULT);
         else if ((lum.lmm_magic != LOV_USER_MAGIC) &&
                  (lum.lmm_magic != LOV_USER_MAGIC_V3))
@@ -621,7 +618,7 @@ int lov_getstripe(struct obd_export *exp, struct lov_stripe_md *lsm,
             (lum.lmm_stripe_count < lsm->lsm_stripe_count)) {
                 /* Return right size of stripe to user */
                 lum.lmm_stripe_count = lsm->lsm_stripe_count;
-                rc = cfs_copy_to_user(lump, &lum, lum_size);
+               rc = copy_to_user(lump, &lum, lum_size);
                 GOTO(out_set, rc = -EOVERFLOW);
         }
         rc = lov_packmd(exp, &lmmk, lsm);
@@ -646,9 +643,8 @@ int lov_getstripe(struct obd_export *exp, struct lov_stripe_md *lsm,
         if (lum.lmm_magic == LOV_USER_MAGIC) {
                 /* User request for v1, we need skip lmm_pool_name */
                 if (lmmk->lmm_magic == LOV_MAGIC_V3) {
-                        memmove((char*)(&lmmk->lmm_stripe_count) +
-                                sizeof(lmmk->lmm_stripe_count),
-                                ((struct lov_mds_md_v3*)lmmk)->lmm_objects,
+                       memmove(((struct lov_mds_md_v1 *)lmmk)->lmm_objects,
+                               ((struct lov_mds_md_v3 *)lmmk)->lmm_objects,
                                 lmmk->lmm_stripe_count *
                                 sizeof(struct lov_ost_data_v1));
                         lmm_size -= LOV_MAXPOOLNAME;
@@ -671,11 +667,10 @@ int lov_getstripe(struct obd_export *exp, struct lov_stripe_md *lsm,
        lum.lmm_layout_gen = lmmk->lmm_layout_gen;
        ((struct lov_user_md *)lmmk)->lmm_layout_gen = lum.lmm_layout_gen;
        ((struct lov_user_md *)lmmk)->lmm_stripe_count = lum.lmm_stripe_count;
-       if (cfs_copy_to_user(lump, lmmk, lmm_size))
+       if (copy_to_user(lump, lmmk, lmm_size))
                rc = -EFAULT;
 
        obd_free_diskmd(exp, &lmmk);
 out_set:
-       set_fs(seg);
        RETURN(rc);
 }