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