LU-2924 Only wake up ldlm_poold as frequently as the check interval

[fs/lustre-release.git] / lustre / ldlm / ldlm_pool.c

diff --git a/lustre/ldlm/ldlm_pool.c b/lustre/ldlm/ldlm_pool.c
index 565c6f7..5289a4e 100644 (file)
--- 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) 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/
  */
 /*
  * 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);
          */
         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;
         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);
 
         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.
         /*
          * 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);
         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);
 
         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
 
         /*
          * 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);
          * 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);
         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;
         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;
 
         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);
          */
         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);
         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);
 
         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);
         }
 
                 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);
         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.
 
         /*
          * 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.
          */
          * 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);
 
          */
         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) {
         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__
         /*
         }
 #ifdef __KERNEL__
         /*


@@ -588,8 +588,7 @@ int ldlm_pool_recalc(struct ldlm_pool *pl)
         if (recalc_interval_sec <= 0)
                 goto recalc;
 
         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.
         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_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);
 
  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
 
 /**
  * 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;
 
         __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);
         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);
         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);
 
         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,
 }
 
 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);
 }
 
 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_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:
 
         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 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_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 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);
 
 }
 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)
 {
  */
 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);
 
 }
 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 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);
 
 }
 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)
 {
  */
 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);
 
 }
 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 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
 
 /*
  * 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;
 {
         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 &&
         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.
          */
         /*
          * 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))) {
                 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);
                         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_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);
         }
                 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.
          */
         /*
          * 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)
                  */
         {
                 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))) {
                 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
                         /*
                          * 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);
                 }
                 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;
 
                 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));
 }
 
                                  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;
 {
         __u32 nr_l = 0, nr_p = 0, l;
         struct ldlm_namespace *ns;

+        struct ldlm_namespace *ns_old = NULL;

         int nr, equal = 0;
         int nr, equal = 0;

+       int time = 50; /* seconds of sleep if no active namespaces */

 
         /*
          * No need to setup pool limit for client pools.
 
         /*
          * 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.
                  */
                 /*
                  * 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)
                 {
                 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 /
                                  * 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) /
                         } 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);
                 }
                                          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.
          */
         }
 
         /*
          * 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
                 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.
                  */
                  * 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);
 
 }
 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";
 {
         struct ptlrpc_thread *thread = (struct ptlrpc_thread *)arg;
         char *t_name = "ldlm_poold";

+       int s_time, c_time;

         ENTRY;
 
         cfs_daemonize(t_name);
         ENTRY;
 
         cfs_daemonize(t_name);


@@ -1308,18 +1353,18 @@ static int ldlm_pools_thread_main(void *arg)
         while (1) {
                 struct l_wait_info lwi;
 
         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),
                 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());
 
         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)
 }
 
 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);
 
         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);
 
         /*
         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.
          */
          * 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;
         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);
 
 }
 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 */
 }
 EXPORT_SYMBOL(ldlm_pools_recalc);
 #endif /* HAVE_LRU_RESIZE_SUPPORT */