From 05bf10903eba13db3d152f2725de56243123e7c5 Mon Sep 17 00:00:00 2001 From: Andreas Dilger Date: Wed, 19 Aug 2015 23:58:25 -0600 Subject: [PATCH] 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 Change-Id: I3a3ef3a0f13d593e9d0f8cedb53cc690528c0c7f Reviewed-on: http://review.whamcloud.com/16032 Tested-by: Jenkins Reviewed-by: Jian Yu Tested-by: Maloo Reviewed-by: James Simmons Reviewed-by: Oleg Drokin --- lustre/osp/lproc_osp.c | 14 +++++++------- lustre/osp/osp_internal.h | 20 ++++++++++---------- lustre/osp/osp_precreate.c | 44 ++++++++++++++++++++++---------------------- 3 files changed, 39 insertions(+), 39 deletions(-) diff --git a/lustre/osp/lproc_osp.c b/lustre/osp/lproc_osp.c index 12c91c4..422b388 100644 --- 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 --- 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..35782365 100644 --- 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); -- 1.8.3.1