Whamcloud - gitweb
b551ea2cd419126da64d6301f2bb454f2ef26bb1
[fs/lustre-release.git] / lustre / ldlm / ldlm_reclaim.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2015, Intel Corporation.
24  * Use is subject to license terms.
25  *
26  * Author: Niu    Yawei    <yawei.niu@intel.com>
27  */
28
29 #define DEBUG_SUBSYSTEM S_LDLM
30
31 #include <linux/kthread.h>
32 #include <lustre_dlm.h>
33 #include <obd_class.h>
34 #include "ldlm_internal.h"
35
36 /*
37  * To avoid ldlm lock exhausting server memory, two global parameters:
38  * ldlm_reclaim_threshold & ldlm_lock_limit are used for reclaiming
39  * granted locks and rejecting incoming enqueue requests defensively.
40  *
41  * ldlm_reclaim_threshold: When the amount of granted locks reaching this
42  * threshold, server start to revoke locks gradually.
43  *
44  * ldlm_lock_limit: When the amount of granted locks reaching this
45  * threshold, server will return -EINPROGRESS to any incoming enqueue
46  * request until the lock count is shrunk below the threshold again.
47  *
48  * ldlm_reclaim_threshold & ldlm_lock_limit is set to 20% & 30% of the
49  * total memory by default. It is tunable via proc entry, when it's set
50  * to 0, the feature is disabled.
51  */
52
53 #ifdef HAVE_SERVER_SUPPORT
54
55 /* Lock count is stored in ldlm_reclaim_threshold & ldlm_lock_limit */
56 __u64 ldlm_reclaim_threshold;
57 __u64 ldlm_lock_limit;
58
59 /* Represents ldlm_reclaim_threshold & ldlm_lock_limit in MB, used for
60  * proc interface. */
61 __u64 ldlm_reclaim_threshold_mb;
62 __u64 ldlm_lock_limit_mb;
63
64 struct percpu_counter           ldlm_granted_total;
65 static atomic_t                 ldlm_nr_reclaimer;
66 static cfs_duration_t           ldlm_last_reclaim_age;
67 static cfs_time_t               ldlm_last_reclaim_time;
68
69 struct ldlm_reclaim_cb_data {
70         struct list_head         rcd_rpc_list;
71         int                      rcd_added;
72         int                      rcd_total;
73         int                      rcd_cursor;
74         int                      rcd_start;
75         bool                     rcd_skip;
76         cfs_duration_t           rcd_age;
77         struct cfs_hash_bd      *rcd_prev_bd;
78 };
79
80 static inline bool ldlm_lock_reclaimable(struct ldlm_lock *lock)
81 {
82         struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
83
84         /* FLOCK & PLAIN lock are not reclaimable. FLOCK is
85          * explicitly controlled by application, PLAIN lock
86          * is used by quota global lock and config lock.
87          */
88         if (ns->ns_client == LDLM_NAMESPACE_SERVER &&
89             (lock->l_resource->lr_type == LDLM_IBITS ||
90              lock->l_resource->lr_type == LDLM_EXTENT))
91                 return true;
92         return false;
93 }
94
95 /**
96  * Callback function for revoking locks from certain resource.
97  *
98  * \param [in] hs       ns_rs_hash
99  * \param [in] bd       current bucket of ns_rsh_hash
100  * \param [in] hnode    hnode of the resource
101  * \param [in] arg      opaque data
102  *
103  * \retval 0            continue the scan
104  * \retval 1            stop the iteration
105  */
106 static int ldlm_reclaim_lock_cb(struct cfs_hash *hs, struct cfs_hash_bd *bd,
107                                 struct hlist_node *hnode, void *arg)
108
109 {
110         struct ldlm_resource            *res;
111         struct ldlm_reclaim_cb_data     *data;
112         struct ldlm_lock                *lock;
113         struct ldlm_ns_bucket           *nsb;
114         int                              rc = 0;
115
116         data = (struct ldlm_reclaim_cb_data *)arg;
117
118         LASSERTF(data->rcd_added < data->rcd_total, "added:%d >= total:%d\n",
119                  data->rcd_added, data->rcd_total);
120
121         nsb = cfs_hash_bd_extra_get(hs, bd);
122         res = cfs_hash_object(hs, hnode);
123
124         if (data->rcd_prev_bd != bd) {
125                 if (data->rcd_prev_bd != NULL)
126                         ldlm_res_to_ns(res)->ns_reclaim_start++;
127                 data->rcd_prev_bd = bd;
128                 data->rcd_cursor = 0;
129                 data->rcd_start = nsb->nsb_reclaim_start %
130                                   cfs_hash_bd_count_get(bd);
131         }
132
133         if (data->rcd_skip && data->rcd_cursor < data->rcd_start) {
134                 data->rcd_cursor++;
135                 return 0;
136         }
137
138         nsb->nsb_reclaim_start++;
139
140         lock_res(res);
141         list_for_each_entry(lock, &res->lr_granted, l_res_link) {
142                 if (!ldlm_lock_reclaimable(lock))
143                         continue;
144
145                 if (!OBD_FAIL_CHECK(OBD_FAIL_LDLM_WATERMARK_LOW) &&
146                     cfs_time_before(cfs_time_current(),
147                                     cfs_time_add(lock->l_last_used,
148                                                  data->rcd_age)))
149                         continue;
150
151                 if (!ldlm_is_ast_sent(lock)) {
152                         ldlm_set_ast_sent(lock);
153                         LASSERT(list_empty(&lock->l_rk_ast));
154                         list_add(&lock->l_rk_ast, &data->rcd_rpc_list);
155                         LDLM_LOCK_GET(lock);
156                         if (++data->rcd_added == data->rcd_total) {
157                                 rc = 1; /* stop the iteration */
158                                 break;
159                         }
160                 }
161         }
162         unlock_res(res);
163
164         return rc;
165 }
166
167 /**
168  * Revoke locks from the resources of a namespace in a roundrobin
169  * manner.
170  *
171  * \param[in] ns        namespace to do the lock revoke on
172  * \param[in] count     count of lock to be revoked
173  * \param[in] age       only revoke locks older than the 'age'
174  * \param[in] skip      scan from the first lock on resource if the
175  *                      'skip' is false, otherwise, continue scan
176  *                      from the last scanned position
177  * \param[out] count    count of lock still to be revoked
178  */
179 static void ldlm_reclaim_res(struct ldlm_namespace *ns, int *count,
180                              cfs_duration_t age, bool skip)
181 {
182         struct ldlm_reclaim_cb_data     data;
183         int                             idx, type, start;
184         ENTRY;
185
186         LASSERT(*count != 0);
187
188         if (ns->ns_obd) {
189                 type = server_name2index(ns->ns_obd->obd_name, &idx, NULL);
190                 if (type != LDD_F_SV_TYPE_MDT && type != LDD_F_SV_TYPE_OST) {
191                         EXIT;
192                         return;
193                 }
194         }
195
196         if (atomic_read(&ns->ns_bref) == 0) {
197                 EXIT;
198                 return;
199         }
200
201         INIT_LIST_HEAD(&data.rcd_rpc_list);
202         data.rcd_added = 0;
203         data.rcd_total = *count;
204         data.rcd_age = age;
205         data.rcd_skip = skip;
206         data.rcd_prev_bd = NULL;
207         start = ns->ns_reclaim_start % CFS_HASH_NBKT(ns->ns_rs_hash);
208
209         cfs_hash_for_each_nolock(ns->ns_rs_hash, ldlm_reclaim_lock_cb, &data,
210                                  start);
211
212         CDEBUG(D_DLMTRACE, "NS(%s): %d locks to be reclaimed, found %d/%d "
213                "locks.\n", ldlm_ns_name(ns), *count, data.rcd_added,
214                data.rcd_total);
215
216         LASSERTF(*count >= data.rcd_added, "count:%d, added:%d\n", *count,
217                  data.rcd_added);
218
219         ldlm_run_ast_work(ns, &data.rcd_rpc_list, LDLM_WORK_REVOKE_AST);
220         *count -= data.rcd_added;
221         EXIT;
222 }
223
224 #define LDLM_RECLAIM_BATCH      512
225 #define LDLM_RECLAIM_AGE_MIN    cfs_time_seconds(300)
226 #define LDLM_RECLAIM_AGE_MAX    (LDLM_DEFAULT_MAX_ALIVE * 3 / 4)
227
228 static inline cfs_duration_t ldlm_reclaim_age(void)
229 {
230         cfs_duration_t  age;
231
232         age = ldlm_last_reclaim_age +
233                 cfs_time_sub(cfs_time_current(), ldlm_last_reclaim_time);
234         if (age > LDLM_RECLAIM_AGE_MAX)
235                 age = LDLM_RECLAIM_AGE_MAX;
236         else if (age < (LDLM_RECLAIM_AGE_MIN * 2))
237                 age = LDLM_RECLAIM_AGE_MIN;
238         return age;
239 }
240
241 /**
242  * Revoke certain amount of locks from all the server namespaces
243  * in a roundrobin manner. Lock age is used to avoid reclaim on
244  * the non-aged locks.
245  */
246 static void ldlm_reclaim_ns(void)
247 {
248         struct ldlm_namespace   *ns;
249         int                      count = LDLM_RECLAIM_BATCH;
250         int                      ns_nr, nr_processed;
251         enum ldlm_side           ns_cli = LDLM_NAMESPACE_SERVER;
252         cfs_duration_t           age;
253         bool                     skip = true;
254         ENTRY;
255
256         if (!atomic_add_unless(&ldlm_nr_reclaimer, 1, 1)) {
257                 EXIT;
258                 return;
259         }
260
261         age = ldlm_reclaim_age();
262 again:
263         nr_processed = 0;
264         ns_nr = ldlm_namespace_nr_read(ns_cli);
265         while (count > 0 && nr_processed < ns_nr) {
266                 mutex_lock(ldlm_namespace_lock(ns_cli));
267
268                 if (list_empty(ldlm_namespace_list(ns_cli))) {
269                         mutex_unlock(ldlm_namespace_lock(ns_cli));
270                         goto out;
271                 }
272
273                 ns = ldlm_namespace_first_locked(ns_cli);
274                 ldlm_namespace_move_to_active_locked(ns, ns_cli);
275                 mutex_unlock(ldlm_namespace_lock(ns_cli));
276
277                 ldlm_reclaim_res(ns, &count, age, skip);
278                 ldlm_namespace_put(ns);
279                 nr_processed++;
280         }
281
282         if (count > 0 && age > LDLM_RECLAIM_AGE_MIN) {
283                 age >>= 1;
284                 if (age < (LDLM_RECLAIM_AGE_MIN * 2))
285                         age = LDLM_RECLAIM_AGE_MIN;
286                 skip = false;
287                 goto again;
288         }
289
290         ldlm_last_reclaim_age = age;
291         ldlm_last_reclaim_time = cfs_time_current();
292 out:
293         atomic_add_unless(&ldlm_nr_reclaimer, -1, 0);
294         EXIT;
295 }
296
297 void ldlm_reclaim_add(struct ldlm_lock *lock)
298 {
299         if (!ldlm_lock_reclaimable(lock))
300                 return;
301         percpu_counter_add(&ldlm_granted_total, 1);
302         lock->l_last_used = cfs_time_current();
303 }
304
305 void ldlm_reclaim_del(struct ldlm_lock *lock)
306 {
307         if (!ldlm_lock_reclaimable(lock))
308                 return;
309         percpu_counter_sub(&ldlm_granted_total, 1);
310 }
311
312 /**
313  * Check on the total granted locks: return true if it reaches the
314  * high watermark (ldlm_lock_limit), otherwise return false; It also
315  * triggers lock reclaim if the low watermark (ldlm_reclaim_threshold)
316  * is reached.
317  *
318  * \retval true         high watermark reached.
319  * \retval false        high watermark not reached.
320  */
321 bool ldlm_reclaim_full(void)
322 {
323         __u64 high = ldlm_lock_limit;
324         __u64 low = ldlm_reclaim_threshold;
325
326         if (low != 0 && OBD_FAIL_CHECK(OBD_FAIL_LDLM_WATERMARK_LOW))
327                 low = cfs_fail_val;
328
329         if (low != 0 &&
330             percpu_counter_sum_positive(&ldlm_granted_total) > low)
331                 ldlm_reclaim_ns();
332
333         if (high != 0 && OBD_FAIL_CHECK(OBD_FAIL_LDLM_WATERMARK_HIGH))
334                 high = cfs_fail_val;
335
336         if (high != 0 &&
337             percpu_counter_sum_positive(&ldlm_granted_total) > high)
338                 return true;
339
340         return false;
341 }
342
343 static inline __u64 ldlm_ratio2locknr(int ratio)
344 {
345         __u64 locknr;
346
347         locknr = ((__u64)NUM_CACHEPAGES << PAGE_SHIFT) * ratio;
348         do_div(locknr, 100 * sizeof(struct ldlm_lock));
349
350         return locknr;
351 }
352
353 static inline __u64 ldlm_locknr2mb(__u64 locknr)
354 {
355         return (locknr * sizeof(struct ldlm_lock) + 512 * 1024) >> 20;
356 }
357
358 #define LDLM_WM_RATIO_LOW_DEFAULT       20
359 #define LDLM_WM_RATIO_HIGH_DEFAULT      30
360
361 int ldlm_reclaim_setup(void)
362 {
363         atomic_set(&ldlm_nr_reclaimer, 0);
364
365         ldlm_reclaim_threshold = ldlm_ratio2locknr(LDLM_WM_RATIO_LOW_DEFAULT);
366         ldlm_reclaim_threshold_mb = ldlm_locknr2mb(ldlm_reclaim_threshold);
367         ldlm_lock_limit = ldlm_ratio2locknr(LDLM_WM_RATIO_HIGH_DEFAULT);
368         ldlm_lock_limit_mb = ldlm_locknr2mb(ldlm_lock_limit);
369
370         ldlm_last_reclaim_age = LDLM_RECLAIM_AGE_MAX;
371         ldlm_last_reclaim_time = cfs_time_current();
372
373 #ifdef HAVE_PERCPU_COUNTER_INIT_GFP_FLAG
374         return percpu_counter_init(&ldlm_granted_total, 0, GFP_KERNEL);
375 #else
376         return percpu_counter_init(&ldlm_granted_total, 0);
377 #endif
378 }
379
380 void ldlm_reclaim_cleanup(void)
381 {
382         percpu_counter_destroy(&ldlm_granted_total);
383 }
384
385 #else /* HAVE_SERVER_SUPPORT */
386
387 bool ldlm_reclaim_full(void)
388 {
389         return false;
390 }
391
392 void ldlm_reclaim_add(struct ldlm_lock *lock)
393 {
394 }
395
396 void ldlm_reclaim_del(struct ldlm_lock *lock)
397 {
398 }
399
400 int ldlm_reclaim_setup(void)
401 {
402         return 0;
403 }
404
405 void ldlm_reclaim_cleanup(void)
406 {
407 }
408
409 #endif /* HAVE_SERVER_SUPPORT */