LU-4825 osp: rename variables to match /proc entry

Rename the opd_pre_min_grow_count, opd_pre_max_grow_count,
opd_pre_grow_slow, and opd_pre_grow_count to opd_pre_min_create_count,
opd_pre_max_create_count, opd_pre_create_slow and opd_pre_create_count
respectively, for consistency with /proc files osp.*.max_create_count
and osp.*.create_count to make them easier to find, and also many
other internal functions are named "precreate" instead of "grow".

Signed-off-by: Andreas Dilger <andreas.dilger@intel.com>
Change-Id: I3a3ef3a0f13d593e9d0f8cedb53cc690528c0c7f
Reviewed-on: http://review.whamcloud.com/16032
Tested-by: Jenkins
Reviewed-by: Jian Yu <jian.yu@intel.com>
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>

diff --git a/lustre/osp/lproc_osp.c b/lustre/osp/lproc_osp.c
index 12c91c4..422b388 100644 (file)
--- a/lustre/osp/lproc_osp.c
+++ b/lustre/osp/lproc_osp.c
@@ -310,7 +310,7 @@ static int osp_create_count_seq_show(struct seq_file *m, void *data)
        if (osp == NULL || osp->opd_pre == NULL)
                return 0;
 
-       return seq_printf(m, "%d\n", osp->opd_pre_grow_count);
+       return seq_printf(m, "%d\n", osp->opd_pre_create_count);
 }
 
 /**
@@ -351,12 +351,12 @@ osp_create_count_seq_write(struct file *file, const char __user *buffer,
         * filesystem as a safety measure. */
        if (val < OST_MIN_PRECREATE || val > OST_MAX_PRECREATE)
                return -ERANGE;
-       if (val > osp->opd_pre_max_grow_count)
+       if (val > osp->opd_pre_max_create_count)
                return -ERANGE;
 
        for (i = 1; (i << 1) <= val; i <<= 1)
                ;
-       osp->opd_pre_grow_count = i;
+       osp->opd_pre_create_count = i;
 
        return count;
 }
@@ -378,7 +378,7 @@ static int osp_max_create_count_seq_show(struct seq_file *m, void *data)
        if (osp == NULL || osp->opd_pre == NULL)
                return 0;
 
-       return seq_printf(m, "%d\n", osp->opd_pre_max_grow_count);
+       return seq_printf(m, "%d\n", osp->opd_pre_max_create_count);
 }
 
 /**
@@ -412,10 +412,10 @@ osp_max_create_count_seq_write(struct file *file, const char __user *buffer,
        if (val > OST_MAX_PRECREATE)
                return -ERANGE;
 
-       if (osp->opd_pre_grow_count > val)
-               osp->opd_pre_grow_count = val;
+       if (osp->opd_pre_create_count > val)
+               osp->opd_pre_create_count = val;
 
-       osp->opd_pre_max_grow_count = val;
+       osp->opd_pre_max_create_count = val;
 
        return count;
 }

diff --git a/lustre/osp/osp_internal.h b/lustre/osp/osp_internal.h
index 1352d64..2a32244 100644 (file)
--- a/lustre/osp/osp_internal.h
+++ b/lustre/osp/osp_internal.h
@@ -84,12 +84,12 @@ struct osp_precreate {
        wait_queue_head_t                osp_pre_user_waitq;
        /* current precreation status: working, failed, stopping? */
        int                              osp_pre_status;
-       /* how many to precreate next time */
-       int                              osp_pre_grow_count;
-       int                              osp_pre_min_grow_count;
-       int                              osp_pre_max_grow_count;
-       /* whether to grow precreation window next time or not */
-       int                              osp_pre_grow_slow;
+       /* how many objects to precreate next time */
+       int                              osp_pre_create_count;
+       int                              osp_pre_min_create_count;
+       int                              osp_pre_max_create_count;
+       /* whether to increase precreation window next time or not */
+       int                              osp_pre_create_slow;
        /* cleaning up orphans or recreating missing objects */
        int                              osp_pre_recovering;
 };
@@ -256,10 +256,10 @@ struct osp_device {
 #define opd_pre_reserved               opd_pre->osp_pre_reserved
 #define opd_pre_user_waitq             opd_pre->osp_pre_user_waitq
 #define opd_pre_status                 opd_pre->osp_pre_status
-#define opd_pre_grow_count             opd_pre->osp_pre_grow_count
-#define opd_pre_min_grow_count         opd_pre->osp_pre_min_grow_count
-#define opd_pre_max_grow_count         opd_pre->osp_pre_max_grow_count
-#define opd_pre_grow_slow              opd_pre->osp_pre_grow_slow
+#define opd_pre_create_count           opd_pre->osp_pre_create_count
+#define opd_pre_min_create_count       opd_pre->osp_pre_min_create_count
+#define opd_pre_max_create_count       opd_pre->osp_pre_max_create_count
+#define opd_pre_create_slow            opd_pre->osp_pre_create_slow
 #define opd_pre_recovering             opd_pre->osp_pre_recovering
 
 extern struct kmem_cache *osp_object_kmem;

diff --git a/lustre/osp/osp_precreate.c b/lustre/osp/osp_precreate.c
index c03eea9..3578236 100644 (file)
--- a/lustre/osp/osp_precreate.c
+++ b/lustre/osp/osp_precreate.c
@@ -277,7 +277,7 @@ static inline int osp_precreate_near_empty_nolock(const struct lu_env *env,
 
        /* don't consider new precreation till OST is healty and
         * has free space */
-       return ((window - d->opd_pre_reserved < d->opd_pre_grow_count / 2) &&
+       return ((window - d->opd_pre_reserved < d->opd_pre_create_count / 2) &&
                (d->opd_pre_status == 0));
 }
 
@@ -575,9 +575,9 @@ static int osp_precreate_send(const struct lu_env *env, struct osp_device *d)
        }
 
        spin_lock(&d->opd_pre_lock);
-       if (d->opd_pre_grow_count > d->opd_pre_max_grow_count / 2)
-               d->opd_pre_grow_count = d->opd_pre_max_grow_count / 2;
-       grow = d->opd_pre_grow_count;
+       if (d->opd_pre_create_count > d->opd_pre_max_create_count / 2)
+               d->opd_pre_create_count = d->opd_pre_max_create_count / 2;
+       grow = d->opd_pre_create_count;
        spin_unlock(&d->opd_pre_lock);
 
        body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY);
