blob: 88e8a23d0026375c52bf6fd3b69bfd2a87fca598 [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>
Steven Whitehousebc015cb2011-01-19 09:30:01 +000029#include <linux/rcupdate.h>
30#include <linux/rculist_bl.h>
31#include <linux/bit_spinlock.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000032
33#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050034#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000035#include "glock.h"
36#include "glops.h"
37#include "inode.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000038#include "lops.h"
39#include "meta_io.h"
40#include "quota.h"
41#include "super.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050042#include "util.h"
Steven Whitehouse813e0c42008-11-18 13:38:48 +000043#include "bmap.h"
Steven Whitehouse63997772009-06-12 08:49:20 +010044#define CREATE_TRACE_POINTS
45#include "trace_gfs2.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000046
Steven Whitehouse6802e342008-05-21 17:03:22 +010047struct gfs2_glock_iter {
48 int hash; /* hash bucket index */
49 struct gfs2_sbd *sdp; /* incore superblock */
50 struct gfs2_glock *gl; /* current glock struct */
51 char string[512]; /* scratch space */
Robert Peterson7c52b162007-03-16 10:26:37 +000052};
53
David Teiglandb3b94fa2006-01-16 16:50:04 +000054typedef void (*glock_examiner) (struct gfs2_glock * gl);
55
Steven Whitehouse6802e342008-05-21 17:03:22 +010056static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl);
57#define GLOCK_BUG_ON(gl,x) do { if (unlikely(x)) { __dump_glock(NULL, gl); BUG(); } } while(0)
58static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -050059
Robert Peterson7c52b162007-03-16 10:26:37 +000060static struct dentry *gfs2_root;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -050061static struct workqueue_struct *glock_workqueue;
Benjamin Marzinskib94a1702009-07-23 18:52:34 -050062struct workqueue_struct *gfs2_delete_workqueue;
Steven Whitehouse97cc1022008-11-20 13:39:47 +000063static LIST_HEAD(lru_list);
64static atomic_t lru_count = ATOMIC_INIT(0);
Julia Lawalleb8374e2008-12-25 15:35:27 +010065static DEFINE_SPINLOCK(lru_lock);
Adrian Bunk08bc2db2006-04-28 10:59:12 -040066
Steven Whitehouseb6397892006-09-12 10:10:01 -040067#define GFS2_GL_HASH_SHIFT 15
Steven Whitehouse087efdd2006-09-09 16:59:11 -040068#define GFS2_GL_HASH_SIZE (1 << GFS2_GL_HASH_SHIFT)
69#define GFS2_GL_HASH_MASK (GFS2_GL_HASH_SIZE - 1)
70
Steven Whitehousebc015cb2011-01-19 09:30:01 +000071static struct hlist_bl_head gl_hash_table[GFS2_GL_HASH_SIZE];
Robert Peterson04b933f2007-03-23 17:05:15 -050072static struct dentry *gfs2_root;
Steven Whitehouse087efdd2006-09-09 16:59:11 -040073
David Teiglandb3b94fa2006-01-16 16:50:04 +000074/**
David Teiglandb3b94fa2006-01-16 16:50:04 +000075 * 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
Steven Whitehouseb8547852006-09-07 13:12:27 -040081static unsigned int gl_hash(const struct gfs2_sbd *sdp,
82 const struct lm_lockname *name)
David Teiglandb3b94fa2006-01-16 16:50:04 +000083{
84 unsigned int h;
85
Steven Whitehousecd915492006-09-04 12:49:07 -040086 h = jhash(&name->ln_number, sizeof(u64), 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +000087 h = jhash(&name->ln_type, sizeof(unsigned int), h);
Steven Whitehouseb8547852006-09-07 13:12:27 -040088 h = jhash(&sdp, sizeof(struct gfs2_sbd *), h);
David Teiglandb3b94fa2006-01-16 16:50:04 +000089 h &= GFS2_GL_HASH_MASK;
90
91 return h;
92}
93
Steven Whitehousebc015cb2011-01-19 09:30:01 +000094static inline void spin_lock_bucket(unsigned int hash)
David Teiglandb3b94fa2006-01-16 16:50:04 +000095{
Christoph Hellwig1879fd62011-04-25 14:01:36 -040096 hlist_bl_lock(&gl_hash_table[hash]);
Steven Whitehousebc015cb2011-01-19 09:30:01 +000097}
David Teiglandb3b94fa2006-01-16 16:50:04 +000098
Steven Whitehousebc015cb2011-01-19 09:30:01 +000099static inline void spin_unlock_bucket(unsigned int hash)
100{
Christoph Hellwig1879fd62011-04-25 14:01:36 -0400101 hlist_bl_unlock(&gl_hash_table[hash]);
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000102}
103
Steven Whitehousefc0e38d2011-03-09 10:58:04 +0000104static void gfs2_glock_dealloc(struct rcu_head *rcu)
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000105{
106 struct gfs2_glock *gl = container_of(rcu, struct gfs2_glock, gl_rcu);
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000107
108 if (gl->gl_ops->go_flags & GLOF_ASPACE)
109 kmem_cache_free(gfs2_glock_aspace_cachep, gl);
110 else
111 kmem_cache_free(gfs2_glock_cachep, gl);
Steven Whitehousefc0e38d2011-03-09 10:58:04 +0000112}
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000113
Steven Whitehousefc0e38d2011-03-09 10:58:04 +0000114void gfs2_glock_free(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000115{
116 struct gfs2_sbd *sdp = gl->gl_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000117
Steven Whitehousefc0e38d2011-03-09 10:58:04 +0000118 call_rcu(&gl->gl_rcu, gfs2_glock_dealloc);
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000119 if (atomic_dec_and_test(&sdp->sd_glock_disposal))
120 wake_up(&sdp->sd_glock_wait);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000121}
122
123/**
124 * gfs2_glock_hold() - increment reference count on glock
125 * @gl: The glock to hold
126 *
127 */
128
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500129void gfs2_glock_hold(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000130{
Steven Whitehoused8348de2009-02-05 10:12:38 +0000131 GLOCK_BUG_ON(gl, atomic_read(&gl->gl_ref) == 0);
Steven Whitehouse16feb9f2006-09-13 10:43:37 -0400132 atomic_inc(&gl->gl_ref);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000133}
134
135/**
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500136 * demote_ok - Check to see if it's ok to unlock a glock
137 * @gl: the glock
138 *
139 * Returns: 1 if it's ok
140 */
141
142static int demote_ok(const struct gfs2_glock *gl)
143{
144 const struct gfs2_glock_operations *glops = gl->gl_ops;
145
146 if (gl->gl_state == LM_ST_UNLOCKED)
147 return 0;
Steven Whitehousef42ab082011-04-14 16:50:31 +0100148 if (!list_empty(&gl->gl_holders))
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500149 return 0;
150 if (glops->go_demote_ok)
151 return glops->go_demote_ok(gl);
152 return 1;
153}
154
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000155
Steven Whitehouse29687a22011-03-30 16:33:25 +0100156void gfs2_glock_add_to_lru(struct gfs2_glock *gl)
157{
158 spin_lock(&lru_lock);
159
160 if (!list_empty(&gl->gl_lru))
161 list_del_init(&gl->gl_lru);
162 else
163 atomic_inc(&lru_count);
164
165 list_add_tail(&gl->gl_lru, &lru_list);
Steven Whitehouse627c10b2011-04-14 14:09:52 +0100166 set_bit(GLF_LRU, &gl->gl_flags);
Steven Whitehouse29687a22011-03-30 16:33:25 +0100167 spin_unlock(&lru_lock);
168}
169
Steven Whitehousef42ab082011-04-14 16:50:31 +0100170static void gfs2_glock_remove_from_lru(struct gfs2_glock *gl)
171{
172 spin_lock(&lru_lock);
173 if (!list_empty(&gl->gl_lru)) {
174 list_del_init(&gl->gl_lru);
175 atomic_dec(&lru_count);
176 clear_bit(GLF_LRU, &gl->gl_flags);
177 }
178 spin_unlock(&lru_lock);
179}
180
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500181/**
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000182 * __gfs2_glock_schedule_for_reclaim - Add a glock to the reclaim list
Steven Whitehouse97cc1022008-11-20 13:39:47 +0000183 * @gl: the glock
184 *
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000185 * If the glock is demotable, then we add it (or move it) to the end
186 * of the glock LRU list.
Steven Whitehouse97cc1022008-11-20 13:39:47 +0000187 */
188
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000189static void __gfs2_glock_schedule_for_reclaim(struct gfs2_glock *gl)
Steven Whitehouse97cc1022008-11-20 13:39:47 +0000190{
Steven Whitehouse29687a22011-03-30 16:33:25 +0100191 if (demote_ok(gl))
192 gfs2_glock_add_to_lru(gl);
Steven Whitehouse97cc1022008-11-20 13:39:47 +0000193}
194
195/**
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500196 * gfs2_glock_put_nolock() - Decrement reference count on glock
197 * @gl: The glock to put
198 *
199 * This function should only be used if the caller has its own reference
200 * to the glock, in addition to the one it is dropping.
201 */
202
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500203void gfs2_glock_put_nolock(struct gfs2_glock *gl)
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500204{
205 if (atomic_dec_and_test(&gl->gl_ref))
206 GLOCK_BUG_ON(gl, 1);
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500207}
208
209/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000210 * gfs2_glock_put() - Decrement reference count on glock
211 * @gl: The glock to put
212 *
213 */
214
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000215void gfs2_glock_put(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000216{
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000217 struct gfs2_sbd *sdp = gl->gl_sbd;
218 struct address_space *mapping = gfs2_glock2aspace(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000219
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000220 if (atomic_dec_and_test(&gl->gl_ref)) {
221 spin_lock_bucket(gl->gl_hash);
222 hlist_bl_del_rcu(&gl->gl_list);
223 spin_unlock_bucket(gl->gl_hash);
Steven Whitehousef42ab082011-04-14 16:50:31 +0100224 gfs2_glock_remove_from_lru(gl);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100225 GLOCK_BUG_ON(gl, !list_empty(&gl->gl_holders));
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000226 GLOCK_BUG_ON(gl, mapping && mapping->nrpages);
227 trace_gfs2_glock_put(gl);
228 sdp->sd_lockstruct.ls_ops->lm_put_lock(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000229 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000230}
231
232/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000233 * search_bucket() - Find struct gfs2_glock by lock number
234 * @bucket: the bucket to search
235 * @name: The lock name
236 *
237 * Returns: NULL, or the struct gfs2_glock with the requested number
238 */
239
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400240static struct gfs2_glock *search_bucket(unsigned int hash,
Steven Whitehouse899be4d2006-08-30 12:50:28 -0400241 const struct gfs2_sbd *sdp,
Steven Whitehoused6a53722006-08-30 11:16:23 -0400242 const struct lm_lockname *name)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000243{
244 struct gfs2_glock *gl;
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000245 struct hlist_bl_node *h;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000246
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000247 hlist_bl_for_each_entry_rcu(gl, h, &gl_hash_table[hash], gl_list) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000248 if (!lm_name_equal(&gl->gl_name, name))
249 continue;
Steven Whitehouse899be4d2006-08-30 12:50:28 -0400250 if (gl->gl_sbd != sdp)
251 continue;
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000252 if (atomic_inc_not_zero(&gl->gl_ref))
253 return gl;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000254 }
255
256 return NULL;
257}
258
259/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100260 * may_grant - check if its ok to grant a new lock
261 * @gl: The glock
262 * @gh: The lock request which we wish to grant
263 *
264 * Returns: true if its ok to grant the lock
265 */
266
267static inline int may_grant(const struct gfs2_glock *gl, const struct gfs2_holder *gh)
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500268{
Steven Whitehouse6802e342008-05-21 17:03:22 +0100269 const struct gfs2_holder *gh_head = list_entry(gl->gl_holders.next, const struct gfs2_holder, gh_list);
270 if ((gh->gh_state == LM_ST_EXCLUSIVE ||
271 gh_head->gh_state == LM_ST_EXCLUSIVE) && gh != gh_head)
272 return 0;
273 if (gl->gl_state == gh->gh_state)
274 return 1;
275 if (gh->gh_flags & GL_EXACT)
276 return 0;
Steven Whitehouse209806a2008-07-07 10:07:28 +0100277 if (gl->gl_state == LM_ST_EXCLUSIVE) {
278 if (gh->gh_state == LM_ST_SHARED && gh_head->gh_state == LM_ST_SHARED)
279 return 1;
280 if (gh->gh_state == LM_ST_DEFERRED && gh_head->gh_state == LM_ST_DEFERRED)
281 return 1;
282 }
Steven Whitehouse6802e342008-05-21 17:03:22 +0100283 if (gl->gl_state != LM_ST_UNLOCKED && (gh->gh_flags & LM_FLAG_ANY))
284 return 1;
285 return 0;
286}
287
288static void gfs2_holder_wake(struct gfs2_holder *gh)
289{
290 clear_bit(HIF_WAIT, &gh->gh_iflags);
291 smp_mb__after_clear_bit();
292 wake_up_bit(&gh->gh_iflags, HIF_WAIT);
293}
294
295/**
Steven Whitehoused5341a92010-07-23 14:05:51 +0100296 * do_error - Something unexpected has happened during a lock request
297 *
298 */
299
300static inline void do_error(struct gfs2_glock *gl, const int ret)
301{
302 struct gfs2_holder *gh, *tmp;
303
304 list_for_each_entry_safe(gh, tmp, &gl->gl_holders, gh_list) {
305 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
306 continue;
307 if (ret & LM_OUT_ERROR)
308 gh->gh_error = -EIO;
309 else if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))
310 gh->gh_error = GLR_TRYFAILED;
311 else
312 continue;
313 list_del_init(&gh->gh_list);
314 trace_gfs2_glock_queue(gh, 0);
315 gfs2_holder_wake(gh);
316 }
317}
318
319/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100320 * do_promote - promote as many requests as possible on the current queue
321 * @gl: The glock
322 *
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000323 * Returns: 1 if there is a blocked holder at the head of the list, or 2
324 * if a type specific operation is underway.
Steven Whitehouse6802e342008-05-21 17:03:22 +0100325 */
326
327static int do_promote(struct gfs2_glock *gl)
Harvey Harrison55ba4742008-10-24 11:31:12 -0700328__releases(&gl->gl_spin)
329__acquires(&gl->gl_spin)
Steven Whitehouse6802e342008-05-21 17:03:22 +0100330{
331 const struct gfs2_glock_operations *glops = gl->gl_ops;
332 struct gfs2_holder *gh, *tmp;
333 int ret;
334
335restart:
336 list_for_each_entry_safe(gh, tmp, &gl->gl_holders, gh_list) {
337 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
338 continue;
339 if (may_grant(gl, gh)) {
340 if (gh->gh_list.prev == &gl->gl_holders &&
341 glops->go_lock) {
342 spin_unlock(&gl->gl_spin);
343 /* FIXME: eliminate this eventually */
344 ret = glops->go_lock(gh);
345 spin_lock(&gl->gl_spin);
346 if (ret) {
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000347 if (ret == 1)
348 return 2;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100349 gh->gh_error = ret;
350 list_del_init(&gh->gh_list);
Steven Whitehouse63997772009-06-12 08:49:20 +0100351 trace_gfs2_glock_queue(gh, 0);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100352 gfs2_holder_wake(gh);
353 goto restart;
354 }
355 set_bit(HIF_HOLDER, &gh->gh_iflags);
Steven Whitehouse63997772009-06-12 08:49:20 +0100356 trace_gfs2_promote(gh, 1);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100357 gfs2_holder_wake(gh);
358 goto restart;
359 }
360 set_bit(HIF_HOLDER, &gh->gh_iflags);
Steven Whitehouse63997772009-06-12 08:49:20 +0100361 trace_gfs2_promote(gh, 0);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100362 gfs2_holder_wake(gh);
363 continue;
364 }
365 if (gh->gh_list.prev == &gl->gl_holders)
366 return 1;
Steven Whitehoused5341a92010-07-23 14:05:51 +0100367 do_error(gl, 0);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100368 break;
369 }
370 return 0;
371}
372
373/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100374 * find_first_waiter - find the first gh that's waiting for the glock
375 * @gl: the glock
376 */
377
378static inline struct gfs2_holder *find_first_waiter(const struct gfs2_glock *gl)
379{
380 struct gfs2_holder *gh;
381
382 list_for_each_entry(gh, &gl->gl_holders, gh_list) {
383 if (!test_bit(HIF_HOLDER, &gh->gh_iflags))
384 return gh;
385 }
386 return NULL;
387}
388
389/**
390 * state_change - record that the glock is now in a different state
391 * @gl: the glock
392 * @new_state the new state
393 *
394 */
395
396static void state_change(struct gfs2_glock *gl, unsigned int new_state)
397{
398 int held1, held2;
399
400 held1 = (gl->gl_state != LM_ST_UNLOCKED);
401 held2 = (new_state != LM_ST_UNLOCKED);
402
403 if (held1 != held2) {
404 if (held2)
405 gfs2_glock_hold(gl);
406 else
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500407 gfs2_glock_put_nolock(gl);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100408 }
Steven Whitehouse7b5e3d52010-09-03 09:39:20 +0100409 if (held1 && held2 && list_empty(&gl->gl_holders))
410 clear_bit(GLF_QUEUED, &gl->gl_flags);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100411
Bob Peterson7cf8dcd2011-06-15 11:41:48 -0400412 if (new_state != gl->gl_target)
413 /* shorten our minimum hold time */
414 gl->gl_hold_time = max(gl->gl_hold_time - GL_GLOCK_HOLD_DECR,
415 GL_GLOCK_MIN_HOLD);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100416 gl->gl_state = new_state;
417 gl->gl_tchange = jiffies;
418}
419
420static void gfs2_demote_wake(struct gfs2_glock *gl)
421{
422 gl->gl_demote_state = LM_ST_EXCLUSIVE;
423 clear_bit(GLF_DEMOTE, &gl->gl_flags);
424 smp_mb__after_clear_bit();
425 wake_up_bit(&gl->gl_flags, GLF_DEMOTE);
426}
427
428/**
429 * finish_xmote - The DLM has replied to one of our lock requests
430 * @gl: The glock
431 * @ret: The status from the DLM
432 *
433 */
434
435static void finish_xmote(struct gfs2_glock *gl, unsigned int ret)
436{
437 const struct gfs2_glock_operations *glops = gl->gl_ops;
438 struct gfs2_holder *gh;
439 unsigned state = ret & LM_OUT_ST_MASK;
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000440 int rv;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500441
442 spin_lock(&gl->gl_spin);
Steven Whitehouse63997772009-06-12 08:49:20 +0100443 trace_gfs2_glock_state_change(gl, state);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100444 state_change(gl, state);
445 gh = find_first_waiter(gl);
446
447 /* Demote to UN request arrived during demote to SH or DF */
448 if (test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags) &&
449 state != LM_ST_UNLOCKED && gl->gl_demote_state == LM_ST_UNLOCKED)
450 gl->gl_target = LM_ST_UNLOCKED;
451
452 /* Check for state != intended state */
453 if (unlikely(state != gl->gl_target)) {
454 if (gh && !test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags)) {
455 /* move to back of queue and try next entry */
456 if (ret & LM_OUT_CANCELED) {
457 if ((gh->gh_flags & LM_FLAG_PRIORITY) == 0)
458 list_move_tail(&gh->gh_list, &gl->gl_holders);
459 gh = find_first_waiter(gl);
460 gl->gl_target = gh->gh_state;
461 goto retry;
462 }
463 /* Some error or failed "try lock" - report it */
464 if ((ret & LM_OUT_ERROR) ||
465 (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) {
466 gl->gl_target = gl->gl_state;
467 do_error(gl, ret);
468 goto out;
469 }
470 }
471 switch(state) {
472 /* Unlocked due to conversion deadlock, try again */
473 case LM_ST_UNLOCKED:
474retry:
475 do_xmote(gl, gh, gl->gl_target);
476 break;
477 /* Conversion fails, unlock and try again */
478 case LM_ST_SHARED:
479 case LM_ST_DEFERRED:
480 do_xmote(gl, gh, LM_ST_UNLOCKED);
481 break;
482 default: /* Everything else */
483 printk(KERN_ERR "GFS2: wanted %u got %u\n", gl->gl_target, state);
484 GLOCK_BUG_ON(gl, 1);
485 }
486 spin_unlock(&gl->gl_spin);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100487 return;
488 }
489
490 /* Fast path - we got what we asked for */
491 if (test_and_clear_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags))
492 gfs2_demote_wake(gl);
493 if (state != LM_ST_UNLOCKED) {
494 if (glops->go_xmote_bh) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100495 spin_unlock(&gl->gl_spin);
496 rv = glops->go_xmote_bh(gl, gh);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100497 spin_lock(&gl->gl_spin);
498 if (rv) {
499 do_error(gl, rv);
500 goto out;
501 }
502 }
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000503 rv = do_promote(gl);
504 if (rv == 2)
505 goto out_locked;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100506 }
507out:
508 clear_bit(GLF_LOCK, &gl->gl_flags);
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000509out_locked:
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500510 spin_unlock(&gl->gl_spin);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500511}
512
Steven Whitehouse6802e342008-05-21 17:03:22 +0100513/**
514 * do_xmote - Calls the DLM to change the state of a lock
515 * @gl: The lock state
516 * @gh: The holder (only for promotes)
517 * @target: The target lock state
518 *
519 */
520
521static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target)
Harvey Harrison55ba4742008-10-24 11:31:12 -0700522__releases(&gl->gl_spin)
523__acquires(&gl->gl_spin)
Steven Whitehouse6802e342008-05-21 17:03:22 +0100524{
525 const struct gfs2_glock_operations *glops = gl->gl_ops;
526 struct gfs2_sbd *sdp = gl->gl_sbd;
527 unsigned int lck_flags = gh ? gh->gh_flags : 0;
528 int ret;
529
530 lck_flags &= (LM_FLAG_TRY | LM_FLAG_TRY_1CB | LM_FLAG_NOEXP |
531 LM_FLAG_PRIORITY);
Steven Whitehouse921169c2010-11-29 12:50:38 +0000532 GLOCK_BUG_ON(gl, gl->gl_state == target);
533 GLOCK_BUG_ON(gl, gl->gl_state == gl->gl_target);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100534 if ((target == LM_ST_UNLOCKED || target == LM_ST_DEFERRED) &&
535 glops->go_inval) {
536 set_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);
537 do_error(gl, 0); /* Fail queued try locks */
538 }
Steven Whitehouse47a25382010-11-30 15:49:31 +0000539 gl->gl_req = target;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100540 spin_unlock(&gl->gl_spin);
541 if (glops->go_xmote_th)
542 glops->go_xmote_th(gl);
543 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags))
544 glops->go_inval(gl, target == LM_ST_DEFERRED ? 0 : DIO_METADATA);
545 clear_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);
546
547 gfs2_glock_hold(gl);
Steven Whitehouse921169c2010-11-29 12:50:38 +0000548 if (sdp->sd_lockstruct.ls_ops->lm_lock) {
549 /* lock_dlm */
550 ret = sdp->sd_lockstruct.ls_ops->lm_lock(gl, target, lck_flags);
551 GLOCK_BUG_ON(gl, ret);
552 } else { /* lock_nolock */
553 finish_xmote(gl, target);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100554 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
555 gfs2_glock_put(gl);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100556 }
Steven Whitehouse921169c2010-11-29 12:50:38 +0000557
Steven Whitehouse6802e342008-05-21 17:03:22 +0100558 spin_lock(&gl->gl_spin);
559}
560
561/**
562 * find_first_holder - find the first "holder" gh
563 * @gl: the glock
564 */
565
566static inline struct gfs2_holder *find_first_holder(const struct gfs2_glock *gl)
567{
568 struct gfs2_holder *gh;
569
570 if (!list_empty(&gl->gl_holders)) {
571 gh = list_entry(gl->gl_holders.next, struct gfs2_holder, gh_list);
572 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
573 return gh;
574 }
575 return NULL;
576}
577
578/**
579 * run_queue - do all outstanding tasks related to a glock
580 * @gl: The glock in question
581 * @nonblock: True if we must not block in run_queue
582 *
583 */
584
585static void run_queue(struct gfs2_glock *gl, const int nonblock)
Harvey Harrison55ba4742008-10-24 11:31:12 -0700586__releases(&gl->gl_spin)
587__acquires(&gl->gl_spin)
Steven Whitehouse6802e342008-05-21 17:03:22 +0100588{
589 struct gfs2_holder *gh = NULL;
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000590 int ret;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100591
592 if (test_and_set_bit(GLF_LOCK, &gl->gl_flags))
593 return;
594
595 GLOCK_BUG_ON(gl, test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags));
596
597 if (test_bit(GLF_DEMOTE, &gl->gl_flags) &&
598 gl->gl_demote_state != gl->gl_state) {
599 if (find_first_holder(gl))
Steven Whitehoused8348de2009-02-05 10:12:38 +0000600 goto out_unlock;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100601 if (nonblock)
602 goto out_sched;
603 set_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags);
Steven Whitehouse265d529c2008-07-07 10:02:36 +0100604 GLOCK_BUG_ON(gl, gl->gl_demote_state == LM_ST_EXCLUSIVE);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100605 gl->gl_target = gl->gl_demote_state;
606 } else {
607 if (test_bit(GLF_DEMOTE, &gl->gl_flags))
608 gfs2_demote_wake(gl);
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000609 ret = do_promote(gl);
610 if (ret == 0)
Steven Whitehoused8348de2009-02-05 10:12:38 +0000611 goto out_unlock;
Steven Whitehouse813e0c42008-11-18 13:38:48 +0000612 if (ret == 2)
Steven Whitehousea228df62009-04-07 14:01:34 +0100613 goto out;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100614 gh = find_first_waiter(gl);
615 gl->gl_target = gh->gh_state;
616 if (!(gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)))
617 do_error(gl, 0); /* Fail queued try locks */
618 }
619 do_xmote(gl, gh, gl->gl_target);
Steven Whitehousea228df62009-04-07 14:01:34 +0100620out:
Steven Whitehouse6802e342008-05-21 17:03:22 +0100621 return;
622
623out_sched:
Steven Whitehouse7e71c552009-09-22 10:56:16 +0100624 clear_bit(GLF_LOCK, &gl->gl_flags);
625 smp_mb__after_clear_bit();
Steven Whitehouse6802e342008-05-21 17:03:22 +0100626 gfs2_glock_hold(gl);
627 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
Benjamin Marzinski8ff22a62009-07-10 18:04:24 -0500628 gfs2_glock_put_nolock(gl);
Steven Whitehouse7e71c552009-09-22 10:56:16 +0100629 return;
630
Steven Whitehoused8348de2009-02-05 10:12:38 +0000631out_unlock:
Steven Whitehouse6802e342008-05-21 17:03:22 +0100632 clear_bit(GLF_LOCK, &gl->gl_flags);
Steven Whitehouse7e71c552009-09-22 10:56:16 +0100633 smp_mb__after_clear_bit();
634 return;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100635}
636
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500637static void delete_work_func(struct work_struct *work)
638{
639 struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_delete);
640 struct gfs2_sbd *sdp = gl->gl_sbd;
Steven Whitehouse044b9412010-11-03 20:01:07 +0000641 struct gfs2_inode *ip;
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500642 struct inode *inode;
Steven Whitehouse044b9412010-11-03 20:01:07 +0000643 u64 no_addr = gl->gl_name.ln_number;
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500644
Steven Whitehouse044b9412010-11-03 20:01:07 +0000645 ip = gl->gl_object;
646 /* Note: Unsafe to dereference ip as we don't hold right refs/locks */
647
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500648 if (ip)
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100649 inode = gfs2_ilookup(sdp->sd_vfs, no_addr, 1);
Steven Whitehouse044b9412010-11-03 20:01:07 +0000650 else
651 inode = gfs2_lookup_by_inum(sdp, no_addr, NULL, GFS2_BLKST_UNLINKED);
652 if (inode && !IS_ERR(inode)) {
653 d_prune_aliases(inode);
654 iput(inode);
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500655 }
656 gfs2_glock_put(gl);
657}
658
Steven Whitehouse6802e342008-05-21 17:03:22 +0100659static void glock_work_func(struct work_struct *work)
660{
661 unsigned long delay = 0;
662 struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_work.work);
Steven Whitehouse26bb7502009-11-27 10:31:11 +0000663 int drop_ref = 0;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100664
Steven Whitehouse26bb7502009-11-27 10:31:11 +0000665 if (test_and_clear_bit(GLF_REPLY_PENDING, &gl->gl_flags)) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100666 finish_xmote(gl, gl->gl_reply);
Steven Whitehouse26bb7502009-11-27 10:31:11 +0000667 drop_ref = 1;
668 }
Steven Whitehouse6802e342008-05-21 17:03:22 +0100669 spin_lock(&gl->gl_spin);
Bob Petersonf90e5b52011-05-24 10:44:42 -0400670 if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
Steven Whitehouse265d529c2008-07-07 10:02:36 +0100671 gl->gl_state != LM_ST_UNLOCKED &&
672 gl->gl_demote_state != LM_ST_EXCLUSIVE) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100673 unsigned long holdtime, now = jiffies;
Bob Petersonf90e5b52011-05-24 10:44:42 -0400674
Bob Peterson7cf8dcd2011-06-15 11:41:48 -0400675 holdtime = gl->gl_tchange + gl->gl_hold_time;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100676 if (time_before(now, holdtime))
677 delay = holdtime - now;
Bob Petersonf90e5b52011-05-24 10:44:42 -0400678
679 if (!delay) {
680 clear_bit(GLF_PENDING_DEMOTE, &gl->gl_flags);
681 set_bit(GLF_DEMOTE, &gl->gl_flags);
682 }
Steven Whitehouse6802e342008-05-21 17:03:22 +0100683 }
684 run_queue(gl, 0);
685 spin_unlock(&gl->gl_spin);
Bob Peterson7cf8dcd2011-06-15 11:41:48 -0400686 if (!delay)
Steven Whitehouse6802e342008-05-21 17:03:22 +0100687 gfs2_glock_put(gl);
Bob Peterson7cf8dcd2011-06-15 11:41:48 -0400688 else {
689 if (gl->gl_name.ln_type != LM_TYPE_INODE)
690 delay = 0;
691 if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
692 gfs2_glock_put(gl);
693 }
Steven Whitehouse26bb7502009-11-27 10:31:11 +0000694 if (drop_ref)
695 gfs2_glock_put(gl);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100696}
697
David Teiglandb3b94fa2006-01-16 16:50:04 +0000698/**
699 * gfs2_glock_get() - Get a glock, or create one if one doesn't exist
700 * @sdp: The GFS2 superblock
701 * @number: the lock number
702 * @glops: The glock_operations to use
703 * @create: If 0, don't create the glock if it doesn't exist
704 * @glp: the glock is returned here
705 *
706 * This does not lock a glock, just finds/creates structures for one.
707 *
708 * Returns: errno
709 */
710
Steven Whitehousecd915492006-09-04 12:49:07 -0400711int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400712 const struct gfs2_glock_operations *glops, int create,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000713 struct gfs2_glock **glp)
714{
Steven Whitehouse009d8512009-12-08 12:12:13 +0000715 struct super_block *s = sdp->sd_vfs;
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400716 struct lm_lockname name = { .ln_number = number, .ln_type = glops->go_type };
David Teiglandb3b94fa2006-01-16 16:50:04 +0000717 struct gfs2_glock *gl, *tmp;
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400718 unsigned int hash = gl_hash(sdp, &name);
Steven Whitehouse009d8512009-12-08 12:12:13 +0000719 struct address_space *mapping;
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000720 struct kmem_cache *cachep;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000721
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000722 rcu_read_lock();
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400723 gl = search_bucket(hash, sdp, &name);
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000724 rcu_read_unlock();
David Teiglandb3b94fa2006-01-16 16:50:04 +0000725
Steven Whitehouse64d576b2009-02-12 13:31:58 +0000726 *glp = gl;
727 if (gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000728 return 0;
Steven Whitehouse64d576b2009-02-12 13:31:58 +0000729 if (!create)
730 return -ENOENT;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000731
Steven Whitehouse009d8512009-12-08 12:12:13 +0000732 if (glops->go_flags & GLOF_ASPACE)
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000733 cachep = gfs2_glock_aspace_cachep;
Steven Whitehouse009d8512009-12-08 12:12:13 +0000734 else
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000735 cachep = gfs2_glock_cachep;
736 gl = kmem_cache_alloc(cachep, GFP_KERNEL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000737 if (!gl)
738 return -ENOMEM;
739
Steven Whitehouse8f052282010-01-29 15:21:27 +0000740 atomic_inc(&sdp->sd_glock_disposal);
Steven Whitehouseec45d9f2006-08-30 10:36:52 -0400741 gl->gl_flags = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000742 gl->gl_name = name;
Steven Whitehouse16feb9f2006-09-13 10:43:37 -0400743 atomic_set(&gl->gl_ref, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000744 gl->gl_state = LM_ST_UNLOCKED;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100745 gl->gl_target = LM_ST_UNLOCKED;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500746 gl->gl_demote_state = LM_ST_EXCLUSIVE;
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400747 gl->gl_hash = hash;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000748 gl->gl_ops = glops;
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000749 snprintf(gl->gl_strname, GDLM_STRNAME_BYTES, "%8x%16llx", name.ln_type, (unsigned long long)number);
750 memset(&gl->gl_lksb, 0, sizeof(struct dlm_lksb));
751 gl->gl_lksb.sb_lvbptr = gl->gl_lvb;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500752 gl->gl_tchange = jiffies;
Steven Whitehouseec45d9f2006-08-30 10:36:52 -0400753 gl->gl_object = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000754 gl->gl_sbd = sdp;
Bob Peterson7cf8dcd2011-06-15 11:41:48 -0400755 gl->gl_hold_time = GL_GLOCK_DFT_HOLD;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500756 INIT_DELAYED_WORK(&gl->gl_work, glock_work_func);
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500757 INIT_WORK(&gl->gl_delete, delete_work_func);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000758
Steven Whitehouse009d8512009-12-08 12:12:13 +0000759 mapping = gfs2_glock2aspace(gl);
760 if (mapping) {
761 mapping->a_ops = &gfs2_meta_aops;
762 mapping->host = s->s_bdev->bd_inode;
763 mapping->flags = 0;
764 mapping_set_gfp_mask(mapping, GFP_NOFS);
765 mapping->assoc_mapping = NULL;
766 mapping->backing_dev_info = s->s_bdi;
767 mapping->writeback_index = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000768 }
769
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000770 spin_lock_bucket(hash);
Steven Whitehouse37b2fa62006-09-08 13:35:56 -0400771 tmp = search_bucket(hash, sdp, &name);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000772 if (tmp) {
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000773 spin_unlock_bucket(hash);
774 kmem_cache_free(cachep, gl);
Steven Whitehousefc0e38d2011-03-09 10:58:04 +0000775 atomic_dec(&sdp->sd_glock_disposal);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000776 gl = tmp;
777 } else {
Steven Whitehousebc015cb2011-01-19 09:30:01 +0000778 hlist_bl_add_head_rcu(&gl->gl_list, &gl_hash_table[hash]);
779 spin_unlock_bucket(hash);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000780 }
781
782 *glp = gl;
783
784 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000785}
786
787/**
788 * gfs2_holder_init - initialize a struct gfs2_holder in the default way
789 * @gl: the glock
790 * @state: the state we're requesting
791 * @flags: the modifier flags
792 * @gh: the holder structure
793 *
794 */
795
Steven Whitehouse190562b2006-04-20 16:57:23 -0400796void gfs2_holder_init(struct gfs2_glock *gl, unsigned int state, unsigned flags,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000797 struct gfs2_holder *gh)
798{
799 INIT_LIST_HEAD(&gh->gh_list);
800 gh->gh_gl = gl;
Steven Whitehoused0dc80d2006-03-29 14:36:49 -0500801 gh->gh_ip = (unsigned long)__builtin_return_address(0);
Pavel Emelyanovb1e058d2008-02-07 00:13:19 -0800802 gh->gh_owner_pid = get_pid(task_pid(current));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000803 gh->gh_state = state;
804 gh->gh_flags = flags;
805 gh->gh_error = 0;
806 gh->gh_iflags = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000807 gfs2_glock_hold(gl);
808}
809
810/**
811 * gfs2_holder_reinit - reinitialize a struct gfs2_holder so we can requeue it
812 * @state: the state we're requesting
813 * @flags: the modifier flags
814 * @gh: the holder structure
815 *
816 * Don't mess with the glock.
817 *
818 */
819
Steven Whitehouse190562b2006-04-20 16:57:23 -0400820void gfs2_holder_reinit(unsigned int state, unsigned flags, struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000821{
822 gh->gh_state = state;
Steven Whitehouse579b78a2006-04-26 14:58:26 -0400823 gh->gh_flags = flags;
Steven Whitehouse3b8249f2007-03-16 09:40:31 +0000824 gh->gh_iflags = 0;
Steven Whitehoused0dc80d2006-03-29 14:36:49 -0500825 gh->gh_ip = (unsigned long)__builtin_return_address(0);
Bob Peterson1a0eae82010-04-14 11:58:16 -0400826 if (gh->gh_owner_pid)
827 put_pid(gh->gh_owner_pid);
828 gh->gh_owner_pid = get_pid(task_pid(current));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000829}
830
831/**
832 * gfs2_holder_uninit - uninitialize a holder structure (drop glock reference)
833 * @gh: the holder structure
834 *
835 */
836
837void gfs2_holder_uninit(struct gfs2_holder *gh)
838{
Pavel Emelyanovb1e058d2008-02-07 00:13:19 -0800839 put_pid(gh->gh_owner_pid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000840 gfs2_glock_put(gh->gh_gl);
841 gh->gh_gl = NULL;
Steven Whitehoused0dc80d2006-03-29 14:36:49 -0500842 gh->gh_ip = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000843}
844
Steven Whitehousefe64d512009-05-19 10:01:18 +0100845/**
846 * gfs2_glock_holder_wait
847 * @word: unused
848 *
849 * This function and gfs2_glock_demote_wait both show up in the WCHAN
850 * field. Thus I've separated these otherwise identical functions in
851 * order to be more informative to the user.
852 */
853
854static int gfs2_glock_holder_wait(void *word)
Steven Whitehousefee852e2007-01-17 15:33:23 +0000855{
856 schedule();
857 return 0;
858}
859
Steven Whitehousefe64d512009-05-19 10:01:18 +0100860static int gfs2_glock_demote_wait(void *word)
861{
862 schedule();
863 return 0;
864}
865
Steven Whitehousefee852e2007-01-17 15:33:23 +0000866static void wait_on_holder(struct gfs2_holder *gh)
867{
Bob Peterson7cf8dcd2011-06-15 11:41:48 -0400868 unsigned long time1 = jiffies;
869
Steven Whitehousefee852e2007-01-17 15:33:23 +0000870 might_sleep();
Steven Whitehousefe64d512009-05-19 10:01:18 +0100871 wait_on_bit(&gh->gh_iflags, HIF_WAIT, gfs2_glock_holder_wait, TASK_UNINTERRUPTIBLE);
Bob Peterson7cf8dcd2011-06-15 11:41:48 -0400872 if (time_after(jiffies, time1 + HZ)) /* have we waited > a second? */
873 /* Lengthen the minimum hold time. */
874 gh->gh_gl->gl_hold_time = min(gh->gh_gl->gl_hold_time +
875 GL_GLOCK_HOLD_INCR,
876 GL_GLOCK_MAX_HOLD);
Abhijith Dasd93cfa92007-06-11 08:22:32 +0100877}
878
Abhijith Dasd93cfa92007-06-11 08:22:32 +0100879static void wait_on_demote(struct gfs2_glock *gl)
880{
881 might_sleep();
Steven Whitehousefe64d512009-05-19 10:01:18 +0100882 wait_on_bit(&gl->gl_flags, GLF_DEMOTE, gfs2_glock_demote_wait, TASK_UNINTERRUPTIBLE);
Steven Whitehousefee852e2007-01-17 15:33:23 +0000883}
884
David Teiglandb3b94fa2006-01-16 16:50:04 +0000885/**
Steven Whitehouse3b8249f2007-03-16 09:40:31 +0000886 * handle_callback - process a demote request
David Teiglandb3b94fa2006-01-16 16:50:04 +0000887 * @gl: the glock
888 * @state: the state the caller wants us to change to
889 *
Steven Whitehouse3b8249f2007-03-16 09:40:31 +0000890 * There are only two requests that we are going to see in actual
891 * practise: LM_ST_SHARED and LM_ST_UNLOCKED
David Teiglandb3b94fa2006-01-16 16:50:04 +0000892 */
893
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500894static void handle_callback(struct gfs2_glock *gl, unsigned int state,
Steven Whitehouse97cc1022008-11-20 13:39:47 +0000895 unsigned long delay)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000896{
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500897 int bit = delay ? GLF_PENDING_DEMOTE : GLF_DEMOTE;
898
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -0500899 set_bit(bit, &gl->gl_flags);
900 if (gl->gl_demote_state == LM_ST_EXCLUSIVE) {
Steven Whitehouse3b8249f2007-03-16 09:40:31 +0000901 gl->gl_demote_state = state;
902 gl->gl_demote_time = jiffies;
Josef Whiter26caee52007-07-23 10:02:40 +0100903 } else if (gl->gl_demote_state != LM_ST_UNLOCKED &&
904 gl->gl_demote_state != state) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100905 gl->gl_demote_state = LM_ST_UNLOCKED;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000906 }
Benjamin Marzinskib94a1702009-07-23 18:52:34 -0500907 if (gl->gl_ops->go_callback)
908 gl->gl_ops->go_callback(gl);
Steven Whitehouse63997772009-06-12 08:49:20 +0100909 trace_gfs2_demote_rq(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000910}
911
912/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100913 * gfs2_glock_wait - wait on a glock acquisition
David Teiglandb3b94fa2006-01-16 16:50:04 +0000914 * @gh: the glock holder
915 *
916 * Returns: 0 on success
917 */
918
Steven Whitehouse6802e342008-05-21 17:03:22 +0100919int gfs2_glock_wait(struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000920{
Steven Whitehousefee852e2007-01-17 15:33:23 +0000921 wait_on_holder(gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000922 return gh->gh_error;
923}
924
Steven Whitehouse6802e342008-05-21 17:03:22 +0100925void gfs2_print_dbg(struct seq_file *seq, const char *fmt, ...)
Robert Peterson7c52b162007-03-16 10:26:37 +0000926{
Joe Perches5e690692010-11-09 16:35:20 -0800927 struct va_format vaf;
Robert Peterson7c52b162007-03-16 10:26:37 +0000928 va_list args;
929
930 va_start(args, fmt);
Joe Perches5e690692010-11-09 16:35:20 -0800931
Steven Whitehouse6802e342008-05-21 17:03:22 +0100932 if (seq) {
933 struct gfs2_glock_iter *gi = seq->private;
Robert Peterson7c52b162007-03-16 10:26:37 +0000934 vsprintf(gi->string, fmt, args);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100935 seq_printf(seq, gi->string);
936 } else {
Joe Perches5e690692010-11-09 16:35:20 -0800937 vaf.fmt = fmt;
938 vaf.va = &args;
939
940 printk(KERN_ERR " %pV", &vaf);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100941 }
Joe Perches5e690692010-11-09 16:35:20 -0800942
Robert Peterson7c52b162007-03-16 10:26:37 +0000943 va_end(args);
944}
945
David Teiglandb3b94fa2006-01-16 16:50:04 +0000946/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000947 * add_to_queue - Add a holder to the wait queue (but look for recursion)
948 * @gh: the holder structure to add
949 *
Steven Whitehouse6802e342008-05-21 17:03:22 +0100950 * Eventually we should move the recursive locking trap to a
951 * debugging option or something like that. This is the fast
952 * path and needs to have the minimum number of distractions.
953 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000954 */
955
Steven Whitehouse6802e342008-05-21 17:03:22 +0100956static inline void add_to_queue(struct gfs2_holder *gh)
Harvey Harrison55ba4742008-10-24 11:31:12 -0700957__releases(&gl->gl_spin)
958__acquires(&gl->gl_spin)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000959{
960 struct gfs2_glock *gl = gh->gh_gl;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100961 struct gfs2_sbd *sdp = gl->gl_sbd;
962 struct list_head *insert_pt = NULL;
963 struct gfs2_holder *gh2;
964 int try_lock = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000965
Pavel Emelyanovb1e058d2008-02-07 00:13:19 -0800966 BUG_ON(gh->gh_owner_pid == NULL);
Steven Whitehousefee852e2007-01-17 15:33:23 +0000967 if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags))
968 BUG();
Steven Whitehouse190562b2006-04-20 16:57:23 -0400969
Steven Whitehouse6802e342008-05-21 17:03:22 +0100970 if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)) {
971 if (test_bit(GLF_LOCK, &gl->gl_flags))
972 try_lock = 1;
973 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags))
974 goto fail;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000975 }
976
Steven Whitehouse6802e342008-05-21 17:03:22 +0100977 list_for_each_entry(gh2, &gl->gl_holders, gh_list) {
978 if (unlikely(gh2->gh_owner_pid == gh->gh_owner_pid &&
979 (gh->gh_gl->gl_ops->go_type != LM_TYPE_FLOCK)))
980 goto trap_recursive;
981 if (try_lock &&
982 !(gh2->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)) &&
983 !may_grant(gl, gh)) {
984fail:
985 gh->gh_error = GLR_TRYFAILED;
986 gfs2_holder_wake(gh);
987 return;
988 }
989 if (test_bit(HIF_HOLDER, &gh2->gh_iflags))
990 continue;
991 if (unlikely((gh->gh_flags & LM_FLAG_PRIORITY) && !insert_pt))
992 insert_pt = &gh2->gh_list;
993 }
Steven Whitehouse7b5e3d52010-09-03 09:39:20 +0100994 set_bit(GLF_QUEUED, &gl->gl_flags);
Steven Whitehouseedae38a2011-01-31 09:38:12 +0000995 trace_gfs2_glock_queue(gh, 1);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100996 if (likely(insert_pt == NULL)) {
997 list_add_tail(&gh->gh_list, &gl->gl_holders);
998 if (unlikely(gh->gh_flags & LM_FLAG_PRIORITY))
999 goto do_cancel;
1000 return;
1001 }
1002 list_add_tail(&gh->gh_list, insert_pt);
1003do_cancel:
1004 gh = list_entry(gl->gl_holders.next, struct gfs2_holder, gh_list);
1005 if (!(gh->gh_flags & LM_FLAG_PRIORITY)) {
1006 spin_unlock(&gl->gl_spin);
Steven Whitehouse048bca22008-05-23 14:46:04 +01001007 if (sdp->sd_lockstruct.ls_ops->lm_cancel)
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001008 sdp->sd_lockstruct.ls_ops->lm_cancel(gl);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001009 spin_lock(&gl->gl_spin);
1010 }
1011 return;
1012
1013trap_recursive:
1014 print_symbol(KERN_ERR "original: %s\n", gh2->gh_ip);
1015 printk(KERN_ERR "pid: %d\n", pid_nr(gh2->gh_owner_pid));
1016 printk(KERN_ERR "lock type: %d req lock state : %d\n",
1017 gh2->gh_gl->gl_name.ln_type, gh2->gh_state);
1018 print_symbol(KERN_ERR "new: %s\n", gh->gh_ip);
1019 printk(KERN_ERR "pid: %d\n", pid_nr(gh->gh_owner_pid));
1020 printk(KERN_ERR "lock type: %d req lock state : %d\n",
1021 gh->gh_gl->gl_name.ln_type, gh->gh_state);
1022 __dump_glock(NULL, gl);
1023 BUG();
David Teiglandb3b94fa2006-01-16 16:50:04 +00001024}
1025
1026/**
1027 * gfs2_glock_nq - enqueue a struct gfs2_holder onto a glock (acquire a glock)
1028 * @gh: the holder structure
1029 *
1030 * if (gh->gh_flags & GL_ASYNC), this never returns an error
1031 *
1032 * Returns: 0, GLR_TRYFAILED, or errno on failure
1033 */
1034
1035int gfs2_glock_nq(struct gfs2_holder *gh)
1036{
1037 struct gfs2_glock *gl = gh->gh_gl;
1038 struct gfs2_sbd *sdp = gl->gl_sbd;
1039 int error = 0;
1040
Steven Whitehouse6802e342008-05-21 17:03:22 +01001041 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001042 return -EIO;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001043
Steven Whitehousef42ab082011-04-14 16:50:31 +01001044 if (test_bit(GLF_LRU, &gl->gl_flags))
1045 gfs2_glock_remove_from_lru(gl);
1046
David Teiglandb3b94fa2006-01-16 16:50:04 +00001047 spin_lock(&gl->gl_spin);
1048 add_to_queue(gh);
Steven Whitehouse0809f6e2010-08-02 10:15:17 +01001049 if ((LM_FLAG_NOEXP & gh->gh_flags) &&
1050 test_and_clear_bit(GLF_FROZEN, &gl->gl_flags))
1051 set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001052 run_queue(gl, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001053 spin_unlock(&gl->gl_spin);
1054
Steven Whitehouse6802e342008-05-21 17:03:22 +01001055 if (!(gh->gh_flags & GL_ASYNC))
1056 error = gfs2_glock_wait(gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001057
David Teiglandb3b94fa2006-01-16 16:50:04 +00001058 return error;
1059}
1060
1061/**
1062 * gfs2_glock_poll - poll to see if an async request has been completed
1063 * @gh: the holder
1064 *
1065 * Returns: 1 if the request is ready to be gfs2_glock_wait()ed on
1066 */
1067
1068int gfs2_glock_poll(struct gfs2_holder *gh)
1069{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001070 return test_bit(HIF_WAIT, &gh->gh_iflags) ? 0 : 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001071}
1072
1073/**
1074 * gfs2_glock_dq - dequeue a struct gfs2_holder from a glock (release a glock)
1075 * @gh: the glock holder
1076 *
1077 */
1078
1079void gfs2_glock_dq(struct gfs2_holder *gh)
1080{
1081 struct gfs2_glock *gl = gh->gh_gl;
Steven Whitehouse8fb4b532006-08-30 09:30:00 -04001082 const struct gfs2_glock_operations *glops = gl->gl_ops;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001083 unsigned delay = 0;
Steven Whitehouse6802e342008-05-21 17:03:22 +01001084 int fast_path = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001085
Steven Whitehouse6802e342008-05-21 17:03:22 +01001086 spin_lock(&gl->gl_spin);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001087 if (gh->gh_flags & GL_NOCACHE)
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001088 handle_callback(gl, LM_ST_UNLOCKED, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001089
David Teiglandb3b94fa2006-01-16 16:50:04 +00001090 list_del_init(&gh->gh_list);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001091 if (find_first_holder(gl) == NULL) {
Steven Whitehouse3042a2c2007-11-02 08:39:34 +00001092 if (glops->go_unlock) {
Steven Whitehouse6802e342008-05-21 17:03:22 +01001093 GLOCK_BUG_ON(gl, test_and_set_bit(GLF_LOCK, &gl->gl_flags));
Steven Whitehouse3042a2c2007-11-02 08:39:34 +00001094 spin_unlock(&gl->gl_spin);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001095 glops->go_unlock(gh);
Steven Whitehouse3042a2c2007-11-02 08:39:34 +00001096 spin_lock(&gl->gl_spin);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001097 clear_bit(GLF_LOCK, &gl->gl_flags);
Steven Whitehouse3042a2c2007-11-02 08:39:34 +00001098 }
Steven Whitehouse6802e342008-05-21 17:03:22 +01001099 if (list_empty(&gl->gl_holders) &&
1100 !test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
1101 !test_bit(GLF_DEMOTE, &gl->gl_flags))
1102 fast_path = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001103 }
Steven Whitehousef42ab082011-04-14 16:50:31 +01001104 if (!test_bit(GLF_LFLUSH, &gl->gl_flags))
1105 __gfs2_glock_schedule_for_reclaim(gl);
Steven Whitehouse63997772009-06-12 08:49:20 +01001106 trace_gfs2_glock_queue(gh, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001107 spin_unlock(&gl->gl_spin);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001108 if (likely(fast_path))
1109 return;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001110
1111 gfs2_glock_hold(gl);
1112 if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
Bob Peterson7cf8dcd2011-06-15 11:41:48 -04001113 !test_bit(GLF_DEMOTE, &gl->gl_flags) &&
1114 gl->gl_name.ln_type == LM_TYPE_INODE)
1115 delay = gl->gl_hold_time;
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001116 if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
1117 gfs2_glock_put(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001118}
1119
Abhijith Dasd93cfa92007-06-11 08:22:32 +01001120void gfs2_glock_dq_wait(struct gfs2_holder *gh)
1121{
1122 struct gfs2_glock *gl = gh->gh_gl;
1123 gfs2_glock_dq(gh);
1124 wait_on_demote(gl);
1125}
1126
David Teiglandb3b94fa2006-01-16 16:50:04 +00001127/**
David Teiglandb3b94fa2006-01-16 16:50:04 +00001128 * gfs2_glock_dq_uninit - dequeue a holder from a glock and initialize it
1129 * @gh: the holder structure
1130 *
1131 */
1132
1133void gfs2_glock_dq_uninit(struct gfs2_holder *gh)
1134{
1135 gfs2_glock_dq(gh);
1136 gfs2_holder_uninit(gh);
1137}
1138
1139/**
1140 * gfs2_glock_nq_num - acquire a glock based on lock number
1141 * @sdp: the filesystem
1142 * @number: the lock number
1143 * @glops: the glock operations for the type of glock
1144 * @state: the state to acquire the glock in
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001145 * @flags: modifier flags for the acquisition
David Teiglandb3b94fa2006-01-16 16:50:04 +00001146 * @gh: the struct gfs2_holder
1147 *
1148 * Returns: errno
1149 */
1150
Steven Whitehousecd915492006-09-04 12:49:07 -04001151int gfs2_glock_nq_num(struct gfs2_sbd *sdp, u64 number,
Steven Whitehouse8fb4b532006-08-30 09:30:00 -04001152 const struct gfs2_glock_operations *glops,
1153 unsigned int state, int flags, struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001154{
1155 struct gfs2_glock *gl;
1156 int error;
1157
1158 error = gfs2_glock_get(sdp, number, glops, CREATE, &gl);
1159 if (!error) {
1160 error = gfs2_glock_nq_init(gl, state, flags, gh);
1161 gfs2_glock_put(gl);
1162 }
1163
1164 return error;
1165}
1166
1167/**
1168 * glock_compare - Compare two struct gfs2_glock structures for sorting
1169 * @arg_a: the first structure
1170 * @arg_b: the second structure
1171 *
1172 */
1173
1174static int glock_compare(const void *arg_a, const void *arg_b)
1175{
Steven Whitehousea5e08a92006-09-09 17:07:05 -04001176 const struct gfs2_holder *gh_a = *(const struct gfs2_holder **)arg_a;
1177 const struct gfs2_holder *gh_b = *(const struct gfs2_holder **)arg_b;
1178 const struct lm_lockname *a = &gh_a->gh_gl->gl_name;
1179 const struct lm_lockname *b = &gh_b->gh_gl->gl_name;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001180
1181 if (a->ln_number > b->ln_number)
Steven Whitehousea5e08a92006-09-09 17:07:05 -04001182 return 1;
1183 if (a->ln_number < b->ln_number)
1184 return -1;
Steven Whitehouse1c0f4872007-01-22 12:10:39 -05001185 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 -04001186 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001187}
1188
1189/**
1190 * nq_m_sync - synchonously acquire more than one glock in deadlock free order
1191 * @num_gh: the number of structures
1192 * @ghs: an array of struct gfs2_holder structures
1193 *
1194 * Returns: 0 on success (all glocks acquired),
1195 * errno on failure (no glocks acquired)
1196 */
1197
1198static int nq_m_sync(unsigned int num_gh, struct gfs2_holder *ghs,
1199 struct gfs2_holder **p)
1200{
1201 unsigned int x;
1202 int error = 0;
1203
1204 for (x = 0; x < num_gh; x++)
1205 p[x] = &ghs[x];
1206
1207 sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare, NULL);
1208
1209 for (x = 0; x < num_gh; x++) {
1210 p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1211
1212 error = gfs2_glock_nq(p[x]);
1213 if (error) {
1214 while (x--)
1215 gfs2_glock_dq(p[x]);
1216 break;
1217 }
1218 }
1219
1220 return error;
1221}
1222
1223/**
1224 * gfs2_glock_nq_m - acquire multiple glocks
1225 * @num_gh: the number of structures
1226 * @ghs: an array of struct gfs2_holder structures
1227 *
David Teiglandb3b94fa2006-01-16 16:50:04 +00001228 *
1229 * Returns: 0 on success (all glocks acquired),
1230 * errno on failure (no glocks acquired)
1231 */
1232
1233int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs)
1234{
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001235 struct gfs2_holder *tmp[4];
1236 struct gfs2_holder **pph = tmp;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001237 int error = 0;
1238
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001239 switch(num_gh) {
1240 case 0:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001241 return 0;
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001242 case 1:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001243 ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1244 return gfs2_glock_nq(ghs);
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001245 default:
1246 if (num_gh <= 4)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001247 break;
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001248 pph = kmalloc(num_gh * sizeof(struct gfs2_holder *), GFP_NOFS);
1249 if (!pph)
1250 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001251 }
1252
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001253 error = nq_m_sync(num_gh, ghs, pph);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001254
Steven Whitehouseeaf5bd32007-06-19 15:38:17 +01001255 if (pph != tmp)
1256 kfree(pph);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001257
1258 return error;
1259}
1260
1261/**
1262 * gfs2_glock_dq_m - release multiple glocks
1263 * @num_gh: the number of structures
1264 * @ghs: an array of struct gfs2_holder structures
1265 *
1266 */
1267
1268void gfs2_glock_dq_m(unsigned int num_gh, struct gfs2_holder *ghs)
1269{
Bob Petersonfa1bbde2011-03-10 11:41:57 -05001270 while (num_gh--)
1271 gfs2_glock_dq(&ghs[num_gh]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001272}
1273
1274/**
1275 * gfs2_glock_dq_uninit_m - release multiple glocks
1276 * @num_gh: the number of structures
1277 * @ghs: an array of struct gfs2_holder structures
1278 *
1279 */
1280
1281void gfs2_glock_dq_uninit_m(unsigned int num_gh, struct gfs2_holder *ghs)
1282{
Bob Petersonfa1bbde2011-03-10 11:41:57 -05001283 while (num_gh--)
1284 gfs2_glock_dq_uninit(&ghs[num_gh]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001285}
1286
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001287void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state)
Steven Whitehouseda755fd2008-01-30 15:34:04 +00001288{
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001289 unsigned long delay = 0;
1290 unsigned long holdtime;
1291 unsigned long now = jiffies;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001292
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001293 gfs2_glock_hold(gl);
Bob Peterson7cf8dcd2011-06-15 11:41:48 -04001294 holdtime = gl->gl_tchange + gl->gl_hold_time;
1295 if (test_bit(GLF_QUEUED, &gl->gl_flags) &&
1296 gl->gl_name.ln_type == LM_TYPE_INODE) {
Steven Whitehouse7b5e3d52010-09-03 09:39:20 +01001297 if (time_before(now, holdtime))
1298 delay = holdtime - now;
1299 if (test_bit(GLF_REPLY_PENDING, &gl->gl_flags))
Bob Peterson7cf8dcd2011-06-15 11:41:48 -04001300 delay = gl->gl_hold_time;
Steven Whitehouse7b5e3d52010-09-03 09:39:20 +01001301 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001302
Steven Whitehouse6802e342008-05-21 17:03:22 +01001303 spin_lock(&gl->gl_spin);
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001304 handle_callback(gl, state, delay);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001305 spin_unlock(&gl->gl_spin);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001306 if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
1307 gfs2_glock_put(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001308}
1309
1310/**
Steven Whitehouse0809f6e2010-08-02 10:15:17 +01001311 * gfs2_should_freeze - Figure out if glock should be frozen
1312 * @gl: The glock in question
1313 *
1314 * Glocks are not frozen if (a) the result of the dlm operation is
1315 * an error, (b) the locking operation was an unlock operation or
1316 * (c) if there is a "noexp" flagged request anywhere in the queue
1317 *
1318 * Returns: 1 if freezing should occur, 0 otherwise
1319 */
1320
1321static int gfs2_should_freeze(const struct gfs2_glock *gl)
1322{
1323 const struct gfs2_holder *gh;
1324
1325 if (gl->gl_reply & ~LM_OUT_ST_MASK)
1326 return 0;
1327 if (gl->gl_target == LM_ST_UNLOCKED)
1328 return 0;
1329
1330 list_for_each_entry(gh, &gl->gl_holders, gh_list) {
1331 if (test_bit(HIF_HOLDER, &gh->gh_iflags))
1332 continue;
1333 if (LM_FLAG_NOEXP & gh->gh_flags)
1334 return 0;
1335 }
1336
1337 return 1;
1338}
1339
1340/**
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001341 * gfs2_glock_complete - Callback used by locking
1342 * @gl: Pointer to the glock
1343 * @ret: The return value from the dlm
David Teiglandb3b94fa2006-01-16 16:50:04 +00001344 *
Steven Whitehouse47a25382010-11-30 15:49:31 +00001345 * The gl_reply field is under the gl_spin lock so that it is ok
1346 * to use a bitfield shared with other glock state fields.
David Teiglandb3b94fa2006-01-16 16:50:04 +00001347 */
1348
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001349void gfs2_glock_complete(struct gfs2_glock *gl, int ret)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001350{
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001351 struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct;
Steven Whitehouse0809f6e2010-08-02 10:15:17 +01001352
Steven Whitehouse47a25382010-11-30 15:49:31 +00001353 spin_lock(&gl->gl_spin);
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001354 gl->gl_reply = ret;
Steven Whitehouse0809f6e2010-08-02 10:15:17 +01001355
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001356 if (unlikely(test_bit(DFL_BLOCK_LOCKS, &ls->ls_flags))) {
Steven Whitehouse0809f6e2010-08-02 10:15:17 +01001357 if (gfs2_should_freeze(gl)) {
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001358 set_bit(GLF_FROZEN, &gl->gl_flags);
Steven Whitehouse0809f6e2010-08-02 10:15:17 +01001359 spin_unlock(&gl->gl_spin);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001360 return;
Steven Whitehouse0809f6e2010-08-02 10:15:17 +01001361 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001362 }
Steven Whitehouse47a25382010-11-30 15:49:31 +00001363
1364 spin_unlock(&gl->gl_spin);
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001365 set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
Steven Whitehouse47a25382010-11-30 15:49:31 +00001366 smp_wmb();
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001367 gfs2_glock_hold(gl);
1368 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
1369 gfs2_glock_put(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001370}
1371
David Teiglandb3b94fa2006-01-16 16:50:04 +00001372
Ying Han1495f232011-05-24 17:12:27 -07001373static int gfs2_shrink_glock_memory(struct shrinker *shrink,
1374 struct shrink_control *sc)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001375{
1376 struct gfs2_glock *gl;
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001377 int may_demote;
1378 int nr_skipped = 0;
Ying Han1495f232011-05-24 17:12:27 -07001379 int nr = sc->nr_to_scan;
1380 gfp_t gfp_mask = sc->gfp_mask;
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001381 LIST_HEAD(skipped);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001382
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001383 if (nr == 0)
1384 goto out;
1385
1386 if (!(gfp_mask & __GFP_FS))
1387 return -1;
1388
1389 spin_lock(&lru_lock);
1390 while(nr && !list_empty(&lru_list)) {
1391 gl = list_entry(lru_list.next, struct gfs2_glock, gl_lru);
1392 list_del_init(&gl->gl_lru);
Steven Whitehouse627c10b2011-04-14 14:09:52 +01001393 clear_bit(GLF_LRU, &gl->gl_flags);
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001394 atomic_dec(&lru_count);
1395
1396 /* Test for being demotable */
1397 if (!test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
1398 gfs2_glock_hold(gl);
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001399 spin_unlock(&lru_lock);
1400 spin_lock(&gl->gl_spin);
1401 may_demote = demote_ok(gl);
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001402 if (may_demote) {
1403 handle_callback(gl, LM_ST_UNLOCKED, 0);
1404 nr--;
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001405 }
Steven Whitehouse7e71c552009-09-22 10:56:16 +01001406 clear_bit(GLF_LOCK, &gl->gl_flags);
1407 smp_mb__after_clear_bit();
Steven Whitehouse2163b1e2009-06-25 16:30:26 +01001408 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
Benjamin Marzinskib94a1702009-07-23 18:52:34 -05001409 gfs2_glock_put_nolock(gl);
1410 spin_unlock(&gl->gl_spin);
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001411 spin_lock(&lru_lock);
Steven Whitehouse2163b1e2009-06-25 16:30:26 +01001412 continue;
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001413 }
Steven Whitehouse2163b1e2009-06-25 16:30:26 +01001414 nr_skipped++;
1415 list_add(&gl->gl_lru, &skipped);
Steven Whitehouse627c10b2011-04-14 14:09:52 +01001416 set_bit(GLF_LRU, &gl->gl_flags);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001417 }
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001418 list_splice(&skipped, &lru_list);
1419 atomic_add(nr_skipped, &lru_count);
1420 spin_unlock(&lru_lock);
1421out:
1422 return (atomic_read(&lru_count) / 100) * sysctl_vfs_cache_pressure;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001423}
1424
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001425static struct shrinker glock_shrinker = {
1426 .shrink = gfs2_shrink_glock_memory,
1427 .seeks = DEFAULT_SEEKS,
1428};
1429
David Teiglandb3b94fa2006-01-16 16:50:04 +00001430/**
1431 * examine_bucket - Call a function for glock in a hash bucket
1432 * @examiner: the function
1433 * @sdp: the filesystem
1434 * @bucket: the bucket
1435 *
David Teiglandb3b94fa2006-01-16 16:50:04 +00001436 */
1437
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001438static void examine_bucket(glock_examiner examiner, const struct gfs2_sbd *sdp,
Steven Whitehouse37b2fa62006-09-08 13:35:56 -04001439 unsigned int hash)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001440{
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001441 struct gfs2_glock *gl;
1442 struct hlist_bl_head *head = &gl_hash_table[hash];
1443 struct hlist_bl_node *pos;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001444
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001445 rcu_read_lock();
1446 hlist_bl_for_each_entry_rcu(gl, pos, head, gl_list) {
1447 if ((gl->gl_sbd == sdp) && atomic_read(&gl->gl_ref))
Steven Whitehouse24264432006-09-11 21:40:30 -04001448 examiner(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001449 }
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001450 rcu_read_unlock();
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001451 cond_resched();
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001452}
1453
1454static void glock_hash_walk(glock_examiner examiner, const struct gfs2_sbd *sdp)
1455{
1456 unsigned x;
1457
1458 for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
1459 examine_bucket(examiner, sdp, x);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001460}
1461
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001462
1463/**
1464 * thaw_glock - thaw out a glock which has an unprocessed reply waiting
1465 * @gl: The glock to thaw
1466 *
1467 * N.B. When we freeze a glock, we leave a ref to the glock outstanding,
1468 * so this has to result in the ref count being dropped by one.
1469 */
1470
1471static void thaw_glock(struct gfs2_glock *gl)
1472{
1473 if (!test_and_clear_bit(GLF_FROZEN, &gl->gl_flags))
1474 return;
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001475 set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
1476 gfs2_glock_hold(gl);
1477 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
1478 gfs2_glock_put(gl);
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001479}
1480
David Teiglandb3b94fa2006-01-16 16:50:04 +00001481/**
David Teiglandb3b94fa2006-01-16 16:50:04 +00001482 * clear_glock - look at a glock and see if we can free it from glock cache
1483 * @gl: the glock to look at
1484 *
1485 */
1486
1487static void clear_glock(struct gfs2_glock *gl)
1488{
Steven Whitehousef42ab082011-04-14 16:50:31 +01001489 gfs2_glock_remove_from_lru(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001490
Steven Whitehouse6802e342008-05-21 17:03:22 +01001491 spin_lock(&gl->gl_spin);
Steven Whitehousec741c452010-09-29 14:20:52 +01001492 if (gl->gl_state != LM_ST_UNLOCKED)
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001493 handle_callback(gl, LM_ST_UNLOCKED, 0);
Steven Whitehouse6802e342008-05-21 17:03:22 +01001494 spin_unlock(&gl->gl_spin);
1495 gfs2_glock_hold(gl);
1496 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
1497 gfs2_glock_put(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001498}
1499
1500/**
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001501 * gfs2_glock_thaw - Thaw any frozen glocks
1502 * @sdp: The super block
1503 *
1504 */
1505
1506void gfs2_glock_thaw(struct gfs2_sbd *sdp)
1507{
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001508 glock_hash_walk(thaw_glock, sdp);
1509}
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001510
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001511static int dump_glock(struct seq_file *seq, struct gfs2_glock *gl)
1512{
1513 int ret;
1514 spin_lock(&gl->gl_spin);
1515 ret = __dump_glock(seq, gl);
1516 spin_unlock(&gl->gl_spin);
1517 return ret;
1518}
1519
1520static void dump_glock_func(struct gfs2_glock *gl)
1521{
1522 dump_glock(NULL, gl);
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001523}
1524
1525/**
David Teiglandb3b94fa2006-01-16 16:50:04 +00001526 * gfs2_gl_hash_clear - Empty out the glock hash table
1527 * @sdp: the filesystem
1528 * @wait: wait until it's all gone
1529 *
Steven Whitehouse1bdad602008-06-03 14:09:53 +01001530 * Called when unmounting the filesystem.
David Teiglandb3b94fa2006-01-16 16:50:04 +00001531 */
1532
Steven Whitehousefefc03b2008-12-19 15:32:06 +00001533void gfs2_gl_hash_clear(struct gfs2_sbd *sdp)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001534{
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001535 glock_hash_walk(clear_glock, sdp);
Steven Whitehouse8f052282010-01-29 15:21:27 +00001536 flush_workqueue(glock_workqueue);
1537 wait_event(sdp->sd_glock_wait, atomic_read(&sdp->sd_glock_disposal) == 0);
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001538 glock_hash_walk(dump_glock_func, sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001539}
1540
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001541void gfs2_glock_finish_truncate(struct gfs2_inode *ip)
1542{
1543 struct gfs2_glock *gl = ip->i_gl;
1544 int ret;
1545
1546 ret = gfs2_truncatei_resume(ip);
1547 gfs2_assert_withdraw(gl->gl_sbd, ret == 0);
1548
1549 spin_lock(&gl->gl_spin);
1550 clear_bit(GLF_LOCK, &gl->gl_flags);
1551 run_queue(gl, 1);
1552 spin_unlock(&gl->gl_spin);
1553}
1554
Steven Whitehouse6802e342008-05-21 17:03:22 +01001555static const char *state2str(unsigned state)
Robert Peterson04b933f2007-03-23 17:05:15 -05001556{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001557 switch(state) {
1558 case LM_ST_UNLOCKED:
1559 return "UN";
1560 case LM_ST_SHARED:
1561 return "SH";
1562 case LM_ST_DEFERRED:
1563 return "DF";
1564 case LM_ST_EXCLUSIVE:
1565 return "EX";
1566 }
1567 return "??";
1568}
Robert Peterson04b933f2007-03-23 17:05:15 -05001569
Steven Whitehouse6802e342008-05-21 17:03:22 +01001570static const char *hflags2str(char *buf, unsigned flags, unsigned long iflags)
1571{
1572 char *p = buf;
1573 if (flags & LM_FLAG_TRY)
1574 *p++ = 't';
1575 if (flags & LM_FLAG_TRY_1CB)
1576 *p++ = 'T';
1577 if (flags & LM_FLAG_NOEXP)
1578 *p++ = 'e';
1579 if (flags & LM_FLAG_ANY)
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001580 *p++ = 'A';
Steven Whitehouse6802e342008-05-21 17:03:22 +01001581 if (flags & LM_FLAG_PRIORITY)
1582 *p++ = 'p';
1583 if (flags & GL_ASYNC)
1584 *p++ = 'a';
1585 if (flags & GL_EXACT)
1586 *p++ = 'E';
Steven Whitehouse6802e342008-05-21 17:03:22 +01001587 if (flags & GL_NOCACHE)
1588 *p++ = 'c';
1589 if (test_bit(HIF_HOLDER, &iflags))
1590 *p++ = 'H';
1591 if (test_bit(HIF_WAIT, &iflags))
1592 *p++ = 'W';
1593 if (test_bit(HIF_FIRST, &iflags))
1594 *p++ = 'F';
1595 *p = 0;
1596 return buf;
Robert Peterson04b933f2007-03-23 17:05:15 -05001597}
1598
David Teiglandb3b94fa2006-01-16 16:50:04 +00001599/**
1600 * dump_holder - print information about a glock holder
Steven Whitehouse6802e342008-05-21 17:03:22 +01001601 * @seq: the seq_file struct
David Teiglandb3b94fa2006-01-16 16:50:04 +00001602 * @gh: the glock holder
1603 *
1604 * Returns: 0 on success, -ENOBUFS when we run out of space
1605 */
1606
Steven Whitehouse6802e342008-05-21 17:03:22 +01001607static int dump_holder(struct seq_file *seq, const struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001608{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001609 struct task_struct *gh_owner = NULL;
Steven Whitehouse6802e342008-05-21 17:03:22 +01001610 char flags_buf[32];
David Teiglandb3b94fa2006-01-16 16:50:04 +00001611
Steven Whitehouse6802e342008-05-21 17:03:22 +01001612 if (gh->gh_owner_pid)
Pavel Emelyanovb1e058d2008-02-07 00:13:19 -08001613 gh_owner = pid_task(gh->gh_owner_pid, PIDTYPE_PID);
Joe Perchescc181522010-11-05 16:12:36 -07001614 gfs2_print_dbg(seq, " H: s:%s f:%s e:%d p:%ld [%s] %pS\n",
1615 state2str(gh->gh_state),
1616 hflags2str(flags_buf, gh->gh_flags, gh->gh_iflags),
1617 gh->gh_error,
1618 gh->gh_owner_pid ? (long)pid_nr(gh->gh_owner_pid) : -1,
1619 gh_owner ? gh_owner->comm : "(ended)",
1620 (void *)gh->gh_ip);
Robert Peterson7c52b162007-03-16 10:26:37 +00001621 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001622}
1623
Steven Whitehouse627c10b2011-04-14 14:09:52 +01001624static const char *gflags2str(char *buf, const struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001625{
Steven Whitehouse627c10b2011-04-14 14:09:52 +01001626 const unsigned long *gflags = &gl->gl_flags;
Steven Whitehouse6802e342008-05-21 17:03:22 +01001627 char *p = buf;
Steven Whitehouse627c10b2011-04-14 14:09:52 +01001628
Steven Whitehouse6802e342008-05-21 17:03:22 +01001629 if (test_bit(GLF_LOCK, gflags))
1630 *p++ = 'l';
Steven Whitehouse6802e342008-05-21 17:03:22 +01001631 if (test_bit(GLF_DEMOTE, gflags))
1632 *p++ = 'D';
1633 if (test_bit(GLF_PENDING_DEMOTE, gflags))
1634 *p++ = 'd';
1635 if (test_bit(GLF_DEMOTE_IN_PROGRESS, gflags))
1636 *p++ = 'p';
1637 if (test_bit(GLF_DIRTY, gflags))
1638 *p++ = 'y';
1639 if (test_bit(GLF_LFLUSH, gflags))
1640 *p++ = 'f';
1641 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, gflags))
1642 *p++ = 'i';
1643 if (test_bit(GLF_REPLY_PENDING, gflags))
1644 *p++ = 'r';
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001645 if (test_bit(GLF_INITIAL, gflags))
Steven Whitehoused8348de2009-02-05 10:12:38 +00001646 *p++ = 'I';
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001647 if (test_bit(GLF_FROZEN, gflags))
1648 *p++ = 'F';
Steven Whitehouse7b5e3d52010-09-03 09:39:20 +01001649 if (test_bit(GLF_QUEUED, gflags))
1650 *p++ = 'q';
Steven Whitehouse627c10b2011-04-14 14:09:52 +01001651 if (test_bit(GLF_LRU, gflags))
1652 *p++ = 'L';
1653 if (gl->gl_object)
1654 *p++ = 'o';
Steven Whitehouse6802e342008-05-21 17:03:22 +01001655 *p = 0;
1656 return buf;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001657}
1658
1659/**
Steven Whitehouse6802e342008-05-21 17:03:22 +01001660 * __dump_glock - print information about a glock
1661 * @seq: The seq_file struct
David Teiglandb3b94fa2006-01-16 16:50:04 +00001662 * @gl: the glock
Steven Whitehouse6802e342008-05-21 17:03:22 +01001663 *
1664 * The file format is as follows:
1665 * One line per object, capital letters are used to indicate objects
1666 * G = glock, I = Inode, R = rgrp, H = holder. Glocks are not indented,
1667 * other objects are indented by a single space and follow the glock to
1668 * which they are related. Fields are indicated by lower case letters
1669 * followed by a colon and the field value, except for strings which are in
1670 * [] so that its possible to see if they are composed of spaces for
1671 * example. The field's are n = number (id of the object), f = flags,
1672 * t = type, s = state, r = refcount, e = error, p = pid.
David Teiglandb3b94fa2006-01-16 16:50:04 +00001673 *
1674 * Returns: 0 on success, -ENOBUFS when we run out of space
1675 */
1676
Steven Whitehouse6802e342008-05-21 17:03:22 +01001677static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001678{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001679 const struct gfs2_glock_operations *glops = gl->gl_ops;
1680 unsigned long long dtime;
1681 const struct gfs2_holder *gh;
1682 char gflags_buf[32];
1683 int error = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001684
Steven Whitehouse6802e342008-05-21 17:03:22 +01001685 dtime = jiffies - gl->gl_demote_time;
1686 dtime *= 1000000/HZ; /* demote time in uSec */
1687 if (!test_bit(GLF_DEMOTE, &gl->gl_flags))
1688 dtime = 0;
Bob Peterson7cf8dcd2011-06-15 11:41:48 -04001689 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",
Steven Whitehouse6802e342008-05-21 17:03:22 +01001690 state2str(gl->gl_state),
1691 gl->gl_name.ln_type,
1692 (unsigned long long)gl->gl_name.ln_number,
Steven Whitehouse627c10b2011-04-14 14:09:52 +01001693 gflags2str(gflags_buf, gl),
Steven Whitehouse6802e342008-05-21 17:03:22 +01001694 state2str(gl->gl_target),
1695 state2str(gl->gl_demote_state), dtime,
Steven Whitehouse6802e342008-05-21 17:03:22 +01001696 atomic_read(&gl->gl_ail_count),
Steven Whitehousef42ab082011-04-14 16:50:31 +01001697 atomic_read(&gl->gl_revokes),
Bob Peterson7cf8dcd2011-06-15 11:41:48 -04001698 atomic_read(&gl->gl_ref), gl->gl_hold_time);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001699
David Teiglandb3b94fa2006-01-16 16:50:04 +00001700 list_for_each_entry(gh, &gl->gl_holders, gh_list) {
Steven Whitehouse6802e342008-05-21 17:03:22 +01001701 error = dump_holder(seq, gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001702 if (error)
1703 goto out;
1704 }
Steven Whitehouse6802e342008-05-21 17:03:22 +01001705 if (gl->gl_state != LM_ST_UNLOCKED && glops->go_dump)
1706 error = glops->go_dump(seq, gl);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001707out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001708 return error;
1709}
1710
Steven Whitehouse6802e342008-05-21 17:03:22 +01001711
David Teiglandb3b94fa2006-01-16 16:50:04 +00001712
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001713
Steven Whitehouse85d1da62006-09-07 14:40:21 -04001714int __init gfs2_glock_init(void)
1715{
1716 unsigned i;
1717 for(i = 0; i < GFS2_GL_HASH_SIZE; i++) {
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001718 INIT_HLIST_BL_HEAD(&gl_hash_table[i]);
Steven Whitehouse85d1da62006-09-07 14:40:21 -04001719 }
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001720
Steven Whitehoused2115772010-11-03 19:58:53 +00001721 glock_workqueue = alloc_workqueue("glock_workqueue", WQ_MEM_RECLAIM |
Tejun Heo58a69cb2011-02-16 09:25:31 +01001722 WQ_HIGHPRI | WQ_FREEZABLE, 0);
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001723 if (IS_ERR(glock_workqueue))
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001724 return PTR_ERR(glock_workqueue);
Steven Whitehoused2115772010-11-03 19:58:53 +00001725 gfs2_delete_workqueue = alloc_workqueue("delete_workqueue",
Tejun Heo58a69cb2011-02-16 09:25:31 +01001726 WQ_MEM_RECLAIM | WQ_FREEZABLE,
Steven Whitehoused2115772010-11-03 19:58:53 +00001727 0);
Benjamin Marzinskib94a1702009-07-23 18:52:34 -05001728 if (IS_ERR(gfs2_delete_workqueue)) {
1729 destroy_workqueue(glock_workqueue);
1730 return PTR_ERR(gfs2_delete_workqueue);
1731 }
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001732
1733 register_shrinker(&glock_shrinker);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001734
Steven Whitehouse85d1da62006-09-07 14:40:21 -04001735 return 0;
1736}
1737
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001738void gfs2_glock_exit(void)
1739{
Steven Whitehouse97cc1022008-11-20 13:39:47 +00001740 unregister_shrinker(&glock_shrinker);
Benjamin Marzinskic4f68a12007-08-23 13:19:05 -05001741 destroy_workqueue(glock_workqueue);
Benjamin Marzinskib94a1702009-07-23 18:52:34 -05001742 destroy_workqueue(gfs2_delete_workqueue);
Steven Whitehouse8fbbfd22007-08-01 13:57:10 +01001743}
1744
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001745static inline struct gfs2_glock *glock_hash_chain(unsigned hash)
1746{
1747 return hlist_bl_entry(hlist_bl_first_rcu(&gl_hash_table[hash]),
1748 struct gfs2_glock, gl_list);
1749}
1750
1751static inline struct gfs2_glock *glock_hash_next(struct gfs2_glock *gl)
1752{
Steven Whitehouse7e32d022011-03-15 08:32:14 +00001753 return hlist_bl_entry(rcu_dereference(gl->gl_list.next),
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001754 struct gfs2_glock, gl_list);
1755}
1756
Steven Whitehouse6802e342008-05-21 17:03:22 +01001757static int gfs2_glock_iter_next(struct gfs2_glock_iter *gi)
Robert Peterson7c52b162007-03-16 10:26:37 +00001758{
Steven Whitehouse7b08fc62007-07-24 13:53:36 +01001759 struct gfs2_glock *gl;
1760
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001761 do {
1762 gl = gi->gl;
1763 if (gl) {
1764 gi->gl = glock_hash_next(gl);
1765 } else {
1766 gi->gl = glock_hash_chain(gi->hash);
1767 }
1768 while (gi->gl == NULL) {
1769 gi->hash++;
1770 if (gi->hash >= GFS2_GL_HASH_SIZE) {
1771 rcu_read_unlock();
1772 return 1;
1773 }
1774 gi->gl = glock_hash_chain(gi->hash);
1775 }
1776 /* Skip entries for other sb and dead entries */
1777 } while (gi->sdp != gi->gl->gl_sbd || atomic_read(&gi->gl->gl_ref) == 0);
Abhijith Dasa947e032007-08-21 09:57:29 -05001778
Robert Peterson7c52b162007-03-16 10:26:37 +00001779 return 0;
1780}
1781
Steven Whitehouse6802e342008-05-21 17:03:22 +01001782static void *gfs2_glock_seq_start(struct seq_file *seq, loff_t *pos)
Robert Peterson7c52b162007-03-16 10:26:37 +00001783{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001784 struct gfs2_glock_iter *gi = seq->private;
Robert Peterson7c52b162007-03-16 10:26:37 +00001785 loff_t n = *pos;
1786
Steven Whitehouse6802e342008-05-21 17:03:22 +01001787 gi->hash = 0;
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001788 rcu_read_lock();
Robert Peterson7c52b162007-03-16 10:26:37 +00001789
Steven Whitehouse6802e342008-05-21 17:03:22 +01001790 do {
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001791 if (gfs2_glock_iter_next(gi))
Robert Peterson7c52b162007-03-16 10:26:37 +00001792 return NULL;
Steven Whitehouse6802e342008-05-21 17:03:22 +01001793 } while (n--);
Robert Peterson7c52b162007-03-16 10:26:37 +00001794
Steven Whitehouse6802e342008-05-21 17:03:22 +01001795 return gi->gl;
Robert Peterson7c52b162007-03-16 10:26:37 +00001796}
1797
Steven Whitehouse6802e342008-05-21 17:03:22 +01001798static void *gfs2_glock_seq_next(struct seq_file *seq, void *iter_ptr,
Robert Peterson7c52b162007-03-16 10:26:37 +00001799 loff_t *pos)
1800{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001801 struct gfs2_glock_iter *gi = seq->private;
Robert Peterson7c52b162007-03-16 10:26:37 +00001802
1803 (*pos)++;
1804
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001805 if (gfs2_glock_iter_next(gi))
Robert Peterson7c52b162007-03-16 10:26:37 +00001806 return NULL;
Robert Peterson7c52b162007-03-16 10:26:37 +00001807
Steven Whitehouse6802e342008-05-21 17:03:22 +01001808 return gi->gl;
Robert Peterson7c52b162007-03-16 10:26:37 +00001809}
1810
Steven Whitehouse6802e342008-05-21 17:03:22 +01001811static void gfs2_glock_seq_stop(struct seq_file *seq, void *iter_ptr)
Robert Peterson7c52b162007-03-16 10:26:37 +00001812{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001813 struct gfs2_glock_iter *gi = seq->private;
Steven Whitehousebc015cb2011-01-19 09:30:01 +00001814
1815 if (gi->gl)
1816 rcu_read_unlock();
1817 gi->gl = NULL;
Robert Peterson7c52b162007-03-16 10:26:37 +00001818}
1819
Steven Whitehouse6802e342008-05-21 17:03:22 +01001820static int gfs2_glock_seq_show(struct seq_file *seq, void *iter_ptr)
Robert Peterson7c52b162007-03-16 10:26:37 +00001821{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001822 return dump_glock(seq, iter_ptr);
Robert Peterson7c52b162007-03-16 10:26:37 +00001823}
1824
Denis Cheng4ef29002007-07-31 18:31:11 +08001825static const struct seq_operations gfs2_glock_seq_ops = {
Robert Peterson7c52b162007-03-16 10:26:37 +00001826 .start = gfs2_glock_seq_start,
1827 .next = gfs2_glock_seq_next,
1828 .stop = gfs2_glock_seq_stop,
1829 .show = gfs2_glock_seq_show,
1830};
1831
1832static int gfs2_debugfs_open(struct inode *inode, struct file *file)
1833{
Steven Whitehouse6802e342008-05-21 17:03:22 +01001834 int ret = seq_open_private(file, &gfs2_glock_seq_ops,
1835 sizeof(struct gfs2_glock_iter));
1836 if (ret == 0) {
1837 struct seq_file *seq = file->private_data;
1838 struct gfs2_glock_iter *gi = seq->private;
1839 gi->sdp = inode->i_private;
1840 }
1841 return ret;
Robert Peterson7c52b162007-03-16 10:26:37 +00001842}
1843
1844static const struct file_operations gfs2_debug_fops = {
1845 .owner = THIS_MODULE,
1846 .open = gfs2_debugfs_open,
1847 .read = seq_read,
1848 .llseek = seq_lseek,
Steven Whitehouse6802e342008-05-21 17:03:22 +01001849 .release = seq_release_private,
Robert Peterson7c52b162007-03-16 10:26:37 +00001850};
1851
1852int gfs2_create_debugfs_file(struct gfs2_sbd *sdp)
1853{
Robert Peterson5f882092007-04-18 11:41:11 -05001854 sdp->debugfs_dir = debugfs_create_dir(sdp->sd_table_name, gfs2_root);
1855 if (!sdp->debugfs_dir)
1856 return -ENOMEM;
1857 sdp->debugfs_dentry_glocks = debugfs_create_file("glocks",
1858 S_IFREG | S_IRUGO,
1859 sdp->debugfs_dir, sdp,
1860 &gfs2_debug_fops);
1861 if (!sdp->debugfs_dentry_glocks)
Robert Peterson7c52b162007-03-16 10:26:37 +00001862 return -ENOMEM;
1863
1864 return 0;
1865}
1866
1867void gfs2_delete_debugfs_file(struct gfs2_sbd *sdp)
1868{
Robert Peterson5f882092007-04-18 11:41:11 -05001869 if (sdp && sdp->debugfs_dir) {
1870 if (sdp->debugfs_dentry_glocks) {
1871 debugfs_remove(sdp->debugfs_dentry_glocks);
1872 sdp->debugfs_dentry_glocks = NULL;
1873 }
1874 debugfs_remove(sdp->debugfs_dir);
1875 sdp->debugfs_dir = NULL;
1876 }
Robert Peterson7c52b162007-03-16 10:26:37 +00001877}
1878
1879int gfs2_register_debugfs(void)
1880{
1881 gfs2_root = debugfs_create_dir("gfs2", NULL);
1882 return gfs2_root ? 0 : -ENOMEM;
1883}
1884
1885void gfs2_unregister_debugfs(void)
1886{
1887 debugfs_remove(gfs2_root);
Robert Peterson5f882092007-04-18 11:41:11 -05001888 gfs2_root = NULL;
Robert Peterson7c52b162007-03-16 10:26:37 +00001889}