?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: fsl-dpaa2/eth: Always call napi_gro_receive()
[linux-2.6/btrfs-unstable.git] / fs / gfs2 / glock.c
blob959a19ced4d5f83fccf7e82c88a5855f3d1d26cc
1 /*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
4 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2.
8 */
9
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12 #include <linux/sched.h>
13 #include <linux/slab.h>
14 #include <linux/spinlock.h>
15 #include <linux/buffer_head.h>
16 #include <linux/delay.h>
17 #include <linux/sort.h>
18 #include <linux/jhash.h>
19 #include <linux/kallsyms.h>
20 #include <linux/gfs2_ondisk.h>
21 #include <linux/list.h>
22 #include <linux/wait.h>
23 #include <linux/module.h>
24 #include <linux/uaccess.h>
25 #include <linux/seq_file.h>
26 #include <linux/debugfs.h>
27 #include <linux/kthread.h>
28 #include <linux/freezer.h>
29 #include <linux/workqueue.h>
30 #include <linux/jiffies.h>
31 #include <linux/rcupdate.h>
32 #include <linux/rculist_bl.h>
33 #include <linux/bit_spinlock.h>
34 #include <linux/percpu.h>
35 #include <linux/list_sort.h>
36 #include <linux/lockref.h>
37 #include <linux/rhashtable.h>
38
39 #include "gfs2.h"
40 #include "incore.h"
41 #include "glock.h"
42 #include "glops.h"
43 #include "inode.h"
44 #include "lops.h"
45 #include "meta_io.h"
46 #include "quota.h"
47 #include "super.h"
48 #include "util.h"
49 #include "bmap.h"
50 #define CREATE_TRACE_POINTS
51 #include "trace_gfs2.h"
52
53 struct gfs2_glock_iter {
54 struct gfs2_sbd *sdp; /* incore superblock */
55 struct rhashtable_iter hti; /* rhashtable iterator */
56 struct gfs2_glock *gl; /* current glock struct */
57 loff_t last_pos; /* last position */
58 };
59
60 typedef void (*glock_examiner) (struct gfs2_glock * gl);
61
62 static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target);
63
64 static struct dentry *gfs2_root;
65 static struct workqueue_struct *glock_workqueue;
66 struct workqueue_struct *gfs2_delete_workqueue;
67 static LIST_HEAD(lru_list);
68 static atomic_t lru_count = ATOMIC_INIT(0);
69 static DEFINE_SPINLOCK(lru_lock);
70
71 #define GFS2_GL_HASH_SHIFT 15
72 #define GFS2_GL_HASH_SIZE BIT(GFS2_GL_HASH_SHIFT)
73
74 static struct rhashtable_params ht_parms = {
75 .nelem_hint = GFS2_GL_HASH_SIZE * 3 / 4,
76 .key_len = offsetofend(struct lm_lockname, ln_type),
77 .key_offset = offsetof(struct gfs2_glock, gl_name),
78 .head_offset = offsetof(struct gfs2_glock, gl_node),
79 };
80
81 static struct rhashtable gl_hash_table;
82
83 void gfs2_glock_free(struct gfs2_glock *gl)
84 {
85 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
86
87 if (gl->gl_ops->go_flags & GLOF_ASPACE) {
88 kmem_cache_free(gfs2_glock_aspace_cachep, gl);
89 } else {
90 kfree(gl->gl_lksb.sb_lvbptr);
91 kmem_cache_free(gfs2_glock_cachep, gl);
92 }
93 if (atomic_dec_and_test(&sdp->sd_glock_disposal))
94 wake_up(&sdp->sd_glock_wait);
95 }
96
97 /**
98 * gfs2_glock_hold() - increment reference count on glock
99 * @gl: The glock to hold
100 *
101 */
102
103 static void gfs2_glock_hold(struct gfs2_glock *gl)
104 {
105 GLOCK_BUG_ON(gl, __lockref_is_dead(&gl->gl_lockref));
106 lockref_get(&gl->gl_lockref);
107 }
108
109 /**
110 * demote_ok - Check to see if it's ok to unlock a glock
111 * @gl: the glock
112 *
113 * Returns: 1 if it's ok
114 */
115
116 static int demote_ok(const struct gfs2_glock *gl)
117 {
118 const struct gfs2_glock_operations *glops = gl->gl_ops;
119
120 if (gl->gl_state == LM_ST_UNLOCKED)
121 return 0;
122 if (!list_empty(&gl->gl_holders))
123 return 0;
124 if (glops->go_demote_ok)
125 return glops->go_demote_ok(gl);
126 return 1;
127 }
128
129
130 void gfs2_glock_add_to_lru(struct gfs2_glock *gl)
131 {
132 spin_lock(&lru_lock);
133
134 if (!list_empty(&gl->gl_lru))
135 list_del_init(&gl->gl_lru);
136 else
137 atomic_inc(&lru_count);
138
139 list_add_tail(&gl->gl_lru, &lru_list);
140 set_bit(GLF_LRU, &gl->gl_flags);
141 spin_unlock(&lru_lock);
142 }
143
144 static void gfs2_glock_remove_from_lru(struct gfs2_glock *gl)
145 {
146 spin_lock(&lru_lock);
147 if (!list_empty(&gl->gl_lru)) {
148 list_del_init(&gl->gl_lru);
149 atomic_dec(&lru_count);
150 clear_bit(GLF_LRU, &gl->gl_flags);
151 }
152 spin_unlock(&lru_lock);
153 }
154
155 /**
156 * gfs2_glock_put() - Decrement reference count on glock
157 * @gl: The glock to put
158 *
159 */
160
161 void gfs2_glock_put(struct gfs2_glock *gl)
162 {
163 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
164 struct address_space *mapping = gfs2_glock2aspace(gl);
165
166 if (lockref_put_or_lock(&gl->gl_lockref))
167 return;
168
169 lockref_mark_dead(&gl->gl_lockref);
170
171 gfs2_glock_remove_from_lru(gl);
172 spin_unlock(&gl->gl_lockref.lock);
173 rhashtable_remove_fast(&gl_hash_table, &gl->gl_node, ht_parms);
174 GLOCK_BUG_ON(gl, !list_empty(&gl->gl_holders));
175 GLOCK_BUG_ON(gl, mapping && mapping->nrpages);
176 trace_gfs2_glock_put(gl);
177 sdp->sd_lockstruct.ls_ops->lm_put_lock(gl);
178 }
179
180 /**
181 * may_grant - check if its ok to grant a new lock
182 * @gl: The glock
183 * @gh: The lock request which we wish to grant
184 *
185 * Returns: true if its ok to grant the lock
186 */
187
188 static inline int may_grant(const struct gfs2_glock *gl, const struct gfs2_holder *gh)
189 {
190 const struct gfs2_holder *gh_head = list_entry(gl->gl_holders.next, const struct gfs2_holder, gh_list);
191 if ((gh->gh_state == LM_ST_EXCLUSIVE ||
192 gh_head->gh_state == LM_ST_EXCLUSIVE) && gh != gh_head)
193 return 0;
194 if (gl->gl_state == gh->gh_state)
195 return 1;
196 if (gh->gh_flags & GL_EXACT)
197 return 0;
198 if (gl->gl_state == LM_ST_EXCLUSIVE) {
199 if (gh->gh_state == LM_ST_SHARED && gh_head->gh_state == LM_ST_SHARED)
200 return 1;
201 if (gh->gh_state == LM_ST_DEFERRED && gh_head->gh_state == LM_ST_DEFERRED)
202 return 1;
203 }
204 if (gl->gl_state != LM_ST_UNLOCKED && (gh->gh_flags & LM_FLAG_ANY))
205 return 1;
206 return 0;
207 }
208
209 static void gfs2_holder_wake(struct gfs2_holder *gh)
210 {
211 clear_bit(HIF_WAIT, &gh->gh_iflags);
212 smp_mb__after_atomic();
213 wake_up_bit(&gh->gh_iflags, HIF_WAIT);
214 }
215
216 /**
217 * do_error - Something unexpected has happened during a lock request
218 *
219 */
220
221 static void do_error(struct gfs2_glock *gl, const int ret)
222 {
223 struct gfs2_holder *gh, *tmp;
224
225 list_for_each_entry_safe(gh, tmp, &gl->gl_holders, gh_list) {
226 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
227 continue;
228 if (ret & LM_OUT_ERROR)
229 gh->gh_error = -EIO;
230 else if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))
231 gh->gh_error = GLR_TRYFAILED;
232 else
233 continue;
234 list_del_init(&gh->gh_list);
235 trace_gfs2_glock_queue(gh, 0);
236 gfs2_holder_wake(gh);
237 }
238 }
239
240 /**
241 * do_promote - promote as many requests as possible on the current queue
242 * @gl: The glock
243 *
244 * Returns: 1 if there is a blocked holder at the head of the list, or 2
245 * if a type specific operation is underway.
246 */
247
248 static int do_promote(struct gfs2_glock *gl)
249 __releases(&gl->gl_lockref.lock)
250 __acquires(&gl->gl_lockref.lock)
251 {
252 const struct gfs2_glock_operations *glops = gl->gl_ops;
253 struct gfs2_holder *gh, *tmp;
254 int ret;
255
256 restart:
257 list_for_each_entry_safe(gh, tmp, &gl->gl_holders, gh_list) {
258 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
259 continue;
260 if (may_grant(gl, gh)) {
261 if (gh->gh_list.prev == &gl->gl_holders &&
262 glops->go_lock) {
263 spin_unlock(&gl->gl_lockref.lock);
264 /* FIXME: eliminate this eventually */
265 ret = glops->go_lock(gh);
266 spin_lock(&gl->gl_lockref.lock);
267 if (ret) {
268 if (ret == 1)
269 return 2;
270 gh->gh_error = ret;
271 list_del_init(&gh->gh_list);
272 trace_gfs2_glock_queue(gh, 0);
273 gfs2_holder_wake(gh);
274 goto restart;
275 }
276 set_bit(HIF_HOLDER, &gh->gh_iflags);
277 trace_gfs2_promote(gh, 1);
278 gfs2_holder_wake(gh);
279 goto restart;
280 }
281 set_bit(HIF_HOLDER, &gh->gh_iflags);
282 trace_gfs2_promote(gh, 0);
283 gfs2_holder_wake(gh);
284 continue;
285 }
286 if (gh->gh_list.prev == &gl->gl_holders)
287 return 1;
288 do_error(gl, 0);
289 break;
290 }
291 return 0;
292 }
293
294 /**
295 * find_first_waiter - find the first gh that's waiting for the glock
296 * @gl: the glock
297 */
298
299 static inline struct gfs2_holder *find_first_waiter(const struct gfs2_glock *gl)
300 {
301 struct gfs2_holder *gh;
302
303 list_for_each_entry(gh, &gl->gl_holders, gh_list) {
304 if (!test_bit(HIF_HOLDER, &gh->gh_iflags))
305 return gh;
306 }
307 return NULL;
308 }
309
310 /**
311 * state_change - record that the glock is now in a different state
312 * @gl: the glock
313 * @new_state the new state
314 *
315 */
316
317 static void state_change(struct gfs2_glock *gl, unsigned int new_state)
318 {
319 int held1, held2;
320
321 held1 = (gl->gl_state != LM_ST_UNLOCKED);
322 held2 = (new_state != LM_ST_UNLOCKED);
323
324 if (held1 != held2) {
325 GLOCK_BUG_ON(gl, __lockref_is_dead(&gl->gl_lockref));
326 if (held2)
327 gl->gl_lockref.count++;
328 else
329 gl->gl_lockref.count--;
330 }
331 if (held1 && held2 && list_empty(&gl->gl_holders))
332 clear_bit(GLF_QUEUED, &gl->gl_flags);
333
334 if (new_state != gl->gl_target)
335 /* shorten our minimum hold time */
336 gl->gl_hold_time = max(gl->gl_hold_time - GL_GLOCK_HOLD_DECR,
337 GL_GLOCK_MIN_HOLD);
338 gl->gl_state = new_state;
339 gl->gl_tchange = jiffies;
340 }
341
342 static void gfs2_demote_wake(struct gfs2_glock *gl)
343 {
344 gl->gl_demote_state = LM_ST_EXCLUSIVE;
345 clear_bit(GLF_DEMOTE, &gl->gl_flags);
346 smp_mb__after_atomic();
347 wake_up_bit(&gl->gl_flags, GLF_DEMOTE);
348 }
349
350 /**
351 * finish_xmote - The DLM has replied to one of our lock requests
352 * @gl: The glock
353 * @ret: The status from the DLM
354 *
355 */
356
357 static void finish_xmote(struct gfs2_glock *gl, unsigned int ret)
358 {
359 const struct gfs2_glock_operations *glops = gl->gl_ops;
360 struct gfs2_holder *gh;
361 unsigned state = ret & LM_OUT_ST_MASK;
362 int rv;
363
364 spin_lock(&gl->gl_lockref.lock);
365 trace_gfs2_glock_state_change(gl, state);
366 state_change(gl, state);
367 gh = find_first_waiter(gl);
368
369 /* Demote to UN request arrived during demote to SH or DF */
370 if (test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags) &&
371 state != LM_ST_UNLOCKED && gl->gl_demote_state == LM_ST_UNLOCKED)
372 gl->gl_target = LM_ST_UNLOCKED;
373
374 /* Check for state != intended state */
375 if (unlikely(state != gl->gl_target)) {
376 if (gh && !test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags)) {
377 /* move to back of queue and try next entry */
378 if (ret & LM_OUT_CANCELED) {
379 if ((gh->gh_flags & LM_FLAG_PRIORITY) == 0)
380 list_move_tail(&gh->gh_list, &gl->gl_holders);
381 gh = find_first_waiter(gl);
382 gl->gl_target = gh->gh_state;
383 goto retry;
384 }
385 /* Some error or failed "try lock" - report it */
386 if ((ret & LM_OUT_ERROR) ||
387 (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) {
388 gl->gl_target = gl->gl_state;
389 do_error(gl, ret);
390 goto out;
391 }
392 }
393 switch(state) {
394 /* Unlocked due to conversion deadlock, try again */
395 case LM_ST_UNLOCKED:
396 retry:
397 do_xmote(gl, gh, gl->gl_target);
398 break;
399 /* Conversion fails, unlock and try again */
400 case LM_ST_SHARED:
401 case LM_ST_DEFERRED:
402 do_xmote(gl, gh, LM_ST_UNLOCKED);
403 break;
404 default: /* Everything else */
405 pr_err("wanted %u got %u\n", gl->gl_target, state);
406 GLOCK_BUG_ON(gl, 1);
407 }
408 spin_unlock(&gl->gl_lockref.lock);
409 return;
410 }
411
412 /* Fast path - we got what we asked for */
413 if (test_and_clear_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags))
414 gfs2_demote_wake(gl);
415 if (state != LM_ST_UNLOCKED) {
416 if (glops->go_xmote_bh) {
417 spin_unlock(&gl->gl_lockref.lock);
418 rv = glops->go_xmote_bh(gl, gh);
419 spin_lock(&gl->gl_lockref.lock);
420 if (rv) {
421 do_error(gl, rv);
422 goto out;
423 }
424 }
425 rv = do_promote(gl);
426 if (rv == 2)
427 goto out_locked;
428 }
429 out:
430 clear_bit(GLF_LOCK, &gl->gl_flags);
431 out_locked:
432 spin_unlock(&gl->gl_lockref.lock);
433 }
434
435 /**
436 * do_xmote - Calls the DLM to change the state of a lock
437 * @gl: The lock state
438 * @gh: The holder (only for promotes)
439 * @target: The target lock state
440 *
441 */
442
443 static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target)
444 __releases(&gl->gl_lockref.lock)
445 __acquires(&gl->gl_lockref.lock)
446 {
447 const struct gfs2_glock_operations *glops = gl->gl_ops;
448 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
449 unsigned int lck_flags = (unsigned int)(gh ? gh->gh_flags : 0);
450 int ret;
451
452 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) &&
453 target != LM_ST_UNLOCKED)
454 return;
455 lck_flags &= (LM_FLAG_TRY | LM_FLAG_TRY_1CB | LM_FLAG_NOEXP |
456 LM_FLAG_PRIORITY);
457 GLOCK_BUG_ON(gl, gl->gl_state == target);
458 GLOCK_BUG_ON(gl, gl->gl_state == gl->gl_target);
459 if ((target == LM_ST_UNLOCKED || target == LM_ST_DEFERRED) &&
460 glops->go_inval) {
461 set_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);
462 do_error(gl, 0); /* Fail queued try locks */
463 }
464 gl->gl_req = target;
465 set_bit(GLF_BLOCKING, &gl->gl_flags);
466 if ((gl->gl_req == LM_ST_UNLOCKED) ||
467 (gl->gl_state == LM_ST_EXCLUSIVE) ||
468 (lck_flags & (LM_FLAG_TRY|LM_FLAG_TRY_1CB)))
469 clear_bit(GLF_BLOCKING, &gl->gl_flags);
470 spin_unlock(&gl->gl_lockref.lock);
471 if (glops->go_sync)
472 glops->go_sync(gl);
473 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags))
474 glops->go_inval(gl, target == LM_ST_DEFERRED ? 0 : DIO_METADATA);
475 clear_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);
476
477 gfs2_glock_hold(gl);
478 if (sdp->sd_lockstruct.ls_ops->lm_lock) {
479 /* lock_dlm */
480 ret = sdp->sd_lockstruct.ls_ops->lm_lock(gl, target, lck_flags);
481 if (ret == -EINVAL && gl->gl_target == LM_ST_UNLOCKED &&
482 target == LM_ST_UNLOCKED &&
483 test_bit(SDF_SKIP_DLM_UNLOCK, &sdp->sd_flags)) {
484 finish_xmote(gl, target);
485 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
486 gfs2_glock_put(gl);
487 }
488 else if (ret) {
489 pr_err("lm_lock ret %d\n", ret);
490 GLOCK_BUG_ON(gl, !test_bit(SDF_SHUTDOWN,
491 &sdp->sd_flags));
492 }
493 } else { /* lock_nolock */
494 finish_xmote(gl, target);
495 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
496 gfs2_glock_put(gl);
497 }
498
499 spin_lock(&gl->gl_lockref.lock);
500 }
501
502 /**
503 * find_first_holder - find the first "holder" gh
504 * @gl: the glock
505 */
506
507 static inline struct gfs2_holder *find_first_holder(const struct gfs2_glock *gl)
508 {
509 struct gfs2_holder *gh;
510
511 if (!list_empty(&gl->gl_holders)) {
512 gh = list_entry(gl->gl_holders.next, struct gfs2_holder, gh_list);
513 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
514 return gh;
515 }
516 return NULL;
517 }
518
519 /**
520 * run_queue - do all outstanding tasks related to a glock
521 * @gl: The glock in question
522 * @nonblock: True if we must not block in run_queue
523 *
524 */
525
526 static void run_queue(struct gfs2_glock *gl, const int nonblock)
527 __releases(&gl->gl_lockref.lock)
528 __acquires(&gl->gl_lockref.lock)
529 {
530 struct gfs2_holder *gh = NULL;
531 int ret;
532
533 if (test_and_set_bit(GLF_LOCK, &gl->gl_flags))
534 return;
535
536 GLOCK_BUG_ON(gl, test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags));
537
538 if (test_bit(GLF_DEMOTE, &gl->gl_flags) &&
539 gl->gl_demote_state != gl->gl_state) {
540 if (find_first_holder(gl))
541 goto out_unlock;
542 if (nonblock)
543 goto out_sched;
544 set_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags);
545 GLOCK_BUG_ON(gl, gl->gl_demote_state == LM_ST_EXCLUSIVE);
546 gl->gl_target = gl->gl_demote_state;
547 } else {
548 if (test_bit(GLF_DEMOTE, &gl->gl_flags))
549 gfs2_demote_wake(gl);
550 ret = do_promote(gl);
551 if (ret == 0)
552 goto out_unlock;
553 if (ret == 2)
554 goto out;
555 gh = find_first_waiter(gl);
556 gl->gl_target = gh->gh_state;
557 if (!(gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)))
558 do_error(gl, 0); /* Fail queued try locks */
559 }
560 do_xmote(gl, gh, gl->gl_target);
561 out:
562 return;
563
564 out_sched:
565 clear_bit(GLF_LOCK, &gl->gl_flags);
566 smp_mb__after_atomic();
567 gl->gl_lockref.count++;
568 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
569 gl->gl_lockref.count--;
570 return;
571
572 out_unlock:
573 clear_bit(GLF_LOCK, &gl->gl_flags);
574 smp_mb__after_atomic();
575 return;
576 }
577
578 static void delete_work_func(struct work_struct *work)
579 {
580 struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_delete);
581 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
582 struct inode *inode;
583 u64 no_addr = gl->gl_name.ln_number;
584
585 /* If someone's using this glock to create a new dinode, the block must
586 have been freed by another node, then re-used, in which case our
587 iopen callback is too late after the fact. Ignore it. */
588 if (test_bit(GLF_INODE_CREATING, &gl->gl_flags))
589 goto out;
590
591 inode = gfs2_lookup_by_inum(sdp, no_addr, NULL, GFS2_BLKST_UNLINKED);
592 if (inode && !IS_ERR(inode)) {
593 d_prune_aliases(inode);
594 iput(inode);
595 }
596 out:
597 gfs2_glock_put(gl);
598 }
599
600 static void glock_work_func(struct work_struct *work)
601 {
602 unsigned long delay = 0;
603 struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_work.work);
604 int drop_ref = 0;
605
606 if (test_and_clear_bit(GLF_REPLY_PENDING, &gl->gl_flags)) {
607 finish_xmote(gl, gl->gl_reply);
608 drop_ref = 1;
609 }
610 spin_lock(&gl->gl_lockref.lock);
611 if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
612 gl->gl_state != LM_ST_UNLOCKED &&
613 gl->gl_demote_state != LM_ST_EXCLUSIVE) {
614 unsigned long holdtime, now = jiffies;
615
616 holdtime = gl->gl_tchange + gl->gl_hold_time;
617 if (time_before(now, holdtime))
618 delay = holdtime - now;
619
620 if (!delay) {
621 clear_bit(GLF_PENDING_DEMOTE, &gl->gl_flags);
622 set_bit(GLF_DEMOTE, &gl->gl_flags);
623 }
624 }
625 run_queue(gl, 0);
626 spin_unlock(&gl->gl_lockref.lock);
627 if (!delay)
628 gfs2_glock_put(gl);
629 else {
630 if (gl->gl_name.ln_type != LM_TYPE_INODE)
631 delay = 0;
632 if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
633 gfs2_glock_put(gl);
634 }
635 if (drop_ref)
636 gfs2_glock_put(gl);
637 }
638
639 /**
640 * gfs2_glock_get() - Get a glock, or create one if one doesn't exist
641 * @sdp: The GFS2 superblock
642 * @number: the lock number
643 * @glops: The glock_operations to use
644 * @create: If 0, don't create the glock if it doesn't exist
645 * @glp: the glock is returned here
646 *
647 * This does not lock a glock, just finds/creates structures for one.
648 *
649 * Returns: errno
650 */
651
652 int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
653 const struct gfs2_glock_operations *glops, int create,
654 struct gfs2_glock **glp)
655 {
656 struct super_block *s = sdp->sd_vfs;
657 struct lm_lockname name = { .ln_number = number,
658 .ln_type = glops->go_type,
659 .ln_sbd = sdp };
660 struct gfs2_glock *gl, *tmp;
661 struct address_space *mapping;
662 struct kmem_cache *cachep;
663 int ret = 0;
664
665 rcu_read_lock();
666 gl = rhashtable_lookup_fast(&gl_hash_table, &name, ht_parms);
667 if (gl && !lockref_get_not_dead(&gl->gl_lockref))
668 gl = NULL;
669 rcu_read_unlock();
670
671 *glp = gl;
672 if (gl)
673 return 0;
674 if (!create)
675 return -ENOENT;
676
677 if (glops->go_flags & GLOF_ASPACE)
678 cachep = gfs2_glock_aspace_cachep;
679 else
680 cachep = gfs2_glock_cachep;
681 gl = kmem_cache_alloc(cachep, GFP_NOFS);
682 if (!gl)
683 return -ENOMEM;
684
685 memset(&gl->gl_lksb, 0, sizeof(struct dlm_lksb));
686
687 if (glops->go_flags & GLOF_LVB) {
688 gl->gl_lksb.sb_lvbptr = kzalloc(GFS2_MIN_LVB_SIZE, GFP_NOFS);
689 if (!gl->gl_lksb.sb_lvbptr) {
690 kmem_cache_free(cachep, gl);
691 return -ENOMEM;
692 }
693 }
694
695 atomic_inc(&sdp->sd_glock_disposal);
696 gl->gl_node.next = NULL;
697 gl->gl_flags = 0;
698 gl->gl_name = name;
699 gl->gl_lockref.count = 1;
700 gl->gl_state = LM_ST_UNLOCKED;
701 gl->gl_target = LM_ST_UNLOCKED;
702 gl->gl_demote_state = LM_ST_EXCLUSIVE;
703 gl->gl_ops = glops;
704 gl->gl_dstamp = 0;
705 preempt_disable();
706 /* We use the global stats to estimate the initial per-glock stats */
707 gl->gl_stats = this_cpu_ptr(sdp->sd_lkstats)->lkstats[glops->go_type];
708 preempt_enable();
709 gl->gl_stats.stats[GFS2_LKS_DCOUNT] = 0;
710 gl->gl_stats.stats[GFS2_LKS_QCOUNT] = 0;
711 gl->gl_tchange = jiffies;
712 gl->gl_object = NULL;
713 gl->gl_hold_time = GL_GLOCK_DFT_HOLD;
714 INIT_DELAYED_WORK(&gl->gl_work, glock_work_func);
715 INIT_WORK(&gl->gl_delete, delete_work_func);
716
717 mapping = gfs2_glock2aspace(gl);
718 if (mapping) {
719 mapping->a_ops = &gfs2_meta_aops;
720 mapping->host = s->s_bdev->bd_inode;
721 mapping->flags = 0;
722 mapping_set_gfp_mask(mapping, GFP_NOFS);
723 mapping->private_data = NULL;
724 mapping->writeback_index = 0;
725 }
726
727 again:
728 rcu_read_lock();
729 tmp = rhashtable_lookup_get_insert_fast(&gl_hash_table, &gl->gl_node,
730 ht_parms);
731 if (!tmp) {
732 *glp = gl;
733 goto out;
734 }
735 if (IS_ERR(tmp)) {
736 ret = PTR_ERR(tmp);
737 goto out_free;
738 }
739 if (lockref_get_not_dead(&tmp->gl_lockref)) {
740 *glp = tmp;
741 goto out_free;
742 }
743 rcu_read_unlock();
744 cond_resched();
745 goto again;
746
747 out_free:
748 kfree(gl->gl_lksb.sb_lvbptr);
749 kmem_cache_free(cachep, gl);
750 atomic_dec(&sdp->sd_glock_disposal);
751
752 out:
753 rcu_read_unlock();
754 return ret;
755 }
756
757 /**
758 * gfs2_holder_init - initialize a struct gfs2_holder in the default way
759 * @gl: the glock
760 * @state: the state we're requesting
761 * @flags: the modifier flags
762 * @gh: the holder structure
763 *
764 */
765
766 void gfs2_holder_init(struct gfs2_glock *gl, unsigned int state, u16 flags,
767 struct gfs2_holder *gh)
768 {
769 INIT_LIST_HEAD(&gh->gh_list);
770 gh->gh_gl = gl;
771 gh->gh_ip = _RET_IP_;
772 gh->gh_owner_pid = get_pid(task_pid(current));
773 gh->gh_state = state;
774 gh->gh_flags = flags;
775 gh->gh_error = 0;
776 gh->gh_iflags = 0;
777 gfs2_glock_hold(gl);
778 }
779
780 /**
781 * gfs2_holder_reinit - reinitialize a struct gfs2_holder so we can requeue it
782 * @state: the state we're requesting
783 * @flags: the modifier flags
784 * @gh: the holder structure
785 *
786 * Don't mess with the glock.
787 *
788 */
789
790 void gfs2_holder_reinit(unsigned int state, u16 flags, struct gfs2_holder *gh)
791 {
792 gh->gh_state = state;
793 gh->gh_flags = flags;
794 gh->gh_iflags = 0;
795 gh->gh_ip = _RET_IP_;
796 put_pid(gh->gh_owner_pid);
797 gh->gh_owner_pid = get_pid(task_pid(current));
798 }
799
800 /**
801 * gfs2_holder_uninit - uninitialize a holder structure (drop glock reference)
802 * @gh: the holder structure
803 *
804 */
805
806 void gfs2_holder_uninit(struct gfs2_holder *gh)
807 {
808 put_pid(gh->gh_owner_pid);
809 gfs2_glock_put(gh->gh_gl);
810 gfs2_holder_mark_uninitialized(gh);
811 gh->gh_ip = 0;
812 }
813
814 /**
815 * gfs2_glock_wait - wait on a glock acquisition
816 * @gh: the glock holder
817 *
818 * Returns: 0 on success
819 */
820
821 int gfs2_glock_wait(struct gfs2_holder *gh)
822 {
823 unsigned long time1 = jiffies;
824
825 might_sleep();
826 wait_on_bit(&gh->gh_iflags, HIF_WAIT, TASK_UNINTERRUPTIBLE);
827 if (time_after(jiffies, time1 + HZ)) /* have we waited > a second? */
828 /* Lengthen the minimum hold time. */
829 gh->gh_gl->gl_hold_time = min(gh->gh_gl->gl_hold_time +
830 GL_GLOCK_HOLD_INCR,
831 GL_GLOCK_MAX_HOLD);
832 return gh->gh_error;
833 }
834
835 /**
836 * handle_callback - process a demote request
837 * @gl: the glock
838 * @state: the state the caller wants us to change to
839 *
840 * There are only two requests that we are going to see in actual
841 * practise: LM_ST_SHARED and LM_ST_UNLOCKED
842 */
843
844 static void handle_callback(struct gfs2_glock *gl, unsigned int state,
845 unsigned long delay, bool remote)
846 {
847 int bit = delay ? GLF_PENDING_DEMOTE : GLF_DEMOTE;
848
849 set_bit(bit, &gl->gl_flags);
850 if (gl->gl_demote_state == LM_ST_EXCLUSIVE) {
851 gl->gl_demote_state = state;
852 gl->gl_demote_time = jiffies;
853 } else if (gl->gl_demote_state != LM_ST_UNLOCKED &&
854 gl->gl_demote_state != state) {
855 gl->gl_demote_state = LM_ST_UNLOCKED;
856 }
857 if (gl->gl_ops->go_callback)
858 gl->gl_ops->go_callback(gl, remote);
859 trace_gfs2_demote_rq(gl, remote);
860 }
861
862 void gfs2_print_dbg(struct seq_file *seq, const char *fmt, ...)
863 {
864 struct va_format vaf;
865 va_list args;
866
867 va_start(args, fmt);
868
869 if (seq) {
870 seq_vprintf(seq, fmt, args);
871 } else {
872 vaf.fmt = fmt;
873 vaf.va = &args;
874
875 pr_err("%pV", &vaf);
876 }
877
878 va_end(args);
879 }
880
881 /**
882 * add_to_queue - Add a holder to the wait queue (but look for recursion)
883 * @gh: the holder structure to add
884 *
885 * Eventually we should move the recursive locking trap to a
886 * debugging option or something like that. This is the fast
887 * path and needs to have the minimum number of distractions.
888 *
889 */
890
891 static inline void add_to_queue(struct gfs2_holder *gh)
892 __releases(&gl->gl_lockref.lock)
893 __acquires(&gl->gl_lockref.lock)
894 {
895 struct gfs2_glock *gl = gh->gh_gl;
896 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
897 struct list_head *insert_pt = NULL;
898 struct gfs2_holder *gh2;
899 int try_futile = 0;
900
901 BUG_ON(gh->gh_owner_pid == NULL);
902 if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags))
903 BUG();
904
905 if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)) {
906 if (test_bit(GLF_LOCK, &gl->gl_flags))
907 try_futile = !may_grant(gl, gh);
908 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags))
909 goto fail;
910 }
911
912 list_for_each_entry(gh2, &gl->gl_holders, gh_list) {
913 if (unlikely(gh2->gh_owner_pid == gh->gh_owner_pid &&
914 (gh->gh_gl->gl_ops->go_type != LM_TYPE_FLOCK)))
915 goto trap_recursive;
916 if (try_futile &&
917 !(gh2->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) {
918 fail:
919 gh->gh_error = GLR_TRYFAILED;
920 gfs2_holder_wake(gh);
921 return;
922 }
923 if (test_bit(HIF_HOLDER, &gh2->gh_iflags))
924 continue;
925 if (unlikely((gh->gh_flags & LM_FLAG_PRIORITY) && !insert_pt))
926 insert_pt = &gh2->gh_list;
927 }
928 set_bit(GLF_QUEUED, &gl->gl_flags);
929 trace_gfs2_glock_queue(gh, 1);
930 gfs2_glstats_inc(gl, GFS2_LKS_QCOUNT);
931 gfs2_sbstats_inc(gl, GFS2_LKS_QCOUNT);
932 if (likely(insert_pt == NULL)) {
933 list_add_tail(&gh->gh_list, &gl->gl_holders);
934 if (unlikely(gh->gh_flags & LM_FLAG_PRIORITY))
935 goto do_cancel;
936 return;
937 }
938 list_add_tail(&gh->gh_list, insert_pt);
939 do_cancel:
940 gh = list_entry(gl->gl_holders.next, struct gfs2_holder, gh_list);
941 if (!(gh->gh_flags & LM_FLAG_PRIORITY)) {
942 spin_unlock(&gl->gl_lockref.lock);
943 if (sdp->sd_lockstruct.ls_ops->lm_cancel)
944 sdp->sd_lockstruct.ls_ops->lm_cancel(gl);
945 spin_lock(&gl->gl_lockref.lock);
946 }
947 return;
948
949 trap_recursive:
950 pr_err("original: %pSR\n", (void *)gh2->gh_ip);
951 pr_err("pid: %d\n", pid_nr(gh2->gh_owner_pid));
952 pr_err("lock type: %d req lock state : %d\n",
953 gh2->gh_gl->gl_name.ln_type, gh2->gh_state);
954 pr_err("new: %pSR\n", (void *)gh->gh_ip);
955 pr_err("pid: %d\n", pid_nr(gh->gh_owner_pid));
956 pr_err("lock type: %d req lock state : %d\n",
957 gh->gh_gl->gl_name.ln_type, gh->gh_state);
958 gfs2_dump_glock(NULL, gl);
959 BUG();
960 }
961
962 /**
963 * gfs2_glock_nq - enqueue a struct gfs2_holder onto a glock (acquire a glock)
964 * @gh: the holder structure
965 *
966 * if (gh->gh_flags & GL_ASYNC), this never returns an error
967 *
968 * Returns: 0, GLR_TRYFAILED, or errno on failure
969 */
970
971 int gfs2_glock_nq(struct gfs2_holder *gh)
972 {
973 struct gfs2_glock *gl = gh->gh_gl;
974 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
975 int error = 0;
976
977 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
978 return -EIO;
979
980 if (test_bit(GLF_LRU, &gl->gl_flags))
981 gfs2_glock_remove_from_lru(gl);
982
983 spin_lock(&gl->gl_lockref.lock);
984 add_to_queue(gh);
985 if (unlikely((LM_FLAG_NOEXP & gh->gh_flags) &&
986 test_and_clear_bit(GLF_FROZEN, &gl->gl_flags))) {
987 set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
988 gl->gl_lockref.count++;
989 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
990 gl->gl_lockref.count--;
991 }
992 run_queue(gl, 1);
993 spin_unlock(&gl->gl_lockref.lock);
994
995 if (!(gh->gh_flags & GL_ASYNC))
996 error = gfs2_glock_wait(gh);
997
998 return error;
999 }
1000
1001 /**
1002 * gfs2_glock_poll - poll to see if an async request has been completed
1003 * @gh: the holder
1004 *
1005 * Returns: 1 if the request is ready to be gfs2_glock_wait()ed on
1006 */
1007
1008 int gfs2_glock_poll(struct gfs2_holder *gh)
1009 {
1010 return test_bit(HIF_WAIT, &gh->gh_iflags) ? 0 : 1;
1011 }
1012
1013 /**
1014 * gfs2_glock_dq - dequeue a struct gfs2_holder from a glock (release a glock)
1015 * @gh: the glock holder
1016 *
1017 */
1018
1019 void gfs2_glock_dq(struct gfs2_holder *gh)
1020 {
1021 struct gfs2_glock *gl = gh->gh_gl;
1022 const struct gfs2_glock_operations *glops = gl->gl_ops;
1023 unsigned delay = 0;
1024 int fast_path = 0;
1025
1026 spin_lock(&gl->gl_lockref.lock);
1027 if (gh->gh_flags & GL_NOCACHE)
1028 handle_callback(gl, LM_ST_UNLOCKED, 0, false);
1029
1030 list_del_init(&gh->gh_list);
1031 clear_bit(HIF_HOLDER, &gh->gh_iflags);
1032 if (find_first_holder(gl) == NULL) {
1033 if (glops->go_unlock) {
1034 GLOCK_BUG_ON(gl, test_and_set_bit(GLF_LOCK, &gl->gl_flags));
1035 spin_unlock(&gl->gl_lockref.lock);
1036 glops->go_unlock(gh);
1037 spin_lock(&gl->gl_lockref.lock);
1038 clear_bit(GLF_LOCK, &gl->gl_flags);
1039 }
1040 if (list_empty(&gl->gl_holders) &&
1041 !test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
1042 !test_bit(GLF_DEMOTE, &gl->gl_flags))
1043 fast_path = 1;
1044 }
1045 if (!test_bit(GLF_LFLUSH, &gl->gl_flags) && demote_ok(gl) &&
1046 (glops->go_flags & GLOF_LRU))
1047 gfs2_glock_add_to_lru(gl);
1048
1049 trace_gfs2_glock_queue(gh, 0);
1050 spin_unlock(&gl->gl_lockref.lock);
1051 if (likely(fast_path))
1052 return;
1053
1054 gfs2_glock_hold(gl);
1055 if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
1056 !test_bit(GLF_DEMOTE, &gl->gl_flags) &&
1057 gl->gl_name.ln_type == LM_TYPE_INODE)
1058 delay = gl->gl_hold_time;
1059 if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
1060 gfs2_glock_put(gl);
1061 }
1062
1063 void gfs2_glock_dq_wait(struct gfs2_holder *gh)
1064 {
1065 struct gfs2_glock *gl = gh->gh_gl;
1066 gfs2_glock_dq(gh);
1067 might_sleep();
1068 wait_on_bit(&gl->gl_flags, GLF_DEMOTE, TASK_UNINTERRUPTIBLE);
1069 }
1070
1071 /**
1072 * gfs2_glock_dq_uninit - dequeue a holder from a glock and initialize it
1073 * @gh: the holder structure
1074 *
1075 */
1076
1077 void gfs2_glock_dq_uninit(struct gfs2_holder *gh)
1078 {
1079 gfs2_glock_dq(gh);
1080 gfs2_holder_uninit(gh);
1081 }
1082
1083 /**
1084 * gfs2_glock_nq_num - acquire a glock based on lock number
1085 * @sdp: the filesystem
1086 * @number: the lock number
1087 * @glops: the glock operations for the type of glock
1088 * @state: the state to acquire the glock in
1089 * @flags: modifier flags for the acquisition
1090 * @gh: the struct gfs2_holder
1091 *
1092 * Returns: errno
1093 */
1094
1095 int gfs2_glock_nq_num(struct gfs2_sbd *sdp, u64 number,
1096 const struct gfs2_glock_operations *glops,
1097 unsigned int state, u16 flags, struct gfs2_holder *gh)
1098 {
1099 struct gfs2_glock *gl;
1100 int error;
1101
1102 error = gfs2_glock_get(sdp, number, glops, CREATE, &gl);
1103 if (!error) {
1104 error = gfs2_glock_nq_init(gl, state, flags, gh);
1105 gfs2_glock_put(gl);
1106 }
1107
1108 return error;
1109 }
1110
1111 /**
1112 * glock_compare - Compare two struct gfs2_glock structures for sorting
1113 * @arg_a: the first structure
1114 * @arg_b: the second structure
1115 *
1116 */
1117
1118 static int glock_compare(const void *arg_a, const void *arg_b)
1119 {
1120 const struct gfs2_holder *gh_a = *(const struct gfs2_holder **)arg_a;
1121 const struct gfs2_holder *gh_b = *(const struct gfs2_holder **)arg_b;
1122 const struct lm_lockname *a = &gh_a->gh_gl->gl_name;
1123 const struct lm_lockname *b = &gh_b->gh_gl->gl_name;
1124
1125 if (a->ln_number > b->ln_number)
1126 return 1;
1127 if (a->ln_number < b->ln_number)
1128 return -1;
1129 BUG_ON(gh_a->gh_gl->gl_ops->go_type == gh_b->gh_gl->gl_ops->go_type);
1130 return 0;
1131 }
1132
1133 /**
1134 * nq_m_sync - synchonously acquire more than one glock in deadlock free order
1135 * @num_gh: the number of structures
1136 * @ghs: an array of struct gfs2_holder structures
1137 *
1138 * Returns: 0 on success (all glocks acquired),
1139 * errno on failure (no glocks acquired)
1140 */
1141
1142 static int nq_m_sync(unsigned int num_gh, struct gfs2_holder *ghs,
1143 struct gfs2_holder **p)
1144 {
1145 unsigned int x;
1146 int error = 0;
1147
1148 for (x = 0; x < num_gh; x++)
1149 p[x] = &ghs[x];
1150
1151 sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare, NULL);
1152
1153 for (x = 0; x < num_gh; x++) {
1154 p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1155
1156 error = gfs2_glock_nq(p[x]);
1157 if (error) {
1158 while (x--)
1159 gfs2_glock_dq(p[x]);
1160 break;
1161 }
1162 }
1163
1164 return error;
1165 }
1166
1167 /**
1168 * gfs2_glock_nq_m - acquire multiple glocks
1169 * @num_gh: the number of structures
1170 * @ghs: an array of struct gfs2_holder structures
1171 *
1172 *
1173 * Returns: 0 on success (all glocks acquired),
1174 * errno on failure (no glocks acquired)
1175 */
1176
1177 int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs)
1178 {
1179 struct gfs2_holder *tmp[4];
1180 struct gfs2_holder **pph = tmp;
1181 int error = 0;
1182
1183 switch(num_gh) {
1184 case 0:
1185 return 0;
1186 case 1:
1187 ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1188 return gfs2_glock_nq(ghs);
1189 default:
1190 if (num_gh <= 4)
1191 break;
1192 pph = kmalloc(num_gh * sizeof(struct gfs2_holder *), GFP_NOFS);
1193 if (!pph)
1194 return -ENOMEM;
1195 }
1196
1197 error = nq_m_sync(num_gh, ghs, pph);
1198
1199 if (pph != tmp)
1200 kfree(pph);
1201
1202 return error;
1203 }
1204
1205 /**
1206 * gfs2_glock_dq_m - release multiple glocks
1207 * @num_gh: the number of structures
1208 * @ghs: an array of struct gfs2_holder structures
1209 *
1210 */
1211
1212 void gfs2_glock_dq_m(unsigned int num_gh, struct gfs2_holder *ghs)
1213 {
1214 while (num_gh--)
1215 gfs2_glock_dq(&ghs[num_gh]);
1216 }
1217
1218 void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state)
1219 {
1220 unsigned long delay = 0;
1221 unsigned long holdtime;
1222 unsigned long now = jiffies;
1223
1224 gfs2_glock_hold(gl);
1225 holdtime = gl->gl_tchange + gl->gl_hold_time;
1226 if (test_bit(GLF_QUEUED, &gl->gl_flags) &&
1227 gl->gl_name.ln_type == LM_TYPE_INODE) {
1228 if (time_before(now, holdtime))
1229 delay = holdtime - now;
1230 if (test_bit(GLF_REPLY_PENDING, &gl->gl_flags))
1231 delay = gl->gl_hold_time;
1232 }
1233
1234 spin_lock(&gl->gl_lockref.lock);
1235 handle_callback(gl, state, delay, true);
1236 spin_unlock(&gl->gl_lockref.lock);
1237 if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
1238 gfs2_glock_put(gl);
1239 }
1240
1241 /**
1242 * gfs2_should_freeze - Figure out if glock should be frozen
1243 * @gl: The glock in question
1244 *
1245 * Glocks are not frozen if (a) the result of the dlm operation is
1246 * an error, (b) the locking operation was an unlock operation or
1247 * (c) if there is a "noexp" flagged request anywhere in the queue
1248 *
1249 * Returns: 1 if freezing should occur, 0 otherwise
1250 */
1251
1252 static int gfs2_should_freeze(const struct gfs2_glock *gl)
1253 {
1254 const struct gfs2_holder *gh;
1255
1256 if (gl->gl_reply & ~LM_OUT_ST_MASK)
1257 return 0;
1258 if (gl->gl_target == LM_ST_UNLOCKED)
1259 return 0;
1260
1261 list_for_each_entry(gh, &gl->gl_holders, gh_list) {
1262 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
1263 continue;
1264 if (LM_FLAG_NOEXP & gh->gh_flags)
1265 return 0;
1266 }
1267
1268 return 1;
1269 }
1270
1271 /**
1272 * gfs2_glock_complete - Callback used by locking
1273 * @gl: Pointer to the glock
1274 * @ret: The return value from the dlm
1275 *
1276 * The gl_reply field is under the gl_lockref.lock lock so that it is ok
1277 * to use a bitfield shared with other glock state fields.
1278 */
1279
1280 void gfs2_glock_complete(struct gfs2_glock *gl, int ret)
1281 {
1282 struct lm_lockstruct *ls = &gl->gl_name.ln_sbd->sd_lockstruct;
1283
1284 spin_lock(&gl->gl_lockref.lock);
1285 gl->gl_reply = ret;
1286
1287 if (unlikely(test_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags))) {
1288 if (gfs2_should_freeze(gl)) {
1289 set_bit(GLF_FROZEN, &gl->gl_flags);
1290 spin_unlock(&gl->gl_lockref.lock);
1291 return;
1292 }
1293 }
1294
1295 gl->gl_lockref.count++;
1296 set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
1297 spin_unlock(&gl->gl_lockref.lock);
1298
1299 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
1300 gfs2_glock_put(gl);
1301 }
1302
1303 static int glock_cmp(void *priv, struct list_head *a, struct list_head *b)
1304 {
1305 struct gfs2_glock *gla, *glb;
1306
1307 gla = list_entry(a, struct gfs2_glock, gl_lru);
1308 glb = list_entry(b, struct gfs2_glock, gl_lru);
1309
1310 if (gla->gl_name.ln_number > glb->gl_name.ln_number)
1311 return 1;
1312 if (gla->gl_name.ln_number < glb->gl_name.ln_number)
1313 return -1;
1314
1315 return 0;
1316 }
1317
1318 /**
1319 * gfs2_dispose_glock_lru - Demote a list of glocks
1320 * @list: The list to dispose of
1321 *
1322 * Disposing of glocks may involve disk accesses, so that here we sort
1323 * the glocks by number (i.e. disk location of the inodes) so that if
1324 * there are any such accesses, they'll be sent in order (mostly).
1325 *
1326 * Must be called under the lru_lock, but may drop and retake this
1327 * lock. While the lru_lock is dropped, entries may vanish from the
1328 * list, but no new entries will appear on the list (since it is
1329 * private)
1330 */
1331
1332 static void gfs2_dispose_glock_lru(struct list_head *list)
1333 __releases(&lru_lock)
1334 __acquires(&lru_lock)
1335 {
1336 struct gfs2_glock *gl;
1337
1338 list_sort(NULL, list, glock_cmp);
1339
1340 while(!list_empty(list)) {
1341 gl = list_entry(list->next, struct gfs2_glock, gl_lru);
1342 list_del_init(&gl->gl_lru);
1343 if (!spin_trylock(&gl->gl_lockref.lock)) {
1344 add_back_to_lru:
1345 list_add(&gl->gl_lru, &lru_list);
1346 atomic_inc(&lru_count);
1347 continue;
1348 }
1349 if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
1350 spin_unlock(&gl->gl_lockref.lock);
1351 goto add_back_to_lru;
1352 }
1353 clear_bit(GLF_LRU, &gl->gl_flags);
1354 gl->gl_lockref.count++;
1355 if (demote_ok(gl))
1356 handle_callback(gl, LM_ST_UNLOCKED, 0, false);
1357 WARN_ON(!test_and_clear_bit(GLF_LOCK, &gl->gl_flags));
1358 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
1359 gl->gl_lockref.count--;
1360 spin_unlock(&gl->gl_lockref.lock);
1361 cond_resched_lock(&lru_lock);
1362 }
1363 }
1364
1365 /**
1366 * gfs2_scan_glock_lru - Scan the LRU looking for locks to demote
1367 * @nr: The number of entries to scan
1368 *
1369 * This function selects the entries on the LRU which are able to
1370 * be demoted, and then kicks off the process by calling
1371 * gfs2_dispose_glock_lru() above.
1372 */
1373
1374 static long gfs2_scan_glock_lru(int nr)
1375 {
1376 struct gfs2_glock *gl;
1377 LIST_HEAD(skipped);
1378 LIST_HEAD(dispose);
1379 long freed = 0;
1380
1381 spin_lock(&lru_lock);
1382 while ((nr-- >= 0) && !list_empty(&lru_list)) {
1383 gl = list_entry(lru_list.next, struct gfs2_glock, gl_lru);
1384
1385 /* Test for being demotable */
1386 if (!test_bit(GLF_LOCK, &gl->gl_flags)) {
1387 list_move(&gl->gl_lru, &dispose);
1388 atomic_dec(&lru_count);
1389 freed++;
1390 continue;
1391 }
1392
1393 list_move(&gl->gl_lru, &skipped);
1394 }
1395 list_splice(&skipped, &lru_list);
1396 if (!list_empty(&dispose))
1397 gfs2_dispose_glock_lru(&dispose);
1398 spin_unlock(&lru_lock);
1399
1400 return freed;
1401 }
1402
1403 static unsigned long gfs2_glock_shrink_scan(struct shrinker *shrink,
1404 struct shrink_control *sc)
1405 {
1406 if (!(sc->gfp_mask & __GFP_FS))
1407 return SHRINK_STOP;
1408 return gfs2_scan_glock_lru(sc->nr_to_scan);
1409 }
1410
1411 static unsigned long gfs2_glock_shrink_count(struct shrinker *shrink,
1412 struct shrink_control *sc)
1413 {
1414 return vfs_pressure_ratio(atomic_read(&lru_count));
1415 }
1416
1417 static struct shrinker glock_shrinker = {
1418 .seeks = DEFAULT_SEEKS,
1419 .count_objects = gfs2_glock_shrink_count,
1420 .scan_objects = gfs2_glock_shrink_scan,
1421 };
1422
1423 /**
1424 * examine_bucket - Call a function for glock in a hash bucket
1425 * @examiner: the function
1426 * @sdp: the filesystem
1427 * @bucket: the bucket
1428 *
1429 * Note that the function can be called multiple times on the same
1430 * object. So the user must ensure that the function can cope with
1431 * that.
1432 */
1433
1434 static void glock_hash_walk(glock_examiner examiner, const struct gfs2_sbd *sdp)
1435 {
1436 struct gfs2_glock *gl;
1437 struct rhashtable_iter iter;
1438
1439 rhashtable_walk_enter(&gl_hash_table, &iter);
1440
1441 do {
1442 gl = ERR_PTR(rhashtable_walk_start(&iter));
1443 if (gl)
1444 continue;
1445
1446 while ((gl = rhashtable_walk_next(&iter)) && !IS_ERR(gl))
1447 if ((gl->gl_name.ln_sbd == sdp) &&
1448 lockref_get_not_dead(&gl->gl_lockref))
1449 examiner(gl);
1450
1451 rhashtable_walk_stop(&iter);
1452 } while (cond_resched(), gl == ERR_PTR(-EAGAIN));
1453
1454 rhashtable_walk_exit(&iter);
1455 }
1456
1457 /**
1458 * thaw_glock - thaw out a glock which has an unprocessed reply waiting
1459 * @gl: The glock to thaw
1460 *
1461 */
1462
1463 static void thaw_glock(struct gfs2_glock *gl)
1464 {
1465 if (!test_and_clear_bit(GLF_FROZEN, &gl->gl_flags))
1466 goto out;
1467 set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
1468 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0) {
1469 out:
1470 gfs2_glock_put(gl);
1471 }
1472 }
1473
1474 /**
1475 * clear_glock - look at a glock and see if we can free it from glock cache
1476 * @gl: the glock to look at
1477 *
1478 */
1479
1480 static void clear_glock(struct gfs2_glock *gl)
1481 {
1482 gfs2_glock_remove_from_lru(gl);
1483
1484 spin_lock(&gl->gl_lockref.lock);
1485 if (gl->gl_state != LM_ST_UNLOCKED)
1486 handle_callback(gl, LM_ST_UNLOCKED, 0, false);
1487 spin_unlock(&gl->gl_lockref.lock);
1488 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
1489 gfs2_glock_put(gl);
1490 }
1491
1492 /**
1493 * gfs2_glock_thaw - Thaw any frozen glocks
1494 * @sdp: The super block
1495 *
1496 */
1497
1498 void gfs2_glock_thaw(struct gfs2_sbd *sdp)
1499 {
1500 glock_hash_walk(thaw_glock, sdp);
1501 }
1502
1503 static void dump_glock(struct seq_file *seq, struct gfs2_glock *gl)
1504 {
1505 spin_lock(&gl->gl_lockref.lock);
1506 gfs2_dump_glock(seq, gl);
1507 spin_unlock(&gl->gl_lockref.lock);
1508 }
1509
1510 static void dump_glock_func(struct gfs2_glock *gl)
1511 {
1512 dump_glock(NULL, gl);
1513 }
1514
1515 /**
1516 * gfs2_gl_hash_clear - Empty out the glock hash table
1517 * @sdp: the filesystem
1518 * @wait: wait until it's all gone
1519 *
1520 * Called when unmounting the filesystem.
1521 */
1522
1523 void gfs2_gl_hash_clear(struct gfs2_sbd *sdp)
1524 {
1525 set_bit(SDF_SKIP_DLM_UNLOCK, &sdp->sd_flags);
1526 flush_workqueue(glock_workqueue);
1527 glock_hash_walk(clear_glock, sdp);
1528 flush_workqueue(glock_workqueue);
1529 wait_event_timeout(sdp->sd_glock_wait,
1530 atomic_read(&sdp->sd_glock_disposal) == 0,
1531 HZ * 600);
1532 glock_hash_walk(dump_glock_func, sdp);
1533 }
1534
1535 void gfs2_glock_finish_truncate(struct gfs2_inode *ip)
1536 {
1537 struct gfs2_glock *gl = ip->i_gl;
1538 int ret;
1539
1540 ret = gfs2_truncatei_resume(ip);
1541 gfs2_assert_withdraw(gl->gl_name.ln_sbd, ret == 0);
1542
1543 spin_lock(&gl->gl_lockref.lock);
1544 clear_bit(GLF_LOCK, &gl->gl_flags);
1545 run_queue(gl, 1);
1546 spin_unlock(&gl->gl_lockref.lock);
1547 }
1548
1549 static const char *state2str(unsigned state)
1550 {
1551 switch(state) {
1552 case LM_ST_UNLOCKED:
1553 return "UN";
1554 case LM_ST_SHARED:
1555 return "SH";
1556 case LM_ST_DEFERRED:
1557 return "DF";
1558 case LM_ST_EXCLUSIVE:
1559 return "EX";
1560 }
1561 return "??";
1562 }
1563
1564 static const char *hflags2str(char *buf, u16 flags, unsigned long iflags)
1565 {
1566 char *p = buf;
1567 if (flags & LM_FLAG_TRY)
1568 *p++ = 't';
1569 if (flags & LM_FLAG_TRY_1CB)
1570 *p++ = 'T';
1571 if (flags & LM_FLAG_NOEXP)
1572 *p++ = 'e';
1573 if (flags & LM_FLAG_ANY)
1574 *p++ = 'A';
1575 if (flags & LM_FLAG_PRIORITY)
1576 *p++ = 'p';
1577 if (flags & GL_ASYNC)
1578 *p++ = 'a';
1579 if (flags & GL_EXACT)
1580 *p++ = 'E';
1581 if (flags & GL_NOCACHE)
1582 *p++ = 'c';
1583 if (test_bit(HIF_HOLDER, &iflags))
1584 *p++ = 'H';
1585 if (test_bit(HIF_WAIT, &iflags))
1586 *p++ = 'W';
1587 if (test_bit(HIF_FIRST, &iflags))
1588 *p++ = 'F';
1589 *p = 0;
1590 return buf;
1591 }
1592
1593 /**
1594 * dump_holder - print information about a glock holder
1595 * @seq: the seq_file struct
1596 * @gh: the glock holder
1597 *
1598 */
1599
1600 static void dump_holder(struct seq_file *seq, const struct gfs2_holder *gh)
1601 {
1602 struct task_struct *gh_owner = NULL;
1603 char flags_buf[32];
1604
1605 rcu_read_lock();
1606 if (gh->gh_owner_pid)
1607 gh_owner = pid_task(gh->gh_owner_pid, PIDTYPE_PID);
1608 gfs2_print_dbg(seq, " H: s:%s f:%s e:%d p:%ld [%s] %pS\n",
1609 state2str(gh->gh_state),
1610 hflags2str(flags_buf, gh->gh_flags, gh->gh_iflags),
1611 gh->gh_error,
1612 gh->gh_owner_pid ? (long)pid_nr(gh->gh_owner_pid) : -1,
1613 gh_owner ? gh_owner->comm : "(ended)",
1614 (void *)gh->gh_ip);
1615 rcu_read_unlock();
1616 }
1617
1618 static const char *gflags2str(char *buf, const struct gfs2_glock *gl)
1619 {
1620 const unsigned long *gflags = &gl->gl_flags;
1621 char *p = buf;
1622
1623 if (test_bit(GLF_LOCK, gflags))
1624 *p++ = 'l';
1625 if (test_bit(GLF_DEMOTE, gflags))
1626 *p++ = 'D';
1627 if (test_bit(GLF_PENDING_DEMOTE, gflags))
1628 *p++ = 'd';
1629 if (test_bit(GLF_DEMOTE_IN_PROGRESS, gflags))
1630 *p++ = 'p';
1631 if (test_bit(GLF_DIRTY, gflags))
1632 *p++ = 'y';
1633 if (test_bit(GLF_LFLUSH, gflags))
1634 *p++ = 'f';
1635 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, gflags))
1636 *p++ = 'i';
1637 if (test_bit(GLF_REPLY_PENDING, gflags))
1638 *p++ = 'r';
1639 if (test_bit(GLF_INITIAL, gflags))
1640 *p++ = 'I';
1641 if (test_bit(GLF_FROZEN, gflags))
1642 *p++ = 'F';
1643 if (test_bit(GLF_QUEUED, gflags))
1644 *p++ = 'q';
1645 if (test_bit(GLF_LRU, gflags))
1646 *p++ = 'L';
1647 if (gl->gl_object)
1648 *p++ = 'o';
1649 if (test_bit(GLF_BLOCKING, gflags))
1650 *p++ = 'b';
1651 *p = 0;
1652 return buf;
1653 }
1654
1655 /**
1656 * gfs2_dump_glock - print information about a glock
1657 * @seq: The seq_file struct
1658 * @gl: the glock
1659 *
1660 * The file format is as follows:
1661 * One line per object, capital letters are used to indicate objects
1662 * G = glock, I = Inode, R = rgrp, H = holder. Glocks are not indented,
1663 * other objects are indented by a single space and follow the glock to
1664 * which they are related. Fields are indicated by lower case letters
1665 * followed by a colon and the field value, except for strings which are in
1666 * [] so that its possible to see if they are composed of spaces for
1667 * example. The field's are n = number (id of the object), f = flags,
1668 * t = type, s = state, r = refcount, e = error, p = pid.
1669 *
1670 */
1671
1672 void gfs2_dump_glock(struct seq_file *seq, const struct gfs2_glock *gl)
1673 {
1674 const struct gfs2_glock_operations *glops = gl->gl_ops;
1675 unsigned long long dtime;
1676 const struct gfs2_holder *gh;
1677 char gflags_buf[32];
1678
1679 dtime = jiffies - gl->gl_demote_time;
1680 dtime *= 1000000/HZ; /* demote time in uSec */
1681 if (!test_bit(GLF_DEMOTE, &gl->gl_flags))
1682 dtime = 0;
1683 gfs2_print_dbg(seq, "G: s:%s n:%u/%llx f:%s t:%s d:%s/%llu a:%d v:%d r:%d m:%ld\n",
1684 state2str(gl->gl_state),
1685 gl->gl_name.ln_type,
1686 (unsigned long long)gl->gl_name.ln_number,
1687 gflags2str(gflags_buf, gl),
1688 state2str(gl->gl_target),
1689 state2str(gl->gl_demote_state), dtime,
1690 atomic_read(&gl->gl_ail_count),
1691 atomic_read(&gl->gl_revokes),
1692 (int)gl->gl_lockref.count, gl->gl_hold_time);
1693
1694 list_for_each_entry(gh, &gl->gl_holders, gh_list)
1695 dump_holder(seq, gh);
1696
1697 if (gl->gl_state != LM_ST_UNLOCKED && glops->go_dump)
1698 glops->go_dump(seq, gl);
1699 }
1700
1701 static int gfs2_glstats_seq_show(struct seq_file *seq, void *iter_ptr)
1702 {
1703 struct gfs2_glock *gl = iter_ptr;
1704
1705 seq_printf(seq, "G: n:%u/%llx rtt:%llu/%llu rttb:%llu/%llu irt:%llu/%llu dcnt: %llu qcnt: %llu\n",
1706 gl->gl_name.ln_type,
1707 (unsigned long long)gl->gl_name.ln_number,
1708 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTT],
1709 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTVAR],
1710 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTB],
1711 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTVARB],
1712 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SIRT],
1713 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SIRTVAR],
1714 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_DCOUNT],
1715 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_QCOUNT]);
1716 return 0;
1717 }
1718
1719 static const char *gfs2_gltype[] = {
1720 "type",
1721 "reserved",
1722 "nondisk",
1723 "inode",
1724 "rgrp",
1725 "meta",
1726 "iopen",
1727 "flock",
1728 "plock",
1729 "quota",
1730 "journal",
1731 };
1732
1733 static const char *gfs2_stype[] = {
1734 [GFS2_LKS_SRTT] = "srtt",
1735 [GFS2_LKS_SRTTVAR] = "srttvar",
1736 [GFS2_LKS_SRTTB] = "srttb",
1737 [GFS2_LKS_SRTTVARB] = "srttvarb",
1738 [GFS2_LKS_SIRT] = "sirt",
1739 [GFS2_LKS_SIRTVAR] = "sirtvar",
1740 [GFS2_LKS_DCOUNT] = "dlm",
1741 [GFS2_LKS_QCOUNT] = "queue",
1742 };
1743
1744 #define GFS2_NR_SBSTATS (ARRAY_SIZE(gfs2_gltype) * ARRAY_SIZE(gfs2_stype))
1745
1746 static int gfs2_sbstats_seq_show(struct seq_file *seq, void *iter_ptr)
1747 {
1748 struct gfs2_sbd *sdp = seq->private;
1749 loff_t pos = *(loff_t *)iter_ptr;
1750 unsigned index = pos >> 3;
1751 unsigned subindex = pos & 0x07;
1752 int i;
1753
1754 if (index == 0 && subindex != 0)
1755 return 0;
1756
1757 seq_printf(seq, "%-10s %8s:", gfs2_gltype[index],
1758 (index == 0) ? "cpu": gfs2_stype[subindex]);
1759
1760 for_each_possible_cpu(i) {
1761 const struct gfs2_pcpu_lkstats *lkstats = per_cpu_ptr(sdp->sd_lkstats, i);
1762
1763 if (index == 0)
1764 seq_printf(seq, " %15u", i);
1765 else
1766 seq_printf(seq, " %15llu", (unsigned long long)lkstats->
1767 lkstats[index - 1].stats[subindex]);
1768 }
1769 seq_putc(seq, '\n');
1770 return 0;
1771 }
1772
1773 int __init gfs2_glock_init(void)
1774 {
1775 int ret;
1776
1777 ret = rhashtable_init(&gl_hash_table, &ht_parms);
1778 if (ret < 0)
1779 return ret;
1780
1781 glock_workqueue = alloc_workqueue("glock_workqueue", WQ_MEM_RECLAIM |
1782 WQ_HIGHPRI | WQ_FREEZABLE, 0);
1783 if (!glock_workqueue) {
1784 rhashtable_destroy(&gl_hash_table);
1785 return -ENOMEM;
1786 }
1787 gfs2_delete_workqueue = alloc_workqueue("delete_workqueue",
1788 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1789 0);
1790 if (!gfs2_delete_workqueue) {
1791 destroy_workqueue(glock_workqueue);
1792 rhashtable_destroy(&gl_hash_table);
1793 return -ENOMEM;
1794 }
1795
1796 ret = register_shrinker(&glock_shrinker);
1797 if (ret) {
1798 destroy_workqueue(gfs2_delete_workqueue);
1799 destroy_workqueue(glock_workqueue);
1800 rhashtable_destroy(&gl_hash_table);
1801 return ret;
1802 }
1803
1804 return 0;
1805 }
1806
1807 void gfs2_glock_exit(void)
1808 {
1809 unregister_shrinker(&glock_shrinker);
1810 rhashtable_destroy(&gl_hash_table);
1811 destroy_workqueue(glock_workqueue);
1812 destroy_workqueue(gfs2_delete_workqueue);
1813 }
1814
1815 static void gfs2_glock_iter_next(struct gfs2_glock_iter *gi)
1816 {
1817 while ((gi->gl = rhashtable_walk_next(&gi->hti))) {
1818 if (IS_ERR(gi->gl)) {
1819 if (PTR_ERR(gi->gl) == -EAGAIN)
1820 continue;
1821 gi->gl = NULL;
1822 return;
1823 }
1824 /* Skip entries for other sb and dead entries */
1825 if (gi->sdp == gi->gl->gl_name.ln_sbd &&
1826 !__lockref_is_dead(&gi->gl->gl_lockref))
1827 return;
1828 }
1829 }
1830
1831 static void *gfs2_glock_seq_start(struct seq_file *seq, loff_t *pos)
1832 {
1833 struct gfs2_glock_iter *gi = seq->private;
1834 loff_t n = *pos;
1835 int ret;
1836
1837 if (gi->last_pos <= *pos)
1838 n = (*pos - gi->last_pos);
1839
1840 ret = rhashtable_walk_start(&gi->hti);
1841 if (ret)
1842 return NULL;
1843
1844 do {
1845 gfs2_glock_iter_next(gi);
1846 } while (gi->gl && n--);
1847
1848 gi->last_pos = *pos;
1849 return gi->gl;
1850 }
1851
1852 static void *gfs2_glock_seq_next(struct seq_file *seq, void *iter_ptr,
1853 loff_t *pos)
1854 {
1855 struct gfs2_glock_iter *gi = seq->private;
1856
1857 (*pos)++;
1858 gi->last_pos = *pos;
1859 gfs2_glock_iter_next(gi);
1860 return gi->gl;
1861 }
1862
1863 static void gfs2_glock_seq_stop(struct seq_file *seq, void *iter_ptr)
1864 {
1865 struct gfs2_glock_iter *gi = seq->private;
1866
1867 gi->gl = NULL;
1868 rhashtable_walk_stop(&gi->hti);
1869 }
1870
1871 static int gfs2_glock_seq_show(struct seq_file *seq, void *iter_ptr)
1872 {
1873 dump_glock(seq, iter_ptr);
1874 return 0;
1875 }
1876
1877 static void *gfs2_sbstats_seq_start(struct seq_file *seq, loff_t *pos)
1878 {
1879 preempt_disable();
1880 if (*pos >= GFS2_NR_SBSTATS)
1881 return NULL;
1882 return pos;
1883 }
1884
1885 static void *gfs2_sbstats_seq_next(struct seq_file *seq, void *iter_ptr,
1886 loff_t *pos)
1887 {
1888 (*pos)++;
1889 if (*pos >= GFS2_NR_SBSTATS)
1890 return NULL;
1891 return pos;
1892 }
1893
1894 static void gfs2_sbstats_seq_stop(struct seq_file *seq, void *iter_ptr)
1895 {
1896 preempt_enable();
1897 }
1898
1899 static const struct seq_operations gfs2_glock_seq_ops = {
1900 .start = gfs2_glock_seq_start,
1901 .next = gfs2_glock_seq_next,
1902 .stop = gfs2_glock_seq_stop,
1903 .show = gfs2_glock_seq_show,
1904 };
1905
1906 static const struct seq_operations gfs2_glstats_seq_ops = {
1907 .start = gfs2_glock_seq_start,
1908 .next = gfs2_glock_seq_next,
1909 .stop = gfs2_glock_seq_stop,
1910 .show = gfs2_glstats_seq_show,
1911 };
1912
1913 static const struct seq_operations gfs2_sbstats_seq_ops = {
1914 .start = gfs2_sbstats_seq_start,
1915 .next = gfs2_sbstats_seq_next,
1916 .stop = gfs2_sbstats_seq_stop,
1917 .show = gfs2_sbstats_seq_show,
1918 };
1919
1920 #define GFS2_SEQ_GOODSIZE min(PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER, 65536UL)
1921
1922 static int __gfs2_glocks_open(struct inode *inode, struct file *file,
1923 const struct seq_operations *ops)
1924 {
1925 int ret = seq_open_private(file, ops, sizeof(struct gfs2_glock_iter));
1926 if (ret == 0) {
1927 struct seq_file *seq = file->private_data;
1928 struct gfs2_glock_iter *gi = seq->private;
1929
1930 gi->sdp = inode->i_private;
1931 gi->last_pos = 0;
1932 seq->buf = kmalloc(GFS2_SEQ_GOODSIZE, GFP_KERNEL | __GFP_NOWARN);
1933 if (seq->buf)
1934 seq->size = GFS2_SEQ_GOODSIZE;
1935 gi->gl = NULL;
1936 rhashtable_walk_enter(&gl_hash_table, &gi->hti);
1937 }
1938 return ret;
1939 }
1940
1941 static int gfs2_glocks_open(struct inode *inode, struct file *file)
1942 {
1943 return __gfs2_glocks_open(inode, file, &gfs2_glock_seq_ops);
1944 }
1945
1946 static int gfs2_glocks_release(struct inode *inode, struct file *file)
1947 {
1948 struct seq_file *seq = file->private_data;
1949 struct gfs2_glock_iter *gi = seq->private;
1950
1951 gi->gl = NULL;
1952 rhashtable_walk_exit(&gi->hti);
1953 return seq_release_private(inode, file);
1954 }
1955
1956 static int gfs2_glstats_open(struct inode *inode, struct file *file)
1957 {
1958 return __gfs2_glocks_open(inode, file, &gfs2_glstats_seq_ops);
1959 }
1960
1961 static int gfs2_sbstats_open(struct inode *inode, struct file *file)
1962 {
1963 int ret = seq_open(file, &gfs2_sbstats_seq_ops);
1964 if (ret == 0) {
1965 struct seq_file *seq = file->private_data;
1966 seq->private = inode->i_private; /* sdp */
1967 }
1968 return ret;
1969 }
1970
1971 static const struct file_operations gfs2_glocks_fops = {
1972 .owner = THIS_MODULE,
1973 .open = gfs2_glocks_open,
1974 .read = seq_read,
1975 .llseek = seq_lseek,
1976 .release = gfs2_glocks_release,
1977 };
1978
1979 static const struct file_operations gfs2_glstats_fops = {
1980 .owner = THIS_MODULE,
1981 .open = gfs2_glstats_open,
1982 .read = seq_read,
1983 .llseek = seq_lseek,
1984 .release = gfs2_glocks_release,
1985 };
1986
1987 static const struct file_operations gfs2_sbstats_fops = {
1988 .owner = THIS_MODULE,
1989 .open = gfs2_sbstats_open,
1990 .read = seq_read,
1991 .llseek = seq_lseek,
1992 .release = seq_release,
1993 };
1994
1995 int gfs2_create_debugfs_file(struct gfs2_sbd *sdp)
1996 {
1997 struct dentry *dent;
1998
1999 dent = debugfs_create_dir(sdp->sd_table_name, gfs2_root);
2000 if (IS_ERR_OR_NULL(dent))
2001 goto fail;
2002 sdp->debugfs_dir = dent;
2003
2004 dent = debugfs_create_file("glocks",
2005 S_IFREG | S_IRUGO,
2006 sdp->debugfs_dir, sdp,
2007 &gfs2_glocks_fops);
2008 if (IS_ERR_OR_NULL(dent))
2009 goto fail;
2010 sdp->debugfs_dentry_glocks = dent;
2011
2012 dent = debugfs_create_file("glstats",
2013 S_IFREG | S_IRUGO,
2014 sdp->debugfs_dir, sdp,
2015 &gfs2_glstats_fops);
2016 if (IS_ERR_OR_NULL(dent))
2017 goto fail;
2018 sdp->debugfs_dentry_glstats = dent;
2019
2020 dent = debugfs_create_file("sbstats",
2021 S_IFREG | S_IRUGO,
2022 sdp->debugfs_dir, sdp,
2023 &gfs2_sbstats_fops);
2024 if (IS_ERR_OR_NULL(dent))
2025 goto fail;
2026 sdp->debugfs_dentry_sbstats = dent;
2027
2028 return 0;
2029 fail:
2030 gfs2_delete_debugfs_file(sdp);
2031 return dent ? PTR_ERR(dent) : -ENOMEM;
2032 }
2033
2034 void gfs2_delete_debugfs_file(struct gfs2_sbd *sdp)
2035 {
2036 if (sdp->debugfs_dir) {
2037 if (sdp->debugfs_dentry_glocks) {
2038 debugfs_remove(sdp->debugfs_dentry_glocks);
2039 sdp->debugfs_dentry_glocks = NULL;
2040 }
2041 if (sdp->debugfs_dentry_glstats) {
2042 debugfs_remove(sdp->debugfs_dentry_glstats);
2043 sdp->debugfs_dentry_glstats = NULL;
2044 }
2045 if (sdp->debugfs_dentry_sbstats) {
2046 debugfs_remove(sdp->debugfs_dentry_sbstats);
2047 sdp->debugfs_dentry_sbstats = NULL;
2048 }
2049 debugfs_remove(sdp->debugfs_dir);
2050 sdp->debugfs_dir = NULL;
2051 }
2052 }
2053
2054 int gfs2_register_debugfs(void)
2055 {
2056 gfs2_root = debugfs_create_dir("gfs2", NULL);
2057 if (IS_ERR(gfs2_root))
2058 return PTR_ERR(gfs2_root);
2059 return gfs2_root ? 0 : -ENOMEM;
2060 }
2061
2062 void gfs2_unregister_debugfs(void)
2063 {
2064 debugfs_remove(gfs2_root);
2065 gfs2_root = NULL;
2066 }
(deprecated) Btrfs devel tree