@@ -633,13 +633,13 @@ static int osp_precreate_send(const struct lu_env *env, struct osp_device *d)
        if (diff < grow) {
                /* the OST has not managed to create all the
                 * objects we asked for */
-               d->opd_pre_grow_count = max(diff, OST_MIN_PRECREATE);
-               d->opd_pre_grow_slow = 1;
+               d->opd_pre_create_count = max(diff, OST_MIN_PRECREATE);
+               d->opd_pre_create_slow = 1;
        } else {
                /* the OST is able to keep up with the work,
-                * we could consider increasing grow_count
+                * we could consider increasing create_count
                 * next time if needed */
-               d->opd_pre_grow_slow = 0;
+               d->opd_pre_create_slow = 0;
        }
 
        body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY);
@@ -861,10 +861,10 @@ static int osp_precreate_cleanup_orphans(struct lu_env *env,
        spin_lock(&d->opd_pre_lock);
        diff = osp_fid_diff(&d->opd_last_used_fid, last_fid);
        if (diff > 0) {
-               d->opd_pre_grow_count = OST_MIN_PRECREATE + diff;
+               d->opd_pre_create_count = OST_MIN_PRECREATE + diff;
                d->opd_pre_last_created_fid = d->opd_last_used_fid;
        } else {
-               d->opd_pre_grow_count = OST_MIN_PRECREATE;
+               d->opd_pre_create_count = OST_MIN_PRECREATE;
                d->opd_pre_last_created_fid = *last_fid;
        }
        /*
@@ -874,7 +874,7 @@ static int osp_precreate_cleanup_orphans(struct lu_env *env,
        LASSERT(fid_oid(&d->opd_pre_last_created_fid) <=
                LUSTRE_DATA_SEQ_MAX_WIDTH);
        d->opd_pre_used_fid = d->opd_pre_last_created_fid;
-       d->opd_pre_grow_slow = 0;
+       d->opd_pre_create_slow = 0;
        spin_unlock(&d->opd_pre_lock);
 
        CDEBUG(D_HA, "%s: Got last_id "DFID" from OST, last_created "DFID
@@ -970,8 +970,8 @@ void osp_pre_update_status(struct osp_device *d, int rc)
                } else if (old == -ENOSPC) {
                        d->opd_pre_status = 0;
                        spin_lock(&d->opd_pre_lock);
-                       d->opd_pre_grow_slow = 0;
-                       d->opd_pre_grow_count = OST_MIN_PRECREATE;
+                       d->opd_pre_create_slow = 0;
+                       d->opd_pre_create_count = OST_MIN_PRECREATE;
                        spin_unlock(&d->opd_pre_lock);
                        wake_up(&d->opd_pre_waitq);
                        CDEBUG(D_INFO, "%s: no space: "LPU64" blocks, "LPU64
@@ -1312,12 +1312,12 @@ int osp_precreate_reserve(const struct lu_env *env, struct osp_device *d)
                 * increase number of precreations
                 */
                precreated = osp_objs_precreated(env, d);
-               if (d->opd_pre_grow_count < d->opd_pre_max_grow_count &&
-                   d->opd_pre_grow_slow == 0 &&
-                   precreated <= (d->opd_pre_grow_count / 4 + 1)) {
+               if (d->opd_pre_create_count < d->opd_pre_max_create_count &&
+                   d->opd_pre_create_slow == 0 &&
+                   precreated <= (d->opd_pre_create_count / 4 + 1)) {
                        spin_lock(&d->opd_pre_lock);
-                       d->opd_pre_grow_slow = 1;
-                       d->opd_pre_grow_count *= 2;
+                       d->opd_pre_create_slow = 1;
+                       d->opd_pre_create_count *= 2;
                        spin_unlock(&d->opd_pre_lock);
                }
 
@@ -1544,10 +1544,10 @@ int osp_init_precreate(struct osp_device *d)
        d->opd_pre_last_created_fid.f_oid = 1;
        d->opd_pre_reserved = 0;
        d->opd_got_disconnected = 1;
-       d->opd_pre_grow_slow = 0;
-       d->opd_pre_grow_count = OST_MIN_PRECREATE;
-       d->opd_pre_min_grow_count = OST_MIN_PRECREATE;
-       d->opd_pre_max_grow_count = OST_MAX_PRECREATE;
+       d->opd_pre_create_slow = 0;
+       d->opd_pre_create_count = OST_MIN_PRECREATE;
+       d->opd_pre_min_create_count = OST_MIN_PRECREATE;
+       d->opd_pre_max_create_count = OST_MAX_PRECREATE;
 
        spin_lock_init(&d->opd_pre_lock);
        init_waitqueue_head(&d->opd_pre_waitq);