LU-10171 lmv: avoid gratuitous 64-bit modulus

[fs/lustre-release.git] / lustre / lmv / lmv_obd.c

diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c
index 63f617c..19bfed4 100644 (file)
--- a/lustre/lmv/lmv_obd.c
+++ b/lustre/lmv/lmv_obd.c
@@ -265,10 +265,12 @@ static int lmv_init_ea_size(struct obd_export *exp, __u32 easize,
        for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
                struct lmv_tgt_desc *tgt = lmv->tgts[i];
 
-               if (tgt == NULL || tgt->ltd_exp == NULL || !tgt->ltd_active) {
+               if (tgt == NULL || tgt->ltd_exp == NULL) {
                        CWARN("%s: NULL export for %d\n", obd->obd_name, i);
                        continue;
                }
+               if (!tgt->ltd_active)
+                       continue;
 
                rc = md_init_ea_size(tgt->ltd_exp, easize, def_easize);
                if (rc) {
@@ -798,23 +800,42 @@ static int lmv_hsm_ct_register(struct obd_device *obd, unsigned int cmd,
                               void __user *uarg)
 {
        struct lmv_obd *lmv = &obd->u.lmv;
-       struct file             *filp;
-       __u32                    i, j;
-       int                      err;
-       bool                     any_set = false;
-       struct kkuc_ct_data      kcd = {
-               .kcd_magic   = KKUC_CT_DATA_MAGIC,
-               .kcd_archive = lk->lk_data,
-       };
-       int                      rc = 0;
+       struct file *filp;
+       __u32 i, j;
+       int err;
+       bool any_set = false;
+       struct kkuc_ct_data *kcd;
+       size_t kcd_size;
+       int rc = 0;
        ENTRY;
 
        filp = fget(lk->lk_wfd);
        if (!filp)
                RETURN(-EBADF);
 
+       if (lk->lk_flags & LK_FLG_DATANR)
+               kcd_size = offsetof(struct kkuc_ct_data,
+                                   kcd_archives[lk->lk_data_count]);
+       else
+               kcd_size = sizeof(*kcd);
+
+       OBD_ALLOC(kcd, kcd_size);
+       if (kcd == NULL)
+               GOTO(err_fput, rc = -ENOMEM);
+
+       kcd->kcd_nr_archives = lk->lk_data_count;
+       if (lk->lk_flags & LK_FLG_DATANR) {
+               kcd->kcd_magic = KKUC_CT_DATA_ARRAY_MAGIC;
+               if (lk->lk_data_count > 0)
+                       memcpy(kcd->kcd_archives, lk->lk_data,
+                              sizeof(*kcd->kcd_archives) * lk->lk_data_count);
+       } else {
+               kcd->kcd_magic = KKUC_CT_DATA_BITMAP_MAGIC;
+       }
+
        rc = libcfs_kkuc_group_add(filp, &obd->obd_uuid, lk->lk_uid,
-                                  lk->lk_group, &kcd, sizeof(kcd));
+                                  lk->lk_group, kcd, kcd_size);
+       OBD_FREE(kcd, kcd_size);
        if (rc)
                GOTO(err_fput, rc);
 
@@ -1352,8 +1373,11 @@ static int lmv_select_statfs_mdt(struct lmv_obd *lmv, __u32 flags)
                        break;
 
                if (LNET_NETTYP(LNET_NIDNET(lnet_id.nid)) != LOLND) {
+                       /* We dont need a full 64-bit modulus, just enough
+                        * to distribute the requests across MDTs evenly.
+                        */
                        lmv->lmv_statfs_start =
-                               lnet_id.nid % lmv->desc.ld_tgt_count;
+                               (u32)lnet_id.nid % lmv->desc.ld_tgt_count;
                        break;
                }
        }
@@ -1935,8 +1959,6 @@ static int lmv_migrate(struct obd_export *exp, struct md_op_data *op_data,
        ENTRY;
 
        LASSERT(op_data->op_cli_flags & CLI_MIGRATE);
-       LASSERTF(fid_is_sane(&op_data->op_fid3), "invalid FID "DFID"\n",
-                PFID(&op_data->op_fid3));
 
        CDEBUG(D_INODE, "MIGRATE "DFID"/%.*s\n",
               PFID(&op_data->op_fid1), (int)namelen, name);
@@ -2006,7 +2028,10 @@ static int lmv_migrate(struct obd_export *exp, struct md_op_data *op_data,
        if (IS_ERR(child_tgt))
                RETURN(PTR_ERR(child_tgt));
 
-       rc = lmv_fid_alloc(NULL, exp, &target_fid, op_data);
+       if (!S_ISDIR(op_data->op_mode) && tp_tgt)
+               rc = __lmv_fid_alloc(lmv, &target_fid, tp_tgt->ltd_idx);
+       else
+               rc = lmv_fid_alloc(NULL, exp, &target_fid, op_data);
        if (rc)
                RETURN(rc);
 
@@ -2276,8 +2301,9 @@ static int lmv_setattr(struct obd_export *exp, struct md_op_data *op_data,
        int                      rc = 0;
        ENTRY;
 
-       CDEBUG(D_INODE, "SETATTR for "DFID", valid 0x%x\n",
-              PFID(&op_data->op_fid1), op_data->op_attr.ia_valid);
+       CDEBUG(D_INODE, "SETATTR for "DFID", valid 0x%x/0x%x\n",
+              PFID(&op_data->op_fid1), op_data->op_attr.ia_valid,
+              op_data->op_xvalid);
 
        op_data->op_flags |= MF_MDC_CANCEL_FID1;
        tgt = lmv_find_target(lmv, &op_data->op_fid1);
@@ -3324,12 +3350,12 @@ static int lmv_merge_attr(struct obd_export *exp,
        for (i = 0; i < lsm->lsm_md_stripe_count; i++) {
                struct inode *inode = lsm->lsm_md_oinfo[i].lmo_root;
 
-               CDEBUG(D_INFO, ""DFID" size %llu, blocks %llu nlink %u,"
-                      " atime %lu ctime %lu, mtime %lu.\n",
+               CDEBUG(D_INFO,
+                      "" DFID " size %llu, blocks %llu nlink %u, atime %lld ctime %lld, mtime %lld.\n",
                       PFID(&lsm->lsm_md_oinfo[i].lmo_fid),
                       i_size_read(inode), (unsigned long long)inode->i_blocks,
-                      inode->i_nlink, LTIME_S(inode->i_atime),
-                      LTIME_S(inode->i_ctime), LTIME_S(inode->i_mtime));
+                      inode->i_nlink, (s64)inode->i_atime.tv_sec,
+                      (s64)inode->i_ctime.tv_sec, (s64)inode->i_mtime.tv_sec);
 
                /* for slave stripe, it needs to subtract nlink for . and .. */
                if (i != 0)
@@ -3340,14 +3366,14 @@ static int lmv_merge_attr(struct obd_export *exp,
                attr->cat_size += i_size_read(inode);
                attr->cat_blocks += inode->i_blocks;
 
-               if (attr->cat_atime < LTIME_S(inode->i_atime))
-                       attr->cat_atime = LTIME_S(inode->i_atime);
+               if (attr->cat_atime < inode->i_atime.tv_sec)
+                       attr->cat_atime = inode->i_atime.tv_sec;
 
-               if (attr->cat_ctime < LTIME_S(inode->i_ctime))
-                       attr->cat_ctime = LTIME_S(inode->i_ctime);
+               if (attr->cat_ctime < inode->i_ctime.tv_sec)
+                       attr->cat_ctime = inode->i_ctime.tv_sec;
 
-               if (attr->cat_mtime < LTIME_S(inode->i_mtime))
-                       attr->cat_mtime = LTIME_S(inode->i_mtime);
+               if (attr->cat_mtime < inode->i_mtime.tv_sec)
+                       attr->cat_mtime = inode->i_mtime.tv_sec;
        }
        return 0;
 }