lustre/ldlm/ldlm_pool.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (c) 2007 Cluster File Systems, Inc.
   5  *   Author: Yury Umanets <umka@clusterfs.com>
   6  *
   7  *   This file is part of the Lustre file system, http://www.lustre.org
   8  *   Lustre is a trademark of Cluster File Systems, Inc.
   9  *
  10  *   You may have signed or agreed to another license before downloading
  11  *   this software.  If so, you are bound by the terms and conditions
  12  *   of that agreement, and the following does not apply to you.  See the
  13  *   LICENSE file included with this distribution for more information.
  14  *
  15  *   If you did not agree to a different license, then this copy of Lustre
  16  *   is open source software; you can redistribute it and/or modify it
  17  *   under the terms of version 2 of the GNU General Public License as
  18  *   published by the Free Software Foundation.
  19  *
  20  *   In either case, Lustre is distributed in the hope that it will be
  21  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  22  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  *   license text for more details.
  24  */
  25
  26 /* Idea of this code is rather simple. Each second, for each server namespace
  27  * we have SLV - server lock volume which is calculated on current number of
  28  * granted locks, grant speed for past period, etc - that is, locking load.
  29  * This SLV number may be thought as a flow definition for simplicity. It is
  30  * sent to clients with each occasion to let them know what is current load
  31  * situation on the server. By default, at the beginning, SLV on server is
  32  * set max value which is calculated as the following: allow to one client
  33  * have all locks of limit ->pl_limit for 10h.
  34  *
  35  * Next, on clients, number of cached locks is not limited artificially in any
  36  * way as it was before. Instead, client calculates CLV, that is, client lock
  37  * volume for each lock and compares it with last SLV from the server. CLV is
  38  * calculated as the number of locks in LRU * lock live time in seconds. If
  39  * CLV > SLV - lock is canceled.
  40  *
  41  * Client has LVF, that is, lock volume factor which regulates how much sensitive
  42  * client should be about last SLV from server. The higher LVF is the more locks
  43  * will be canceled on client. Default value for it is 1. Setting LVF to 2 means
  44  * that client will cancel locks 2 times faster.
  45  *
  46  * Locks on a client will be canceled more intensively in these cases:
  47  * (1) if SLV is smaller, that is, load is higher on the server;
  48  * (2) client has a lot of locks (the more locks are held by client, the bigger
  49  *     chances that some of them should be canceled);
  50  * (3) client has old locks (taken some time ago);
  51  *
  52  * Thus, according to flow paradigm that we use for better understanding SLV,
  53  * CLV is the volume of particle in flow described by SLV. According to this,
  54  * if flow is getting thinner, more and more particles become outside of it and
  55  * as particles are locks, they should be canceled.
  56  *
  57  * General idea of this belongs to Vitaly Fertman (vitaly@clusterfs.com). Andreas
  58  * Dilger (adilger@clusterfs.com) proposed few nice ideas like using LVF and many
  59  * cleanups. Flow definition to allow more easy understanding of the logic belongs
  60  * to Nikita Danilov (nikita@clusterfs.com) as well as many cleanups and fixes.
  61  * And design and implementation are done by Yury Umanets (umka@clusterfs.com).
  62  *
  63  * Glossary for terms used:
  64  *
  65  * pl_limit - Number of allowed locks in pool. Applies to server and client
  66  * side (tunable);
  67  *
  68  * pl_granted - Number of granted locks (calculated);
  69  * pl_grant_rate - Number of granted locks for last T (calculated);
  70  * pl_cancel_rate - Number of canceled locks for last T (calculated);
  71  * pl_grant_speed - Grant speed (GR - CR) for last T (calculated);
  72  * pl_grant_plan - Planned number of granted locks for next T (calculated);
  73  *
  74  * pl_grant_step - Grant plan step, that is how ->pl_grant_plan
  75  * will change in next T (tunable);
  76  *
  77  * pl_server_lock_volume - Current server lock volume (calculated);
  78  *
  79  * As it may be seen from list above, we have few possible tunables which may
  80  * affect behavior much. They all may be modified via proc. However, they also
  81  * give a possibility for constructing few pre-defined behavior policies. If
  82  * none of predefines is suitable for a working pattern being used, new one may
  83  * be "constructed" via proc tunables.
  84  */
  85
  86 #define DEBUG_SUBSYSTEM S_LDLM
  87
  88 #ifdef __KERNEL__
  89 # include <lustre_dlm.h>
  90 #else
  91 # include <liblustre.h>
  92 # include <libcfs/kp30.h>
  93 #endif
  94
  95 #include <obd_class.h>
  96 #include <obd_support.h>
  97 #include "ldlm_internal.h"
  98
  99 #ifdef HAVE_LRU_RESIZE_SUPPORT
 100
 101 /* 50 ldlm locks for 1MB of RAM. */
 102 #define LDLM_POOL_HOST_L ((num_physpages >> (20 - PAGE_SHIFT)) * 50)
 103
 104 /* Default step in % for grant plan. */
 105 #define LDLM_POOL_GSP (5)
 106
 107 /* LDLM_POOL_GSP% of all locks is default GP. */
 108 #define LDLM_POOL_GP(L)   ((L) * LDLM_POOL_GSP / 100)
 109
 110 /* Max age for locks on clients. */
 111 #define LDLM_POOL_MAX_AGE (36000)
 112
 113 #ifdef __KERNEL__
 114 extern cfs_proc_dir_entry_t *ldlm_ns_proc_dir;
 115 #endif
 116
 117 #define avg(src, add) \
 118         ((src) = ((src) + (add)) / 2)
 119
 120 static inline __u64 dru(__u64 val, __u32 div)
 121 {
 122         __u64 ret = val + (div - 1);
 123         do_div(ret, div);
 124         return ret;
 125 }
 126
 127 static inline __u64 ldlm_pool_slv_max(__u32 L)
 128 {
 129         /* Allow to have all locks for 1 client for 10 hrs.
 130          * Formula is the following: limit * 10h / 1 client. */
 131         __u64 lim = L *  LDLM_POOL_MAX_AGE / 1;
 132         return lim;
 133 }
 134
 135 static inline __u64 ldlm_pool_slv_min(__u32 L)
 136 {
 137         return 1;
 138 }
 139
 140 enum {
 141         LDLM_POOL_GRANTED_STAT = 0,
 142         LDLM_POOL_GRANT_RATE_STAT,
 143         LDLM_POOL_CANCEL_RATE_STAT,
 144         LDLM_POOL_GRANT_PLAN_STAT,
 145         LDLM_POOL_SLV_STAT,
 146         LDLM_POOL_LAST_STAT
 147 };
 148
 149 static inline struct ldlm_namespace *ldlm_pl2ns(struct ldlm_pool *pl)
 150 {
 151         return container_of(pl, struct ldlm_namespace, ns_pool);
 152 }
 153
 154 /* Should be called under ->pl_lock taken */
 155 static inline void ldlm_pool_recalc_grant_plan(struct ldlm_pool *pl)
 156 {
 157         int grant_plan, granted;
 158         __u32 limit;
 159
 160         limit = ldlm_pool_get_limit(pl);
 161         granted = atomic_read(&pl->pl_granted);
 162
 163         grant_plan = granted + ((limit - granted) *
 164                 atomic_read(&pl->pl_grant_step)) / 100;
 165         atomic_set(&pl->pl_grant_plan, grant_plan);
 166 }
 167
 168 /* Should be called under ->pl_lock taken */
 169 static inline void ldlm_pool_recalc_slv(struct ldlm_pool *pl)
 170 {
 171         int slv_factor, granted, grant_plan;
 172         __u32 limit;
 173         __u64 slv;
 174
 175         slv = ldlm_pool_get_slv(pl);
 176         limit = ldlm_pool_get_limit(pl);
 177         granted = atomic_read(&pl->pl_granted);
 178         grant_plan = atomic_read(&pl->pl_grant_plan);
 179
 180         if ((slv_factor = limit - (granted - grant_plan)) <= 0)
 181                 slv_factor = 1;
 182
 183         slv = (slv * ((slv_factor * 100) / limit));
 184         slv = dru(slv, 100);
 185
 186         if (slv > ldlm_pool_slv_max(limit)) {
 187                 slv = ldlm_pool_slv_max(limit);
 188         } else if (slv < ldlm_pool_slv_min(limit)) {
 189                 slv = ldlm_pool_slv_min(limit);
 190         }
 191
 192         ldlm_pool_set_slv(pl, slv);
 193 }
 194
 195 static inline void ldlm_pool_recalc_stats(struct ldlm_pool *pl)
 196 {
 197         __u64 slv = ldlm_pool_get_slv(pl);
 198         __u32 granted = atomic_read(&pl->pl_granted);
 199         __u32 grant_rate = atomic_read(&pl->pl_grant_rate);
 200         __u32 grant_plan = atomic_read(&pl->pl_grant_plan);
 201         __u32 cancel_rate = atomic_read(&pl->pl_cancel_rate);
 202
 203         lprocfs_counter_add(pl->pl_stats, LDLM_POOL_SLV_STAT,
 204                             slv);
 205         lprocfs_counter_add(pl->pl_stats, LDLM_POOL_GRANTED_STAT,
 206                             granted);
 207         lprocfs_counter_add(pl->pl_stats, LDLM_POOL_GRANT_RATE_STAT,
 208                             grant_rate);
 209         lprocfs_counter_add(pl->pl_stats, LDLM_POOL_GRANT_PLAN_STAT,
 210                             grant_plan);
 211         lprocfs_counter_add(pl->pl_stats, LDLM_POOL_CANCEL_RATE_STAT,
 212                             cancel_rate);
 213 }
 214
 215 static int ldlm_srv_pool_recalc(struct ldlm_pool *pl)
 216 {
 217         time_t recalc_interval_sec;
 218         ENTRY;
 219
 220         spin_lock(&pl->pl_lock);
 221         recalc_interval_sec = cfs_duration_sec(cfs_time_current() -
 222                                                pl->pl_update_time);
 223         if (recalc_interval_sec > 0) {
 224                 /* Update statistics */
 225                 ldlm_pool_recalc_stats(pl);
 226
 227                 /* Recalc SLV after last period. This should be done
 228                  * _before_ recalculating new grant plan. */
 229                 ldlm_pool_recalc_slv(pl);
 230
 231                 /* Update grant_plan for new period. */
 232                 ldlm_pool_recalc_grant_plan(pl);
 233                 pl->pl_update_time = cfs_time_current();
 234
 235                 /* Zero out all rates and speed for the last period. */
 236                 atomic_set(&pl->pl_grant_rate, 0);
 237                 atomic_set(&pl->pl_cancel_rate, 0);
 238                 atomic_set(&pl->pl_grant_speed, 0);
 239         }
 240         spin_unlock(&pl->pl_lock);
 241         RETURN(0);
 242 }
 243
 244 /* Our goal here is to decrease SLV the way to make a client hold
 245  * @nr locks smaller in next 10h. */
 246 static int ldlm_srv_pool_shrink(struct ldlm_pool *pl,
 247                                 int nr, unsigned int gfp_mask)
 248 {
 249         __u32 granted, limit;
 250         __u64 slv_delta;
 251         ENTRY;
 252
 253         /* Client already canceled locks but server is already in shrinker and
 254          * can't cancel anything. Let's catch this race. */
 255         if ((granted = atomic_read(&pl->pl_granted)) == 0)
 256                 RETURN(0);
 257
 258         spin_lock(&pl->pl_lock);
 259
 260         /* Simple proportion but it gives impression on how much should be
 261          * SLV changed for request @nr of locks to be canceled.*/
 262         slv_delta = nr * ldlm_pool_get_slv(pl);
 263         limit = ldlm_pool_get_limit(pl);
 264         do_div(slv_delta, granted);
 265
 266         /* As SLV has some dependence on historical data, that is new value
 267          * is based on old one, this decreasing will make clients get some
 268          * locks back to the server and after some time it will stabilize.*/
 269         if (slv_delta < ldlm_pool_get_slv(pl))
 270                 ldlm_pool_set_slv(pl, ldlm_pool_get_slv(pl) - slv_delta);
 271         else
 272                 ldlm_pool_set_slv(pl, ldlm_pool_slv_min(limit));
 273         spin_unlock(&pl->pl_lock);
 274
 275         /* We did not really free any memory here so far, it only will be
 276          * freed later may be, so that we return 0 to not confuse VM. */
 277         RETURN(0);
 278 }
 279
 280 static int ldlm_cli_pool_recalc(struct ldlm_pool *pl)
 281 {
 282         time_t recalc_interval_sec;
 283         ENTRY;
 284
 285         spin_lock(&pl->pl_lock);
 286
 287         recalc_interval_sec = cfs_duration_sec(cfs_time_current() -
 288                                                pl->pl_update_time);
 289         if (recalc_interval_sec > 0) {
 290                 /* Update statistics only every T */
 291                 ldlm_pool_recalc_stats(pl);
 292
 293                 /* Zero out grant/cancel rates and speed for last period. */
 294                 atomic_set(&pl->pl_grant_rate, 0);
 295                 atomic_set(&pl->pl_cancel_rate, 0);
 296                 atomic_set(&pl->pl_grant_speed, 0);
 297         }
 298         spin_unlock(&pl->pl_lock);
 299
 300         /* Recalc client pool is done without taking into account pl_update_time
 301          * as this may be called voluntary in the case of emergency. Client
 302          * recalc does not calculate anything, we do not risk to have skew
 303          * of some pool param. */
 304         ldlm_cancel_lru(ldlm_pl2ns(pl), 0, LDLM_ASYNC);
 305         RETURN(0);
 306 }
 307
 308 static int ldlm_cli_pool_shrink(struct ldlm_pool *pl,
 309                                 int nr, unsigned int gfp_mask)
 310 {
 311         ENTRY;
 312         RETURN(ldlm_cancel_lru(ldlm_pl2ns(pl), nr, LDLM_SYNC));
 313 }
 314
 315 int ldlm_pool_recalc(struct ldlm_pool *pl)
 316 {
 317         if (pl->pl_recalc != NULL && pool_recalc_enabled(pl))
 318                 return pl->pl_recalc(pl);
 319         return 0;
 320 }
 321 EXPORT_SYMBOL(ldlm_pool_recalc);
 322
 323 int ldlm_pool_shrink(struct ldlm_pool *pl, int nr,
 324                      unsigned int gfp_mask)
 325 {
 326         if (pl->pl_shrink != NULL && pool_shrink_enabled(pl)) {
 327                 CDEBUG(D_DLMTRACE, "%s: request to shrink %d locks\n",
 328                        pl->pl_name, nr);
 329                 return pl->pl_shrink(pl, nr, gfp_mask);
 330         }
 331         return 0;
 332 }
 333 EXPORT_SYMBOL(ldlm_pool_shrink);
 334
 335 /* The purpose of this function is to re-setup limit and maximal allowed
 336  * slv according to the passed limit. */
 337 int ldlm_pool_setup(struct ldlm_pool *pl, __u32 limit)
 338 {
 339         ENTRY;
 340         if (ldlm_pl2ns(pl)->ns_client == LDLM_NAMESPACE_SERVER)
 341                 ldlm_pool_set_limit(pl, limit);
 342         RETURN(0);
 343 }
 344 EXPORT_SYMBOL(ldlm_pool_setup);
 345
 346 #ifdef __KERNEL__
 347 static int lprocfs_rd_pool_state(char *page, char **start, off_t off,
 348                                  int count, int *eof, void *data)
 349 {
 350         __u32 granted, grant_rate, cancel_rate, grant_step;
 351         int nr = 0, grant_speed, grant_plan;
 352         struct ldlm_pool *pl = data;
 353         __u32 limit;
 354         __u64 slv;
 355
 356         spin_lock(&pl->pl_lock);
 357         slv = ldlm_pool_get_slv(pl);
 358         limit = ldlm_pool_get_limit(pl);
 359         granted = atomic_read(&pl->pl_granted);
 360         grant_rate = atomic_read(&pl->pl_grant_rate);
 361         grant_plan = atomic_read(&pl->pl_grant_plan);
 362         grant_step = atomic_read(&pl->pl_grant_step);
 363         grant_speed = atomic_read(&pl->pl_grant_speed);
 364         cancel_rate = atomic_read(&pl->pl_cancel_rate);
 365         spin_unlock(&pl->pl_lock);
 366
 367         nr += snprintf(page + nr, count - nr, "LDLM pool state (%s):\n",
 368                        pl->pl_name);
 369         nr += snprintf(page + nr, count - nr, "  SLV: "LPU64"\n", slv);
 370
 371         if (ldlm_pl2ns(pl)->ns_client == LDLM_NAMESPACE_CLIENT) {
 372                 nr += snprintf(page + nr, count - nr, "  LVF: %d\n",
 373                                atomic_read(&pl->pl_lock_volume_factor));
 374         }
 375         nr += snprintf(page + nr, count - nr, "  GSP: %d%%\n",
 376                        grant_step);
 377         nr += snprintf(page + nr, count - nr, "  GP:  %d\n",
 378                        grant_plan);
 379         nr += snprintf(page + nr, count - nr, "  GR:  %d\n",
 380                        grant_rate);
 381         nr += snprintf(page + nr, count - nr, "  CR:  %d\n",
 382                        cancel_rate);
 383         nr += snprintf(page + nr, count - nr, "  GS:  %d\n",
 384                        grant_speed);
 385         nr += snprintf(page + nr, count - nr, "  G:   %d\n",
 386                        granted);
 387         nr += snprintf(page + nr, count - nr, "  L:   %d\n",
 388                        limit);
 389         return nr;
 390 }
 391
 392 static int ldlm_pool_proc_init(struct ldlm_pool *pl)
 393 {
 394         struct ldlm_namespace *ns = ldlm_pl2ns(pl);
 395         struct proc_dir_entry *parent_ns_proc;
 396         struct lprocfs_vars pool_vars[2];
 397         char *var_name = NULL;
 398         int rc = 0;
 399         ENTRY;
 400
 401         OBD_ALLOC(var_name, MAX_STRING_SIZE + 1);
 402         if (!var_name)
 403                 RETURN(-ENOMEM);
 404
 405         parent_ns_proc = lprocfs_srch(ldlm_ns_proc_dir, ns->ns_name);
 406         if (parent_ns_proc == NULL) {
 407                 CERROR("%s: proc entry is not initialized\n",
 408                        ns->ns_name);
 409                 GOTO(out_free_name, rc = -EINVAL);
 410         }
 411         pl->pl_proc_dir = lprocfs_register("pool", parent_ns_proc,
 412                                            NULL, NULL);
 413         if (IS_ERR(pl->pl_proc_dir)) {
 414                 CERROR("LProcFS failed in ldlm-pool-init\n");
 415                 rc = PTR_ERR(pl->pl_proc_dir);
 416                 GOTO(out_free_name, rc);
 417         }
 418
 419         var_name[MAX_STRING_SIZE] = '\0';
 420         memset(pool_vars, 0, sizeof(pool_vars));
 421         pool_vars[0].name = var_name;
 422
 423         snprintf(var_name, MAX_STRING_SIZE, "server_lock_volume");
 424         pool_vars[0].data = &pl->pl_server_lock_volume;
 425         pool_vars[0].read_fptr = lprocfs_rd_u64;
 426         lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 427
 428         snprintf(var_name, MAX_STRING_SIZE, "limit");
 429         pool_vars[0].data = &pl->pl_limit;
 430         pool_vars[0].read_fptr = lprocfs_rd_atomic;
 431         pool_vars[0].write_fptr = lprocfs_wr_atomic;
 432         lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 433
 434         snprintf(var_name, MAX_STRING_SIZE, "granted");
 435         pool_vars[0].data = &pl->pl_granted;
 436         pool_vars[0].read_fptr = lprocfs_rd_atomic;
 437         lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 438
 439         snprintf(var_name, MAX_STRING_SIZE, "control");
 440         pool_vars[0].data = &pl->pl_control;
 441         pool_vars[0].read_fptr = lprocfs_rd_uint;
 442         pool_vars[0].write_fptr = lprocfs_wr_uint;
 443         lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 444
 445         snprintf(var_name, MAX_STRING_SIZE, "grant_speed");
 446         pool_vars[0].data = &pl->pl_grant_speed;
 447         pool_vars[0].read_fptr = lprocfs_rd_atomic;
 448         lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 449
 450         snprintf(var_name, MAX_STRING_SIZE, "cancel_rate");
 451         pool_vars[0].data = &pl->pl_cancel_rate;
 452         pool_vars[0].read_fptr = lprocfs_rd_atomic;
 453         lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 454
 455         snprintf(var_name, MAX_STRING_SIZE, "grant_rate");
 456         pool_vars[0].data = &pl->pl_grant_rate;
 457         pool_vars[0].read_fptr = lprocfs_rd_atomic;
 458         lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 459
 460         snprintf(var_name, MAX_STRING_SIZE, "grant_plan");
 461         pool_vars[0].data = &pl->pl_grant_plan;
 462         pool_vars[0].read_fptr = lprocfs_rd_atomic;
 463         lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 464
 465         snprintf(var_name, MAX_STRING_SIZE, "grant_step");
 466         pool_vars[0].data = &pl->pl_grant_step;
 467         pool_vars[0].read_fptr = lprocfs_rd_atomic;
 468         if (ns->ns_client == LDLM_NAMESPACE_SERVER)
 469                 pool_vars[0].write_fptr = lprocfs_wr_atomic;
 470         lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 471
 472         if (ns->ns_client == LDLM_NAMESPACE_CLIENT) {
 473                 snprintf(var_name, MAX_STRING_SIZE, "lock_volume_factor");
 474                 pool_vars[0].data = &pl->pl_lock_volume_factor;
 475                 pool_vars[0].read_fptr = lprocfs_rd_uint;
 476                 pool_vars[0].write_fptr = lprocfs_wr_uint;
 477                 lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 478         }
 479
 480         snprintf(var_name, MAX_STRING_SIZE, "state");
 481         pool_vars[0].data = pl;
 482         pool_vars[0].read_fptr = lprocfs_rd_pool_state;
 483         lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
 484
 485         pl->pl_stats = lprocfs_alloc_stats(LDLM_POOL_LAST_STAT -
 486                                            LDLM_POOL_GRANTED_STAT, 0);
 487         if (!pl->pl_stats)
 488                 GOTO(out_free_name, rc = -ENOMEM);
 489
 490         lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANTED_STAT,
 491                              LPROCFS_CNTR_AVGMINMAX | LPROCFS_CNTR_STDDEV,
 492                              "granted", "locks");
 493         lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANT_RATE_STAT,
 494                              LPROCFS_CNTR_AVGMINMAX | LPROCFS_CNTR_STDDEV,
 495                              "grant_rate", "locks/s");
 496         lprocfs_counter_init(pl->pl_stats, LDLM_POOL_CANCEL_RATE_STAT,
 497                              LPROCFS_CNTR_AVGMINMAX | LPROCFS_CNTR_STDDEV,
 498                              "cancel_rate", "locks/s");
 499         lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANT_PLAN_STAT,
 500                              LPROCFS_CNTR_AVGMINMAX | LPROCFS_CNTR_STDDEV,
 501                              "grant_plan", "locks/s");
 502         lprocfs_counter_init(pl->pl_stats, LDLM_POOL_SLV_STAT,
 503                              LPROCFS_CNTR_AVGMINMAX | LPROCFS_CNTR_STDDEV,
 504                              "slv", "slv");
 505         lprocfs_register_stats(pl->pl_proc_dir, "stats", pl->pl_stats);
 506
 507         EXIT;
 508 out_free_name:
 509         OBD_FREE(var_name, MAX_STRING_SIZE + 1);
 510         return rc;
 511 }
 512
 513 static void ldlm_pool_proc_fini(struct ldlm_pool *pl)
 514 {
 515         if (pl->pl_stats != NULL) {
 516                 lprocfs_free_stats(&pl->pl_stats);
 517                 pl->pl_stats = NULL;
 518         }
 519         if (pl->pl_proc_dir != NULL) {
 520                 lprocfs_remove(&pl->pl_proc_dir);
 521                 pl->pl_proc_dir = NULL;
 522         }
 523 }
 524 #else /* !__KERNEL__*/
 525 #define ldlm_pool_proc_init(pl) (0)
 526 #define ldlm_pool_proc_fini(pl) while (0) {}
 527 #endif
 528
 529 int ldlm_pool_init(struct ldlm_pool *pl, struct ldlm_namespace *ns,
 530                    int idx, ldlm_side_t client)
 531 {
 532         int rc;
 533         ENTRY;
 534
 535         spin_lock_init(&pl->pl_lock);
 536         atomic_set(&pl->pl_granted, 0);
 537         pl->pl_update_time = cfs_time_current();
 538         atomic_set(&pl->pl_lock_volume_factor, 1);
 539
 540         atomic_set(&pl->pl_grant_rate, 0);
 541         atomic_set(&pl->pl_cancel_rate, 0);
 542         atomic_set(&pl->pl_grant_speed, 0);
 543         pl->pl_control = LDLM_POOL_CTL_FULL;
 544         atomic_set(&pl->pl_grant_step, LDLM_POOL_GSP);
 545         atomic_set(&pl->pl_grant_plan, LDLM_POOL_GP(LDLM_POOL_HOST_L));
 546
 547         snprintf(pl->pl_name, sizeof(pl->pl_name), "ldlm-pool-%s-%d",
 548                  ns->ns_name, idx);
 549
 550         if (client == LDLM_NAMESPACE_SERVER) {
 551                 pl->pl_recalc = ldlm_srv_pool_recalc;
 552                 pl->pl_shrink = ldlm_srv_pool_shrink;
 553                 ldlm_pool_set_limit(pl, LDLM_POOL_HOST_L);
 554                 ldlm_pool_set_slv(pl, ldlm_pool_slv_max(LDLM_POOL_HOST_L));
 555         } else {
 556                 ldlm_pool_set_slv(pl, 1);
 557                 ldlm_pool_set_limit(pl, 1);
 558                 pl->pl_recalc = ldlm_cli_pool_recalc;
 559                 pl->pl_shrink = ldlm_cli_pool_shrink;
 560         }
 561
 562         rc = ldlm_pool_proc_init(pl);
 563         if (rc)
 564                 RETURN(rc);
 565
 566         CDEBUG(D_DLMTRACE, "Lock pool %s is initialized\n", pl->pl_name);
 567
 568         RETURN(rc);
 569 }
 570 EXPORT_SYMBOL(ldlm_pool_init);
 571
 572 void ldlm_pool_fini(struct ldlm_pool *pl)
 573 {
 574         ENTRY;
 575         ldlm_pool_proc_fini(pl);
 576         pl->pl_recalc = NULL;
 577         pl->pl_shrink = NULL;
 578         EXIT;
 579 }
 580 EXPORT_SYMBOL(ldlm_pool_fini);
 581
 582 void ldlm_pool_add(struct ldlm_pool *pl, struct ldlm_lock *lock)
 583 {
 584         ENTRY;
 585         atomic_inc(&pl->pl_granted);
 586         atomic_inc(&pl->pl_grant_rate);
 587         atomic_inc(&pl->pl_grant_speed);
 588
 589         /* No need to recalc client pools here as this is already done
 590          * on enqueue/cancel and locks to cancel already packed to the
 591          * rpc. */
 592         if (ldlm_pl2ns(pl)->ns_client == LDLM_NAMESPACE_SERVER)
 593                 ldlm_pool_recalc(pl);
 594         EXIT;
 595 }
 596 EXPORT_SYMBOL(ldlm_pool_add);
 597
 598 void ldlm_pool_del(struct ldlm_pool *pl, struct ldlm_lock *lock)
 599 {
 600         ENTRY;
 601         LASSERT(atomic_read(&pl->pl_granted) > 0);
 602         atomic_dec(&pl->pl_granted);
 603         atomic_inc(&pl->pl_cancel_rate);
 604         atomic_dec(&pl->pl_grant_speed);
 605
 606         /* Same as in ldlm_pool_add() */
 607         if (ldlm_pl2ns(pl)->ns_client == LDLM_NAMESPACE_SERVER)
 608                 ldlm_pool_recalc(pl);
 609         EXIT;
 610 }
 611 EXPORT_SYMBOL(ldlm_pool_del);
 612
 613 /* ->pl_lock should be taken. */
 614 __u64 ldlm_pool_get_slv(struct ldlm_pool *pl)
 615 {
 616         return pl->pl_server_lock_volume;
 617 }
 618 EXPORT_SYMBOL(ldlm_pool_get_slv);
 619
 620 /* ->pl_lock should be taken. */
 621 void ldlm_pool_set_slv(struct ldlm_pool *pl, __u64 slv)
 622 {
 623         pl->pl_server_lock_volume = slv;
 624 }
 625 EXPORT_SYMBOL(ldlm_pool_set_slv);
 626
 627 __u32 ldlm_pool_get_limit(struct ldlm_pool *pl)
 628 {
 629         return atomic_read(&pl->pl_limit);
 630 }
 631 EXPORT_SYMBOL(ldlm_pool_get_limit);
 632
 633 void ldlm_pool_set_limit(struct ldlm_pool *pl, __u32 limit)
 634 {
 635         atomic_set(&pl->pl_limit, limit);
 636 }
 637 EXPORT_SYMBOL(ldlm_pool_set_limit);
 638
 639 /* Server side is only enabled for kernel space for now. */
 640 #ifdef __KERNEL__
 641 static int ldlm_pool_granted(struct ldlm_pool *pl)
 642 {
 643         return atomic_read(&pl->pl_granted);
 644 }
 645
 646 static struct ptlrpc_thread *ldlm_pools_thread;
 647 static struct shrinker *ldlm_pools_srv_shrinker;
 648 static struct shrinker *ldlm_pools_cli_shrinker;
 649 static struct completion ldlm_pools_comp;
 650
 651 void ldlm_pools_wakeup(void)
 652 {
 653         ENTRY;
 654         if (ldlm_pools_thread == NULL)
 655                 return;
 656         ldlm_pools_thread->t_flags |= SVC_EVENT;
 657         cfs_waitq_signal(&ldlm_pools_thread->t_ctl_waitq);
 658         EXIT;
 659 }
 660 EXPORT_SYMBOL(ldlm_pools_wakeup);
 661
 662 /* Cancel @nr locks from all namespaces (if possible). Returns number of
 663  * cached locks after shrink is finished. All namespaces are asked to
 664  * cancel approximately equal amount of locks. */
 665 static int ldlm_pools_shrink(ldlm_side_t client, int nr,
 666                              unsigned int gfp_mask)
 667 {
 668         int total = 0, cached = 0, nr_ns;
 669         struct ldlm_namespace *ns;
 670
 671         if (nr != 0 && !(gfp_mask & __GFP_FS))
 672                 return -1;
 673
 674         CDEBUG(D_DLMTRACE, "request to shrink %d %s locks from all pools\n",
 675                nr, client == LDLM_NAMESPACE_CLIENT ? "client" : "server");
 676
 677         /* Find out how many resources we may release. */
 678         mutex_down(ldlm_namespace_lock(client));
 679         list_for_each_entry(ns, ldlm_namespace_list(client), ns_list_chain)
 680                 total += ldlm_pool_granted(&ns->ns_pool);
 681         mutex_up(ldlm_namespace_lock(client));
 682
 683         if (nr == 0 || total == 0)
 684                 return total;
 685
 686         /* Shrink at least ldlm_namespace_nr(client) namespaces. */
 687         for (nr_ns = atomic_read(ldlm_namespace_nr(client));
 688              nr_ns > 0; nr_ns--)
 689         {
 690                 int cancel, nr_locks;
 691
 692                 /* Do not call shrink under ldlm_namespace_lock(client) */
 693                 mutex_down(ldlm_namespace_lock(client));
 694                 if (list_empty(ldlm_namespace_list(client))) {
 695                         mutex_up(ldlm_namespace_lock(client));
 696                         /* If list is empty, we can't return any @cached > 0,
 697                          * that probably would cause needless shrinker
 698                          * call. */
 699                         cached = 0;
 700                         break;
 701                 }
 702                 ns = ldlm_namespace_first(client);
 703                 ldlm_namespace_get(ns);
 704                 ldlm_namespace_move(ns, client);
 705                 mutex_up(ldlm_namespace_lock(client));
 706
 707                 nr_locks = ldlm_pool_granted(&ns->ns_pool);
 708                 cancel = 1 + nr_locks * nr / total;
 709                 ldlm_pool_shrink(&ns->ns_pool, cancel, gfp_mask);
 710                 cached += ldlm_pool_granted(&ns->ns_pool);
 711                 ldlm_namespace_put(ns, 1);
 712         }
 713         return cached;
 714 }
 715
 716 static int ldlm_pools_srv_shrink(int nr, unsigned int gfp_mask)
 717 {
 718         return ldlm_pools_shrink(LDLM_NAMESPACE_SERVER, nr, gfp_mask);
 719 }
 720
 721 static int ldlm_pools_cli_shrink(int nr, unsigned int gfp_mask)
 722 {
 723         return ldlm_pools_shrink(LDLM_NAMESPACE_CLIENT, nr, gfp_mask);
 724 }
 725
 726 void ldlm_pools_recalc(ldlm_side_t client)
 727 {
 728         __u32 nr_l = 0, nr_p = 0, l;
 729         struct ldlm_namespace *ns;
 730         int rc, nr, equal = 0;
 731
 732         /* Check all modest namespaces. */
 733         mutex_down(ldlm_namespace_lock(client));
 734         list_for_each_entry(ns, ldlm_namespace_list(client), ns_list_chain) {
 735                 if (ns->ns_appetite != LDLM_NAMESPACE_MODEST)
 736                         continue;
 737
 738                 if (client == LDLM_NAMESPACE_SERVER) {
 739                         l = ldlm_pool_granted(&ns->ns_pool);
 740                         if (l == 0)
 741                                 l = 1;
 742
 743                         /* Set the modest pools limit equal to their avg granted
 744                          * locks + 5%. */
 745                         l += dru(l * LDLM_POOLS_MODEST_MARGIN, 100);
 746                         ldlm_pool_setup(&ns->ns_pool, l);
 747                         nr_l += l;
 748                         nr_p++;
 749                 }
 750         }
 751
 752         /* Make sure that modest namespaces did not eat more that 2/3 of limit */
 753         if (nr_l >= 2 * (LDLM_POOL_HOST_L / 3)) {
 754                 CWARN("Modest pools eat out 2/3 of locks limit. %d of %lu. "
 755                       "Upgrade server!\n", nr_l, LDLM_POOL_HOST_L);
 756                 equal = 1;
 757         }
 758
 759         /* The rest is given to greedy namespaces. */
 760         list_for_each_entry(ns, ldlm_namespace_list(client), ns_list_chain) {
 761                 if (!equal && ns->ns_appetite != LDLM_NAMESPACE_GREEDY)
 762                         continue;
 763
 764                 if (client == LDLM_NAMESPACE_SERVER) {
 765                         if (equal) {
 766                                 /* In the case 2/3 locks are eaten out by
 767                                  * modest pools, we re-setup equal limit
 768                                  * for _all_ pools. */
 769                                 l = LDLM_POOL_HOST_L /
 770                                         atomic_read(ldlm_namespace_nr(client));
 771                         } else {
 772                                 /* All the rest of greedy pools will have
 773                                  * all locks in equal parts.*/
 774                                 l = (LDLM_POOL_HOST_L - nr_l) /
 775                                         (atomic_read(ldlm_namespace_nr(client)) -
 776                                          nr_p);
 777                         }
 778                         ldlm_pool_setup(&ns->ns_pool, l);
 779                 }
 780         }
 781         mutex_up(ldlm_namespace_lock(client));
 782
 783         /* Recalc at least ldlm_namespace_nr(client) namespaces. */
 784         for (nr = atomic_read(ldlm_namespace_nr(client)); nr > 0; nr--) {
 785                 /* Lock the list, get first @ns in the list, getref, move it
 786                  * to the tail, unlock and call pool recalc. This way we avoid
 787                  * calling recalc under @ns lock what is really good as we get
 788                  * rid of potential deadlock on client nodes when canceling
 789                  * locks synchronously. */
 790                 mutex_down(ldlm_namespace_lock(client));
 791                 if (list_empty(ldlm_namespace_list(client))) {
 792                         mutex_up(ldlm_namespace_lock(client));
 793                         break;
 794                 }
 795                 ns = ldlm_namespace_first(client);
 796                 ldlm_namespace_get(ns);
 797                 ldlm_namespace_move(ns, client);
 798                 mutex_up(ldlm_namespace_lock(client));
 799
 800                 /* After setup is done - recalc the pool. */
 801                 rc = ldlm_pool_recalc(&ns->ns_pool);
 802                 if (rc)
 803                         CERROR("%s: pool recalculation error "
 804                                "%d\n", ns->ns_pool.pl_name, rc);
 805
 806                 ldlm_namespace_put(ns, 1);
 807         }
 808 }
 809 EXPORT_SYMBOL(ldlm_pools_recalc);
 810
 811 static int ldlm_pools_thread_main(void *arg)
 812 {
 813         struct ptlrpc_thread *thread = (struct ptlrpc_thread *)arg;
 814         char *t_name = "ldlm_poold";
 815         ENTRY;
 816
 817         cfs_daemonize(t_name);
 818         thread->t_flags = SVC_RUNNING;
 819         cfs_waitq_signal(&thread->t_ctl_waitq);
 820
 821         CDEBUG(D_DLMTRACE, "%s: pool thread starting, process %d\n",
 822                t_name, cfs_curproc_pid());
 823
 824         while (1) {
 825                 struct l_wait_info lwi;
 826
 827                 /* Recal all pools on this tick. */
 828                 ldlm_pools_recalc(LDLM_NAMESPACE_CLIENT);
 829                 ldlm_pools_recalc(LDLM_NAMESPACE_SERVER);
 830
 831                 /* Wait until the next check time, or until we're
 832                  * stopped. */
 833                 lwi = LWI_TIMEOUT(cfs_time_seconds(LDLM_POOLS_THREAD_PERIOD),
 834                                   NULL, NULL);
 835                 l_wait_event(thread->t_ctl_waitq, (thread->t_flags &
 836                                                    (SVC_STOPPING|SVC_EVENT)),
 837                              &lwi);
 838
 839                 if (thread->t_flags & SVC_STOPPING) {
 840                         thread->t_flags &= ~SVC_STOPPING;
 841                         break;
 842                 } else if (thread->t_flags & SVC_EVENT) {
 843                         thread->t_flags &= ~SVC_EVENT;
 844                 }
 845         }
 846
 847         thread->t_flags = SVC_STOPPED;
 848         cfs_waitq_signal(&thread->t_ctl_waitq);
 849
 850         CDEBUG(D_DLMTRACE, "%s: pool thread exiting, process %d\n",
 851                t_name, cfs_curproc_pid());
 852
 853         complete_and_exit(&ldlm_pools_comp, 0);
 854 }
 855
 856 static int ldlm_pools_thread_start(ldlm_side_t client)
 857 {
 858         struct l_wait_info lwi = { 0 };
 859         int rc;
 860         ENTRY;
 861
 862         if (ldlm_pools_thread != NULL)
 863                 RETURN(-EALREADY);
 864
 865         OBD_ALLOC_PTR(ldlm_pools_thread);
 866         if (ldlm_pools_thread == NULL)
 867                 RETURN(-ENOMEM);
 868
 869         ldlm_pools_thread->t_id = client;
 870         init_completion(&ldlm_pools_comp);
 871         cfs_waitq_init(&ldlm_pools_thread->t_ctl_waitq);
 872
 873         /* CLONE_VM and CLONE_FILES just avoid a needless copy, because we
 874          * just drop the VM and FILES in ptlrpc_daemonize() right away. */
 875         rc = cfs_kernel_thread(ldlm_pools_thread_main, ldlm_pools_thread,
 876                                CLONE_VM | CLONE_FILES);
 877         if (rc < 0) {
 878                 CERROR("Can't start pool thread, error %d\n",
 879                        rc);
 880                 OBD_FREE(ldlm_pools_thread, sizeof(*ldlm_pools_thread));
 881                 ldlm_pools_thread = NULL;
 882                 RETURN(rc);
 883         }
 884         l_wait_event(ldlm_pools_thread->t_ctl_waitq,
 885                      (ldlm_pools_thread->t_flags & SVC_RUNNING), &lwi);
 886         RETURN(0);
 887 }
 888
 889 static void ldlm_pools_thread_stop(void)
 890 {
 891         ENTRY;
 892
 893         if (ldlm_pools_thread == NULL) {
 894                 EXIT;
 895                 return;
 896         }
 897
 898         ldlm_pools_thread->t_flags = SVC_STOPPING;
 899         cfs_waitq_signal(&ldlm_pools_thread->t_ctl_waitq);
 900
 901         /* Make sure that pools thread is finished before freeing @thread.
 902          * This fixes possible race and oops due to accessing freed memory
 903          * in pools thread. */
 904         wait_for_completion(&ldlm_pools_comp);
 905         OBD_FREE_PTR(ldlm_pools_thread);
 906         ldlm_pools_thread = NULL;
 907         EXIT;
 908 }
 909
 910 int ldlm_pools_init(ldlm_side_t client)
 911 {
 912         int rc;
 913         ENTRY;
 914
 915         rc = ldlm_pools_thread_start(client);
 916         if (rc == 0) {
 917                 ldlm_pools_srv_shrinker = set_shrinker(DEFAULT_SEEKS,
 918                                                        ldlm_pools_srv_shrink);
 919                 ldlm_pools_cli_shrinker = set_shrinker(DEFAULT_SEEKS,
 920                                                        ldlm_pools_cli_shrink);
 921         }
 922         RETURN(rc);
 923 }
 924 EXPORT_SYMBOL(ldlm_pools_init);
 925
 926 void ldlm_pools_fini(void)
 927 {
 928         if (ldlm_pools_srv_shrinker != NULL) {
 929                 remove_shrinker(ldlm_pools_srv_shrinker);
 930                 ldlm_pools_srv_shrinker = NULL;
 931         }
 932         if (ldlm_pools_cli_shrinker != NULL) {
 933                 remove_shrinker(ldlm_pools_cli_shrinker);
 934                 ldlm_pools_cli_shrinker = NULL;
 935         }
 936         ldlm_pools_thread_stop();
 937 }
 938 EXPORT_SYMBOL(ldlm_pools_fini);
 939 #endif /* __KERNEL__ */
 940
 941 #else /* !HAVE_LRU_RESIZE_SUPPORT */
 942 int ldlm_pool_setup(struct ldlm_pool *pl, __u32 limit)
 943 {
 944         return 0;
 945 }
 946 EXPORT_SYMBOL(ldlm_pool_setup);
 947
 948 int ldlm_pool_recalc(struct ldlm_pool *pl)
 949 {
 950         return 0;
 951 }
 952 EXPORT_SYMBOL(ldlm_pool_recalc);
 953
 954 int ldlm_pool_shrink(struct ldlm_pool *pl,
 955                      int nr, unsigned int gfp_mask)
 956 {
 957         return 0;
 958 }
 959 EXPORT_SYMBOL(ldlm_pool_shrink);
 960
 961 int ldlm_pool_init(struct ldlm_pool *pl, struct ldlm_namespace *ns,
 962                    int idx, ldlm_side_t client)
 963 {
 964         return 0;
 965 }
 966 EXPORT_SYMBOL(ldlm_pool_init);
 967
 968 void ldlm_pool_fini(struct ldlm_pool *pl)
 969 {
 970         return;
 971 }
 972 EXPORT_SYMBOL(ldlm_pool_fini);
 973
 974 void ldlm_pool_add(struct ldlm_pool *pl, struct ldlm_lock *lock)
 975 {
 976         return;
 977 }
 978 EXPORT_SYMBOL(ldlm_pool_add);
 979
 980 void ldlm_pool_del(struct ldlm_pool *pl, struct ldlm_lock *lock)
 981 {
 982         return;
 983 }
 984 EXPORT_SYMBOL(ldlm_pool_del);
 985
 986 __u64 ldlm_pool_get_slv(struct ldlm_pool *pl)
 987 {
 988         return 1;
 989 }
 990 EXPORT_SYMBOL(ldlm_pool_get_slv);
 991
 992 void ldlm_pool_set_slv(struct ldlm_pool *pl, __u64 slv)
 993 {
 994         return;
 995 }
 996 EXPORT_SYMBOL(ldlm_pool_set_slv);
 997
 998 __u32 ldlm_pool_get_limit(struct ldlm_pool *pl)
 999 {
1000         return 0;
1001 }
1002 EXPORT_SYMBOL(ldlm_pool_get_limit);
1003
1004 void ldlm_pool_set_limit(struct ldlm_pool *pl, __u32 limit)
1005 {
1006         return;
1007 }
1008 EXPORT_SYMBOL(ldlm_pool_set_limit);
1009
1010 int ldlm_pools_init(ldlm_side_t client)
1011 {
1012         return 0;
1013 }
1014 EXPORT_SYMBOL(ldlm_pools_init);
1015
1016 void ldlm_pools_fini(void)
1017 {
1018         return;
1019 }
1020 EXPORT_SYMBOL(ldlm_pools_fini);
1021
1022 void ldlm_pools_wakeup(void)
1023 {
1024         return;
1025 }
1026 EXPORT_SYMBOL(ldlm_pools_wakeup);
1027
1028 void ldlm_pools_recalc(ldlm_side_t client)
1029 {
1030         return;
1031 }
1032 EXPORT_SYMBOL(ldlm_pools_recalc);
1033 #endif /* HAVE_LRU_RESIZE_SUPPORT */