X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fldlm%2Fldlm_pool.c;h=5289a4e1ee764300f6526496c6bbac5b737bcdb5;hp=565c6f715b13afeda74d5b247809ea905798d004;hb=ff5b59d60a28fe22ef011ab92ff6b806b8e3c552;hpb=e3a7c58aebafce40323db54bf6056029e5af4a70 diff --git a/lustre/ldlm/ldlm_pool.c b/lustre/ldlm/ldlm_pool.c index 565c6f7..5289a4e 100644 --- a/lustre/ldlm/ldlm_pool.c +++ b/lustre/ldlm/ldlm_pool.c @@ -27,7 +27,7 @@ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Whamcloud, Inc. + * Copyright (c) 2010, 2012, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -329,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); } /** @@ -348,12 +348,12 @@ static int ldlm_srv_pool_recalc(struct ldlm_pool *pl) if (recalc_interval_sec < pl->pl_recalc_period) RETURN(0); - 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) { - cfs_spin_unlock(&pl->pl_lock); - RETURN(0); - } + 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. @@ -373,8 +373,8 @@ static int ldlm_srv_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); - RETURN(0); + spin_unlock(&pl->pl_lock); + RETURN(0); } /** @@ -403,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 @@ -428,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; } /** @@ -447,9 +447,9 @@ static int ldlm_srv_pool_setup(struct ldlm_pool *pl, int limit) 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; @@ -468,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); } /** @@ -486,13 +486,13 @@ static int ldlm_cli_pool_recalc(struct ldlm_pool *pl) if (recalc_interval_sec < pl->pl_recalc_period) RETURN(0); - 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); + 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); } @@ -504,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. @@ -518,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)); } /** @@ -546,13 +546,13 @@ static int ldlm_cli_pool_shrink(struct ldlm_pool *pl, */ ldlm_cli_pool_pop_slv(pl); - cfs_spin_lock(&ns->ns_lock); - unused = ns->ns_nr_unused; - cfs_spin_unlock(&ns->ns_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_ASYNC, - LDLM_CANCEL_SHRINK); + canceled = ldlm_cancel_lru(ns, nr, LCF_ASYNC, + LDLM_CANCEL_SHRINK); } #ifdef __KERNEL__ /* @@ -588,8 +588,7 @@ int ldlm_pool_recalc(struct ldlm_pool *pl) if (recalc_interval_sec <= 0) goto recalc; - cfs_spin_lock(&pl->pl_lock); - recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; + spin_lock(&pl->pl_lock); if (recalc_interval_sec > 0) { /* * Update pool statistics every 1s. @@ -602,19 +601,19 @@ 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_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, count); - return count; } + recalc_interval_sec = pl->pl_recalc_time - cfs_time_current_sec() + + pl->pl_recalc_period; - return 0; + return recalc_interval_sec; } -EXPORT_SYMBOL(ldlm_pool_recalc); /** * Pool shrink wrapper. Will call either client or server pool recalc callback @@ -666,7 +665,7 @@ 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); @@ -677,7 +676,7 @@ static int lprocfs_rd_pool_state(char *page, char **start, off_t off, 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); @@ -705,17 +704,17 @@ static int lprocfs_rd_pool_state(char *page, char **start, off_t off, } static int lprocfs_rd_grant_speed(char *page, char **start, off_t off, - int count, int *eof, void *data) + int count, int *eof, void *data) { - struct ldlm_pool *pl = data; - int grant_speed; - - cfs_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); - cfs_spin_unlock(&pl->pl_lock); - return lprocfs_rd_uint(page, start, off, count, eof, &grant_speed); + 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); @@ -845,7 +844,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: @@ -872,10 +871,10 @@ 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); @@ -981,11 +980,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); @@ -996,9 +995,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); @@ -1009,11 +1008,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); @@ -1024,9 +1023,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); @@ -1066,7 +1065,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 @@ -1078,6 +1077,7 @@ static int ldlm_pools_shrink(ldlm_side_t client, int nr, { int total = 0, cached = 0, nr_ns; struct ldlm_namespace *ns; + struct ldlm_namespace *ns_old = NULL; /* loop detection */ void *cookie; if (client == LDLM_NAMESPACE_CLIENT && nr != 0 && @@ -1092,19 +1092,34 @@ static int ldlm_pools_shrink(ldlm_side_t client, int nr, /* * Find out how many resources we may release. */ - for (nr_ns = cfs_atomic_read(ldlm_namespace_nr(client)); - nr_ns > 0; nr_ns--) + for (nr_ns = ldlm_namespace_nr_read(client); + nr_ns > 0; nr_ns--) { - cfs_mutex_lock(ldlm_namespace_lock(client)); + mutex_lock(ldlm_namespace_lock(client)); if (cfs_list_empty(ldlm_namespace_list(client))) { - cfs_mutex_unlock(ldlm_namespace_lock(client)); + mutex_unlock(ldlm_namespace_lock(client)); cl_env_reexit(cookie); return 0; } ns = ldlm_namespace_first_locked(client); + + if (ns == ns_old) { + mutex_unlock(ldlm_namespace_lock(client)); + break; + } + + if (ldlm_ns_empty(ns)) { + ldlm_namespace_move_to_inactive_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); + continue; + } + + if (ns_old == NULL) + ns_old = ns; + ldlm_namespace_get(ns); - ldlm_namespace_move_locked(ns, client); - cfs_mutex_unlock(ldlm_namespace_lock(client)); + ldlm_namespace_move_to_active_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); total += ldlm_pool_shrink(&ns->ns_pool, 0, gfp_mask); ldlm_namespace_put(ns); } @@ -1117,17 +1132,17 @@ static int ldlm_pools_shrink(ldlm_side_t client, int nr, /* * Shrink at least ldlm_namespace_nr(client) namespaces. */ - for (nr_ns = cfs_atomic_read(ldlm_namespace_nr(client)); - nr_ns > 0; nr_ns--) + for (nr_ns = ldlm_namespace_nr_read(client) - nr_ns; + nr_ns > 0; nr_ns--) { int cancel, nr_locks; /* * Do not call shrink under ldlm_namespace_lock(client) */ - cfs_mutex_lock(ldlm_namespace_lock(client)); + mutex_lock(ldlm_namespace_lock(client)); if (cfs_list_empty(ldlm_namespace_list(client))) { - cfs_mutex_unlock(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 @@ -1138,8 +1153,8 @@ 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_unlock(ldlm_namespace_lock(client)); + ldlm_namespace_move_to_active_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); nr_locks = ldlm_pool_granted(&ns->ns_pool); cancel = 1 + nr_locks * nr / total; @@ -1167,11 +1182,13 @@ static int ldlm_pools_cli_shrink(SHRINKER_ARGS(sc, nr_to_scan, gfp_mask)) shrink_param(sc, gfp_mask)); } -void ldlm_pools_recalc(ldlm_side_t client) +int ldlm_pools_recalc(ldlm_side_t client) { __u32 nr_l = 0, nr_p = 0, l; struct ldlm_namespace *ns; + struct ldlm_namespace *ns_old = NULL; int nr, equal = 0; + int time = 50; /* seconds of sleep if no active namespaces */ /* * No need to setup pool limit for client pools. @@ -1180,7 +1197,7 @@ void ldlm_pools_recalc(ldlm_side_t client) /* * Check all modest namespaces first. */ - cfs_mutex_lock(ldlm_namespace_lock(client)); + mutex_lock(ldlm_namespace_lock(client)); cfs_list_for_each_entry(ns, ldlm_namespace_list(client), ns_list_chain) { @@ -1229,27 +1246,25 @@ void ldlm_pools_recalc(ldlm_side_t client) * for _all_ pools. */ l = LDLM_POOL_HOST_L / - cfs_atomic_read( - ldlm_namespace_nr(client)); + ldlm_namespace_nr_read(client); } else { /* * All the rest of greedy pools will have * all locks in equal parts. */ l = (LDLM_POOL_HOST_L - nr_l) / - (cfs_atomic_read( - ldlm_namespace_nr(client)) - + (ldlm_namespace_nr_read(client) - nr_p); } ldlm_pool_setup(&ns->ns_pool, l); } - cfs_mutex_unlock(ldlm_namespace_lock(client)); + mutex_unlock(ldlm_namespace_lock(client)); } /* * Recalc at least ldlm_namespace_nr(client) namespaces. */ - for (nr = cfs_atomic_read(ldlm_namespace_nr(client)); nr > 0; nr--) { + for (nr = ldlm_namespace_nr_read(client); nr > 0; nr--) { int skip; /* * Lock the list, get first @ns in the list, getref, move it @@ -1258,37 +1273,66 @@ void ldlm_pools_recalc(ldlm_side_t client) * rid of potential deadlock on client nodes when canceling * locks synchronously. */ - cfs_mutex_lock(ldlm_namespace_lock(client)); - if (cfs_list_empty(ldlm_namespace_list(client))) { - cfs_mutex_unlock(ldlm_namespace_lock(client)); - break; - } - ns = ldlm_namespace_first_locked(client); - - cfs_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); - } - cfs_spin_unlock(&ns->ns_lock); - - ldlm_namespace_move_locked(ns, client); - cfs_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); - } + 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); + + if (ns_old == ns) { /* Full pass complete */ + mutex_unlock(ldlm_namespace_lock(client)); + break; + } + + /* We got an empty namespace, need to move it back to inactive + * list. + * The race with parallel resource creation is fine: + * - If they do namespace_get before our check, we fail the + * check and they move this item to the end of the list anyway + * - If we do the check and then they do namespace_get, then + * we move the namespace to inactive and they will move + * it back to active (synchronised by the lock, so no clash + * there). + */ + if (ldlm_ns_empty(ns)) { + ldlm_namespace_move_to_inactive_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); + continue; + } + + if (ns_old == NULL) + ns_old = ns; + + 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_to_active_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); + + /* + * After setup is done - recalc the pool. + */ + if (!skip) { + int ttime = ldlm_pool_recalc(&ns->ns_pool); + + if (ttime < time) + time = ttime; + + ldlm_namespace_put(ns); + } } + return time; } EXPORT_SYMBOL(ldlm_pools_recalc); @@ -1296,6 +1340,7 @@ static int ldlm_pools_thread_main(void *arg) { struct ptlrpc_thread *thread = (struct ptlrpc_thread *)arg; char *t_name = "ldlm_poold"; + int s_time, c_time; ENTRY; cfs_daemonize(t_name); @@ -1308,18 +1353,18 @@ static int ldlm_pools_thread_main(void *arg) while (1) { struct l_wait_info lwi; - /* - * Recal all pools on this tick. - */ - ldlm_pools_recalc(LDLM_NAMESPACE_SERVER); - ldlm_pools_recalc(LDLM_NAMESPACE_CLIENT); - - /* - * Wait until the next check time, or until we're - * stopped. - */ - lwi = LWI_TIMEOUT(cfs_time_seconds(LDLM_POOLS_THREAD_PERIOD), - NULL, NULL); + /* + * Recal all pools on this tick. + */ + s_time = ldlm_pools_recalc(LDLM_NAMESPACE_SERVER); + c_time = ldlm_pools_recalc(LDLM_NAMESPACE_CLIENT); + + /* + * Wait until the next check time, or until we're + * stopped. + */ + lwi = LWI_TIMEOUT(cfs_time_seconds(min(s_time, c_time)), + NULL, NULL); l_wait_event(thread->t_ctl_waitq, thread_is_stopping(thread) || thread_is_event(thread), @@ -1337,7 +1382,7 @@ static int ldlm_pools_thread_main(void *arg) 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) @@ -1353,7 +1398,7 @@ 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); /* @@ -1391,7 +1436,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; @@ -1529,9 +1574,9 @@ void ldlm_pools_fini(void) } EXPORT_SYMBOL(ldlm_pools_fini); -void ldlm_pools_recalc(ldlm_side_t client) +int ldlm_pools_recalc(ldlm_side_t client) { - return; + return 0; } EXPORT_SYMBOL(ldlm_pools_recalc); #endif /* HAVE_LRU_RESIZE_SUPPORT */