LU-14291 lustre: rename tgt_pool_* functions.

Functions starting with tgt_* represents code for target handling
used by Lustre servers. Now that the pool functions are used by
both clients and servers rename it to lu_tgt_* to mirror how
lu_tgt_desc_* is used since both represents remote server targets.

Test-Parameters: trivial
Change-Id: I2a9084d5bf9cea3b373c96e15cba1a41631d1172
Signed-off-by: James Simmons <jsimmons@infradead.org>
Reviewed-on: https://review.whamcloud.com/43624
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Aurelien Degremont <degremoa@amazon.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>

diff --git a/lustre/include/lu_object.h b/lustre/include/lu_object.h
index 6969b71..4081923 100644 (file)
--- a/lustre/include/lu_object.h
+++ b/lustre/include/lu_object.h
@@ -1528,12 +1528,12 @@ struct lu_tgt_pool {
        struct rw_semaphore op_rw_sem;  /* to protect lu_tgt_pool use */
 };
 
-int tgt_pool_init(struct lu_tgt_pool *op, unsigned int count);
-int tgt_pool_add(struct lu_tgt_pool *op, __u32 idx, unsigned int min_count);
-int tgt_pool_remove(struct lu_tgt_pool *op, __u32 idx);
-int tgt_pool_free(struct lu_tgt_pool *op);
-int tgt_check_index(int idx, struct lu_tgt_pool *osts);
-int tgt_pool_extend(struct lu_tgt_pool *op, unsigned int min_count);
+int lu_tgt_pool_init(struct lu_tgt_pool *op, unsigned int count);
+int lu_tgt_pool_add(struct lu_tgt_pool *op, __u32 idx, unsigned int min_count);
+int lu_tgt_pool_remove(struct lu_tgt_pool *op, __u32 idx);
+int lu_tgt_pool_free(struct lu_tgt_pool *op);
+int lu_tgt_check_index(int idx, struct lu_tgt_pool *osts);
+int lu_tgt_pool_extend(struct lu_tgt_pool *op, unsigned int min_count);
 
 /* bitflags used in rr / qos allocation */
 enum lq_flag {

diff --git a/lustre/lod/lod_lov.c b/lustre/lod/lod_lov.c
index 2c990cb..10ab3fa 100644 (file)
--- a/lustre/lod/lod_lov.c
+++ b/lustre/lod/lod_lov.c
@@ -87,8 +87,8 @@ void lod_putref(struct lod_device *lod, struct lod_tgt_descs *ltd)
                                continue;
 
                        list_add(&tgt_desc->ltd_kill, &kill);
-                       tgt_pool_remove(&ltd->ltd_tgt_pool,
-                                       tgt_desc->ltd_index);
+                       lu_tgt_pool_remove(&ltd->ltd_tgt_pool,
+                                          tgt_desc->ltd_index);
                        ltd_del_tgt(ltd, tgt_desc);
                        ltd->ltd_death_row--;
                }
