X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fldlm%2Fldlm_pool.c;h=d724a2decbf6a97a4542e1debe8b8f24b2464dd3;hb=d46a76cd7bb2b657a6daabbe18b993abeedb2d94;hp=4b92fcb103543dccb7500818b0b584ba75704ba1;hpb=3b3076ac2c58c5dec52aa9717fd1dfd1ebca5930;p=fs%2Flustre-release.git diff --git a/lustre/ldlm/ldlm_pool.c b/lustre/ldlm/ldlm_pool.c index 4b92fcb..d724a2d 100644 --- a/lustre/ldlm/ldlm_pool.c +++ b/lustre/ldlm/ldlm_pool.c @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -26,8 +24,10 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2010, 2012, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -228,7 +228,7 @@ static inline int ldlm_pool_t2gsp(unsigned int t) * * \pre ->pl_lock is locked. */ -static inline void ldlm_pool_recalc_grant_plan(struct ldlm_pool *pl) +static void ldlm_pool_recalc_grant_plan(struct ldlm_pool *pl) { int granted, grant_step, limit; @@ -238,6 +238,9 @@ static inline void ldlm_pool_recalc_grant_plan(struct ldlm_pool *pl) grant_step = ldlm_pool_t2gsp(pl->pl_recalc_period); grant_step = ((limit - granted) * grant_step) / 100; pl->pl_grant_plan = granted + grant_step; + limit = (limit * 5) >> 2; + if (pl->pl_grant_plan > limit) + pl->pl_grant_plan = limit; } /** @@ -245,7 +248,7 @@ static inline void ldlm_pool_recalc_grant_plan(struct ldlm_pool *pl) * * \pre ->pl_lock is locked. */ -static inline void ldlm_pool_recalc_slv(struct ldlm_pool *pl) +static void ldlm_pool_recalc_slv(struct ldlm_pool *pl) { int granted; int grant_plan; @@ -273,10 +276,6 @@ static inline void ldlm_pool_recalc_slv(struct ldlm_pool *pl) */ slv_factor = (grant_usage << LDLM_POOL_SLV_SHIFT); do_div(slv_factor, limit); - if (2 * abs(granted - limit) > limit) { - slv_factor *= slv_factor; - slv_factor = dru(slv_factor, LDLM_POOL_SLV_SHIFT, round_up); - } slv = slv * slv_factor; slv = dru(slv, LDLM_POOL_SLV_SHIFT, round_up); @@ -294,7 +293,7 @@ static inline void ldlm_pool_recalc_slv(struct ldlm_pool *pl) * * \pre ->pl_lock is locked. */ -static inline void ldlm_pool_recalc_stats(struct ldlm_pool *pl) +static void ldlm_pool_recalc_stats(struct ldlm_pool *pl) { int grant_plan = pl->pl_grant_plan; __u64 slv = pl->pl_server_lock_volume; @@ -330,9 +329,9 @@ static void ldlm_srv_pool_push_slv(struct ldlm_pool *pl) */ obd = ldlm_pl2ns(pl)->ns_obd; LASSERT(obd != NULL); - cfs_write_lock(&obd->obd_pool_lock); + write_lock(&obd->obd_pool_lock); obd->obd_pool_slv = pl->pl_server_lock_volume; - cfs_write_unlock(&obd->obd_pool_lock); + write_unlock(&obd->obd_pool_lock); } /** @@ -345,32 +344,37 @@ static int ldlm_srv_pool_recalc(struct ldlm_pool *pl) time_t recalc_interval_sec; ENTRY; - cfs_spin_lock(&pl->pl_lock); recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; - if (recalc_interval_sec >= pl->pl_recalc_period) { - /* - * Recalc SLV after last period. This should be done - * _before_ recalculating new grant plan. - */ - ldlm_pool_recalc_slv(pl); + if (recalc_interval_sec < pl->pl_recalc_period) + RETURN(0); - /* - * Make sure that pool informed obd of last SLV changes. - */ - ldlm_srv_pool_push_slv(pl); + spin_lock(&pl->pl_lock); + recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; + if (recalc_interval_sec < pl->pl_recalc_period) { + spin_unlock(&pl->pl_lock); + RETURN(0); + } + /* + * Recalc SLV after last period. This should be done + * _before_ recalculating new grant plan. + */ + ldlm_pool_recalc_slv(pl); - /* - * Update grant_plan for new period. - */ - ldlm_pool_recalc_grant_plan(pl); + /* + * Make sure that pool informed obd of last SLV changes. + */ + ldlm_srv_pool_push_slv(pl); - pl->pl_recalc_time = cfs_time_current_sec(); - lprocfs_counter_add(pl->pl_stats, LDLM_POOL_TIMING_STAT, - recalc_interval_sec); - } + /* + * Update grant_plan for new period. + */ + ldlm_pool_recalc_grant_plan(pl); - cfs_spin_unlock(&pl->pl_lock); - RETURN(0); + pl->pl_recalc_time = cfs_time_current_sec(); + lprocfs_counter_add(pl->pl_stats, LDLM_POOL_TIMING_STAT, + recalc_interval_sec); + spin_unlock(&pl->pl_lock); + RETURN(0); } /** @@ -399,7 +403,7 @@ static int ldlm_srv_pool_shrink(struct ldlm_pool *pl, if (cfs_atomic_read(&pl->pl_granted) == 0) RETURN(0); - cfs_spin_lock(&pl->pl_lock); + spin_lock(&pl->pl_lock); /* * We want shrinker to possibly cause cancellation of @nr locks from @@ -424,13 +428,13 @@ static int ldlm_srv_pool_shrink(struct ldlm_pool *pl, * Make sure that pool informed obd of last SLV changes. */ ldlm_srv_pool_push_slv(pl); - cfs_spin_unlock(&pl->pl_lock); + spin_unlock(&pl->pl_lock); - /* - * We did not really free any memory here so far, it only will be - * freed later may be, so that we return 0 to not confuse VM. - */ - return 0; + /* + * We did not really free any memory here so far, it only will be + * freed later may be, so that we return 0 to not confuse VM. + */ + return 0; } /** @@ -439,17 +443,16 @@ static int ldlm_srv_pool_shrink(struct ldlm_pool *pl, static int ldlm_srv_pool_setup(struct ldlm_pool *pl, int limit) { struct obd_device *obd; - ENTRY; obd = ldlm_pl2ns(pl)->ns_obd; LASSERT(obd != NULL && obd != LP_POISON); LASSERT(obd->obd_type != LP_POISON); - cfs_write_lock(&obd->obd_pool_lock); + write_lock(&obd->obd_pool_lock); obd->obd_pool_limit = limit; - cfs_write_unlock(&obd->obd_pool_lock); + write_unlock(&obd->obd_pool_lock); ldlm_pool_set_limit(pl, limit); - RETURN(0); + return 0; } /** @@ -465,10 +468,10 @@ static void ldlm_cli_pool_pop_slv(struct ldlm_pool *pl) */ obd = ldlm_pl2ns(pl)->ns_obd; LASSERT(obd != NULL); - cfs_read_lock(&obd->obd_pool_lock); + read_lock(&obd->obd_pool_lock); pl->pl_server_lock_volume = obd->obd_pool_slv; ldlm_pool_set_limit(pl, obd->obd_pool_limit); - cfs_read_unlock(&obd->obd_pool_lock); + read_unlock(&obd->obd_pool_lock); } /** @@ -479,13 +482,17 @@ static int ldlm_cli_pool_recalc(struct ldlm_pool *pl) time_t recalc_interval_sec; ENTRY; - cfs_spin_lock(&pl->pl_lock); - /* - * Check if we need to recalc lists now. - */ recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; - if (recalc_interval_sec < pl->pl_recalc_period) { - cfs_spin_unlock(&pl->pl_lock); + if (recalc_interval_sec < pl->pl_recalc_period) + RETURN(0); + + spin_lock(&pl->pl_lock); + /* + * Check if we need to recalc lists now. + */ + recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; + if (recalc_interval_sec < pl->pl_recalc_period) { + spin_unlock(&pl->pl_lock); RETURN(0); } @@ -497,7 +504,7 @@ static int ldlm_cli_pool_recalc(struct ldlm_pool *pl) pl->pl_recalc_time = cfs_time_current_sec(); lprocfs_counter_add(pl->pl_stats, LDLM_POOL_TIMING_STAT, recalc_interval_sec); - cfs_spin_unlock(&pl->pl_lock); + spin_unlock(&pl->pl_lock); /* * Do not cancel locks in case lru resize is disabled for this ns. @@ -511,8 +518,8 @@ static int ldlm_cli_pool_recalc(struct ldlm_pool *pl) * It may be called when SLV has changed much, this is why we do not * take into account pl->pl_recalc_time here. */ - RETURN(ldlm_cancel_lru(ldlm_pl2ns(pl), 0, LDLM_SYNC, - LDLM_CANCEL_LRUR)); + RETURN(ldlm_cancel_lru(ldlm_pl2ns(pl), 0, LCF_ASYNC, + LDLM_CANCEL_LRUR)); } /** @@ -539,13 +546,13 @@ static int ldlm_cli_pool_shrink(struct ldlm_pool *pl, */ ldlm_cli_pool_pop_slv(pl); - cfs_spin_lock(&ns->ns_unused_lock); - unused = ns->ns_nr_unused; - cfs_spin_unlock(&ns->ns_unused_lock); - + spin_lock(&ns->ns_lock); + unused = ns->ns_nr_unused; + spin_unlock(&ns->ns_lock); + if (nr) { - canceled = ldlm_cancel_lru(ns, nr, LDLM_SYNC, - LDLM_CANCEL_SHRINK); + canceled = ldlm_cancel_lru(ns, nr, LCF_ASYNC, + LDLM_CANCEL_SHRINK); } #ifdef __KERNEL__ /* @@ -577,7 +584,11 @@ int ldlm_pool_recalc(struct ldlm_pool *pl) time_t recalc_interval_sec; int count; - cfs_spin_lock(&pl->pl_lock); + recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; + if (recalc_interval_sec <= 0) + goto recalc; + + spin_lock(&pl->pl_lock); recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; if (recalc_interval_sec > 0) { /* @@ -590,10 +601,10 @@ int ldlm_pool_recalc(struct ldlm_pool *pl) */ cfs_atomic_set(&pl->pl_grant_rate, 0); cfs_atomic_set(&pl->pl_cancel_rate, 0); - cfs_atomic_set(&pl->pl_grant_speed, 0); } - cfs_spin_unlock(&pl->pl_lock); + spin_unlock(&pl->pl_lock); + recalc: if (pl->pl_ops->po_recalc != NULL) { count = pl->pl_ops->po_recalc(pl); lprocfs_counter_add(pl->pl_stats, LDLM_POOL_RECALC_STAT, @@ -639,10 +650,9 @@ EXPORT_SYMBOL(ldlm_pool_shrink); */ int ldlm_pool_setup(struct ldlm_pool *pl, int limit) { - ENTRY; if (pl->pl_ops->po_setup != NULL) - RETURN(pl->pl_ops->po_setup(pl, limit)); - RETURN(0); + return(pl->pl_ops->po_setup(pl, limit)); + return 0; } EXPORT_SYMBOL(ldlm_pool_setup); @@ -656,18 +666,18 @@ static int lprocfs_rd_pool_state(char *page, char **start, off_t off, __u64 slv, clv; __u32 limit; - cfs_spin_lock(&pl->pl_lock); + spin_lock(&pl->pl_lock); slv = pl->pl_server_lock_volume; clv = pl->pl_client_lock_volume; limit = ldlm_pool_get_limit(pl); grant_plan = pl->pl_grant_plan; granted = cfs_atomic_read(&pl->pl_granted); grant_rate = cfs_atomic_read(&pl->pl_grant_rate); - lvf = cfs_atomic_read(&pl->pl_lock_volume_factor); - grant_speed = cfs_atomic_read(&pl->pl_grant_speed); cancel_rate = cfs_atomic_read(&pl->pl_cancel_rate); + grant_speed = grant_rate - cancel_rate; + lvf = cfs_atomic_read(&pl->pl_lock_volume_factor); grant_step = ldlm_pool_t2gsp(pl->pl_recalc_period); - cfs_spin_unlock(&pl->pl_lock); + spin_unlock(&pl->pl_lock); nr += snprintf(page + nr, count - nr, "LDLM pool state (%s):\n", pl->pl_name); @@ -694,6 +704,20 @@ static int lprocfs_rd_pool_state(char *page, char **start, off_t off, return nr; } +static int lprocfs_rd_grant_speed(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct ldlm_pool *pl = data; + int grant_speed; + + spin_lock(&pl->pl_lock); + /* serialize with ldlm_pool_recalc */ + grant_speed = cfs_atomic_read(&pl->pl_grant_rate) - + cfs_atomic_read(&pl->pl_cancel_rate); + spin_unlock(&pl->pl_lock); + return lprocfs_rd_uint(page, start, off, count, eof, &grant_speed); +} + LDLM_POOL_PROC_READER(grant_plan, int); LDLM_POOL_PROC_READER(recalc_period, int); LDLM_POOL_PROC_WRITER(recalc_period, int); @@ -711,10 +735,11 @@ static int ldlm_pool_proc_init(struct ldlm_pool *pl) if (!var_name) RETURN(-ENOMEM); - parent_ns_proc = lprocfs_srch(ldlm_ns_proc_dir, ns->ns_name); + parent_ns_proc = lprocfs_srch(ldlm_ns_proc_dir, + ldlm_ns_name(ns)); if (parent_ns_proc == NULL) { CERROR("%s: proc entry is not initialized\n", - ns->ns_name); + ldlm_ns_name(ns)); GOTO(out_free_name, rc = -EINVAL); } pl->pl_proc_dir = lprocfs_register("pool", parent_ns_proc, @@ -746,8 +771,8 @@ static int ldlm_pool_proc_init(struct ldlm_pool *pl) lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); snprintf(var_name, MAX_STRING_SIZE, "grant_speed"); - pool_vars[0].data = &pl->pl_grant_speed; - pool_vars[0].read_fptr = lprocfs_rd_atomic; + pool_vars[0].data = pl; + pool_vars[0].read_fptr = lprocfs_rd_grant_speed; lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); snprintf(var_name, MAX_STRING_SIZE, "cancel_rate"); @@ -820,7 +845,7 @@ static int ldlm_pool_proc_init(struct ldlm_pool *pl) lprocfs_counter_init(pl->pl_stats, LDLM_POOL_TIMING_STAT, LPROCFS_CNTR_AVGMINMAX | LPROCFS_CNTR_STDDEV, "recalc_timing", "sec"); - lprocfs_register_stats(pl->pl_proc_dir, "stats", pl->pl_stats); + rc = lprocfs_register_stats(pl->pl_proc_dir, "stats", pl->pl_stats); EXIT; out_free_name: @@ -847,21 +872,20 @@ static void ldlm_pool_proc_fini(struct ldlm_pool *pl) int ldlm_pool_init(struct ldlm_pool *pl, struct ldlm_namespace *ns, int idx, ldlm_side_t client) { - int rc; - ENTRY; + int rc; + ENTRY; - cfs_spin_lock_init(&pl->pl_lock); + spin_lock_init(&pl->pl_lock); cfs_atomic_set(&pl->pl_granted, 0); pl->pl_recalc_time = cfs_time_current_sec(); cfs_atomic_set(&pl->pl_lock_volume_factor, 1); cfs_atomic_set(&pl->pl_grant_rate, 0); cfs_atomic_set(&pl->pl_cancel_rate, 0); - cfs_atomic_set(&pl->pl_grant_speed, 0); pl->pl_grant_plan = LDLM_POOL_GP(LDLM_POOL_HOST_L); snprintf(pl->pl_name, sizeof(pl->pl_name), "ldlm-pool-%s-%d", - ns->ns_name, idx); + ldlm_ns_name(ns), idx); if (client == LDLM_NAMESPACE_SERVER) { pl->pl_ops = &ldlm_srv_pool_ops; @@ -870,7 +894,7 @@ int ldlm_pool_init(struct ldlm_pool *pl, struct ldlm_namespace *ns, pl->pl_server_lock_volume = ldlm_pool_slv_max(LDLM_POOL_HOST_L); } else { ldlm_pool_set_limit(pl, 1); - pl->pl_server_lock_volume = 1; + pl->pl_server_lock_volume = 0; pl->pl_ops = &ldlm_cli_pool_ops; pl->pl_recalc_period = LDLM_POOL_CLI_DEF_RECALC_PERIOD; } @@ -913,13 +937,9 @@ void ldlm_pool_add(struct ldlm_pool *pl, struct ldlm_lock *lock) */ if (lock->l_resource->lr_type == LDLM_FLOCK) return; - ENTRY; - LDLM_DEBUG(lock, "add lock to pool"); cfs_atomic_inc(&pl->pl_granted); cfs_atomic_inc(&pl->pl_grant_rate); - cfs_atomic_inc(&pl->pl_grant_speed); - lprocfs_counter_incr(pl->pl_stats, LDLM_POOL_GRANT_STAT); /* * Do not do pool recalc for client side as all locks which @@ -929,7 +949,6 @@ void ldlm_pool_add(struct ldlm_pool *pl, struct ldlm_lock *lock) */ if (ns_is_server(ldlm_pl2ns(pl))) ldlm_pool_recalc(pl); - EXIT; } EXPORT_SYMBOL(ldlm_pool_add); @@ -943,19 +962,15 @@ void ldlm_pool_del(struct ldlm_pool *pl, struct ldlm_lock *lock) */ if (lock->l_resource->lr_type == LDLM_FLOCK) return; - ENTRY; - LDLM_DEBUG(lock, "del lock from pool"); LASSERT(cfs_atomic_read(&pl->pl_granted) > 0); cfs_atomic_dec(&pl->pl_granted); cfs_atomic_inc(&pl->pl_cancel_rate); - cfs_atomic_dec(&pl->pl_grant_speed); lprocfs_counter_incr(pl->pl_stats, LDLM_POOL_CANCEL_STAT); if (ns_is_server(ldlm_pl2ns(pl))) ldlm_pool_recalc(pl); - EXIT; } EXPORT_SYMBOL(ldlm_pool_del); @@ -966,11 +981,11 @@ EXPORT_SYMBOL(ldlm_pool_del); */ __u64 ldlm_pool_get_slv(struct ldlm_pool *pl) { - __u64 slv; - cfs_spin_lock(&pl->pl_lock); - slv = pl->pl_server_lock_volume; - cfs_spin_unlock(&pl->pl_lock); - return slv; + __u64 slv; + spin_lock(&pl->pl_lock); + slv = pl->pl_server_lock_volume; + spin_unlock(&pl->pl_lock); + return slv; } EXPORT_SYMBOL(ldlm_pool_get_slv); @@ -981,9 +996,9 @@ EXPORT_SYMBOL(ldlm_pool_get_slv); */ void ldlm_pool_set_slv(struct ldlm_pool *pl, __u64 slv) { - cfs_spin_lock(&pl->pl_lock); - pl->pl_server_lock_volume = slv; - cfs_spin_unlock(&pl->pl_lock); + spin_lock(&pl->pl_lock); + pl->pl_server_lock_volume = slv; + spin_unlock(&pl->pl_lock); } EXPORT_SYMBOL(ldlm_pool_set_slv); @@ -994,11 +1009,11 @@ EXPORT_SYMBOL(ldlm_pool_set_slv); */ __u64 ldlm_pool_get_clv(struct ldlm_pool *pl) { - __u64 slv; - cfs_spin_lock(&pl->pl_lock); - slv = pl->pl_client_lock_volume; - cfs_spin_unlock(&pl->pl_lock); - return slv; + __u64 slv; + spin_lock(&pl->pl_lock); + slv = pl->pl_client_lock_volume; + spin_unlock(&pl->pl_lock); + return slv; } EXPORT_SYMBOL(ldlm_pool_get_clv); @@ -1009,9 +1024,9 @@ EXPORT_SYMBOL(ldlm_pool_get_clv); */ void ldlm_pool_set_clv(struct ldlm_pool *pl, __u64 clv) { - cfs_spin_lock(&pl->pl_lock); - pl->pl_client_lock_volume = clv; - cfs_spin_unlock(&pl->pl_lock); + spin_lock(&pl->pl_lock); + pl->pl_client_lock_volume = clv; + spin_unlock(&pl->pl_lock); } EXPORT_SYMBOL(ldlm_pool_set_clv); @@ -1051,7 +1066,7 @@ static int ldlm_pool_granted(struct ldlm_pool *pl) static struct ptlrpc_thread *ldlm_pools_thread; static struct cfs_shrinker *ldlm_pools_srv_shrinker; static struct cfs_shrinker *ldlm_pools_cli_shrinker; -static cfs_completion_t ldlm_pools_comp; +static struct completion ldlm_pools_comp; /* * Cancel \a nr locks from all namespaces (if possible). Returns number of @@ -1065,7 +1080,8 @@ static int ldlm_pools_shrink(ldlm_side_t client, int nr, struct ldlm_namespace *ns; void *cookie; - if (nr != 0 && !(gfp_mask & __GFP_FS)) + if (client == LDLM_NAMESPACE_CLIENT && nr != 0 && + !(gfp_mask & __GFP_FS)) return -1; CDEBUG(D_DLMTRACE, "Request to shrink %d %s locks from all pools\n", @@ -1079,18 +1095,18 @@ static int ldlm_pools_shrink(ldlm_side_t client, int nr, for (nr_ns = cfs_atomic_read(ldlm_namespace_nr(client)); nr_ns > 0; nr_ns--) { - cfs_mutex_down(ldlm_namespace_lock(client)); + mutex_lock(ldlm_namespace_lock(client)); if (cfs_list_empty(ldlm_namespace_list(client))) { - cfs_mutex_up(ldlm_namespace_lock(client)); + mutex_unlock(ldlm_namespace_lock(client)); cl_env_reexit(cookie); return 0; } ns = ldlm_namespace_first_locked(client); ldlm_namespace_get(ns); ldlm_namespace_move_locked(ns, client); - cfs_mutex_up(ldlm_namespace_lock(client)); + mutex_unlock(ldlm_namespace_lock(client)); total += ldlm_pool_shrink(&ns->ns_pool, 0, gfp_mask); - ldlm_namespace_put(ns, 1); + ldlm_namespace_put(ns); } if (nr == 0 || total == 0) { @@ -1109,9 +1125,9 @@ static int ldlm_pools_shrink(ldlm_side_t client, int nr, /* * Do not call shrink under ldlm_namespace_lock(client) */ - cfs_mutex_down(ldlm_namespace_lock(client)); + mutex_lock(ldlm_namespace_lock(client)); if (cfs_list_empty(ldlm_namespace_list(client))) { - cfs_mutex_up(ldlm_namespace_lock(client)); + mutex_unlock(ldlm_namespace_lock(client)); /* * If list is empty, we can't return any @cached > 0, * that probably would cause needless shrinker @@ -1123,26 +1139,32 @@ static int ldlm_pools_shrink(ldlm_side_t client, int nr, ns = ldlm_namespace_first_locked(client); ldlm_namespace_get(ns); ldlm_namespace_move_locked(ns, client); - cfs_mutex_up(ldlm_namespace_lock(client)); + mutex_unlock(ldlm_namespace_lock(client)); nr_locks = ldlm_pool_granted(&ns->ns_pool); cancel = 1 + nr_locks * nr / total; ldlm_pool_shrink(&ns->ns_pool, cancel, gfp_mask); cached += ldlm_pool_granted(&ns->ns_pool); - ldlm_namespace_put(ns, 1); + ldlm_namespace_put(ns); } cl_env_reexit(cookie); - return cached; + /* we only decrease the SLV in server pools shrinker, return -1 to + * kernel to avoid needless loop. LU-1128 */ + return (client == LDLM_NAMESPACE_SERVER) ? -1 : cached; } -static int ldlm_pools_srv_shrink(int nr, unsigned int gfp_mask) +static int ldlm_pools_srv_shrink(SHRINKER_ARGS(sc, nr_to_scan, gfp_mask)) { - return ldlm_pools_shrink(LDLM_NAMESPACE_SERVER, nr, gfp_mask); + return ldlm_pools_shrink(LDLM_NAMESPACE_SERVER, + shrink_param(sc, nr_to_scan), + shrink_param(sc, gfp_mask)); } -static int ldlm_pools_cli_shrink(int nr, unsigned int gfp_mask) +static int ldlm_pools_cli_shrink(SHRINKER_ARGS(sc, nr_to_scan, gfp_mask)) { - return ldlm_pools_shrink(LDLM_NAMESPACE_CLIENT, nr, gfp_mask); + return ldlm_pools_shrink(LDLM_NAMESPACE_CLIENT, + shrink_param(sc, nr_to_scan), + shrink_param(sc, gfp_mask)); } void ldlm_pools_recalc(ldlm_side_t client) @@ -1158,7 +1180,7 @@ void ldlm_pools_recalc(ldlm_side_t client) /* * Check all modest namespaces first. */ - cfs_mutex_down(ldlm_namespace_lock(client)); + mutex_lock(ldlm_namespace_lock(client)); cfs_list_for_each_entry(ns, ldlm_namespace_list(client), ns_list_chain) { @@ -1221,7 +1243,7 @@ void ldlm_pools_recalc(ldlm_side_t client) } ldlm_pool_setup(&ns->ns_pool, l); } - cfs_mutex_up(ldlm_namespace_lock(client)); + mutex_unlock(ldlm_namespace_lock(client)); } /* @@ -1236,35 +1258,35 @@ void ldlm_pools_recalc(ldlm_side_t client) * rid of potential deadlock on client nodes when canceling * locks synchronously. */ - cfs_mutex_down(ldlm_namespace_lock(client)); - if (cfs_list_empty(ldlm_namespace_list(client))) { - cfs_mutex_up(ldlm_namespace_lock(client)); - break; - } - ns = ldlm_namespace_first_locked(client); - - cfs_spin_lock(&ns->ns_hash_lock); - /* - * skip ns which is being freed, and we don't want to increase - * its refcount again, not even temporarily. bz21519. - */ - if (ns->ns_refcount == 0) { - skip = 1; - } else { - skip = 0; - ldlm_namespace_get_locked(ns); - } - cfs_spin_unlock(&ns->ns_hash_lock); - - ldlm_namespace_move_locked(ns, client); - cfs_mutex_up(ldlm_namespace_lock(client)); + mutex_lock(ldlm_namespace_lock(client)); + if (cfs_list_empty(ldlm_namespace_list(client))) { + mutex_unlock(ldlm_namespace_lock(client)); + break; + } + ns = ldlm_namespace_first_locked(client); + + spin_lock(&ns->ns_lock); + /* + * skip ns which is being freed, and we don't want to increase + * its refcount again, not even temporarily. bz21519 & LU-499. + */ + if (ns->ns_stopping) { + skip = 1; + } else { + skip = 0; + ldlm_namespace_get(ns); + } + spin_unlock(&ns->ns_lock); + + ldlm_namespace_move_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); /* * After setup is done - recalc the pool. */ if (!skip) { ldlm_pool_recalc(&ns->ns_pool); - ldlm_namespace_put(ns, 1); + ldlm_namespace_put(ns); } } } @@ -1277,7 +1299,7 @@ static int ldlm_pools_thread_main(void *arg) ENTRY; cfs_daemonize(t_name); - thread->t_flags = SVC_RUNNING; + thread_set_flags(thread, SVC_RUNNING); cfs_waitq_signal(&thread->t_ctl_waitq); CDEBUG(D_DLMTRACE, "%s: pool thread starting, process %d\n", @@ -1298,25 +1320,24 @@ static int ldlm_pools_thread_main(void *arg) */ lwi = LWI_TIMEOUT(cfs_time_seconds(LDLM_POOLS_THREAD_PERIOD), NULL, NULL); - l_wait_event(thread->t_ctl_waitq, (thread->t_flags & - (SVC_STOPPING|SVC_EVENT)), + l_wait_event(thread->t_ctl_waitq, + thread_is_stopping(thread) || + thread_is_event(thread), &lwi); - if (thread->t_flags & SVC_STOPPING) { - thread->t_flags &= ~SVC_STOPPING; + if (thread_test_and_clear_flags(thread, SVC_STOPPING)) break; - } else if (thread->t_flags & SVC_EVENT) { - thread->t_flags &= ~SVC_EVENT; - } + else + thread_test_and_clear_flags(thread, SVC_EVENT); } - thread->t_flags = SVC_STOPPED; + thread_set_flags(thread, SVC_STOPPED); cfs_waitq_signal(&thread->t_ctl_waitq); CDEBUG(D_DLMTRACE, "%s: pool thread exiting, process %d\n", t_name, cfs_curproc_pid()); - cfs_complete_and_exit(&ldlm_pools_comp, 0); + complete_and_exit(&ldlm_pools_comp, 0); } static int ldlm_pools_thread_start(void) @@ -1332,15 +1353,15 @@ static int ldlm_pools_thread_start(void) if (ldlm_pools_thread == NULL) RETURN(-ENOMEM); - cfs_init_completion(&ldlm_pools_comp); + init_completion(&ldlm_pools_comp); cfs_waitq_init(&ldlm_pools_thread->t_ctl_waitq); /* * CLONE_VM and CLONE_FILES just avoid a needless copy, because we * just drop the VM and FILES in cfs_daemonize() right away. */ - rc = cfs_kernel_thread(ldlm_pools_thread_main, ldlm_pools_thread, - CLONE_VM | CLONE_FILES); + rc = cfs_create_thread(ldlm_pools_thread_main, ldlm_pools_thread, + CFS_DAEMON_FLAGS); if (rc < 0) { CERROR("Can't start pool thread, error %d\n", rc); @@ -1349,7 +1370,7 @@ static int ldlm_pools_thread_start(void) RETURN(rc); } l_wait_event(ldlm_pools_thread->t_ctl_waitq, - (ldlm_pools_thread->t_flags & SVC_RUNNING), &lwi); + thread_is_running(ldlm_pools_thread), &lwi); RETURN(0); } @@ -1362,7 +1383,7 @@ static void ldlm_pools_thread_stop(void) return; } - ldlm_pools_thread->t_flags = SVC_STOPPING; + thread_set_flags(ldlm_pools_thread, SVC_STOPPING); cfs_waitq_signal(&ldlm_pools_thread->t_ctl_waitq); /* @@ -1370,7 +1391,7 @@ static void ldlm_pools_thread_stop(void) * This fixes possible race and oops due to accessing freed memory * in pools thread. */ - cfs_wait_for_completion(&ldlm_pools_comp); + wait_for_completion(&ldlm_pools_comp); OBD_FREE_PTR(ldlm_pools_thread); ldlm_pools_thread = NULL; EXIT;