blob: 454d4b4eb36ba7f5b12111cd86730eef90ddc65c [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Bob Petersoncf45b752008-01-31 10:31:39 -06003 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
10#include <linux/sched.h>
11#include <linux/slab.h>
12#include <linux/spinlock.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000013#include <linux/buffer_head.h>
14#include <linux/delay.h>
15#include <linux/sort.h>
16#include <linux/jhash.h>
Steven Whitehoused0dc80d2006-03-29 14:36:49 -050017#include <linux/kallsyms.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050018#include <linux/gfs2_ondisk.h>
Steven Whitehouse24264432006-09-11 21:40:30 -040019#include <linux/list.h>
Steven Whitehousefee852e2007-01-17 15:33:23 +000020#include <linux/wait.h>
akpm@linux-foundation.org95d97b72007-03-05 23:10:39 -080021#include <linux/module.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000022#include <asm/uaccess.h>
Robert Peterson7c52b162007-03-16 10:26:37 +000023#include <linux/seq_file.h>
24#include <linux/debugfs.h>
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +010025#include <linux/kthread.h>
26#include <linux/freezer.h>
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -050027#include <linux/workqueue.h>
28#include <linux/jiffies.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000029
30#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050031#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000032#include "glock.h"
33#include "glops.h"
34#include "inode.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000035#include "lops.h"
36#include "meta_io.h"
37#include "quota.h"
38#include "super.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050039#include "util.h"
Steven Whitehouse813e0c42008-11-18 13:38:48 +000040#include "bmap.h"
Steven Whitehouse63997772009-06-12 08:49:20 +010041#define CREATE_TRACE_POINTS
42#include "trace_gfs2.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000043
Steven Whitehouse37b2fa62006-09-08 13:35:56 -040044struct gfs2_gl_hash_bucket {
Steven Whitehouseb6397892006-09-12 10:10:01 -040045 struct hlist_head hb_list;
Steven Whitehouse37b2fa62006-09-08 13:35:56 -040046};
47
Steven Whitehouse6802e342008-05-21 17:03:22 +010048struct gfs2_glock_iter {
49 int hash; /* hash bucket index */
50 struct gfs2_sbd *sdp; /* incore superblock */
51 struct gfs2_glock *gl; /* current glock struct */
52 char string[512]; /* scratch space */
Robert Peterson7c52b162007-03-16 10:26:37 +000053};
54
David Teiglandb3b94fa2006-01-16 16:50:04 +000055typedef void (*glock_examiner) (struct gfs2_glock * gl);
56
Adrian Bunk08bc2db2006-04-28 10:59:12 -040057static int gfs2_dump_lockstate(struct gfs2_sbd *sdp);
Steven Whitehouse6802e342008-05-21 17:03:22 +010058static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl);
59#define GLOCK_BUG_ON(gl,x) do { if (unlikely(x)) { __dump_glock(NULL, gl); BUG(); } } while(0)
60static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -050061
Robert Peterson7c52b162007-03-16 10:26:37 +000062static struct dentry *gfs2_root;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -050063static struct workqueue_struct *glock_workqueue;
Benjamin Marzinskib94a1702009-07-23 18:52:34 -050064struct workqueue_struct *gfs2_delete_workqueue;
Steven Whitehouse97cc1022008-11-20 13:39:47 +000065static LIST_HEAD(lru_list);
66static atomic_t lru_count = ATOMIC_INIT(0);
Julia Lawalleb8374e2008-12-25 15:35:27 +010067static DEFINE_SPINLOCK(lru_lock);
Adrian Bunk08bc2db2006-04-28 10:59:12 -040068
Steven Whitehouseb6397892006-09-12 10:10:01 -040069#define GFS2_GL_HASH_SHIFT 15
Steven Whitehouse087efdd2006-09-09 16:59:11 -040070#define GFS2_GL_HASH_SIZE (1 << GFS2_GL_HASH_SHIFT)
71#define GFS2_GL_HASH_MASK (GFS2_GL_HASH_SIZE - 1)
72
Steven Whitehouse85d1da62006-09-07 14:40:21 -040073static struct gfs2_gl_hash_bucket gl_hash_table[GFS2_GL_HASH_SIZE];
Robert Peterson04b933f2007-03-23 17:05:15 -050074static struct dentry *gfs2_root;
Steven Whitehouse087efdd2006-09-09 16:59:11 -040075
76/*
77 * Despite what you might think, the numbers below are not arbitrary :-)
78 * They are taken from the ipv4 routing hash code, which is well tested
79 * and thus should be nearly optimal. Later on we might tweek the numbers
80 * but for now this should be fine.
81 *
82 * The reason for putting the locks in a separate array from the list heads
83 * is that we can have fewer locks than list heads and save memory. We use
84 * the same hash function for both, but with a different hash mask.
85 */
86#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) || \
87 defined(CONFIG_PROVE_LOCKING)
88
89#ifdef CONFIG_LOCKDEP
90# define GL_HASH_LOCK_SZ 256
91#else
92# if NR_CPUS >= 32
93# define GL_HASH_LOCK_SZ 4096
94# elif NR_CPUS >= 16
95# define GL_HASH_LOCK_SZ 2048
96# elif NR_CPUS >= 8
97# define GL_HASH_LOCK_SZ 1024
98# elif NR_CPUS >= 4
99# define GL_HASH_LOCK_SZ 512
100# else
101# define GL_HASH_LOCK_SZ 256
102# endif
103#endif
104
105/* We never want more locks than chains */
106#if GFS2_GL_HASH_SIZE < GL_HASH_LOCK_SZ
107# undef GL_HASH_LOCK_SZ
108# define GL_HASH_LOCK_SZ GFS2_GL_HASH_SIZE
109#endif
110
111static rwlock_t gl_hash_locks[GL_HASH_LOCK_SZ];
112
113static inline rwlock_t *gl_lock_addr(unsigned int x)
114{
Steven Whitehouse94610612006-09-09 18:59:27 -0400115 return &gl_hash_locks[x & (GL_HASH_LOCK_SZ-1)];
Steven Whitehouse087efdd2006-09-09 16:59:11 -0400116}
117#else /* not SMP, so no spinlocks required */
Randy Dunlap0ac23062006-11-28 22:29:19 -0800118static inline rwlock_t *gl_lock_addr(unsigned int x)
Steven Whitehouse087efdd2006-09-09 16:59:11 -0400119{
120 return NULL;
121}
122#endif
Steven Whitehouse85d1da62006-09-07 14:40:21 -0400123
David Teiglandb3b94fa2006-01-16 16:50:04 +0000124/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000125 * gl_hash() - Turn glock number into hash bucket number
126 * @lock: The glock number
127 *
128 * Returns: The number of the corresponding hash bucket
129 */
130
Steven Whitehouseb8547852006-09-07 13:12:27 -0400131static unsigned int gl_hash(const struct gfs2_sbd *sdp,
132 const struct lm_lockname *name)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000133{
134 unsigned int h;
135
Steven Whitehousecd915492006-09-04 12:49:07 -0400136 h = jhash(&name->ln_number, sizeof(u64), 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000137 h = jhash(&name->ln_type, sizeof(unsigned int), h);
Steven Whitehouseb8547852006-09-07 13:12:27 -0400138 h = jhash(&sdp, sizeof(struct gfs2_sbd *), h);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000139 h &= GFS2_GL_HASH_MASK;
140
141 return h;
142}
143
144/**
145 * glock_free() - Perform a few checks and then release struct gfs2_glock
146 * @gl: The glock to release
147 *
148 * Also calls lock module to release its internal structure for this glock.
149 *
150 */
151
152static void glock_free(struct gfs2_glock *gl)
153{
154 struct gfs2_sbd *sdp = gl->gl_sbd;
Steven Whitehouse009d8512009-12-08 12:12:13 +0000155 struct address_space *mapping = gfs2_glock2aspace(gl);
156 struct kmem_cache *cachep = gfs2_glock_cachep;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000157
Steven Whitehouse009d8512009-12-08 12:12:13 +0000158 GLOCK_BUG_ON(gl, mapping && mapping->nrpages);
Steven Whitehouse63997772009-06-12 08:49:20 +0100159 trace_gfs2_glock_put(gl);
Steven Whitehouse009d8512009-12-08 12:12:13 +0000160 if (mapping)
161 cachep = gfs2_glock_aspace_cachep;
162 sdp->sd_lockstruct.ls_ops->lm_put_lock(cachep, gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000163}
164
165/**
166 * gfs2_glock_hold() - increment reference count on glock
167 * @gl: The glock to hold
168 *
169 */
170
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500171void gfs2_glock_hold(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000172{
Steven Whitehoused8348de2009-02-05 10:12:38 +0000173 GLOCK_BUG_ON(gl, atomic_read(&gl->gl_ref) == 0);
Steven Whitehouse16feb9f2006-09-13 10:43:37 -0400174 atomic_inc(&gl->gl_ref);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000175}
176
177/**
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500178 * demote_ok - Check to see if it's ok to unlock a glock
179 * @gl: the glock
180 *
181 * Returns: 1 if it's ok
182 */
183
184static int demote_ok(const struct gfs2_glock *gl)
185{
186 const struct gfs2_glock_operations *glops = gl->gl_ops;
187
188 if (gl->gl_state == LM_ST_UNLOCKED)
189 return 0;
190 if (!list_empty(&gl->gl_holders))
191 return 0;
192 if (glops->go_demote_ok)
193 return glops->go_demote_ok(gl);
194 return 1;
195}
196
197/**
Steven Whitehouse97cc1022008-11-20 13:39:47 +0000198 * gfs2_glock_schedule_for_reclaim - Add a glock to the reclaim list
199 * @gl: the glock
200 *
201 */
202
203static void gfs2_glock_schedule_for_reclaim(struct gfs2_glock *gl)
204{
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500205 int may_reclaim;
206 may_reclaim = (demote_ok(gl) &&
207 (atomic_read(&gl->gl_ref) == 1 ||
208 (gl->gl_name.ln_type == LM_TYPE_INODE &&
209 atomic_read(&gl->gl_ref) <= 2)));
Steven Whitehouse97cc1022008-11-20 13:39:47 +0000210 spin_lock(&lru_lock);
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500211 if (list_empty(&gl->gl_lru) && may_reclaim) {
Steven Whitehouse97cc1022008-11-20 13:39:47 +0000212 list_add_tail(&gl->gl_lru, &lru_list);
213 atomic_inc(&lru_count);
214 }
215 spin_unlock(&lru_lock);
216}
217
218/**
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500219 * gfs2_glock_put_nolock() - Decrement reference count on glock
220 * @gl: The glock to put
221 *
222 * This function should only be used if the caller has its own reference
223 * to the glock, in addition to the one it is dropping.
224 */
225
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500226void gfs2_glock_put_nolock(struct gfs2_glock *gl)
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500227{
228 if (atomic_dec_and_test(&gl->gl_ref))
229 GLOCK_BUG_ON(gl, 1);
230 gfs2_glock_schedule_for_reclaim(gl);
231}
232
233/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000234 * gfs2_glock_put() - Decrement reference count on glock
235 * @gl: The glock to put
236 *
237 */
238
239int gfs2_glock_put(struct gfs2_glock *gl)
240{
David Teiglandb3b94fa2006-01-16 16:50:04 +0000241 int rv = 0;
242
Steven Whitehouse087efdd2006-09-09 16:59:11 -0400243 write_lock(gl_lock_addr(gl->gl_hash));
Steven Whitehouse26bb7502009-11-27 10:31:11 +0000244 if (atomic_dec_and_lock(&gl->gl_ref, &lru_lock)) {
Steven Whitehouseb6397892006-09-12 10:10:01 -0400245 hlist_del(&gl->gl_list);
Steven Whitehouse97cc1022008-11-20 13:39:47 +0000246 if (!list_empty(&gl->gl_lru)) {
247 list_del_init(&gl->gl_lru);
248 atomic_dec(&lru_count);
249 }
250 spin_unlock(&lru_lock);
Steven Whitehouse26bb7502009-11-27 10:31:11 +0000251 write_unlock(gl_lock_addr(gl->gl_hash));
Steven Whitehouse6802e342008-05-21 17:03:22 +0100252 GLOCK_BUG_ON(gl, !list_empty(&gl->gl_holders));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000253 glock_free(gl);
254 rv = 1;
255 goto out;
256 }
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500257 spin_lock(&gl->gl_spin);
258 gfs2_glock_schedule_for_reclaim(gl);
259 spin_unlock(&gl->gl_spin);
Steven Whitehoused8348de2009-02-05 10:12:38 +0000260 write_unlock(gl_lock_addr(gl->gl_hash));
Steven Whitehousea2242db2006-08-24 17:03:05 -0400261out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000262 return rv;
263}
264
265/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000266 * search_bucket() - Find struct gfs2_glock by lock number
267 * @bucket: the bucket to search
268 * @name: The lock name
269 *
270 * Returns: NULL, or the struct gfs2_glock with the requested number
271 */
272
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400273static struct gfs2_glock *search_bucket(unsigned int hash,
Steven Whitehouse899be4d2006-08-30 12:50:28 -0400274 const struct gfs2_sbd *sdp,
Steven Whitehoused6a53722006-08-30 11:16:23 -0400275 const struct lm_lockname *name)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000276{
277 struct gfs2_glock *gl;
Steven Whitehouseb6397892006-09-12 10:10:01 -0400278 struct hlist_node *h;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000279
Steven Whitehouseb6397892006-09-12 10:10:01 -0400280 hlist_for_each_entry(gl, h, &gl_hash_table[hash].hb_list, gl_list) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000281 if (!lm_name_equal(&gl->gl_name, name))
282 continue;
Steven Whitehouse899be4d2006-08-30 12:50:28 -0400283 if (gl->gl_sbd != sdp)
284 continue;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000285
Steven Whitehouse16feb9f2006-09-13 10:43:37 -0400286 atomic_inc(&gl->gl_ref);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000287
288 return gl;
289 }
290
291 return NULL;
292}
293
294/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100295 * may_grant - check if its ok to grant a new lock
296 * @gl: The glock
297 * @gh: The lock request which we wish to grant
298 *
299 * Returns: true if its ok to grant the lock
300 */
301
302static inline int may_grant(const struct gfs2_glock *gl, const struct gfs2_holder *gh)
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500303{
Steven Whitehouse6802e342008-05-21 17:03:22 +0100304 const struct gfs2_holder *gh_head = list_entry(gl->gl_holders.next, const struct gfs2_holder, gh_list);
305 if ((gh->gh_state == LM_ST_EXCLUSIVE ||
306 gh_head->gh_state == LM_ST_EXCLUSIVE) && gh != gh_head)
307 return 0;
308 if (gl->gl_state == gh->gh_state)
309 return 1;
310 if (gh->gh_flags & GL_EXACT)
311 return 0;
Steven Whitehouse209806a2008-07-07 10:07:28 +0100312 if (gl->gl_state == LM_ST_EXCLUSIVE) {
313 if (gh->gh_state == LM_ST_SHARED && gh_head->gh_state == LM_ST_SHARED)
314 return 1;
315 if (gh->gh_state == LM_ST_DEFERRED && gh_head->gh_state == LM_ST_DEFERRED)
316 return 1;
317 }
Steven Whitehouse6802e342008-05-21 17:03:22 +0100318 if (gl->gl_state != LM_ST_UNLOCKED && (gh->gh_flags & LM_FLAG_ANY))
319 return 1;
320 return 0;
321}
322
323static void gfs2_holder_wake(struct gfs2_holder *gh)
324{
325 clear_bit(HIF_WAIT, &gh->gh_iflags);
326 smp_mb__after_clear_bit();
327 wake_up_bit(&gh->gh_iflags, HIF_WAIT);
328}
329
330/**
331 * do_promote - promote as many requests as possible on the current queue
332 * @gl: The glock
333 *
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000334 * Returns: 1 if there is a blocked holder at the head of the list, or 2
335 * if a type specific operation is underway.
Steven Whitehouse6802e342008-05-21 17:03:22 +0100336 */
337
338static int do_promote(struct gfs2_glock *gl)
Harvey Harrison55ba4742008-10-24 11:31:12 -0700339__releases(&gl->gl_spin)
340__acquires(&gl->gl_spin)
Steven Whitehouse6802e342008-05-21 17:03:22 +0100341{
342 const struct gfs2_glock_operations *glops = gl->gl_ops;
343 struct gfs2_holder *gh, *tmp;
344 int ret;
345
346restart:
347 list_for_each_entry_safe(gh, tmp, &gl->gl_holders, gh_list) {
348 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
349 continue;
350 if (may_grant(gl, gh)) {
351 if (gh->gh_list.prev == &gl->gl_holders &&
352 glops->go_lock) {
353 spin_unlock(&gl->gl_spin);
354 /* FIXME: eliminate this eventually */
355 ret = glops->go_lock(gh);
356 spin_lock(&gl->gl_spin);
357 if (ret) {
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000358 if (ret == 1)
359 return 2;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100360 gh->gh_error = ret;
361 list_del_init(&gh->gh_list);
Steven Whitehouse63997772009-06-12 08:49:20 +0100362 trace_gfs2_glock_queue(gh, 0);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100363 gfs2_holder_wake(gh);
364 goto restart;
365 }
366 set_bit(HIF_HOLDER, &gh->gh_iflags);
Steven Whitehouse63997772009-06-12 08:49:20 +0100367 trace_gfs2_promote(gh, 1);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100368 gfs2_holder_wake(gh);
369 goto restart;
370 }
371 set_bit(HIF_HOLDER, &gh->gh_iflags);
Steven Whitehouse63997772009-06-12 08:49:20 +0100372 trace_gfs2_promote(gh, 0);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100373 gfs2_holder_wake(gh);
374 continue;
375 }
376 if (gh->gh_list.prev == &gl->gl_holders)
377 return 1;
378 break;
379 }
380 return 0;
381}
382
383/**
384 * do_error - Something unexpected has happened during a lock request
385 *
386 */
387
388static inline void do_error(struct gfs2_glock *gl, const int ret)
389{
390 struct gfs2_holder *gh, *tmp;
391
392 list_for_each_entry_safe(gh, tmp, &gl->gl_holders, gh_list) {
393 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
394 continue;
395 if (ret & LM_OUT_ERROR)
396 gh->gh_error = -EIO;
397 else if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))
398 gh->gh_error = GLR_TRYFAILED;
399 else
400 continue;
401 list_del_init(&gh->gh_list);
Steven Whitehouse63997772009-06-12 08:49:20 +0100402 trace_gfs2_glock_queue(gh, 0);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100403 gfs2_holder_wake(gh);
404 }
405}
406
407/**
408 * find_first_waiter - find the first gh that's waiting for the glock
409 * @gl: the glock
410 */
411
412static inline struct gfs2_holder *find_first_waiter(const struct gfs2_glock *gl)
413{
414 struct gfs2_holder *gh;
415
416 list_for_each_entry(gh, &gl->gl_holders, gh_list) {
417 if (!test_bit(HIF_HOLDER, &gh->gh_iflags))
418 return gh;
419 }
420 return NULL;
421}
422
423/**
424 * state_change - record that the glock is now in a different state
425 * @gl: the glock
426 * @new_state the new state
427 *
428 */
429
430static void state_change(struct gfs2_glock *gl, unsigned int new_state)
431{
432 int held1, held2;
433
434 held1 = (gl->gl_state != LM_ST_UNLOCKED);
435 held2 = (new_state != LM_ST_UNLOCKED);
436
437 if (held1 != held2) {
438 if (held2)
439 gfs2_glock_hold(gl);
440 else
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500441 gfs2_glock_put_nolock(gl);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100442 }
443
444 gl->gl_state = new_state;
445 gl->gl_tchange = jiffies;
446}
447
448static void gfs2_demote_wake(struct gfs2_glock *gl)
449{
450 gl->gl_demote_state = LM_ST_EXCLUSIVE;
451 clear_bit(GLF_DEMOTE, &gl->gl_flags);
452 smp_mb__after_clear_bit();
453 wake_up_bit(&gl->gl_flags, GLF_DEMOTE);
454}
455
456/**
457 * finish_xmote - The DLM has replied to one of our lock requests
458 * @gl: The glock
459 * @ret: The status from the DLM
460 *
461 */
462
463static void finish_xmote(struct gfs2_glock *gl, unsigned int ret)
464{
465 const struct gfs2_glock_operations *glops = gl->gl_ops;
466 struct gfs2_holder *gh;
467 unsigned state = ret & LM_OUT_ST_MASK;
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000468 int rv;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500469
470 spin_lock(&gl->gl_spin);
Steven Whitehouse63997772009-06-12 08:49:20 +0100471 trace_gfs2_glock_state_change(gl, state);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100472 state_change(gl, state);
473 gh = find_first_waiter(gl);
474
475 /* Demote to UN request arrived during demote to SH or DF */
476 if (test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags) &&
477 state != LM_ST_UNLOCKED && gl->gl_demote_state == LM_ST_UNLOCKED)
478 gl->gl_target = LM_ST_UNLOCKED;
479
480 /* Check for state != intended state */
481 if (unlikely(state != gl->gl_target)) {
482 if (gh && !test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags)) {
483 /* move to back of queue and try next entry */
484 if (ret & LM_OUT_CANCELED) {
485 if ((gh->gh_flags & LM_FLAG_PRIORITY) == 0)
486 list_move_tail(&gh->gh_list, &gl->gl_holders);
487 gh = find_first_waiter(gl);
488 gl->gl_target = gh->gh_state;
489 goto retry;
490 }
491 /* Some error or failed "try lock" - report it */
492 if ((ret & LM_OUT_ERROR) ||
493 (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) {
494 gl->gl_target = gl->gl_state;
495 do_error(gl, ret);
496 goto out;
497 }
498 }
499 switch(state) {
500 /* Unlocked due to conversion deadlock, try again */
501 case LM_ST_UNLOCKED:
502retry:
503 do_xmote(gl, gh, gl->gl_target);
504 break;
505 /* Conversion fails, unlock and try again */
506 case LM_ST_SHARED:
507 case LM_ST_DEFERRED:
508 do_xmote(gl, gh, LM_ST_UNLOCKED);
509 break;
510 default: /* Everything else */
511 printk(KERN_ERR "GFS2: wanted %u got %u\n", gl->gl_target, state);
512 GLOCK_BUG_ON(gl, 1);
513 }
514 spin_unlock(&gl->gl_spin);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100515 return;
516 }
517
518 /* Fast path - we got what we asked for */
519 if (test_and_clear_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags))
520 gfs2_demote_wake(gl);
521 if (state != LM_ST_UNLOCKED) {
522 if (glops->go_xmote_bh) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100523 spin_unlock(&gl->gl_spin);
524 rv = glops->go_xmote_bh(gl, gh);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100525 spin_lock(&gl->gl_spin);
526 if (rv) {
527 do_error(gl, rv);
528 goto out;
529 }
530 }
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000531 rv = do_promote(gl);
532 if (rv == 2)
533 goto out_locked;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100534 }
535out:
536 clear_bit(GLF_LOCK, &gl->gl_flags);
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000537out_locked:
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500538 spin_unlock(&gl->gl_spin);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500539}
540
Steven Whitehouse6802e342008-05-21 17:03:22 +0100541static unsigned int gfs2_lm_lock(struct gfs2_sbd *sdp, void *lock,
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000542 unsigned int req_state,
Steven Whitehouse6802e342008-05-21 17:03:22 +0100543 unsigned int flags)
544{
545 int ret = LM_OUT_ERROR;
Steven Whitehouse048bca22008-05-23 14:46:04 +0100546
547 if (!sdp->sd_lockstruct.ls_ops->lm_lock)
548 return req_state == LM_ST_UNLOCKED ? 0 : req_state;
549
Steven Whitehouse6802e342008-05-21 17:03:22 +0100550 if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000551 ret = sdp->sd_lockstruct.ls_ops->lm_lock(lock,
Steven Whitehouse6802e342008-05-21 17:03:22 +0100552 req_state, flags);
553 return ret;
554}
555
556/**
557 * do_xmote - Calls the DLM to change the state of a lock
558 * @gl: The lock state
559 * @gh: The holder (only for promotes)
560 * @target: The target lock state
561 *
562 */
563
564static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target)
Harvey Harrison55ba4742008-10-24 11:31:12 -0700565__releases(&gl->gl_spin)
566__acquires(&gl->gl_spin)
Steven Whitehouse6802e342008-05-21 17:03:22 +0100567{
568 const struct gfs2_glock_operations *glops = gl->gl_ops;
569 struct gfs2_sbd *sdp = gl->gl_sbd;
570 unsigned int lck_flags = gh ? gh->gh_flags : 0;
571 int ret;
572
573 lck_flags &= (LM_FLAG_TRY | LM_FLAG_TRY_1CB | LM_FLAG_NOEXP |
574 LM_FLAG_PRIORITY);
575 BUG_ON(gl->gl_state == target);
576 BUG_ON(gl->gl_state == gl->gl_target);
577 if ((target == LM_ST_UNLOCKED || target == LM_ST_DEFERRED) &&
578 glops->go_inval) {
579 set_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);
580 do_error(gl, 0); /* Fail queued try locks */
581 }
582 spin_unlock(&gl->gl_spin);
583 if (glops->go_xmote_th)
584 glops->go_xmote_th(gl);
585 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags))
586 glops->go_inval(gl, target == LM_ST_DEFERRED ? 0 : DIO_METADATA);
587 clear_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);
588
589 gfs2_glock_hold(gl);
590 if (target != LM_ST_UNLOCKED && (gl->gl_state == LM_ST_SHARED ||
591 gl->gl_state == LM_ST_DEFERRED) &&
592 !(lck_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)))
593 lck_flags |= LM_FLAG_TRY_1CB;
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000594 ret = gfs2_lm_lock(sdp, gl, target, lck_flags);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100595
596 if (!(ret & LM_OUT_ASYNC)) {
597 finish_xmote(gl, ret);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100598 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
599 gfs2_glock_put(gl);
600 } else {
601 GLOCK_BUG_ON(gl, ret != LM_OUT_ASYNC);
602 }
603 spin_lock(&gl->gl_spin);
604}
605
606/**
607 * find_first_holder - find the first "holder" gh
608 * @gl: the glock
609 */
610
611static inline struct gfs2_holder *find_first_holder(const struct gfs2_glock *gl)
612{
613 struct gfs2_holder *gh;
614
615 if (!list_empty(&gl->gl_holders)) {
616 gh = list_entry(gl->gl_holders.next, struct gfs2_holder, gh_list);
617 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
618 return gh;
619 }
620 return NULL;
621}
622
623/**
624 * run_queue - do all outstanding tasks related to a glock
625 * @gl: The glock in question
626 * @nonblock: True if we must not block in run_queue
627 *
628 */
629
630static void run_queue(struct gfs2_glock *gl, const int nonblock)
Harvey Harrison55ba4742008-10-24 11:31:12 -0700631__releases(&gl->gl_spin)
632__acquires(&gl->gl_spin)
Steven Whitehouse6802e342008-05-21 17:03:22 +0100633{
634 struct gfs2_holder *gh = NULL;
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000635 int ret;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100636
637 if (test_and_set_bit(GLF_LOCK, &gl->gl_flags))
638 return;
639
640 GLOCK_BUG_ON(gl, test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags));
641
642 if (test_bit(GLF_DEMOTE, &gl->gl_flags) &&
643 gl->gl_demote_state != gl->gl_state) {
644 if (find_first_holder(gl))
Steven Whitehoused8348de2009-02-05 10:12:38 +0000645 goto out_unlock;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100646 if (nonblock)
647 goto out_sched;
648 set_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags);
Steven Whitehouse265d529c2008-07-07 10:02:36 +0100649 GLOCK_BUG_ON(gl, gl->gl_demote_state == LM_ST_EXCLUSIVE);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100650 gl->gl_target = gl->gl_demote_state;
651 } else {
652 if (test_bit(GLF_DEMOTE, &gl->gl_flags))
653 gfs2_demote_wake(gl);
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000654 ret = do_promote(gl);
655 if (ret == 0)
Steven Whitehoused8348de2009-02-05 10:12:38 +0000656 goto out_unlock;
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000657 if (ret == 2)
Steven Whitehousea228df62009-04-07 14:01:34 +0100658 goto out;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100659 gh = find_first_waiter(gl);
660 gl->gl_target = gh->gh_state;
661 if (!(gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)))
662 do_error(gl, 0); /* Fail queued try locks */
663 }
664 do_xmote(gl, gh, gl->gl_target);
Steven Whitehousea228df62009-04-07 14:01:34 +0100665out:
Steven Whitehouse6802e342008-05-21 17:03:22 +0100666 return;
667
668out_sched:
Steven Whitehouse7e71c552009-09-22 10:56:16 +0100669 clear_bit(GLF_LOCK, &gl->gl_flags);
670 smp_mb__after_clear_bit();
Steven Whitehouse6802e342008-05-21 17:03:22 +0100671 gfs2_glock_hold(gl);
672 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500673 gfs2_glock_put_nolock(gl);
Steven Whitehouse7e71c552009-09-22 10:56:16 +0100674 return;
675
Steven Whitehoused8348de2009-02-05 10:12:38 +0000676out_unlock:
Steven Whitehouse6802e342008-05-21 17:03:22 +0100677 clear_bit(GLF_LOCK, &gl->gl_flags);
Steven Whitehouse7e71c552009-09-22 10:56:16 +0100678 smp_mb__after_clear_bit();
679 return;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100680}
681
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500682static void delete_work_func(struct work_struct *work)
683{
684 struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_delete);
685 struct gfs2_sbd *sdp = gl->gl_sbd;
686 struct gfs2_inode *ip = NULL;
687 struct inode *inode;
688 u64 no_addr = 0;
689
690 spin_lock(&gl->gl_spin);
691 ip = (struct gfs2_inode *)gl->gl_object;
692 if (ip)
693 no_addr = ip->i_no_addr;
694 spin_unlock(&gl->gl_spin);
695 if (ip) {
696 inode = gfs2_ilookup(sdp->sd_vfs, no_addr);
697 if (inode) {
698 d_prune_aliases(inode);
699 iput(inode);
700 }
701 }
702 gfs2_glock_put(gl);
703}
704
Steven Whitehouse6802e342008-05-21 17:03:22 +0100705static void glock_work_func(struct work_struct *work)
706{
707 unsigned long delay = 0;
708 struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_work.work);
Steven Whitehouse26bb7502009-11-27 10:31:11 +0000709 int drop_ref = 0;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100710
Steven Whitehouse26bb7502009-11-27 10:31:11 +0000711 if (test_and_clear_bit(GLF_REPLY_PENDING, &gl->gl_flags)) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100712 finish_xmote(gl, gl->gl_reply);
Steven Whitehouse26bb7502009-11-27 10:31:11 +0000713 drop_ref = 1;
714 }
Steven Whitehouse6802e342008-05-21 17:03:22 +0100715 spin_lock(&gl->gl_spin);
Steven Whitehouse265d529c2008-07-07 10:02:36 +0100716 if (test_and_clear_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
717 gl->gl_state != LM_ST_UNLOCKED &&
718 gl->gl_demote_state != LM_ST_EXCLUSIVE) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100719 unsigned long holdtime, now = jiffies;
720 holdtime = gl->gl_tchange + gl->gl_ops->go_min_hold_time;
721 if (time_before(now, holdtime))
722 delay = holdtime - now;
723 set_bit(delay ? GLF_PENDING_DEMOTE : GLF_DEMOTE, &gl->gl_flags);
724 }
725 run_queue(gl, 0);
726 spin_unlock(&gl->gl_spin);
727 if (!delay ||
728 queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
729 gfs2_glock_put(gl);
Steven Whitehouse26bb7502009-11-27 10:31:11 +0000730 if (drop_ref)
731 gfs2_glock_put(gl);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100732}
733
David Teiglandb3b94fa2006-01-16 16:50:04 +0000734/**
735 * gfs2_glock_get() - Get a glock, or create one if one doesn't exist
736 * @sdp: The GFS2 superblock
737 * @number: the lock number
738 * @glops: The glock_operations to use
739 * @create: If 0, don't create the glock if it doesn't exist
740 * @glp: the glock is returned here
741 *
742 * This does not lock a glock, just finds/creates structures for one.
743 *
744 * Returns: errno
745 */
746
Steven Whitehousecd915492006-09-04 12:49:07 -0400747int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400748 const struct gfs2_glock_operations *glops, int create,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000749 struct gfs2_glock **glp)
750{
Steven Whitehouse009d8512009-12-08 12:12:13 +0000751 struct super_block *s = sdp->sd_vfs;
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400752 struct lm_lockname name = { .ln_number = number, .ln_type = glops->go_type };
David Teiglandb3b94fa2006-01-16 16:50:04 +0000753 struct gfs2_glock *gl, *tmp;
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400754 unsigned int hash = gl_hash(sdp, &name);
Steven Whitehouse009d8512009-12-08 12:12:13 +0000755 struct address_space *mapping;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000756
Steven Whitehouse087efdd2006-09-09 16:59:11 -0400757 read_lock(gl_lock_addr(hash));
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400758 gl = search_bucket(hash, sdp, &name);
Steven Whitehouse087efdd2006-09-09 16:59:11 -0400759 read_unlock(gl_lock_addr(hash));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000760
Steven Whitehouse64d576b2009-02-12 13:31:58 +0000761 *glp = gl;
762 if (gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000763 return 0;
Steven Whitehouse64d576b2009-02-12 13:31:58 +0000764 if (!create)
765 return -ENOENT;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000766
Steven Whitehouse009d8512009-12-08 12:12:13 +0000767 if (glops->go_flags & GLOF_ASPACE)
768 gl = kmem_cache_alloc(gfs2_glock_aspace_cachep, GFP_KERNEL);
769 else
770 gl = kmem_cache_alloc(gfs2_glock_cachep, GFP_KERNEL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000771 if (!gl)
772 return -ENOMEM;
773
Steven Whitehouse8f052282010-01-29 15:21:27 +0000774 atomic_inc(&sdp->sd_glock_disposal);
Steven Whitehouseec45d9f2006-08-30 10:36:52 -0400775 gl->gl_flags = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000776 gl->gl_name = name;
Steven Whitehouse16feb9f2006-09-13 10:43:37 -0400777 atomic_set(&gl->gl_ref, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000778 gl->gl_state = LM_ST_UNLOCKED;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100779 gl->gl_target = LM_ST_UNLOCKED;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500780 gl->gl_demote_state = LM_ST_EXCLUSIVE;
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400781 gl->gl_hash = hash;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000782 gl->gl_ops = glops;
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000783 snprintf(gl->gl_strname, GDLM_STRNAME_BYTES, "%8x%16llx", name.ln_type, (unsigned long long)number);
784 memset(&gl->gl_lksb, 0, sizeof(struct dlm_lksb));
785 gl->gl_lksb.sb_lvbptr = gl->gl_lvb;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500786 gl->gl_tchange = jiffies;
Steven Whitehouseec45d9f2006-08-30 10:36:52 -0400787 gl->gl_object = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000788 gl->gl_sbd = sdp;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500789 INIT_DELAYED_WORK(&gl->gl_work, glock_work_func);
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500790 INIT_WORK(&gl->gl_delete, delete_work_func);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000791
Steven Whitehouse009d8512009-12-08 12:12:13 +0000792 mapping = gfs2_glock2aspace(gl);
793 if (mapping) {
794 mapping->a_ops = &gfs2_meta_aops;
795 mapping->host = s->s_bdev->bd_inode;
796 mapping->flags = 0;
797 mapping_set_gfp_mask(mapping, GFP_NOFS);
798 mapping->assoc_mapping = NULL;
799 mapping->backing_dev_info = s->s_bdi;
800 mapping->writeback_index = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000801 }
802
Steven Whitehouse087efdd2006-09-09 16:59:11 -0400803 write_lock(gl_lock_addr(hash));
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400804 tmp = search_bucket(hash, sdp, &name);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000805 if (tmp) {
Steven Whitehouse087efdd2006-09-09 16:59:11 -0400806 write_unlock(gl_lock_addr(hash));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000807 glock_free(gl);
808 gl = tmp;
809 } else {
Steven Whitehouseb6397892006-09-12 10:10:01 -0400810 hlist_add_head(&gl->gl_list, &gl_hash_table[hash].hb_list);
Steven Whitehouse087efdd2006-09-09 16:59:11 -0400811 write_unlock(gl_lock_addr(hash));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000812 }
813
814 *glp = gl;
815
816 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000817}
818
819/**
820 * gfs2_holder_init - initialize a struct gfs2_holder in the default way
821 * @gl: the glock
822 * @state: the state we're requesting
823 * @flags: the modifier flags
824 * @gh: the holder structure
825 *
826 */
827
Steven Whitehouse190562b2006-04-20 16:57:23 -0400828void gfs2_holder_init(struct gfs2_glock *gl, unsigned int state, unsigned flags,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000829 struct gfs2_holder *gh)
830{
831 INIT_LIST_HEAD(&gh->gh_list);
832 gh->gh_gl = gl;
Steven Whitehoused0dc80d2006-03-29 14:36:49 -0500833 gh->gh_ip = (unsigned long)__builtin_return_address(0);
Pavel Emelyanovb1e058d2008-02-07 00:13:19 -0800834 gh->gh_owner_pid = get_pid(task_pid(current));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000835 gh->gh_state = state;
836 gh->gh_flags = flags;
837 gh->gh_error = 0;
838 gh->gh_iflags = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000839 gfs2_glock_hold(gl);
840}
841
842/**
843 * gfs2_holder_reinit - reinitialize a struct gfs2_holder so we can requeue it
844 * @state: the state we're requesting
845 * @flags: the modifier flags
846 * @gh: the holder structure
847 *
848 * Don't mess with the glock.
849 *
850 */
851
Steven Whitehouse190562b2006-04-20 16:57:23 -0400852void gfs2_holder_reinit(unsigned int state, unsigned flags, struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000853{
854 gh->gh_state = state;
Steven Whitehouse579b78a2006-04-26 14:58:26 -0400855 gh->gh_flags = flags;
Steven Whitehouse3b8249f2007-03-16 09:40:31 +0000856 gh->gh_iflags = 0;
Steven Whitehoused0dc80d2006-03-29 14:36:49 -0500857 gh->gh_ip = (unsigned long)__builtin_return_address(0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000858}
859
860/**
861 * gfs2_holder_uninit - uninitialize a holder structure (drop glock reference)
862 * @gh: the holder structure
863 *
864 */
865
866void gfs2_holder_uninit(struct gfs2_holder *gh)
867{
Pavel Emelyanovb1e058d2008-02-07 00:13:19 -0800868 put_pid(gh->gh_owner_pid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000869 gfs2_glock_put(gh->gh_gl);
870 gh->gh_gl = NULL;
Steven Whitehoused0dc80d2006-03-29 14:36:49 -0500871 gh->gh_ip = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000872}
873
Steven Whitehousefe64d512009-05-19 10:01:18 +0100874/**
875 * gfs2_glock_holder_wait
876 * @word: unused
877 *
878 * This function and gfs2_glock_demote_wait both show up in the WCHAN
879 * field. Thus I've separated these otherwise identical functions in
880 * order to be more informative to the user.
881 */
882
883static int gfs2_glock_holder_wait(void *word)
Steven Whitehousefee852e2007-01-17 15:33:23 +0000884{
885 schedule();
886 return 0;
887}
888
Steven Whitehousefe64d512009-05-19 10:01:18 +0100889static int gfs2_glock_demote_wait(void *word)
890{
891 schedule();
892 return 0;
893}
894
Steven Whitehousefee852e2007-01-17 15:33:23 +0000895static void wait_on_holder(struct gfs2_holder *gh)
896{
897 might_sleep();
Steven Whitehousefe64d512009-05-19 10:01:18 +0100898 wait_on_bit(&gh->gh_iflags, HIF_WAIT, gfs2_glock_holder_wait, TASK_UNINTERRUPTIBLE);
Abhijith Dasd93cfa92007-06-11 08:22:32 +0100899}
900
Abhijith Dasd93cfa92007-06-11 08:22:32 +0100901static void wait_on_demote(struct gfs2_glock *gl)
902{
903 might_sleep();
Steven Whitehousefe64d512009-05-19 10:01:18 +0100904 wait_on_bit(&gl->gl_flags, GLF_DEMOTE, gfs2_glock_demote_wait, TASK_UNINTERRUPTIBLE);
Steven Whitehousefee852e2007-01-17 15:33:23 +0000905}
906
David Teiglandb3b94fa2006-01-16 16:50:04 +0000907/**
Steven Whitehouse3b8249f2007-03-16 09:40:31 +0000908 * handle_callback - process a demote request
David Teiglandb3b94fa2006-01-16 16:50:04 +0000909 * @gl: the glock
910 * @state: the state the caller wants us to change to
911 *
Steven Whitehouse3b8249f2007-03-16 09:40:31 +0000912 * There are only two requests that we are going to see in actual
913 * practise: LM_ST_SHARED and LM_ST_UNLOCKED
David Teiglandb3b94fa2006-01-16 16:50:04 +0000914 */
915
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500916static void handle_callback(struct gfs2_glock *gl, unsigned int state,
Steven Whitehouse97cc1022008-11-20 13:39:47 +0000917 unsigned long delay)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000918{
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500919 int bit = delay ? GLF_PENDING_DEMOTE : GLF_DEMOTE;
920
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500921 set_bit(bit, &gl->gl_flags);
922 if (gl->gl_demote_state == LM_ST_EXCLUSIVE) {
Steven Whitehouse3b8249f2007-03-16 09:40:31 +0000923 gl->gl_demote_state = state;
924 gl->gl_demote_time = jiffies;
Josef Whiter26caee52007-07-23 10:02:40 +0100925 } else if (gl->gl_demote_state != LM_ST_UNLOCKED &&
926 gl->gl_demote_state != state) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100927 gl->gl_demote_state = LM_ST_UNLOCKED;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000928 }
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500929 if (gl->gl_ops->go_callback)
930 gl->gl_ops->go_callback(gl);
Steven Whitehouse63997772009-06-12 08:49:20 +0100931 trace_gfs2_demote_rq(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000932}
933
934/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100935 * gfs2_glock_wait - wait on a glock acquisition
David Teiglandb3b94fa2006-01-16 16:50:04 +0000936 * @gh: the glock holder
937 *
938 * Returns: 0 on success
939 */
940
Steven Whitehouse6802e342008-05-21 17:03:22 +0100941int gfs2_glock_wait(struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000942{
Steven Whitehousefee852e2007-01-17 15:33:23 +0000943 wait_on_holder(gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000944 return gh->gh_error;
945}
946
Steven Whitehouse6802e342008-05-21 17:03:22 +0100947void gfs2_print_dbg(struct seq_file *seq, const char *fmt, ...)
Robert Peterson7c52b162007-03-16 10:26:37 +0000948{
949 va_list args;
950
951 va_start(args, fmt);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100952 if (seq) {
953 struct gfs2_glock_iter *gi = seq->private;
Robert Peterson7c52b162007-03-16 10:26:37 +0000954 vsprintf(gi->string, fmt, args);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100955 seq_printf(seq, gi->string);
956 } else {
957 printk(KERN_ERR " ");
Robert Peterson7c52b162007-03-16 10:26:37 +0000958 vprintk(fmt, args);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100959 }
Robert Peterson7c52b162007-03-16 10:26:37 +0000960 va_end(args);
961}
962
David Teiglandb3b94fa2006-01-16 16:50:04 +0000963/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000964 * add_to_queue - Add a holder to the wait queue (but look for recursion)
965 * @gh: the holder structure to add
966 *
Steven Whitehouse6802e342008-05-21 17:03:22 +0100967 * Eventually we should move the recursive locking trap to a
968 * debugging option or something like that. This is the fast
969 * path and needs to have the minimum number of distractions.
970 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000971 */
972
Steven Whitehouse6802e342008-05-21 17:03:22 +0100973static inline void add_to_queue(struct gfs2_holder *gh)
Harvey Harrison55ba4742008-10-24 11:31:12 -0700974__releases(&gl->gl_spin)
975__acquires(&gl->gl_spin)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000976{
977 struct gfs2_glock *gl = gh->gh_gl;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100978 struct gfs2_sbd *sdp = gl->gl_sbd;
979 struct list_head *insert_pt = NULL;
980 struct gfs2_holder *gh2;
981 int try_lock = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000982
Pavel Emelyanovb1e058d2008-02-07 00:13:19 -0800983 BUG_ON(gh->gh_owner_pid == NULL);
Steven Whitehousefee852e2007-01-17 15:33:23 +0000984 if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags))
985 BUG();
Steven Whitehouse190562b2006-04-20 16:57:23 -0400986
Steven Whitehouse6802e342008-05-21 17:03:22 +0100987 if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)) {
988 if (test_bit(GLF_LOCK, &gl->gl_flags))
989 try_lock = 1;
990 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags))
991 goto fail;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000992 }
993
Steven Whitehouse6802e342008-05-21 17:03:22 +0100994 list_for_each_entry(gh2, &gl->gl_holders, gh_list) {
995 if (unlikely(gh2->gh_owner_pid == gh->gh_owner_pid &&
996 (gh->gh_gl->gl_ops->go_type != LM_TYPE_FLOCK)))
997 goto trap_recursive;
998 if (try_lock &&
999 !(gh2->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)) &&
1000 !may_grant(gl, gh)) {
1001fail:
1002 gh->gh_error = GLR_TRYFAILED;
1003 gfs2_holder_wake(gh);
1004 return;
1005 }
1006 if (test_bit(HIF_HOLDER, &gh2->gh_iflags))
1007 continue;
1008 if (unlikely((gh->gh_flags & LM_FLAG_PRIORITY) && !insert_pt))
1009 insert_pt = &gh2->gh_list;
1010 }
1011 if (likely(insert_pt == NULL)) {
1012 list_add_tail(&gh->gh_list, &gl->gl_holders);
1013 if (unlikely(gh->gh_flags & LM_FLAG_PRIORITY))
1014 goto do_cancel;
1015 return;
1016 }
Steven Whitehouse63997772009-06-12 08:49:20 +01001017 trace_gfs2_glock_queue(gh, 1);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001018 list_add_tail(&gh->gh_list, insert_pt);
1019do_cancel:
1020 gh = list_entry(gl->gl_holders.next, struct gfs2_holder, gh_list);
1021 if (!(gh->gh_flags & LM_FLAG_PRIORITY)) {
1022 spin_unlock(&gl->gl_spin);
Steven Whitehouse048bca22008-05-23 14:46:04 +01001023 if (sdp->sd_lockstruct.ls_ops->lm_cancel)
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001024 sdp->sd_lockstruct.ls_ops->lm_cancel(gl);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001025 spin_lock(&gl->gl_spin);
1026 }
1027 return;
1028
1029trap_recursive:
1030 print_symbol(KERN_ERR "original: %s\n", gh2->gh_ip);
1031 printk(KERN_ERR "pid: %d\n", pid_nr(gh2->gh_owner_pid));
1032 printk(KERN_ERR "lock type: %d req lock state : %d\n",
1033 gh2->gh_gl->gl_name.ln_type, gh2->gh_state);
1034 print_symbol(KERN_ERR "new: %s\n", gh->gh_ip);
1035 printk(KERN_ERR "pid: %d\n", pid_nr(gh->gh_owner_pid));
1036 printk(KERN_ERR "lock type: %d req lock state : %d\n",
1037 gh->gh_gl->gl_name.ln_type, gh->gh_state);
1038 __dump_glock(NULL, gl);
1039 BUG();
David Teiglandb3b94fa2006-01-16 16:50:04 +00001040}
1041
1042/**
1043 * gfs2_glock_nq - enqueue a struct gfs2_holder onto a glock (acquire a glock)
1044 * @gh: the holder structure
1045 *
1046 * if (gh->gh_flags & GL_ASYNC), this never returns an error
1047 *
1048 * Returns: 0, GLR_TRYFAILED, or errno on failure
1049 */
1050
1051int gfs2_glock_nq(struct gfs2_holder *gh)
1052{
1053 struct gfs2_glock *gl = gh->gh_gl;
1054 struct gfs2_sbd *sdp = gl->gl_sbd;
1055 int error = 0;
1056
Steven Whitehouse6802e342008-05-21 17:03:22 +01001057 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001058 return -EIO;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001059
David Teiglandb3b94fa2006-01-16 16:50:04 +00001060 spin_lock(&gl->gl_spin);
1061 add_to_queue(gh);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001062 run_queue(gl, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001063 spin_unlock(&gl->gl_spin);
1064
Steven Whitehouse6802e342008-05-21 17:03:22 +01001065 if (!(gh->gh_flags & GL_ASYNC))
1066 error = gfs2_glock_wait(gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001067
David Teiglandb3b94fa2006-01-16 16:50:04 +00001068 return error;
1069}
1070
1071/**
1072 * gfs2_glock_poll - poll to see if an async request has been completed
1073 * @gh: the holder
1074 *
1075 * Returns: 1 if the request is ready to be gfs2_glock_wait()ed on
1076 */
1077
1078int gfs2_glock_poll(struct gfs2_holder *gh)
1079{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001080 return test_bit(HIF_WAIT, &gh->gh_iflags) ? 0 : 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001081}
1082
1083/**
1084 * gfs2_glock_dq - dequeue a struct gfs2_holder from a glock (release a glock)
1085 * @gh: the glock holder
1086 *
1087 */
1088
1089void gfs2_glock_dq(struct gfs2_holder *gh)
1090{
1091 struct gfs2_glock *gl = gh->gh_gl;
Steven Whitehouse8fb4b532006-08-30 09:30:00 -04001092 const struct gfs2_glock_operations *glops = gl->gl_ops;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001093 unsigned delay = 0;
Steven Whitehouse6802e342008-05-21 17:03:22 +01001094 int fast_path = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001095
Steven Whitehouse6802e342008-05-21 17:03:22 +01001096 spin_lock(&gl->gl_spin);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001097 if (gh->gh_flags & GL_NOCACHE)
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001098 handle_callback(gl, LM_ST_UNLOCKED, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001099
David Teiglandb3b94fa2006-01-16 16:50:04 +00001100 list_del_init(&gh->gh_list);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001101 if (find_first_holder(gl) == NULL) {
Steven Whitehouse3042a2c2007-11-02 08:39:34 +00001102 if (glops->go_unlock) {
Steven Whitehouse6802e342008-05-21 17:03:22 +01001103 GLOCK_BUG_ON(gl, test_and_set_bit(GLF_LOCK, &gl->gl_flags));
Steven Whitehouse3042a2c2007-11-02 08:39:34 +00001104 spin_unlock(&gl->gl_spin);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001105 glops->go_unlock(gh);
Steven Whitehouse3042a2c2007-11-02 08:39:34 +00001106 spin_lock(&gl->gl_spin);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001107 clear_bit(GLF_LOCK, &gl->gl_flags);
Steven Whitehouse3042a2c2007-11-02 08:39:34 +00001108 }
Steven Whitehouse6802e342008-05-21 17:03:22 +01001109 if (list_empty(&gl->gl_holders) &&
1110 !test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
1111 !test_bit(GLF_DEMOTE, &gl->gl_flags))
1112 fast_path = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001113 }
Steven Whitehouse63997772009-06-12 08:49:20 +01001114 trace_gfs2_glock_queue(gh, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001115 spin_unlock(&gl->gl_spin);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001116 if (likely(fast_path))
1117 return;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001118
1119 gfs2_glock_hold(gl);
1120 if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
1121 !test_bit(GLF_DEMOTE, &gl->gl_flags))
1122 delay = gl->gl_ops->go_min_hold_time;
1123 if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
1124 gfs2_glock_put(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001125}
1126
Abhijith Dasd93cfa92007-06-11 08:22:32 +01001127void gfs2_glock_dq_wait(struct gfs2_holder *gh)
1128{
1129 struct gfs2_glock *gl = gh->gh_gl;
1130 gfs2_glock_dq(gh);
1131 wait_on_demote(gl);
1132}
1133
David Teiglandb3b94fa2006-01-16 16:50:04 +00001134/**
David Teiglandb3b94fa2006-01-16 16:50:04 +00001135 * gfs2_glock_dq_uninit - dequeue a holder from a glock and initialize it
1136 * @gh: the holder structure
1137 *
1138 */
1139
1140void 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 aquisition
1153 * @gh: the struct gfs2_holder
1154 *
1155 * Returns: errno
1156 */
1157
Steven Whitehousecd915492006-09-04 12:49:07 -04001158int gfs2_glock_nq_num(struct gfs2_sbd *sdp, u64 number,
Steven Whitehouse8fb4b532006-08-30 09:30:00 -04001159 const struct gfs2_glock_operations *glops,
1160 unsigned int state, int flags, struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001161{
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
1181static int glock_compare(const void *arg_a, const void *arg_b)
1182{
Steven Whitehousea5e08a92006-09-09 17:07:05 -04001183 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;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001187
1188 if (a->ln_number > b->ln_number)
Steven Whitehousea5e08a92006-09-09 17:07:05 -04001189 return 1;
1190 if (a->ln_number < b->ln_number)
1191 return -1;
Steven Whitehouse1c0f4872007-01-22 12:10:39 -05001192 BUG_ON(gh_a->gh_gl->gl_ops->go_type == gh_b->gh_gl->gl_ops->go_type);
Steven Whitehousea5e08a92006-09-09 17:07:05 -04001193 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001194}
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
1205static 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 *
David Teiglandb3b94fa2006-01-16 16:50:04 +00001235 *
1236 * Returns: 0 on success (all glocks acquired),
1237 * errno on failure (no glocks acquired)
1238 */
1239
1240int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs)
1241{
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001242 struct gfs2_holder *tmp[4];
1243 struct gfs2_holder **pph = tmp;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001244 int error = 0;
1245
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001246 switch(num_gh) {
1247 case 0:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001248 return 0;
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001249 case 1:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001250 ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1251 return gfs2_glock_nq(ghs);
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001252 default:
1253 if (num_gh <= 4)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001254 break;
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001255 pph = kmalloc(num_gh * sizeof(struct gfs2_holder *), GFP_NOFS);
1256 if (!pph)
1257 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001258 }
1259
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001260 error = nq_m_sync(num_gh, ghs, pph);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001261
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001262 if (pph != tmp)
1263 kfree(pph);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001264
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
1275void gfs2_glock_dq_m(unsigned int num_gh, struct gfs2_holder *ghs)
1276{
1277 unsigned int x;
1278
1279 for (x = 0; x < num_gh; x++)
1280 gfs2_glock_dq(&ghs[x]);
1281}
1282
1283/**
1284 * gfs2_glock_dq_uninit_m - release multiple glocks
1285 * @num_gh: the number of structures
1286 * @ghs: an array of struct gfs2_holder structures
1287 *
1288 */
1289
1290void gfs2_glock_dq_uninit_m(unsigned int num_gh, struct gfs2_holder *ghs)
1291{
1292 unsigned int x;
1293
1294 for (x = 0; x < num_gh; x++)
1295 gfs2_glock_dq_uninit(&ghs[x]);
1296}
1297
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001298void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state)
Steven Whitehouseda755fd2008-01-30 15:34:04 +00001299{
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001300 unsigned long delay = 0;
1301 unsigned long holdtime;
1302 unsigned long now = jiffies;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001303
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001304 gfs2_glock_hold(gl);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001305 holdtime = gl->gl_tchange + gl->gl_ops->go_min_hold_time;
1306 if (time_before(now, holdtime))
1307 delay = holdtime - now;
Steven Whitehousedff52572008-09-02 13:33:17 +01001308 if (test_bit(GLF_REPLY_PENDING, &gl->gl_flags))
1309 delay = gl->gl_ops->go_min_hold_time;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001310
Steven Whitehouse6802e342008-05-21 17:03:22 +01001311 spin_lock(&gl->gl_spin);
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001312 handle_callback(gl, state, delay);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001313 spin_unlock(&gl->gl_spin);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001314 if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
1315 gfs2_glock_put(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001316}
1317
1318/**
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001319 * gfs2_glock_complete - Callback used by locking
1320 * @gl: Pointer to the glock
1321 * @ret: The return value from the dlm
David Teiglandb3b94fa2006-01-16 16:50:04 +00001322 *
David Teiglandb3b94fa2006-01-16 16:50:04 +00001323 */
1324
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001325void gfs2_glock_complete(struct gfs2_glock *gl, int ret)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001326{
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001327 struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct;
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001328 gl->gl_reply = ret;
1329 if (unlikely(test_bit(DFL_BLOCK_LOCKS, &ls->ls_flags))) {
1330 struct gfs2_holder *gh;
1331 spin_lock(&gl->gl_spin);
1332 gh = find_first_waiter(gl);
1333 if ((!(gh && (gh->gh_flags & LM_FLAG_NOEXP)) &&
1334 (gl->gl_target != LM_ST_UNLOCKED)) ||
1335 ((ret & ~LM_OUT_ST_MASK) != 0))
1336 set_bit(GLF_FROZEN, &gl->gl_flags);
1337 spin_unlock(&gl->gl_spin);
Steven Whitehoused8348de2009-02-05 10:12:38 +00001338 if (test_bit(GLF_FROZEN, &gl->gl_flags))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001339 return;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001340 }
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001341 set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
1342 gfs2_glock_hold(gl);
1343 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
1344 gfs2_glock_put(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001345}
1346
David Teiglandb3b94fa2006-01-16 16:50:04 +00001347
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001348static int gfs2_shrink_glock_memory(int nr, gfp_t gfp_mask)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001349{
1350 struct gfs2_glock *gl;
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001351 int may_demote;
1352 int nr_skipped = 0;
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001353 LIST_HEAD(skipped);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001354
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001355 if (nr == 0)
1356 goto out;
1357
1358 if (!(gfp_mask & __GFP_FS))
1359 return -1;
1360
1361 spin_lock(&lru_lock);
1362 while(nr && !list_empty(&lru_list)) {
1363 gl = list_entry(lru_list.next, struct gfs2_glock, gl_lru);
1364 list_del_init(&gl->gl_lru);
1365 atomic_dec(&lru_count);
1366
1367 /* Test for being demotable */
1368 if (!test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
1369 gfs2_glock_hold(gl);
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001370 spin_unlock(&lru_lock);
1371 spin_lock(&gl->gl_spin);
1372 may_demote = demote_ok(gl);
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001373 if (may_demote) {
1374 handle_callback(gl, LM_ST_UNLOCKED, 0);
1375 nr--;
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001376 }
Steven Whitehouse7e71c552009-09-22 10:56:16 +01001377 clear_bit(GLF_LOCK, &gl->gl_flags);
1378 smp_mb__after_clear_bit();
Steven Whitehouse2163b1e2009-06-25 16:30:26 +01001379 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
Benjamin Marzinskib94a1702009-07-23 18:52:34 -05001380 gfs2_glock_put_nolock(gl);
1381 spin_unlock(&gl->gl_spin);
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001382 spin_lock(&lru_lock);
Steven Whitehouse2163b1e2009-06-25 16:30:26 +01001383 continue;
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001384 }
Steven Whitehouse2163b1e2009-06-25 16:30:26 +01001385 nr_skipped++;
1386 list_add(&gl->gl_lru, &skipped);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001387 }
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001388 list_splice(&skipped, &lru_list);
1389 atomic_add(nr_skipped, &lru_count);
1390 spin_unlock(&lru_lock);
1391out:
1392 return (atomic_read(&lru_count) / 100) * sysctl_vfs_cache_pressure;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001393}
1394
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001395static struct shrinker glock_shrinker = {
1396 .shrink = gfs2_shrink_glock_memory,
1397 .seeks = DEFAULT_SEEKS,
1398};
1399
David Teiglandb3b94fa2006-01-16 16:50:04 +00001400/**
1401 * examine_bucket - Call a function for glock in a hash bucket
1402 * @examiner: the function
1403 * @sdp: the filesystem
1404 * @bucket: the bucket
1405 *
1406 * Returns: 1 if the bucket has entries
1407 */
1408
1409static int examine_bucket(glock_examiner examiner, struct gfs2_sbd *sdp,
Steven Whitehouse37b2fa62006-09-08 13:35:56 -04001410 unsigned int hash)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001411{
Steven Whitehouse24264432006-09-11 21:40:30 -04001412 struct gfs2_glock *gl, *prev = NULL;
1413 int has_entries = 0;
Steven Whitehouseb6397892006-09-12 10:10:01 -04001414 struct hlist_head *head = &gl_hash_table[hash].hb_list;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001415
Steven Whitehouse24264432006-09-11 21:40:30 -04001416 read_lock(gl_lock_addr(hash));
Steven Whitehouseb6397892006-09-12 10:10:01 -04001417 /* Can't use hlist_for_each_entry - don't want prefetch here */
1418 if (hlist_empty(head))
Steven Whitehouse24264432006-09-11 21:40:30 -04001419 goto out;
Steven Whitehouseb6397892006-09-12 10:10:01 -04001420 gl = list_entry(head->first, struct gfs2_glock, gl_list);
1421 while(1) {
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001422 if (!sdp || gl->gl_sbd == sdp) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001423 gfs2_glock_hold(gl);
Steven Whitehouse24264432006-09-11 21:40:30 -04001424 read_unlock(gl_lock_addr(hash));
1425 if (prev)
1426 gfs2_glock_put(prev);
1427 prev = gl;
1428 examiner(gl);
Steven Whitehousea8336342006-09-14 13:57:38 -04001429 has_entries = 1;
Steven Whitehouse24264432006-09-11 21:40:30 -04001430 read_lock(gl_lock_addr(hash));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001431 }
Steven Whitehouseb6397892006-09-12 10:10:01 -04001432 if (gl->gl_list.next == NULL)
1433 break;
Steven Whitehouse24264432006-09-11 21:40:30 -04001434 gl = list_entry(gl->gl_list.next, struct gfs2_glock, gl_list);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001435 }
Steven Whitehouse24264432006-09-11 21:40:30 -04001436out:
1437 read_unlock(gl_lock_addr(hash));
1438 if (prev)
1439 gfs2_glock_put(prev);
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001440 cond_resched();
Steven Whitehouse24264432006-09-11 21:40:30 -04001441 return has_entries;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001442}
1443
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001444
1445/**
1446 * thaw_glock - thaw out a glock which has an unprocessed reply waiting
1447 * @gl: The glock to thaw
1448 *
1449 * N.B. When we freeze a glock, we leave a ref to the glock outstanding,
1450 * so this has to result in the ref count being dropped by one.
1451 */
1452
1453static void thaw_glock(struct gfs2_glock *gl)
1454{
1455 if (!test_and_clear_bit(GLF_FROZEN, &gl->gl_flags))
1456 return;
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001457 set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
1458 gfs2_glock_hold(gl);
1459 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
1460 gfs2_glock_put(gl);
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001461}
1462
David Teiglandb3b94fa2006-01-16 16:50:04 +00001463/**
David Teiglandb3b94fa2006-01-16 16:50:04 +00001464 * clear_glock - look at a glock and see if we can free it from glock cache
1465 * @gl: the glock to look at
1466 *
1467 */
1468
1469static void clear_glock(struct gfs2_glock *gl)
1470{
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001471 spin_lock(&lru_lock);
1472 if (!list_empty(&gl->gl_lru)) {
1473 list_del_init(&gl->gl_lru);
1474 atomic_dec(&lru_count);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001475 }
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001476 spin_unlock(&lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001477
Steven Whitehouse6802e342008-05-21 17:03:22 +01001478 spin_lock(&gl->gl_spin);
1479 if (find_first_holder(gl) == NULL && gl->gl_state != LM_ST_UNLOCKED)
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001480 handle_callback(gl, LM_ST_UNLOCKED, 0);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001481 spin_unlock(&gl->gl_spin);
1482 gfs2_glock_hold(gl);
1483 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
1484 gfs2_glock_put(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001485}
1486
1487/**
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001488 * gfs2_glock_thaw - Thaw any frozen glocks
1489 * @sdp: The super block
1490 *
1491 */
1492
1493void gfs2_glock_thaw(struct gfs2_sbd *sdp)
1494{
1495 unsigned x;
1496
1497 for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
1498 examine_bucket(thaw_glock, sdp, x);
1499}
1500
1501/**
David Teiglandb3b94fa2006-01-16 16:50:04 +00001502 * gfs2_gl_hash_clear - Empty out the glock hash table
1503 * @sdp: the filesystem
1504 * @wait: wait until it's all gone
1505 *
Steven Whitehouse1bdad602008-06-03 14:09:53 +01001506 * Called when unmounting the filesystem.
David Teiglandb3b94fa2006-01-16 16:50:04 +00001507 */
1508
Steven Whitehousefefc03b2008-12-19 15:32:06 +00001509void gfs2_gl_hash_clear(struct gfs2_sbd *sdp)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001510{
David Teiglandb3b94fa2006-01-16 16:50:04 +00001511 unsigned int x;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001512
Steven Whitehousec1184f82010-01-08 16:14:29 +00001513 for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
1514 examine_bucket(clear_glock, sdp, x);
Steven Whitehouse8f052282010-01-29 15:21:27 +00001515 flush_workqueue(glock_workqueue);
1516 wait_event(sdp->sd_glock_wait, atomic_read(&sdp->sd_glock_disposal) == 0);
1517 gfs2_dump_lockstate(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001518}
1519
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001520void gfs2_glock_finish_truncate(struct gfs2_inode *ip)
1521{
1522 struct gfs2_glock *gl = ip->i_gl;
1523 int ret;
1524
1525 ret = gfs2_truncatei_resume(ip);
1526 gfs2_assert_withdraw(gl->gl_sbd, ret == 0);
1527
1528 spin_lock(&gl->gl_spin);
1529 clear_bit(GLF_LOCK, &gl->gl_flags);
1530 run_queue(gl, 1);
1531 spin_unlock(&gl->gl_spin);
1532}
1533
Steven Whitehouse6802e342008-05-21 17:03:22 +01001534static const char *state2str(unsigned state)
Robert Peterson04b933f2007-03-23 17:05:15 -05001535{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001536 switch(state) {
1537 case LM_ST_UNLOCKED:
1538 return "UN";
1539 case LM_ST_SHARED:
1540 return "SH";
1541 case LM_ST_DEFERRED:
1542 return "DF";
1543 case LM_ST_EXCLUSIVE:
1544 return "EX";
1545 }
1546 return "??";
1547}
Robert Peterson04b933f2007-03-23 17:05:15 -05001548
Steven Whitehouse6802e342008-05-21 17:03:22 +01001549static const char *hflags2str(char *buf, unsigned flags, unsigned long iflags)
1550{
1551 char *p = buf;
1552 if (flags & LM_FLAG_TRY)
1553 *p++ = 't';
1554 if (flags & LM_FLAG_TRY_1CB)
1555 *p++ = 'T';
1556 if (flags & LM_FLAG_NOEXP)
1557 *p++ = 'e';
1558 if (flags & LM_FLAG_ANY)
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001559 *p++ = 'A';
Steven Whitehouse6802e342008-05-21 17:03:22 +01001560 if (flags & LM_FLAG_PRIORITY)
1561 *p++ = 'p';
1562 if (flags & GL_ASYNC)
1563 *p++ = 'a';
1564 if (flags & GL_EXACT)
1565 *p++ = 'E';
Steven Whitehouse6802e342008-05-21 17:03:22 +01001566 if (flags & GL_NOCACHE)
1567 *p++ = 'c';
1568 if (test_bit(HIF_HOLDER, &iflags))
1569 *p++ = 'H';
1570 if (test_bit(HIF_WAIT, &iflags))
1571 *p++ = 'W';
1572 if (test_bit(HIF_FIRST, &iflags))
1573 *p++ = 'F';
1574 *p = 0;
1575 return buf;
Robert Peterson04b933f2007-03-23 17:05:15 -05001576}
1577
David Teiglandb3b94fa2006-01-16 16:50:04 +00001578/**
1579 * dump_holder - print information about a glock holder
Steven Whitehouse6802e342008-05-21 17:03:22 +01001580 * @seq: the seq_file struct
David Teiglandb3b94fa2006-01-16 16:50:04 +00001581 * @gh: the glock holder
1582 *
1583 * Returns: 0 on success, -ENOBUFS when we run out of space
1584 */
1585
Steven Whitehouse6802e342008-05-21 17:03:22 +01001586static int dump_holder(struct seq_file *seq, const struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001587{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001588 struct task_struct *gh_owner = NULL;
1589 char buffer[KSYM_SYMBOL_LEN];
1590 char flags_buf[32];
David Teiglandb3b94fa2006-01-16 16:50:04 +00001591
Steven Whitehouse6802e342008-05-21 17:03:22 +01001592 sprint_symbol(buffer, gh->gh_ip);
1593 if (gh->gh_owner_pid)
Pavel Emelyanovb1e058d2008-02-07 00:13:19 -08001594 gh_owner = pid_task(gh->gh_owner_pid, PIDTYPE_PID);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001595 gfs2_print_dbg(seq, " H: s:%s f:%s e:%d p:%ld [%s] %s\n",
1596 state2str(gh->gh_state),
1597 hflags2str(flags_buf, gh->gh_flags, gh->gh_iflags),
1598 gh->gh_error,
1599 gh->gh_owner_pid ? (long)pid_nr(gh->gh_owner_pid) : -1,
1600 gh_owner ? gh_owner->comm : "(ended)", buffer);
Robert Peterson7c52b162007-03-16 10:26:37 +00001601 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001602}
1603
Steven Whitehouse6802e342008-05-21 17:03:22 +01001604static const char *gflags2str(char *buf, const unsigned long *gflags)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001605{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001606 char *p = buf;
1607 if (test_bit(GLF_LOCK, gflags))
1608 *p++ = 'l';
Steven Whitehouse6802e342008-05-21 17:03:22 +01001609 if (test_bit(GLF_DEMOTE, gflags))
1610 *p++ = 'D';
1611 if (test_bit(GLF_PENDING_DEMOTE, gflags))
1612 *p++ = 'd';
1613 if (test_bit(GLF_DEMOTE_IN_PROGRESS, gflags))
1614 *p++ = 'p';
1615 if (test_bit(GLF_DIRTY, gflags))
1616 *p++ = 'y';
1617 if (test_bit(GLF_LFLUSH, gflags))
1618 *p++ = 'f';
1619 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, gflags))
1620 *p++ = 'i';
1621 if (test_bit(GLF_REPLY_PENDING, gflags))
1622 *p++ = 'r';
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001623 if (test_bit(GLF_INITIAL, gflags))
Steven Whitehoused8348de2009-02-05 10:12:38 +00001624 *p++ = 'I';
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001625 if (test_bit(GLF_FROZEN, gflags))
1626 *p++ = 'F';
Steven Whitehouse6802e342008-05-21 17:03:22 +01001627 *p = 0;
1628 return buf;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001629}
1630
1631/**
Steven Whitehouse6802e342008-05-21 17:03:22 +01001632 * __dump_glock - print information about a glock
1633 * @seq: The seq_file struct
David Teiglandb3b94fa2006-01-16 16:50:04 +00001634 * @gl: the glock
Steven Whitehouse6802e342008-05-21 17:03:22 +01001635 *
1636 * The file format is as follows:
1637 * One line per object, capital letters are used to indicate objects
1638 * G = glock, I = Inode, R = rgrp, H = holder. Glocks are not indented,
1639 * other objects are indented by a single space and follow the glock to
1640 * which they are related. Fields are indicated by lower case letters
1641 * followed by a colon and the field value, except for strings which are in
1642 * [] so that its possible to see if they are composed of spaces for
1643 * example. The field's are n = number (id of the object), f = flags,
1644 * t = type, s = state, r = refcount, e = error, p = pid.
David Teiglandb3b94fa2006-01-16 16:50:04 +00001645 *
1646 * Returns: 0 on success, -ENOBUFS when we run out of space
1647 */
1648
Steven Whitehouse6802e342008-05-21 17:03:22 +01001649static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001650{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001651 const struct gfs2_glock_operations *glops = gl->gl_ops;
1652 unsigned long long dtime;
1653 const struct gfs2_holder *gh;
1654 char gflags_buf[32];
1655 int error = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001656
Steven Whitehouse6802e342008-05-21 17:03:22 +01001657 dtime = jiffies - gl->gl_demote_time;
1658 dtime *= 1000000/HZ; /* demote time in uSec */
1659 if (!test_bit(GLF_DEMOTE, &gl->gl_flags))
1660 dtime = 0;
Bob Peterson48189722010-02-23 12:20:00 -05001661 gfs2_print_dbg(seq, "G: s:%s n:%u/%llx f:%s t:%s d:%s/%llu a:%d r:%d\n",
Steven Whitehouse6802e342008-05-21 17:03:22 +01001662 state2str(gl->gl_state),
1663 gl->gl_name.ln_type,
1664 (unsigned long long)gl->gl_name.ln_number,
1665 gflags2str(gflags_buf, &gl->gl_flags),
1666 state2str(gl->gl_target),
1667 state2str(gl->gl_demote_state), dtime,
Steven Whitehouse6802e342008-05-21 17:03:22 +01001668 atomic_read(&gl->gl_ail_count),
1669 atomic_read(&gl->gl_ref));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001670
David Teiglandb3b94fa2006-01-16 16:50:04 +00001671 list_for_each_entry(gh, &gl->gl_holders, gh_list) {
Steven Whitehouse6802e342008-05-21 17:03:22 +01001672 error = dump_holder(seq, gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001673 if (error)
1674 goto out;
1675 }
Steven Whitehouse6802e342008-05-21 17:03:22 +01001676 if (gl->gl_state != LM_ST_UNLOCKED && glops->go_dump)
1677 error = glops->go_dump(seq, gl);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001678out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001679 return error;
1680}
1681
Steven Whitehouse6802e342008-05-21 17:03:22 +01001682static int dump_glock(struct seq_file *seq, struct gfs2_glock *gl)
1683{
1684 int ret;
1685 spin_lock(&gl->gl_spin);
1686 ret = __dump_glock(seq, gl);
1687 spin_unlock(&gl->gl_spin);
1688 return ret;
1689}
1690
David Teiglandb3b94fa2006-01-16 16:50:04 +00001691/**
1692 * gfs2_dump_lockstate - print out the current lockstate
1693 * @sdp: the filesystem
1694 * @ub: the buffer to copy the information into
1695 *
1696 * If @ub is NULL, dump the lockstate to the console.
1697 *
1698 */
1699
Adrian Bunk08bc2db2006-04-28 10:59:12 -04001700static int gfs2_dump_lockstate(struct gfs2_sbd *sdp)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001701{
David Teiglandb3b94fa2006-01-16 16:50:04 +00001702 struct gfs2_glock *gl;
Steven Whitehouseb6397892006-09-12 10:10:01 -04001703 struct hlist_node *h;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001704 unsigned int x;
1705 int error = 0;
1706
1707 for (x = 0; x < GFS2_GL_HASH_SIZE; x++) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001708
Steven Whitehouse087efdd2006-09-09 16:59:11 -04001709 read_lock(gl_lock_addr(x));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001710
Steven Whitehouseb6397892006-09-12 10:10:01 -04001711 hlist_for_each_entry(gl, h, &gl_hash_table[x].hb_list, gl_list) {
Steven Whitehouse85d1da62006-09-07 14:40:21 -04001712 if (gl->gl_sbd != sdp)
1713 continue;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001714
Robert Peterson7c52b162007-03-16 10:26:37 +00001715 error = dump_glock(NULL, gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001716 if (error)
1717 break;
1718 }
1719
Steven Whitehouse087efdd2006-09-09 16:59:11 -04001720 read_unlock(gl_lock_addr(x));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001721
1722 if (error)
1723 break;
1724 }
1725
1726
1727 return error;
1728}
1729
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001730
Steven Whitehouse85d1da62006-09-07 14:40:21 -04001731int __init gfs2_glock_init(void)
1732{
1733 unsigned i;
1734 for(i = 0; i < GFS2_GL_HASH_SIZE; i++) {
Steven Whitehouseb6397892006-09-12 10:10:01 -04001735 INIT_HLIST_HEAD(&gl_hash_table[i].hb_list);
Steven Whitehouse85d1da62006-09-07 14:40:21 -04001736 }
Steven Whitehouse087efdd2006-09-09 16:59:11 -04001737#ifdef GL_HASH_LOCK_SZ
1738 for(i = 0; i < GL_HASH_LOCK_SZ; i++) {
1739 rwlock_init(&gl_hash_locks[i]);
1740 }
1741#endif
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001742
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001743 glock_workqueue = create_workqueue("glock_workqueue");
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001744 if (IS_ERR(glock_workqueue))
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001745 return PTR_ERR(glock_workqueue);
Benjamin Marzinskib94a1702009-07-23 18:52:34 -05001746 gfs2_delete_workqueue = create_workqueue("delete_workqueue");
1747 if (IS_ERR(gfs2_delete_workqueue)) {
1748 destroy_workqueue(glock_workqueue);
1749 return PTR_ERR(gfs2_delete_workqueue);
1750 }
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001751
1752 register_shrinker(&glock_shrinker);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001753
Steven Whitehouse85d1da62006-09-07 14:40:21 -04001754 return 0;
1755}
1756
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001757void gfs2_glock_exit(void)
1758{
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001759 unregister_shrinker(&glock_shrinker);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001760 destroy_workqueue(glock_workqueue);
Benjamin Marzinskib94a1702009-07-23 18:52:34 -05001761 destroy_workqueue(gfs2_delete_workqueue);
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001762}
1763
Steven Whitehouse6802e342008-05-21 17:03:22 +01001764static int gfs2_glock_iter_next(struct gfs2_glock_iter *gi)
Robert Peterson7c52b162007-03-16 10:26:37 +00001765{
Steven Whitehouse7b08fc62007-07-24 13:53:36 +01001766 struct gfs2_glock *gl;
1767
Abhijith Dasa947e032007-08-21 09:57:29 -05001768restart:
Robert Peterson7a0079d2007-04-17 11:37:11 -05001769 read_lock(gl_lock_addr(gi->hash));
Steven Whitehouse7b08fc62007-07-24 13:53:36 +01001770 gl = gi->gl;
1771 if (gl) {
Abhijith Dasa947e032007-08-21 09:57:29 -05001772 gi->gl = hlist_entry(gl->gl_list.next,
1773 struct gfs2_glock, gl_list);
Steven Whitehousec1e817d2008-07-22 22:58:03 +01001774 } else {
1775 gi->gl = hlist_entry(gl_hash_table[gi->hash].hb_list.first,
1776 struct gfs2_glock, gl_list);
Robert Peterson7c52b162007-03-16 10:26:37 +00001777 }
Steven Whitehousec1e817d2008-07-22 22:58:03 +01001778 if (gi->gl)
1779 gfs2_glock_hold(gi->gl);
Robert Peterson7a0079d2007-04-17 11:37:11 -05001780 read_unlock(gl_lock_addr(gi->hash));
Steven Whitehouse7b08fc62007-07-24 13:53:36 +01001781 if (gl)
1782 gfs2_glock_put(gl);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001783 while (gi->gl == NULL) {
Steven Whitehousec1e817d2008-07-22 22:58:03 +01001784 gi->hash++;
Steven Whitehouse7b08fc62007-07-24 13:53:36 +01001785 if (gi->hash >= GFS2_GL_HASH_SIZE)
1786 return 1;
1787 read_lock(gl_lock_addr(gi->hash));
1788 gi->gl = hlist_entry(gl_hash_table[gi->hash].hb_list.first,
1789 struct gfs2_glock, gl_list);
1790 if (gi->gl)
1791 gfs2_glock_hold(gi->gl);
1792 read_unlock(gl_lock_addr(gi->hash));
1793 }
Abhijith Dasa947e032007-08-21 09:57:29 -05001794
1795 if (gi->sdp != gi->gl->gl_sbd)
1796 goto restart;
1797
Robert Peterson7c52b162007-03-16 10:26:37 +00001798 return 0;
1799}
1800
Steven Whitehouse6802e342008-05-21 17:03:22 +01001801static void gfs2_glock_iter_free(struct gfs2_glock_iter *gi)
Robert Peterson7c52b162007-03-16 10:26:37 +00001802{
Steven Whitehouse7b08fc62007-07-24 13:53:36 +01001803 if (gi->gl)
1804 gfs2_glock_put(gi->gl);
Abhijith Dasa947e032007-08-21 09:57:29 -05001805 gi->gl = NULL;
Robert Peterson7c52b162007-03-16 10:26:37 +00001806}
1807
Steven Whitehouse6802e342008-05-21 17:03:22 +01001808static void *gfs2_glock_seq_start(struct seq_file *seq, loff_t *pos)
Robert Peterson7c52b162007-03-16 10:26:37 +00001809{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001810 struct gfs2_glock_iter *gi = seq->private;
Robert Peterson7c52b162007-03-16 10:26:37 +00001811 loff_t n = *pos;
1812
Steven Whitehouse6802e342008-05-21 17:03:22 +01001813 gi->hash = 0;
Robert Peterson7c52b162007-03-16 10:26:37 +00001814
Steven Whitehouse6802e342008-05-21 17:03:22 +01001815 do {
Robert Peterson7c52b162007-03-16 10:26:37 +00001816 if (gfs2_glock_iter_next(gi)) {
1817 gfs2_glock_iter_free(gi);
1818 return NULL;
1819 }
Steven Whitehouse6802e342008-05-21 17:03:22 +01001820 } while (n--);
Robert Peterson7c52b162007-03-16 10:26:37 +00001821
Steven Whitehouse6802e342008-05-21 17:03:22 +01001822 return gi->gl;
Robert Peterson7c52b162007-03-16 10:26:37 +00001823}
1824
Steven Whitehouse6802e342008-05-21 17:03:22 +01001825static void *gfs2_glock_seq_next(struct seq_file *seq, void *iter_ptr,
Robert Peterson7c52b162007-03-16 10:26:37 +00001826 loff_t *pos)
1827{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001828 struct gfs2_glock_iter *gi = seq->private;
Robert Peterson7c52b162007-03-16 10:26:37 +00001829
1830 (*pos)++;
1831
1832 if (gfs2_glock_iter_next(gi)) {
1833 gfs2_glock_iter_free(gi);
1834 return NULL;
1835 }
1836
Steven Whitehouse6802e342008-05-21 17:03:22 +01001837 return gi->gl;
Robert Peterson7c52b162007-03-16 10:26:37 +00001838}
1839
Steven Whitehouse6802e342008-05-21 17:03:22 +01001840static void gfs2_glock_seq_stop(struct seq_file *seq, void *iter_ptr)
Robert Peterson7c52b162007-03-16 10:26:37 +00001841{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001842 struct gfs2_glock_iter *gi = seq->private;
1843 gfs2_glock_iter_free(gi);
Robert Peterson7c52b162007-03-16 10:26:37 +00001844}
1845
Steven Whitehouse6802e342008-05-21 17:03:22 +01001846static int gfs2_glock_seq_show(struct seq_file *seq, void *iter_ptr)
Robert Peterson7c52b162007-03-16 10:26:37 +00001847{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001848 return dump_glock(seq, iter_ptr);
Robert Peterson7c52b162007-03-16 10:26:37 +00001849}
1850
Denis Cheng4ef29002007-07-31 18:31:11 +08001851static const struct seq_operations gfs2_glock_seq_ops = {
Robert Peterson7c52b162007-03-16 10:26:37 +00001852 .start = gfs2_glock_seq_start,
1853 .next = gfs2_glock_seq_next,
1854 .stop = gfs2_glock_seq_stop,
1855 .show = gfs2_glock_seq_show,
1856};
1857
1858static int gfs2_debugfs_open(struct inode *inode, struct file *file)
1859{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001860 int ret = seq_open_private(file, &gfs2_glock_seq_ops,
1861 sizeof(struct gfs2_glock_iter));
1862 if (ret == 0) {
1863 struct seq_file *seq = file->private_data;
1864 struct gfs2_glock_iter *gi = seq->private;
1865 gi->sdp = inode->i_private;
1866 }
1867 return ret;
Robert Peterson7c52b162007-03-16 10:26:37 +00001868}
1869
1870static const struct file_operations gfs2_debug_fops = {
1871 .owner = THIS_MODULE,
1872 .open = gfs2_debugfs_open,
1873 .read = seq_read,
1874 .llseek = seq_lseek,
Steven Whitehouse6802e342008-05-21 17:03:22 +01001875 .release = seq_release_private,
Robert Peterson7c52b162007-03-16 10:26:37 +00001876};
1877
1878int gfs2_create_debugfs_file(struct gfs2_sbd *sdp)
1879{
Robert Peterson5f882092007-04-18 11:41:11 -05001880 sdp->debugfs_dir = debugfs_create_dir(sdp->sd_table_name, gfs2_root);
1881 if (!sdp->debugfs_dir)
1882 return -ENOMEM;
1883 sdp->debugfs_dentry_glocks = debugfs_create_file("glocks",
1884 S_IFREG | S_IRUGO,
1885 sdp->debugfs_dir, sdp,
1886 &gfs2_debug_fops);
1887 if (!sdp->debugfs_dentry_glocks)
Robert Peterson7c52b162007-03-16 10:26:37 +00001888 return -ENOMEM;
1889
1890 return 0;
1891}
1892
1893void gfs2_delete_debugfs_file(struct gfs2_sbd *sdp)
1894{
Robert Peterson5f882092007-04-18 11:41:11 -05001895 if (sdp && sdp->debugfs_dir) {
1896 if (sdp->debugfs_dentry_glocks) {
1897 debugfs_remove(sdp->debugfs_dentry_glocks);
1898 sdp->debugfs_dentry_glocks = NULL;
1899 }
1900 debugfs_remove(sdp->debugfs_dir);
1901 sdp->debugfs_dir = NULL;
1902 }
Robert Peterson7c52b162007-03-16 10:26:37 +00001903}
1904
1905int gfs2_register_debugfs(void)
1906{
1907 gfs2_root = debugfs_create_dir("gfs2", NULL);
1908 return gfs2_root ? 0 : -ENOMEM;
1909}
1910
1911void gfs2_unregister_debugfs(void)
1912{
1913 debugfs_remove(gfs2_root);
Robert Peterson5f882092007-04-18 11:41:11 -05001914 gfs2_root = NULL;
Robert Peterson7c52b162007-03-16 10:26:37 +00001915}