@@ -252,7 +252,7 @@ int lod_add_device(const struct lu_env *env, struct lod_device *lod,
        if (rc)
                GOTO(out_del_tgt, rc);
 
-       rc = tgt_pool_add(&ltd->ltd_tgt_pool, index,
+       rc = lu_tgt_pool_add(&ltd->ltd_tgt_pool, index,
                          ltd->ltd_lov_desc.ld_tgt_count);
        if (rc) {
                CERROR("%s: can't set up pool, failed with %d\n",
@@ -288,7 +288,7 @@ out_fini_llog:
 out_ltd:
        down_write(&ltd->ltd_rw_sem);
        mutex_lock(&ltd->ltd_mutex);
-       tgt_pool_remove(&ltd->ltd_tgt_pool, index);
+       lu_tgt_pool_remove(&ltd->ltd_tgt_pool, index);
 out_del_tgt:
        ltd_del_tgt(ltd, tgt_desc);
 out_mutex:
@@ -2214,30 +2214,30 @@ int lod_pools_init(struct lod_device *lod, struct lustre_cfg *lcfg)
 
        INIT_LIST_HEAD(&lod->lod_pool_list);
        lod->lod_pool_count = 0;
-       rc = tgt_pool_init(&lod->lod_mdt_descs.ltd_tgt_pool, 0);
+       rc = lu_tgt_pool_init(&lod->lod_mdt_descs.ltd_tgt_pool, 0);
        if (rc)
                GOTO(out_hash, rc);
 
-       rc = tgt_pool_init(&lod->lod_mdt_descs.ltd_qos.lq_rr.lqr_pool, 0);
+       rc = lu_tgt_pool_init(&lod->lod_mdt_descs.ltd_qos.lq_rr.lqr_pool, 0);
        if (rc)
                GOTO(out_mdt_pool, rc);
 
-       rc = tgt_pool_init(&lod->lod_ost_descs.ltd_tgt_pool, 0);
+       rc = lu_tgt_pool_init(&lod->lod_ost_descs.ltd_tgt_pool, 0);
        if (rc)
                GOTO(out_mdt_rr_pool, rc);
 
-       rc = tgt_pool_init(&lod->lod_ost_descs.ltd_qos.lq_rr.lqr_pool, 0);
+       rc = lu_tgt_pool_init(&lod->lod_ost_descs.ltd_qos.lq_rr.lqr_pool, 0);
        if (rc)
                GOTO(out_ost_pool, rc);
 
        RETURN(0);
 
 out_ost_pool:
-       tgt_pool_free(&lod->lod_ost_descs.ltd_tgt_pool);
+       lu_tgt_pool_free(&lod->lod_ost_descs.ltd_tgt_pool);
 out_mdt_rr_pool:
-       tgt_pool_free(&lod->lod_mdt_descs.ltd_qos.lq_rr.lqr_pool);
+       lu_tgt_pool_free(&lod->lod_mdt_descs.ltd_qos.lq_rr.lqr_pool);
 out_mdt_pool:
-       tgt_pool_free(&lod->lod_mdt_descs.ltd_tgt_pool);
+       lu_tgt_pool_free(&lod->lod_mdt_descs.ltd_tgt_pool);
 out_hash:
        lod_pool_hash_destroy(&lod->lod_pools_hash_body);
 
@@ -2267,10 +2267,10 @@ int lod_pools_fini(struct lod_device *lod)
        }
 
        lod_pool_hash_destroy(&lod->lod_pools_hash_body);
-       tgt_pool_free(&lod->lod_ost_descs.ltd_qos.lq_rr.lqr_pool);
-       tgt_pool_free(&lod->lod_ost_descs.ltd_tgt_pool);
-       tgt_pool_free(&lod->lod_mdt_descs.ltd_qos.lq_rr.lqr_pool);
-       tgt_pool_free(&lod->lod_mdt_descs.ltd_tgt_pool);
+       lu_tgt_pool_free(&lod->lod_ost_descs.ltd_qos.lq_rr.lqr_pool);
+       lu_tgt_pool_free(&lod->lod_ost_descs.ltd_tgt_pool);
+       lu_tgt_pool_free(&lod->lod_mdt_descs.ltd_qos.lq_rr.lqr_pool);
+       lu_tgt_pool_free(&lod->lod_mdt_descs.ltd_tgt_pool);
 
        RETURN(0);
 }

diff --git a/lustre/lod/lod_pool.c b/lustre/lod/lod_pool.c
index 2f038c6..0a3fce1 100644 (file)
--- a/lustre/lod/lod_pool.c
+++ b/lustre/lod/lod_pool.c
@@ -99,8 +99,8 @@ void lod_pool_putref(struct pool_desc *pool)
        if (atomic_dec_and_test(&pool->pool_refcount)) {
                LASSERT(list_empty(&pool->pool_list));
                LASSERT(pool->pool_proc_entry == NULL);
-               tgt_pool_free(&(pool->pool_rr.lqr_pool));
-               tgt_pool_free(&(pool->pool_obds));
+               lu_tgt_pool_free(&(pool->pool_rr.lqr_pool));
+               lu_tgt_pool_free(&(pool->pool_obds));
                kfree_rcu(pool, pool_rcu);
                EXIT;
        }
@@ -408,13 +408,13 @@ int lod_pool_new(struct obd_device *obd, char *poolname)
        strlcpy(new_pool->pool_name, poolname, sizeof(new_pool->pool_name));
        new_pool->pool_lobd = obd;
        atomic_set(&new_pool->pool_refcount, 1);
-       rc = tgt_pool_init(&new_pool->pool_obds, 0);
+       rc = lu_tgt_pool_init(&new_pool->pool_obds, 0);
        if (rc)
                GOTO(out_err, rc);
 
        lu_qos_rr_init(&new_pool->pool_rr);
 
-       rc = tgt_pool_init(&new_pool->pool_rr.lqr_pool, 0);
+       rc = lu_tgt_pool_init(&new_pool->pool_rr.lqr_pool, 0);
        if (rc)
                GOTO(out_free_pool_obds, rc);
 
@@ -465,9 +465,9 @@ out_err:
 
        lprocfs_remove(&new_pool->pool_proc_entry);
 
-       tgt_pool_free(&new_pool->pool_rr.lqr_pool);
+       lu_tgt_pool_free(&new_pool->pool_rr.lqr_pool);
 out_free_pool_obds:
-       tgt_pool_free(&new_pool->pool_obds);
+       lu_tgt_pool_free(&new_pool->pool_obds);
        OBD_FREE_PTR(new_pool);
        return rc;
 }
@@ -560,8 +560,8 @@ int lod_pool_add(struct obd_device *obd, char *poolname, char *ostname)
        if (rc)
                GOTO(out, rc);
 
-       rc = tgt_pool_add(&pool->pool_obds, tgt->ltd_index,
-                             lod->lod_ost_count);
+       rc = lu_tgt_pool_add(&pool->pool_obds, tgt->ltd_index,
+                            lod->lod_ost_count);
        if (rc)
                GOTO(out, rc);
 
@@ -624,7 +624,7 @@ int lod_pool_remove(struct obd_device *obd, char *poolname, char *ostname)
        if (rc)
                GOTO(out, rc);
 
-       tgt_pool_remove(&pool->pool_obds, ost->ltd_index);
+       lu_tgt_pool_remove(&pool->pool_obds, ost->ltd_index);
        set_bit(LQ_DIRTY, &pool->pool_rr.lqr_flags);
 
        CDEBUG(D_CONFIG, "%s removed from "LOV_POOLNAMEF"\n", ostname,
@@ -654,7 +654,7 @@ int lod_check_index_in_pool(__u32 idx, struct pool_desc *pool)
        int rc;
 
        pool_getref(pool);
-       rc = tgt_check_index(idx, &pool->pool_obds);
+       rc = lu_tgt_check_index(idx, &pool->pool_obds);
        lod_pool_putref(pool);
        return rc;
 }

diff --git a/lustre/lod/lod_qos.c b/lustre/lod/lod_qos.c
index cd50647..ef8a581 100644 (file)
--- a/lustre/lod/lod_qos.c
+++ b/lustre/lod/lod_qos.c
@@ -286,7 +286,7 @@ static int lod_qos_calc_rr(struct lod_device *lod, struct lu_tgt_descs *ltd,
           deleting from the pool. The lq_rw_sem insures that nobody else
           is reading. */
        lqr->lqr_pool.op_count = real_count;
-       rc = tgt_pool_extend(&lqr->lqr_pool, real_count);
+       rc = lu_tgt_pool_extend(&lqr->lqr_pool, real_count);
        if (rc) {
                up_write(&ltd->ltd_qos.lq_rw_sem);
                RETURN(rc);

diff --git a/lustre/lov/lov_obd.c b/lustre/lov/lov_obd.c
index 2d33394..3efba72 100644 (file)
--- a/lustre/lov/lov_obd.c
+++ b/lustre/lov/lov_obd.c
@@ -90,7 +90,7 @@ void lov_tgts_putref(struct obd_device *obd)
                         /* XXX - right now there is a dependency on ld_tgt_count
                          * being the maximum tgt index for computing the
                          * mds_max_easize. So we can't shrink it. */
-                       tgt_pool_remove(&lov->lov_packed, i);
+                       lu_tgt_pool_remove(&lov->lov_packed, i);
                         lov->lov_tgts[i] = NULL;
                         lov->lov_death_row--;
                 }
@@ -537,7 +537,7 @@ static int lov_add_target(struct obd_device *obd, struct obd_uuid *uuidp,
                 RETURN(-ENOMEM);
         }
 
-       rc = tgt_pool_add(&lov->lov_packed, index, lov->lov_tgt_size);
+       rc = lu_tgt_pool_add(&lov->lov_packed, index, lov->lov_tgt_size);
         if (rc) {
                mutex_unlock(&lov->lov_lock);
                 OBD_FREE_PTR(tgt);
@@ -755,7 +755,7 @@ int lov_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
        if (rc)
                GOTO(out, rc);
 
-       rc = tgt_pool_init(&lov->lov_packed, 0);
+       rc = lu_tgt_pool_init(&lov->lov_packed, 0);
         if (rc)
                GOTO(out, rc);
 
@@ -792,7 +792,7 @@ static int lov_cleanup(struct obd_device *obd)
                 lov_pool_del(obd, pool->pool_name);
         }
        lov_pool_hash_destroy(&lov->lov_pools_hash_body);
-       tgt_pool_free(&lov->lov_packed);
+       lu_tgt_pool_free(&lov->lov_packed);
 
        lprocfs_obd_cleanup(obd);
         if (lov->lov_tgts) {
@@ -1244,7 +1244,7 @@ static int lov_quotactl(struct obd_device *obd, struct obd_export *exp,
                         continue;
 
                if (pool &&
-                   tgt_check_index(tgt->ltd_index, &pool->pool_obds))
+                   lu_tgt_check_index(tgt->ltd_index, &pool->pool_obds))
                        continue;
 
                if (!tgt->ltd_active || tgt->ltd_reap) {

diff --git a/lustre/lov/lov_pool.c b/lustre/lov/lov_pool.c
index c44963c..5ce1741 100644 (file)
--- a/lustre/lov/lov_pool.c
+++ b/lustre/lov/lov_pool.c
@@ -86,7 +86,7 @@ void lov_pool_putref(struct pool_desc *pool)
        if (atomic_dec_and_test(&pool->pool_refcount)) {
                LASSERT(list_empty(&pool->pool_list));
                LASSERT(pool->pool_proc_entry == NULL);
-               tgt_pool_free(&(pool->pool_obds));
+               lu_tgt_pool_free(&(pool->pool_obds));
                kfree_rcu(pool, pool_rcu);
                EXIT;
        }
@@ -271,7 +271,7 @@ int lov_pool_new(struct obd_device *obd, char *poolname)
         * up to deletion
         */
        atomic_set(&new_pool->pool_refcount, 1);
-       rc = tgt_pool_init(&new_pool->pool_obds, 0);
+       rc = lu_tgt_pool_init(&new_pool->pool_obds, 0);
        if (rc)
                GOTO(out_err, rc);
 
@@ -320,7 +320,7 @@ out_err:
        lov->lov_pool_count--;
        spin_unlock(&obd->obd_dev_lock);
         lprocfs_remove(&new_pool->pool_proc_entry);
-       tgt_pool_free(&new_pool->pool_obds);
+       lu_tgt_pool_free(&new_pool->pool_obds);
        OBD_FREE_PTR(new_pool);
 
        return rc;
@@ -416,7 +416,7 @@ int lov_pool_add(struct obd_device *obd, char *poolname, char *ostname)
         if (lov_idx == lov->desc.ld_tgt_count)
                 GOTO(out, rc = -EINVAL);
 
-       rc = tgt_pool_add(&pool->pool_obds, lov_idx, lov->lov_tgt_size);
+       rc = lu_tgt_pool_add(&pool->pool_obds, lov_idx, lov->lov_tgt_size);
         if (rc)
                 GOTO(out, rc);
 
@@ -469,7 +469,7 @@ int lov_pool_remove(struct obd_device *obd, char *poolname, char *ostname)
         if (lov_idx == lov->desc.ld_tgt_count)
                 GOTO(out, rc = -EINVAL);
 
-       tgt_pool_remove(&pool->pool_obds, lov_idx);
+       lu_tgt_pool_remove(&pool->pool_obds, lov_idx);
 
         CDEBUG(D_CONFIG, "%s removed from "LOV_POOLNAMEF"\n", ostname,
                poolname);

diff --git a/lustre/obdclass/lu_tgt_pool.c b/lustre/obdclass/lu_tgt_pool.c
index 488dfc2..bd8aa1d 100644 (file)
--- a/lustre/obdclass/lu_tgt_pool.c
+++ b/lustre/obdclass/lu_tgt_pool.c
@@ -60,7 +60,7 @@
  * \retval             negative error number on failure
  */
 #define POOL_INIT_COUNT 2
-int tgt_pool_init(struct lu_tgt_pool *op, unsigned int count)
+int lu_tgt_pool_init(struct lu_tgt_pool *op, unsigned int count)
 {
        ENTRY;
 
@@ -78,7 +78,7 @@ int tgt_pool_init(struct lu_tgt_pool *op, unsigned int count)
        EXIT;
        return 0;
 }
-EXPORT_SYMBOL(tgt_pool_init);
+EXPORT_SYMBOL(lu_tgt_pool_init);
 
 /**
  * Increase the op_array size to hold more targets in this pool.
@@ -93,7 +93,7 @@ EXPORT_SYMBOL(tgt_pool_init);
  * \retval             0 on success
  * \retval             negative error number on failure.
  */
-int tgt_pool_extend(struct lu_tgt_pool *op, unsigned int min_count)
+int lu_tgt_pool_extend(struct lu_tgt_pool *op, unsigned int min_count)
 {
        __u32 *new;
        __u32 new_size;
@@ -117,7 +117,7 @@ int tgt_pool_extend(struct lu_tgt_pool *op, unsigned int min_count)
 
        return 0;
 }
-EXPORT_SYMBOL(tgt_pool_extend);
+EXPORT_SYMBOL(lu_tgt_pool_extend);
 
 /**
  * Add a new target to an existing pool.
@@ -132,7 +132,7 @@ EXPORT_SYMBOL(tgt_pool_extend);
  * \retval             0 if target could be added to the pool
  * \retval             negative error if target \a idx was not added
  */
-int tgt_pool_add(struct lu_tgt_pool *op, __u32 idx, unsigned int min_count)
+int lu_tgt_pool_add(struct lu_tgt_pool *op, __u32 idx, unsigned int min_count)
 {
        unsigned int i;
        int rc = 0;
@@ -140,7 +140,7 @@ int tgt_pool_add(struct lu_tgt_pool *op, __u32 idx, unsigned int min_count)
 
        down_write(&op->op_rw_sem);
 
-       rc = tgt_pool_extend(op, min_count);
+       rc = lu_tgt_pool_extend(op, min_count);
        if (rc)
                GOTO(out, rc);
 
@@ -157,7 +157,7 @@ out:
        up_write(&op->op_rw_sem);
        return rc;
 }
-EXPORT_SYMBOL(tgt_pool_add);
+EXPORT_SYMBOL(lu_tgt_pool_add);
 
 /**
  * Remove an existing pool from the system.
@@ -173,7 +173,7 @@ EXPORT_SYMBOL(tgt_pool_add);
  * \retval             0 on success
  * \retval             negative error number on failure
  */
-int tgt_pool_remove(struct lu_tgt_pool *op, __u32 idx)
+int lu_tgt_pool_remove(struct lu_tgt_pool *op, __u32 idx)
 {
        unsigned int i;
        ENTRY;
@@ -195,9 +195,9 @@ int tgt_pool_remove(struct lu_tgt_pool *op, __u32 idx)
        up_write(&op->op_rw_sem);
        RETURN(-EINVAL);
 }
-EXPORT_SYMBOL(tgt_pool_remove);
+EXPORT_SYMBOL(lu_tgt_pool_remove);
 
-int tgt_check_index(int idx, struct lu_tgt_pool *osts)
+int lu_tgt_check_index(int idx, struct lu_tgt_pool *osts)
 {
        int rc, i;
        ENTRY;
@@ -213,7 +213,7 @@ out:
        up_read(&osts->op_rw_sem);
        return rc;
 }
-EXPORT_SYMBOL(tgt_check_index);
+EXPORT_SYMBOL(lu_tgt_check_index);
 
 /**
  * Free the pool after it was emptied and removed from /proc.
@@ -226,7 +226,7 @@ EXPORT_SYMBOL(tgt_check_index);
  *
  * \retval             0 on success or if pool was already freed
  */
-int tgt_pool_free(struct lu_tgt_pool *op)
+int lu_tgt_pool_free(struct lu_tgt_pool *op)
 {
        ENTRY;
 
@@ -243,4 +243,4 @@ int tgt_pool_free(struct lu_tgt_pool *op)
        up_write(&op->op_rw_sem);
        RETURN(0);
 }
-EXPORT_SYMBOL(tgt_pool_free);
+EXPORT_SYMBOL(lu_tgt_pool_free);

diff --git a/lustre/quota/qmt_pool.c b/lustre/quota/qmt_pool.c
index 0806d75..8d4fee7 100644 (file)
--- a/lustre/quota/qmt_pool.c
+++ b/lustre/quota/qmt_pool.c
@@ -1510,7 +1510,7 @@ static inline int qmt_sarr_pool_init(struct qmt_pool_info *qpi)
 
        switch (qpi->qpi_rtype) {
        case LQUOTA_RES_DT:
-               return tgt_pool_init(&qpi->qpi_sarr.osts, 0);
+               return lu_tgt_pool_init(&qpi->qpi_sarr.osts, 0);
        case LQUOTA_RES_MD:
        default:
                return 0;
@@ -1521,7 +1521,7 @@ static inline int qmt_sarr_pool_add(struct qmt_pool_info *qpi, int idx, int min)
 {
        switch (qpi->qpi_rtype) {
        case LQUOTA_RES_DT:
-               return tgt_pool_add(&qpi->qpi_sarr.osts, idx, min);
+               return lu_tgt_pool_add(&qpi->qpi_sarr.osts, idx, min);
        case LQUOTA_RES_MD:
        default:
                return 0;
@@ -1532,7 +1532,7 @@ static inline int qmt_sarr_pool_rem(struct qmt_pool_info *qpi, int idx)
 {
        switch (qpi->qpi_rtype) {
        case LQUOTA_RES_DT:
-               return tgt_pool_remove(&qpi->qpi_sarr.osts, idx);
+               return lu_tgt_pool_remove(&qpi->qpi_sarr.osts, idx);
        case LQUOTA_RES_MD:
        default:
                return 0;
@@ -1548,7 +1548,7 @@ static inline int qmt_sarr_pool_free(struct qmt_pool_info *qpi)
        case LQUOTA_RES_DT:
                if (!qpi->qpi_sarr.osts.op_array)
                        return 0;
-               return tgt_pool_free(&qpi->qpi_sarr.osts);
+               return lu_tgt_pool_free(&qpi->qpi_sarr.osts);
        case LQUOTA_RES_MD:
        default:
                return 0;
@@ -1562,7 +1562,7 @@ static inline int qmt_sarr_check_idx(struct qmt_pool_info *qpi, int idx)
 
        switch (qpi->qpi_rtype) {
        case LQUOTA_RES_DT:
-               return tgt_check_index(idx, &qpi->qpi_sarr.osts);
+               return lu_tgt_check_index(idx, &qpi->qpi_sarr.osts);
        case LQUOTA_RES_MD:
        default:
                return 0;