glock.c 51.3 KB
Newer Older
D
David Teigland 已提交
1 2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
D
David Teigland 已提交
4 5 6
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
7
 * of the GNU General Public License version 2.
D
David Teigland 已提交
8 9
 */

10 11
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

D
David Teigland 已提交
12 13 14 15 16 17 18
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/buffer_head.h>
#include <linux/delay.h>
#include <linux/sort.h>
#include <linux/jhash.h>
S
Steven Whitehouse 已提交
19
#include <linux/kallsyms.h>
20
#include <linux/gfs2_ondisk.h>
21
#include <linux/list.h>
22
#include <linux/wait.h>
A
akpm@linux-foundation.org 已提交
23
#include <linux/module.h>
24
#include <linux/uaccess.h>
25 26
#include <linux/seq_file.h>
#include <linux/debugfs.h>
27 28
#include <linux/kthread.h>
#include <linux/freezer.h>
29 30
#include <linux/workqueue.h>
#include <linux/jiffies.h>
31 32 33
#include <linux/rcupdate.h>
#include <linux/rculist_bl.h>
#include <linux/bit_spinlock.h>
34
#include <linux/percpu.h>
35
#include <linux/list_sort.h>
S
Steven Whitehouse 已提交
36
#include <linux/lockref.h>
37
#include <linux/rhashtable.h>
D
David Teigland 已提交
38 39

#include "gfs2.h"
40
#include "incore.h"
D
David Teigland 已提交
41 42 43 44 45 46 47
#include "glock.h"
#include "glops.h"
#include "inode.h"
#include "lops.h"
#include "meta_io.h"
#include "quota.h"
#include "super.h"
48
#include "util.h"
49
#include "bmap.h"
S
Steven Whitehouse 已提交
50 51
#define CREATE_TRACE_POINTS
#include "trace_gfs2.h"
D
David Teigland 已提交
52

53
struct gfs2_glock_iter {
54
	struct gfs2_sbd *sdp;		/* incore superblock           */
55
	struct rhashtable_iter hti;	/* rhashtable iterator         */
56 57
	struct gfs2_glock *gl;		/* current glock struct        */
	loff_t last_pos;		/* last position               */
58 59
};

D
David Teigland 已提交
60 61
typedef void (*glock_examiner) (struct gfs2_glock * gl);

62
static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target);
63

64
static struct dentry *gfs2_root;
65
static struct workqueue_struct *glock_workqueue;
66
struct workqueue_struct *gfs2_delete_workqueue;
67 68
static LIST_HEAD(lru_list);
static atomic_t lru_count = ATOMIC_INIT(0);
J
Julia Lawall 已提交
69
static DEFINE_SPINLOCK(lru_lock);
70

71
#define GFS2_GL_HASH_SHIFT      15
F
Fabian Frederick 已提交
72
#define GFS2_GL_HASH_SIZE       BIT(GFS2_GL_HASH_SHIFT)
73

74 75 76 77 78 79
static struct rhashtable_params ht_parms = {
	.nelem_hint = GFS2_GL_HASH_SIZE * 3 / 4,
	.key_len = sizeof(struct lm_lockname),
	.key_offset = offsetof(struct gfs2_glock, gl_name),
	.head_offset = offsetof(struct gfs2_glock, gl_node),
};
D
David Teigland 已提交
80

81
static struct rhashtable gl_hash_table;
D
David Teigland 已提交
82

83
void gfs2_glock_free(struct gfs2_glock *gl)
D
David Teigland 已提交
84
{
85
	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
D
David Teigland 已提交
86

87
	if (gl->gl_ops->go_flags & GLOF_ASPACE) {
88
		kmem_cache_free(gfs2_glock_aspace_cachep, gl);
89
	} else {
90
		kfree(gl->gl_lksb.sb_lvbptr);
91
		kmem_cache_free(gfs2_glock_cachep, gl);
92
	}
93 94
	if (atomic_dec_and_test(&sdp->sd_glock_disposal))
		wake_up(&sdp->sd_glock_wait);
D
David Teigland 已提交
95 96 97 98 99 100 101 102
}

/**
 * gfs2_glock_hold() - increment reference count on glock
 * @gl: The glock to hold
 *
 */

S
Steven Whitehouse 已提交
103
static void gfs2_glock_hold(struct gfs2_glock *gl)
D
David Teigland 已提交
104
{
S
Steven Whitehouse 已提交
105 106
	GLOCK_BUG_ON(gl, __lockref_is_dead(&gl->gl_lockref));
	lockref_get(&gl->gl_lockref);
D
David Teigland 已提交
107 108
}

109 110 111 112 113 114 115 116 117 118 119 120 121
/**
 * demote_ok - Check to see if it's ok to unlock a glock
 * @gl: the glock
 *
 * Returns: 1 if it's ok
 */

static int demote_ok(const struct gfs2_glock *gl)
{
	const struct gfs2_glock_operations *glops = gl->gl_ops;

	if (gl->gl_state == LM_ST_UNLOCKED)
		return 0;
122
	if (!list_empty(&gl->gl_holders))
123 124 125 126 127 128
		return 0;
	if (glops->go_demote_ok)
		return glops->go_demote_ok(gl);
	return 1;
}

129

130 131 132 133 134 135 136 137 138 139
void gfs2_glock_add_to_lru(struct gfs2_glock *gl)
{
	spin_lock(&lru_lock);

	if (!list_empty(&gl->gl_lru))
		list_del_init(&gl->gl_lru);
	else
		atomic_inc(&lru_count);

	list_add_tail(&gl->gl_lru, &lru_list);
140
	set_bit(GLF_LRU, &gl->gl_flags);
141 142 143
	spin_unlock(&lru_lock);
}

144
static void gfs2_glock_remove_from_lru(struct gfs2_glock *gl)
145
{
146
	spin_lock(&lru_lock);
147 148 149 150 151 152 153 154
	if (!list_empty(&gl->gl_lru)) {
		list_del_init(&gl->gl_lru);
		atomic_dec(&lru_count);
		clear_bit(GLF_LRU, &gl->gl_flags);
	}
	spin_unlock(&lru_lock);
}

D
David Teigland 已提交
155 156 157 158 159 160
/**
 * gfs2_glock_put() - Decrement reference count on glock
 * @gl: The glock to put
 *
 */

161
void gfs2_glock_put(struct gfs2_glock *gl)
D
David Teigland 已提交
162
{
163
	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
164
	struct address_space *mapping = gfs2_glock2aspace(gl);
D
David Teigland 已提交
165

S
Steven Whitehouse 已提交
166 167 168 169 170
	if (lockref_put_or_lock(&gl->gl_lockref))
		return;

	lockref_mark_dead(&gl->gl_lockref);

171
	gfs2_glock_remove_from_lru(gl);
S
Steven Whitehouse 已提交
172
	spin_unlock(&gl->gl_lockref.lock);
173
	rhashtable_remove_fast(&gl_hash_table, &gl->gl_node, ht_parms);
S
Steven Whitehouse 已提交
174 175 176 177
	GLOCK_BUG_ON(gl, !list_empty(&gl->gl_holders));
	GLOCK_BUG_ON(gl, mapping && mapping->nrpages);
	trace_gfs2_glock_put(gl);
	sdp->sd_lockstruct.ls_ops->lm_put_lock(gl);
D
David Teigland 已提交
178 179
}

180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
/**
 * may_grant - check if its ok to grant a new lock
 * @gl: The glock
 * @gh: The lock request which we wish to grant
 *
 * Returns: true if its ok to grant the lock
 */

static inline int may_grant(const struct gfs2_glock *gl, const struct gfs2_holder *gh)
{
	const struct gfs2_holder *gh_head = list_entry(gl->gl_holders.next, const struct gfs2_holder, gh_list);
	if ((gh->gh_state == LM_ST_EXCLUSIVE ||
	     gh_head->gh_state == LM_ST_EXCLUSIVE) && gh != gh_head)
		return 0;
	if (gl->gl_state == gh->gh_state)
		return 1;
	if (gh->gh_flags & GL_EXACT)
		return 0;
198 199 200 201 202 203
	if (gl->gl_state == LM_ST_EXCLUSIVE) {
		if (gh->gh_state == LM_ST_SHARED && gh_head->gh_state == LM_ST_SHARED)
			return 1;
		if (gh->gh_state == LM_ST_DEFERRED && gh_head->gh_state == LM_ST_DEFERRED)
			return 1;
	}
204 205 206 207 208 209 210 211
	if (gl->gl_state != LM_ST_UNLOCKED && (gh->gh_flags & LM_FLAG_ANY))
		return 1;
	return 0;
}

static void gfs2_holder_wake(struct gfs2_holder *gh)
{
	clear_bit(HIF_WAIT, &gh->gh_iflags);
212
	smp_mb__after_atomic();
213 214 215
	wake_up_bit(&gh->gh_iflags, HIF_WAIT);
}

216 217 218 219 220
/**
 * do_error - Something unexpected has happened during a lock request
 *
 */

221
static void do_error(struct gfs2_glock *gl, const int ret)
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
{
	struct gfs2_holder *gh, *tmp;

	list_for_each_entry_safe(gh, tmp, &gl->gl_holders, gh_list) {
		if (test_bit(HIF_HOLDER, &gh->gh_iflags))
			continue;
		if (ret & LM_OUT_ERROR)
			gh->gh_error = -EIO;
		else if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))
			gh->gh_error = GLR_TRYFAILED;
		else
			continue;
		list_del_init(&gh->gh_list);
		trace_gfs2_glock_queue(gh, 0);
		gfs2_holder_wake(gh);
	}
}

240 241 242 243
/**
 * do_promote - promote as many requests as possible on the current queue
 * @gl: The glock
 * 
244 245
 * Returns: 1 if there is a blocked holder at the head of the list, or 2
 *          if a type specific operation is underway.
246 247 248
 */

static int do_promote(struct gfs2_glock *gl)
A
Andreas Gruenbacher 已提交
249 250
__releases(&gl->gl_lockref.lock)
__acquires(&gl->gl_lockref.lock)
251 252 253 254 255 256 257 258 259 260 261 262
{
	const struct gfs2_glock_operations *glops = gl->gl_ops;
	struct gfs2_holder *gh, *tmp;
	int ret;

restart:
	list_for_each_entry_safe(gh, tmp, &gl->gl_holders, gh_list) {
		if (test_bit(HIF_HOLDER, &gh->gh_iflags))
			continue;
		if (may_grant(gl, gh)) {
			if (gh->gh_list.prev == &gl->gl_holders &&
			    glops->go_lock) {
A
Andreas Gruenbacher 已提交
263
				spin_unlock(&gl->gl_lockref.lock);
264 265
				/* FIXME: eliminate this eventually */
				ret = glops->go_lock(gh);
A
Andreas Gruenbacher 已提交
266
				spin_lock(&gl->gl_lockref.lock);
267
				if (ret) {
268 269
					if (ret == 1)
						return 2;
270 271
					gh->gh_error = ret;
					list_del_init(&gh->gh_list);
S
Steven Whitehouse 已提交
272
					trace_gfs2_glock_queue(gh, 0);
273 274 275 276
					gfs2_holder_wake(gh);
					goto restart;
				}
				set_bit(HIF_HOLDER, &gh->gh_iflags);
S
Steven Whitehouse 已提交
277
				trace_gfs2_promote(gh, 1);
278 279 280 281
				gfs2_holder_wake(gh);
				goto restart;
			}
			set_bit(HIF_HOLDER, &gh->gh_iflags);
S
Steven Whitehouse 已提交
282
			trace_gfs2_promote(gh, 0);
283 284 285 286 287
			gfs2_holder_wake(gh);
			continue;
		}
		if (gh->gh_list.prev == &gl->gl_holders)
			return 1;
288
		do_error(gl, 0);
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
		break;
	}
	return 0;
}

/**
 * find_first_waiter - find the first gh that's waiting for the glock
 * @gl: the glock
 */

static inline struct gfs2_holder *find_first_waiter(const struct gfs2_glock *gl)
{
	struct gfs2_holder *gh;

	list_for_each_entry(gh, &gl->gl_holders, gh_list) {
		if (!test_bit(HIF_HOLDER, &gh->gh_iflags))
			return gh;
	}
	return NULL;
}

/**
 * state_change - record that the glock is now in a different state
 * @gl: the glock
 * @new_state the new state
 *
 */

static void state_change(struct gfs2_glock *gl, unsigned int new_state)
{
	int held1, held2;

	held1 = (gl->gl_state != LM_ST_UNLOCKED);
	held2 = (new_state != LM_ST_UNLOCKED);

	if (held1 != held2) {
S
Steven Whitehouse 已提交
325
		GLOCK_BUG_ON(gl, __lockref_is_dead(&gl->gl_lockref));
326
		if (held2)
S
Steven Whitehouse 已提交
327
			gl->gl_lockref.count++;
328
		else
S
Steven Whitehouse 已提交
329
			gl->gl_lockref.count--;
330
	}
331 332
	if (held1 && held2 && list_empty(&gl->gl_holders))
		clear_bit(GLF_QUEUED, &gl->gl_flags);
333

334 335 336 337
	if (new_state != gl->gl_target)
		/* shorten our minimum hold time */
		gl->gl_hold_time = max(gl->gl_hold_time - GL_GLOCK_HOLD_DECR,
				       GL_GLOCK_MIN_HOLD);
338 339 340 341 342 343 344 345
	gl->gl_state = new_state;
	gl->gl_tchange = jiffies;
}

static void gfs2_demote_wake(struct gfs2_glock *gl)
{
	gl->gl_demote_state = LM_ST_EXCLUSIVE;
	clear_bit(GLF_DEMOTE, &gl->gl_flags);
346
	smp_mb__after_atomic();
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
	wake_up_bit(&gl->gl_flags, GLF_DEMOTE);
}

/**
 * finish_xmote - The DLM has replied to one of our lock requests
 * @gl: The glock
 * @ret: The status from the DLM
 *
 */

static void finish_xmote(struct gfs2_glock *gl, unsigned int ret)
{
	const struct gfs2_glock_operations *glops = gl->gl_ops;
	struct gfs2_holder *gh;
	unsigned state = ret & LM_OUT_ST_MASK;
362
	int rv;
363

A
Andreas Gruenbacher 已提交
364
	spin_lock(&gl->gl_lockref.lock);
S
Steven Whitehouse 已提交
365
	trace_gfs2_glock_state_change(gl, state);
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
	state_change(gl, state);
	gh = find_first_waiter(gl);

	/* Demote to UN request arrived during demote to SH or DF */
	if (test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags) &&
	    state != LM_ST_UNLOCKED && gl->gl_demote_state == LM_ST_UNLOCKED)
		gl->gl_target = LM_ST_UNLOCKED;

	/* Check for state != intended state */
	if (unlikely(state != gl->gl_target)) {
		if (gh && !test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags)) {
			/* move to back of queue and try next entry */
			if (ret & LM_OUT_CANCELED) {
				if ((gh->gh_flags & LM_FLAG_PRIORITY) == 0)
					list_move_tail(&gh->gh_list, &gl->gl_holders);
				gh = find_first_waiter(gl);
				gl->gl_target = gh->gh_state;
				goto retry;
			}
			/* Some error or failed "try lock" - report it */
			if ((ret & LM_OUT_ERROR) ||
			    (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) {
				gl->gl_target = gl->gl_state;
				do_error(gl, ret);
				goto out;
			}
		}
		switch(state) {
		/* Unlocked due to conversion deadlock, try again */
		case LM_ST_UNLOCKED:
retry:
			do_xmote(gl, gh, gl->gl_target);
			break;
		/* Conversion fails, unlock and try again */
		case LM_ST_SHARED:
		case LM_ST_DEFERRED:
			do_xmote(gl, gh, LM_ST_UNLOCKED);
			break;
		default: /* Everything else */
405
			pr_err("wanted %u got %u\n", gl->gl_target, state);
406 407
			GLOCK_BUG_ON(gl, 1);
		}
A
Andreas Gruenbacher 已提交
408
		spin_unlock(&gl->gl_lockref.lock);
409 410 411 412 413 414 415 416
		return;
	}

	/* Fast path - we got what we asked for */
	if (test_and_clear_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags))
		gfs2_demote_wake(gl);
	if (state != LM_ST_UNLOCKED) {
		if (glops->go_xmote_bh) {
A
Andreas Gruenbacher 已提交
417
			spin_unlock(&gl->gl_lockref.lock);
418
			rv = glops->go_xmote_bh(gl, gh);
A
Andreas Gruenbacher 已提交
419
			spin_lock(&gl->gl_lockref.lock);
420 421 422 423 424
			if (rv) {
				do_error(gl, rv);
				goto out;
			}
		}
425 426 427
		rv = do_promote(gl);
		if (rv == 2)
			goto out_locked;
428 429 430
	}
out:
	clear_bit(GLF_LOCK, &gl->gl_flags);
431
out_locked:
A
Andreas Gruenbacher 已提交
432
	spin_unlock(&gl->gl_lockref.lock);
433 434 435 436 437 438 439 440 441 442 443
}

/**
 * do_xmote - Calls the DLM to change the state of a lock
 * @gl: The lock state
 * @gh: The holder (only for promotes)
 * @target: The target lock state
 *
 */

static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target)
A
Andreas Gruenbacher 已提交
444 445
__releases(&gl->gl_lockref.lock)
__acquires(&gl->gl_lockref.lock)
446 447
{
	const struct gfs2_glock_operations *glops = gl->gl_ops;
448
	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
B
Bob Peterson 已提交
449
	unsigned int lck_flags = (unsigned int)(gh ? gh->gh_flags : 0);
450 451 452 453
	int ret;

	lck_flags &= (LM_FLAG_TRY | LM_FLAG_TRY_1CB | LM_FLAG_NOEXP |
		      LM_FLAG_PRIORITY);
454 455
	GLOCK_BUG_ON(gl, gl->gl_state == target);
	GLOCK_BUG_ON(gl, gl->gl_state == gl->gl_target);
456 457 458 459 460
	if ((target == LM_ST_UNLOCKED || target == LM_ST_DEFERRED) &&
	    glops->go_inval) {
		set_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);
		do_error(gl, 0); /* Fail queued try locks */
	}
461
	gl->gl_req = target;
462 463 464 465 466
	set_bit(GLF_BLOCKING, &gl->gl_flags);
	if ((gl->gl_req == LM_ST_UNLOCKED) ||
	    (gl->gl_state == LM_ST_EXCLUSIVE) ||
	    (lck_flags & (LM_FLAG_TRY|LM_FLAG_TRY_1CB)))
		clear_bit(GLF_BLOCKING, &gl->gl_flags);
A
Andreas Gruenbacher 已提交
467
	spin_unlock(&gl->gl_lockref.lock);
468 469
	if (glops->go_sync)
		glops->go_sync(gl);
470 471 472 473 474
	if (test_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags))
		glops->go_inval(gl, target == LM_ST_DEFERRED ? 0 : DIO_METADATA);
	clear_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);

	gfs2_glock_hold(gl);
475 476 477
	if (sdp->sd_lockstruct.ls_ops->lm_lock)	{
		/* lock_dlm */
		ret = sdp->sd_lockstruct.ls_ops->lm_lock(gl, target, lck_flags);
478 479 480 481 482 483 484 485
		if (ret == -EINVAL && gl->gl_target == LM_ST_UNLOCKED &&
		    target == LM_ST_UNLOCKED &&
		    test_bit(SDF_SKIP_DLM_UNLOCK, &sdp->sd_flags)) {
			finish_xmote(gl, target);
			if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
				gfs2_glock_put(gl);
		}
		else if (ret) {
486
			pr_err("lm_lock ret %d\n", ret);
487 488
			GLOCK_BUG_ON(gl, 1);
		}
489 490
	} else { /* lock_nolock */
		finish_xmote(gl, target);
491 492 493
		if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
			gfs2_glock_put(gl);
	}
494

A
Andreas Gruenbacher 已提交
495
	spin_lock(&gl->gl_lockref.lock);
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
}

/**
 * find_first_holder - find the first "holder" gh
 * @gl: the glock
 */

static inline struct gfs2_holder *find_first_holder(const struct gfs2_glock *gl)
{
	struct gfs2_holder *gh;

	if (!list_empty(&gl->gl_holders)) {
		gh = list_entry(gl->gl_holders.next, struct gfs2_holder, gh_list);
		if (test_bit(HIF_HOLDER, &gh->gh_iflags))
			return gh;
	}
	return NULL;
}

/**
 * run_queue - do all outstanding tasks related to a glock
 * @gl: The glock in question
 * @nonblock: True if we must not block in run_queue
 *
 */

static void run_queue(struct gfs2_glock *gl, const int nonblock)
A
Andreas Gruenbacher 已提交
523 524
__releases(&gl->gl_lockref.lock)
__acquires(&gl->gl_lockref.lock)
525 526
{
	struct gfs2_holder *gh = NULL;
527
	int ret;
528 529 530 531 532 533 534 535 536

	if (test_and_set_bit(GLF_LOCK, &gl->gl_flags))
		return;

	GLOCK_BUG_ON(gl, test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags));

	if (test_bit(GLF_DEMOTE, &gl->gl_flags) &&
	    gl->gl_demote_state != gl->gl_state) {
		if (find_first_holder(gl))
537
			goto out_unlock;
538 539 540
		if (nonblock)
			goto out_sched;
		set_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags);
541
		GLOCK_BUG_ON(gl, gl->gl_demote_state == LM_ST_EXCLUSIVE);
542 543 544 545
		gl->gl_target = gl->gl_demote_state;
	} else {
		if (test_bit(GLF_DEMOTE, &gl->gl_flags))
			gfs2_demote_wake(gl);
546 547
		ret = do_promote(gl);
		if (ret == 0)
548
			goto out_unlock;
549
		if (ret == 2)
550
			goto out;
551 552 553 554 555 556
		gh = find_first_waiter(gl);
		gl->gl_target = gh->gh_state;
		if (!(gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)))
			do_error(gl, 0); /* Fail queued try locks */
	}
	do_xmote(gl, gh, gl->gl_target);
557
out:
558 559 560
	return;

out_sched:
561
	clear_bit(GLF_LOCK, &gl->gl_flags);
562
	smp_mb__after_atomic();
S
Steven Whitehouse 已提交
563
	gl->gl_lockref.count++;
564
	if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
S
Steven Whitehouse 已提交
565
		gl->gl_lockref.count--;
566 567
	return;

568
out_unlock:
569
	clear_bit(GLF_LOCK, &gl->gl_flags);
570
	smp_mb__after_atomic();
571
	return;
572 573
}

574 575 576
static void delete_work_func(struct work_struct *work)
{
	struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_delete);
577
	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
578
	struct inode *inode;
579 580
	u64 no_addr = gl->gl_name.ln_number;

581 582 583 584 585 586
	/* If someone's using this glock to create a new dinode, the block must
	   have been freed by another node, then re-used, in which case our
	   iopen callback is too late after the fact. Ignore it. */
	if (test_bit(GLF_INODE_CREATING, &gl->gl_flags))
		goto out;

587
	inode = gfs2_lookup_by_inum(sdp, no_addr, NULL, GFS2_BLKST_UNLINKED);
588 589 590
	if (inode && !IS_ERR(inode)) {
		d_prune_aliases(inode);
		iput(inode);
591
	}
592
out:
593 594 595
	gfs2_glock_put(gl);
}

596 597
static void glock_work_func(struct work_struct *work)
{
598
	unsigned long delay = 0;
599
	struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_work.work);
600
	int drop_ref = 0;
601

602
	if (test_and_clear_bit(GLF_REPLY_PENDING, &gl->gl_flags)) {
603
		finish_xmote(gl, gl->gl_reply);
604 605
		drop_ref = 1;
	}
A
Andreas Gruenbacher 已提交
606
	spin_lock(&gl->gl_lockref.lock);
607
	if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
608 609
	    gl->gl_state != LM_ST_UNLOCKED &&
	    gl->gl_demote_state != LM_ST_EXCLUSIVE) {
610
		unsigned long holdtime, now = jiffies;
611

612
		holdtime = gl->gl_tchange + gl->gl_hold_time;
613 614
		if (time_before(now, holdtime))
			delay = holdtime - now;
615 616 617 618 619

		if (!delay) {
			clear_bit(GLF_PENDING_DEMOTE, &gl->gl_flags);
			set_bit(GLF_DEMOTE, &gl->gl_flags);
		}
620 621
	}
	run_queue(gl, 0);
A
Andreas Gruenbacher 已提交
622
	spin_unlock(&gl->gl_lockref.lock);
623
	if (!delay)
624
		gfs2_glock_put(gl);
625 626 627 628 629 630
	else {
		if (gl->gl_name.ln_type != LM_TYPE_INODE)
			delay = 0;
		if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
			gfs2_glock_put(gl);
	}
631 632
	if (drop_ref)
		gfs2_glock_put(gl);
633 634
}

D
David Teigland 已提交
635 636 637 638 639 640 641 642 643 644 645 646 647
/**
 * gfs2_glock_get() - Get a glock, or create one if one doesn't exist
 * @sdp: The GFS2 superblock
 * @number: the lock number
 * @glops: The glock_operations to use
 * @create: If 0, don't create the glock if it doesn't exist
 * @glp: the glock is returned here
 *
 * This does not lock a glock, just finds/creates structures for one.
 *
 * Returns: errno
 */

648
int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
649
		   const struct gfs2_glock_operations *glops, int create,
D
David Teigland 已提交
650 651
		   struct gfs2_glock **glp)
{
652
	struct super_block *s = sdp->sd_vfs;
653 654 655
	struct lm_lockname name = { .ln_number = number,
				    .ln_type = glops->go_type,
				    .ln_sbd = sdp };
656
	struct gfs2_glock *gl, *tmp = NULL;
657
	struct address_space *mapping;
658
	struct kmem_cache *cachep;
659
	int ret, tries = 0;
D
David Teigland 已提交
660

661 662 663
	gl = rhashtable_lookup_fast(&gl_hash_table, &name, ht_parms);
	if (gl && !lockref_get_not_dead(&gl->gl_lockref))
		gl = NULL;
D
David Teigland 已提交
664

665 666
	*glp = gl;
	if (gl)
D
David Teigland 已提交
667
		return 0;
668 669
	if (!create)
		return -ENOENT;
D
David Teigland 已提交
670

671
	if (glops->go_flags & GLOF_ASPACE)
672
		cachep = gfs2_glock_aspace_cachep;
673
	else
674
		cachep = gfs2_glock_cachep;
675
	gl = kmem_cache_alloc(cachep, GFP_NOFS);
D
David Teigland 已提交
676 677 678
	if (!gl)
		return -ENOMEM;

679 680 681
	memset(&gl->gl_lksb, 0, sizeof(struct dlm_lksb));

	if (glops->go_flags & GLOF_LVB) {
682
		gl->gl_lksb.sb_lvbptr = kzalloc(GFS2_MIN_LVB_SIZE, GFP_NOFS);
683
		if (!gl->gl_lksb.sb_lvbptr) {
684 685 686 687 688
			kmem_cache_free(cachep, gl);
			return -ENOMEM;
		}
	}

689
	atomic_inc(&sdp->sd_glock_disposal);
690
	gl->gl_node.next = NULL;
691
	gl->gl_flags = 0;
D
David Teigland 已提交
692
	gl->gl_name = name;
S
Steven Whitehouse 已提交
693
	gl->gl_lockref.count = 1;
D
David Teigland 已提交
694
	gl->gl_state = LM_ST_UNLOCKED;
695
	gl->gl_target = LM_ST_UNLOCKED;
696
	gl->gl_demote_state = LM_ST_EXCLUSIVE;
D
David Teigland 已提交
697
	gl->gl_ops = glops;
T
Thomas Gleixner 已提交
698
	gl->gl_dstamp = 0;
699 700 701 702 703 704
	preempt_disable();
	/* We use the global stats to estimate the initial per-glock stats */
	gl->gl_stats = this_cpu_ptr(sdp->sd_lkstats)->lkstats[glops->go_type];
	preempt_enable();
	gl->gl_stats.stats[GFS2_LKS_DCOUNT] = 0;
	gl->gl_stats.stats[GFS2_LKS_QCOUNT] = 0;
705
	gl->gl_tchange = jiffies;
706
	gl->gl_object = NULL;
707
	gl->gl_hold_time = GL_GLOCK_DFT_HOLD;
708
	INIT_DELAYED_WORK(&gl->gl_work, glock_work_func);
709
	INIT_WORK(&gl->gl_delete, delete_work_func);
D
David Teigland 已提交
710

711 712 713 714 715 716
	mapping = gfs2_glock2aspace(gl);
	if (mapping) {
                mapping->a_ops = &gfs2_meta_aops;
		mapping->host = s->s_bdev->bd_inode;
		mapping->flags = 0;
		mapping_set_gfp_mask(mapping, GFP_NOFS);
717
		mapping->private_data = NULL;
718
		mapping->writeback_index = 0;
D
David Teigland 已提交
719 720
	}

721 722 723 724 725 726
again:
	ret = rhashtable_lookup_insert_fast(&gl_hash_table, &gl->gl_node,
					    ht_parms);
	if (ret == 0) {
		*glp = gl;
		return 0;
D
David Teigland 已提交
727 728
	}

729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
	if (ret == -EEXIST) {
		ret = 0;
		tmp = rhashtable_lookup_fast(&gl_hash_table, &name, ht_parms);
		if (tmp == NULL || !lockref_get_not_dead(&tmp->gl_lockref)) {
			if (++tries < 100) {
				cond_resched();
				goto again;
			}
			tmp = NULL;
			ret = -ENOMEM;
		}
	} else {
		WARN_ON_ONCE(ret);
	}
	kfree(gl->gl_lksb.sb_lvbptr);
	kmem_cache_free(cachep, gl);
	atomic_dec(&sdp->sd_glock_disposal);
	*glp = tmp;
D
David Teigland 已提交
747

748
	return ret;
D
David Teigland 已提交
749 750 751 752 753 754 755 756 757 758 759
}

/**
 * gfs2_holder_init - initialize a struct gfs2_holder in the default way
 * @gl: the glock
 * @state: the state we're requesting
 * @flags: the modifier flags
 * @gh: the holder structure
 *
 */

B
Bob Peterson 已提交
760
void gfs2_holder_init(struct gfs2_glock *gl, unsigned int state, u16 flags,
D
David Teigland 已提交
761 762 763 764
		      struct gfs2_holder *gh)
{
	INIT_LIST_HEAD(&gh->gh_list);
	gh->gh_gl = gl;
765
	gh->gh_ip = _RET_IP_;
766
	gh->gh_owner_pid = get_pid(task_pid(current));
D
David Teigland 已提交
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783
	gh->gh_state = state;
	gh->gh_flags = flags;
	gh->gh_error = 0;
	gh->gh_iflags = 0;
	gfs2_glock_hold(gl);
}

/**
 * gfs2_holder_reinit - reinitialize a struct gfs2_holder so we can requeue it
 * @state: the state we're requesting
 * @flags: the modifier flags
 * @gh: the holder structure
 *
 * Don't mess with the glock.
 *
 */

B
Bob Peterson 已提交
784
void gfs2_holder_reinit(unsigned int state, u16 flags, struct gfs2_holder *gh)
D
David Teigland 已提交
785 786
{
	gh->gh_state = state;
787
	gh->gh_flags = flags;
788
	gh->gh_iflags = 0;
789
	gh->gh_ip = _RET_IP_;
790
	put_pid(gh->gh_owner_pid);
B
Bob Peterson 已提交
791
	gh->gh_owner_pid = get_pid(task_pid(current));
D
David Teigland 已提交
792 793 794 795 796 797 798 799 800 801
}

/**
 * gfs2_holder_uninit - uninitialize a holder structure (drop glock reference)
 * @gh: the holder structure
 *
 */

void gfs2_holder_uninit(struct gfs2_holder *gh)
{
802
	put_pid(gh->gh_owner_pid);
D
David Teigland 已提交
803
	gfs2_glock_put(gh->gh_gl);
A
Andreas Gruenbacher 已提交
804
	gfs2_holder_mark_uninitialized(gh);
S
Steven Whitehouse 已提交
805
	gh->gh_ip = 0;
D
David Teigland 已提交
806 807
}

808 809 810 811 812 813 814 815
/**
 * gfs2_glock_wait - wait on a glock acquisition
 * @gh: the glock holder
 *
 * Returns: 0 on success
 */

int gfs2_glock_wait(struct gfs2_holder *gh)
816
{
817 818
	unsigned long time1 = jiffies;

819
	might_sleep();
820
	wait_on_bit(&gh->gh_iflags, HIF_WAIT, TASK_UNINTERRUPTIBLE);
821 822 823 824 825
	if (time_after(jiffies, time1 + HZ)) /* have we waited > a second? */
		/* Lengthen the minimum hold time. */
		gh->gh_gl->gl_hold_time = min(gh->gh_gl->gl_hold_time +
					      GL_GLOCK_HOLD_INCR,
					      GL_GLOCK_MAX_HOLD);
826
	return gh->gh_error;
827 828
}

D
David Teigland 已提交
829
/**
830 831 832
 * handle_callback - process a demote request
 * @gl: the glock
 * @state: the state the caller wants us to change to
D
David Teigland 已提交
833
 *
834 835
 * There are only two requests that we are going to see in actual
 * practise: LM_ST_SHARED and LM_ST_UNLOCKED
D
David Teigland 已提交
836 837
 */

838
static void handle_callback(struct gfs2_glock *gl, unsigned int state,
839
			    unsigned long delay, bool remote)
D
David Teigland 已提交
840
{
841
	int bit = delay ? GLF_PENDING_DEMOTE : GLF_DEMOTE;
D
David Teigland 已提交
842

843 844 845 846 847 848 849
	set_bit(bit, &gl->gl_flags);
	if (gl->gl_demote_state == LM_ST_EXCLUSIVE) {
		gl->gl_demote_state = state;
		gl->gl_demote_time = jiffies;
	} else if (gl->gl_demote_state != LM_ST_UNLOCKED &&
			gl->gl_demote_state != state) {
		gl->gl_demote_state = LM_ST_UNLOCKED;
D
David Teigland 已提交
850
	}
851
	if (gl->gl_ops->go_callback)
852
		gl->gl_ops->go_callback(gl, remote);
853
	trace_gfs2_demote_rq(gl, remote);
D
David Teigland 已提交
854 855
}

856
void gfs2_print_dbg(struct seq_file *seq, const char *fmt, ...)
857
{
858
	struct va_format vaf;
859 860 861
	va_list args;

	va_start(args, fmt);
862

863
	if (seq) {
864
		seq_vprintf(seq, fmt, args);
865
	} else {
866 867 868
		vaf.fmt = fmt;
		vaf.va = &args;

869
		pr_err("%pV", &vaf);
870
	}
871

872 873 874
	va_end(args);
}

D
David Teigland 已提交
875 876 877 878
/**
 * add_to_queue - Add a holder to the wait queue (but look for recursion)
 * @gh: the holder structure to add
 *
879 880 881 882
 * Eventually we should move the recursive locking trap to a
 * debugging option or something like that. This is the fast
 * path and needs to have the minimum number of distractions.
 * 
D
David Teigland 已提交
883 884
 */

885
static inline void add_to_queue(struct gfs2_holder *gh)
A
Andreas Gruenbacher 已提交
886 887
__releases(&gl->gl_lockref.lock)
__acquires(&gl->gl_lockref.lock)
D
David Teigland 已提交
888 889
{
	struct gfs2_glock *gl = gh->gh_gl;
890
	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
891 892
	struct list_head *insert_pt = NULL;
	struct gfs2_holder *gh2;
893
	int try_futile = 0;
D
David Teigland 已提交
894

895
	BUG_ON(gh->gh_owner_pid == NULL);
896 897
	if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags))
		BUG();
898

899 900
	if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)) {
		if (test_bit(GLF_LOCK, &gl->gl_flags))
901
			try_futile = !may_grant(gl, gh);
902 903 904 905 906 907 908 909
		if (test_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags))
			goto fail;
	}

	list_for_each_entry(gh2, &gl->gl_holders, gh_list) {
		if (unlikely(gh2->gh_owner_pid == gh->gh_owner_pid &&
		    (gh->gh_gl->gl_ops->go_type != LM_TYPE_FLOCK)))
			goto trap_recursive;
910 911
		if (try_futile &&
		    !(gh2->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) {
912 913 914 915
fail:
			gh->gh_error = GLR_TRYFAILED;
			gfs2_holder_wake(gh);
			return;
916
		}
917 918 919 920 921
		if (test_bit(HIF_HOLDER, &gh2->gh_iflags))
			continue;
		if (unlikely((gh->gh_flags & LM_FLAG_PRIORITY) && !insert_pt))
			insert_pt = &gh2->gh_list;
	}
922
	set_bit(GLF_QUEUED, &gl->gl_flags);
923
	trace_gfs2_glock_queue(gh, 1);
924 925
	gfs2_glstats_inc(gl, GFS2_LKS_QCOUNT);
	gfs2_sbstats_inc(gl, GFS2_LKS_QCOUNT);
926 927 928 929 930 931 932 933 934 935
	if (likely(insert_pt == NULL)) {
		list_add_tail(&gh->gh_list, &gl->gl_holders);
		if (unlikely(gh->gh_flags & LM_FLAG_PRIORITY))
			goto do_cancel;
		return;
	}
	list_add_tail(&gh->gh_list, insert_pt);
do_cancel:
	gh = list_entry(gl->gl_holders.next, struct gfs2_holder, gh_list);
	if (!(gh->gh_flags & LM_FLAG_PRIORITY)) {
A
Andreas Gruenbacher 已提交
936
		spin_unlock(&gl->gl_lockref.lock);
S
Steven Whitehouse 已提交
937
		if (sdp->sd_lockstruct.ls_ops->lm_cancel)
938
			sdp->sd_lockstruct.ls_ops->lm_cancel(gl);
A
Andreas Gruenbacher 已提交
939
		spin_lock(&gl->gl_lockref.lock);
D
David Teigland 已提交
940
	}
941
	return;
D
David Teigland 已提交
942

943
trap_recursive:
944 945 946
	pr_err("original: %pSR\n", (void *)gh2->gh_ip);
	pr_err("pid: %d\n", pid_nr(gh2->gh_owner_pid));
	pr_err("lock type: %d req lock state : %d\n",
947
	       gh2->gh_gl->gl_name.ln_type, gh2->gh_state);
948 949 950
	pr_err("new: %pSR\n", (void *)gh->gh_ip);
	pr_err("pid: %d\n", pid_nr(gh->gh_owner_pid));
	pr_err("lock type: %d req lock state : %d\n",
951
	       gh->gh_gl->gl_name.ln_type, gh->gh_state);
952
	gfs2_dump_glock(NULL, gl);
953
	BUG();
D
David Teigland 已提交
954 955 956 957 958 959 960 961 962 963 964 965 966 967
}

/**
 * gfs2_glock_nq - enqueue a struct gfs2_holder onto a glock (acquire a glock)
 * @gh: the holder structure
 *
 * if (gh->gh_flags & GL_ASYNC), this never returns an error
 *
 * Returns: 0, GLR_TRYFAILED, or errno on failure
 */

int gfs2_glock_nq(struct gfs2_holder *gh)
{
	struct gfs2_glock *gl = gh->gh_gl;
968
	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
D
David Teigland 已提交
969 970
	int error = 0;

971
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
D
David Teigland 已提交
972 973
		return -EIO;

974 975 976
	if (test_bit(GLF_LRU, &gl->gl_flags))
		gfs2_glock_remove_from_lru(gl);

A
Andreas Gruenbacher 已提交
977
	spin_lock(&gl->gl_lockref.lock);
D
David Teigland 已提交
978
	add_to_queue(gh);
979 980
	if (unlikely((LM_FLAG_NOEXP & gh->gh_flags) &&
		     test_and_clear_bit(GLF_FROZEN, &gl->gl_flags))) {
981
		set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
982 983 984 985
		gl->gl_lockref.count++;
		if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
			gl->gl_lockref.count--;
	}
986
	run_queue(gl, 1);
A
Andreas Gruenbacher 已提交
987
	spin_unlock(&gl->gl_lockref.lock);
D
David Teigland 已提交
988

989 990
	if (!(gh->gh_flags & GL_ASYNC))
		error = gfs2_glock_wait(gh);
D
David Teigland 已提交
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003

	return error;
}

/**
 * gfs2_glock_poll - poll to see if an async request has been completed
 * @gh: the holder
 *
 * Returns: 1 if the request is ready to be gfs2_glock_wait()ed on
 */

int gfs2_glock_poll(struct gfs2_holder *gh)
{
1004
	return test_bit(HIF_WAIT, &gh->gh_iflags) ? 0 : 1;
D
David Teigland 已提交
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
}

/**
 * gfs2_glock_dq - dequeue a struct gfs2_holder from a glock (release a glock)
 * @gh: the glock holder
 *
 */

void gfs2_glock_dq(struct gfs2_holder *gh)
{
	struct gfs2_glock *gl = gh->gh_gl;
1016
	const struct gfs2_glock_operations *glops = gl->gl_ops;
1017
	unsigned delay = 0;
1018
	int fast_path = 0;
D
David Teigland 已提交
1019

A
Andreas Gruenbacher 已提交
1020
	spin_lock(&gl->gl_lockref.lock);
D
David Teigland 已提交
1021
	if (gh->gh_flags & GL_NOCACHE)
1022
		handle_callback(gl, LM_ST_UNLOCKED, 0, false);
D
David Teigland 已提交
1023 1024

	list_del_init(&gh->gh_list);
1025
	clear_bit(HIF_HOLDER, &gh->gh_iflags);
1026
	if (find_first_holder(gl) == NULL) {
1027
		if (glops->go_unlock) {
1028
			GLOCK_BUG_ON(gl, test_and_set_bit(GLF_LOCK, &gl->gl_flags));
A
Andreas Gruenbacher 已提交
1029
			spin_unlock(&gl->gl_lockref.lock);
D
David Teigland 已提交
1030
			glops->go_unlock(gh);
A
Andreas Gruenbacher 已提交
1031
			spin_lock(&gl->gl_lockref.lock);
1032
			clear_bit(GLF_LOCK, &gl->gl_flags);
1033
		}
1034 1035 1036 1037
		if (list_empty(&gl->gl_holders) &&
		    !test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
		    !test_bit(GLF_DEMOTE, &gl->gl_flags))
			fast_path = 1;
D
David Teigland 已提交
1038
	}
1039 1040
	if (!test_bit(GLF_LFLUSH, &gl->gl_flags) && demote_ok(gl) &&
	    (glops->go_flags & GLOF_LRU))
1041 1042
		gfs2_glock_add_to_lru(gl);

S
Steven Whitehouse 已提交
1043
	trace_gfs2_glock_queue(gh, 0);
A
Andreas Gruenbacher 已提交
1044
	spin_unlock(&gl->gl_lockref.lock);
1045 1046
	if (likely(fast_path))
		return;
1047 1048 1049

	gfs2_glock_hold(gl);
	if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
1050 1051 1052
	    !test_bit(GLF_DEMOTE, &gl->gl_flags) &&
	    gl->gl_name.ln_type == LM_TYPE_INODE)
		delay = gl->gl_hold_time;
1053 1054
	if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
		gfs2_glock_put(gl);
D
David Teigland 已提交
1055 1056
}

A
Abhijith Das 已提交
1057 1058 1059 1060
void gfs2_glock_dq_wait(struct gfs2_holder *gh)
{
	struct gfs2_glock *gl = gh->gh_gl;
	gfs2_glock_dq(gh);
1061
	might_sleep();
1062
	wait_on_bit(&gl->gl_flags, GLF_DEMOTE, TASK_UNINTERRUPTIBLE);
A
Abhijith Das 已提交
1063 1064
}

D
David Teigland 已提交
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
/**
 * gfs2_glock_dq_uninit - dequeue a holder from a glock and initialize it
 * @gh: the holder structure
 *
 */

void gfs2_glock_dq_uninit(struct gfs2_holder *gh)
{
	gfs2_glock_dq(gh);
	gfs2_holder_uninit(gh);
}

/**
 * gfs2_glock_nq_num - acquire a glock based on lock number
 * @sdp: the filesystem
 * @number: the lock number
 * @glops: the glock operations for the type of glock
 * @state: the state to acquire the glock in
L
Lucas De Marchi 已提交
1083
 * @flags: modifier flags for the acquisition
D
David Teigland 已提交
1084 1085 1086 1087 1088
 * @gh: the struct gfs2_holder
 *
 * Returns: errno
 */

1089
int gfs2_glock_nq_num(struct gfs2_sbd *sdp, u64 number,
1090
		      const struct gfs2_glock_operations *glops,
B
Bob Peterson 已提交
1091
		      unsigned int state, u16 flags, struct gfs2_holder *gh)
D
David Teigland 已提交
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
{
	struct gfs2_glock *gl;
	int error;

	error = gfs2_glock_get(sdp, number, glops, CREATE, &gl);
	if (!error) {
		error = gfs2_glock_nq_init(gl, state, flags, gh);
		gfs2_glock_put(gl);
	}

	return error;
}

/**
 * glock_compare - Compare two struct gfs2_glock structures for sorting
 * @arg_a: the first structure
 * @arg_b: the second structure
 *
 */

static int glock_compare(const void *arg_a, const void *arg_b)
{
1114 1115 1116 1117
	const struct gfs2_holder *gh_a = *(const struct gfs2_holder **)arg_a;
	const struct gfs2_holder *gh_b = *(const struct gfs2_holder **)arg_b;
	const struct lm_lockname *a = &gh_a->gh_gl->gl_name;
	const struct lm_lockname *b = &gh_b->gh_gl->gl_name;
D
David Teigland 已提交
1118 1119

	if (a->ln_number > b->ln_number)
1120 1121 1122
		return 1;
	if (a->ln_number < b->ln_number)
		return -1;
1123
	BUG_ON(gh_a->gh_gl->gl_ops->go_type == gh_b->gh_gl->gl_ops->go_type);
1124
	return 0;
D
David Teigland 已提交
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
}

/**
 * nq_m_sync - synchonously acquire more than one glock in deadlock free order
 * @num_gh: the number of structures
 * @ghs: an array of struct gfs2_holder structures
 *
 * Returns: 0 on success (all glocks acquired),
 *          errno on failure (no glocks acquired)
 */

static int nq_m_sync(unsigned int num_gh, struct gfs2_holder *ghs,
		     struct gfs2_holder **p)
{
	unsigned int x;
	int error = 0;

	for (x = 0; x < num_gh; x++)
		p[x] = &ghs[x];

	sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare, NULL);

	for (x = 0; x < num_gh; x++) {
		p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);

		error = gfs2_glock_nq(p[x]);
		if (error) {
			while (x--)
				gfs2_glock_dq(p[x]);
			break;
		}
	}

	return error;
}

/**
 * gfs2_glock_nq_m - acquire multiple glocks
 * @num_gh: the number of structures
 * @ghs: an array of struct gfs2_holder structures
 *
 *
 * Returns: 0 on success (all glocks acquired),
 *          errno on failure (no glocks acquired)
 */

int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs)
{
1173 1174
	struct gfs2_holder *tmp[4];
	struct gfs2_holder **pph = tmp;
D
David Teigland 已提交
1175 1176
	int error = 0;

1177 1178
	switch(num_gh) {
	case 0:
D
David Teigland 已提交
1179
		return 0;
1180
	case 1:
D
David Teigland 已提交
1181 1182
		ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
		return gfs2_glock_nq(ghs);
1183 1184
	default:
		if (num_gh <= 4)
D
David Teigland 已提交
1185
			break;
1186 1187 1188
		pph = kmalloc(num_gh * sizeof(struct gfs2_holder *), GFP_NOFS);
		if (!pph)
			return -ENOMEM;
D
David Teigland 已提交
1189 1190
	}

1191
	error = nq_m_sync(num_gh, ghs, pph);
D
David Teigland 已提交
1192

1193 1194
	if (pph != tmp)
		kfree(pph);
D
David Teigland 已提交
1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207

	return error;
}

/**
 * gfs2_glock_dq_m - release multiple glocks
 * @num_gh: the number of structures
 * @ghs: an array of struct gfs2_holder structures
 *
 */

void gfs2_glock_dq_m(unsigned int num_gh, struct gfs2_holder *ghs)
{
1208 1209
	while (num_gh--)
		gfs2_glock_dq(&ghs[num_gh]);
D
David Teigland 已提交
1210 1211
}

1212
void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state)
1213
{
1214 1215 1216
	unsigned long delay = 0;
	unsigned long holdtime;
	unsigned long now = jiffies;
D
David Teigland 已提交
1217

1218
	gfs2_glock_hold(gl);
1219 1220 1221
	holdtime = gl->gl_tchange + gl->gl_hold_time;
	if (test_bit(GLF_QUEUED, &gl->gl_flags) &&
	    gl->gl_name.ln_type == LM_TYPE_INODE) {
1222 1223 1224
		if (time_before(now, holdtime))
			delay = holdtime - now;
		if (test_bit(GLF_REPLY_PENDING, &gl->gl_flags))
1225
			delay = gl->gl_hold_time;
1226
	}
D
David Teigland 已提交
1227

A
Andreas Gruenbacher 已提交
1228
	spin_lock(&gl->gl_lockref.lock);
1229
	handle_callback(gl, state, delay, true);
A
Andreas Gruenbacher 已提交
1230
	spin_unlock(&gl->gl_lockref.lock);
1231 1232
	if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
		gfs2_glock_put(gl);
D
David Teigland 已提交
1233 1234
}

1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
/**
 * gfs2_should_freeze - Figure out if glock should be frozen
 * @gl: The glock in question
 *
 * Glocks are not frozen if (a) the result of the dlm operation is
 * an error, (b) the locking operation was an unlock operation or
 * (c) if there is a "noexp" flagged request anywhere in the queue
 *
 * Returns: 1 if freezing should occur, 0 otherwise
 */

static int gfs2_should_freeze(const struct gfs2_glock *gl)
{
	const struct gfs2_holder *gh;

	if (gl->gl_reply & ~LM_OUT_ST_MASK)
		return 0;
	if (gl->gl_target == LM_ST_UNLOCKED)
		return 0;

	list_for_each_entry(gh, &gl->gl_holders, gh_list) {
		if (test_bit(HIF_HOLDER, &gh->gh_iflags))
			continue;
		if (LM_FLAG_NOEXP & gh->gh_flags)
			return 0;
	}

	return 1;
}

D
David Teigland 已提交
1265
/**
1266 1267 1268
 * gfs2_glock_complete - Callback used by locking
 * @gl: Pointer to the glock
 * @ret: The return value from the dlm
D
David Teigland 已提交
1269
 *
A
Andreas Gruenbacher 已提交
1270
 * The gl_reply field is under the gl_lockref.lock lock so that it is ok
1271
 * to use a bitfield shared with other glock state fields.
D
David Teigland 已提交
1272 1273
 */

1274
void gfs2_glock_complete(struct gfs2_glock *gl, int ret)
D
David Teigland 已提交
1275
{
1276
	struct lm_lockstruct *ls = &gl->gl_name.ln_sbd->sd_lockstruct;
1277

A
Andreas Gruenbacher 已提交
1278
	spin_lock(&gl->gl_lockref.lock);
1279
	gl->gl_reply = ret;
1280

1281
	if (unlikely(test_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags))) {
1282
		if (gfs2_should_freeze(gl)) {
1283
			set_bit(GLF_FROZEN, &gl->gl_flags);
A
Andreas Gruenbacher 已提交
1284
			spin_unlock(&gl->gl_lockref.lock);
D
David Teigland 已提交
1285
			return;
1286
		}
D
David Teigland 已提交
1287
	}
1288

S
Steven Whitehouse 已提交
1289
	gl->gl_lockref.count++;
1290
	set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
A
Andreas Gruenbacher 已提交
1291
	spin_unlock(&gl->gl_lockref.lock);
S
Steven Whitehouse 已提交
1292

1293 1294
	if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
		gfs2_glock_put(gl);
D
David Teigland 已提交
1295 1296
}

1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336
static int glock_cmp(void *priv, struct list_head *a, struct list_head *b)
{
	struct gfs2_glock *gla, *glb;

	gla = list_entry(a, struct gfs2_glock, gl_lru);
	glb = list_entry(b, struct gfs2_glock, gl_lru);

	if (gla->gl_name.ln_number > glb->gl_name.ln_number)
		return 1;
	if (gla->gl_name.ln_number < glb->gl_name.ln_number)
		return -1;

	return 0;
}

/**
 * gfs2_dispose_glock_lru - Demote a list of glocks
 * @list: The list to dispose of
 *
 * Disposing of glocks may involve disk accesses, so that here we sort
 * the glocks by number (i.e. disk location of the inodes) so that if
 * there are any such accesses, they'll be sent in order (mostly).
 *
 * Must be called under the lru_lock, but may drop and retake this
 * lock. While the lru_lock is dropped, entries may vanish from the
 * list, but no new entries will appear on the list (since it is
 * private)
 */

static void gfs2_dispose_glock_lru(struct list_head *list)
__releases(&lru_lock)
__acquires(&lru_lock)
{
	struct gfs2_glock *gl;

	list_sort(NULL, list, glock_cmp);

	while(!list_empty(list)) {
		gl = list_entry(list->next, struct gfs2_glock, gl_lru);
		list_del_init(&gl->gl_lru);
A
Andreas Gruenbacher 已提交
1337
		if (!spin_trylock(&gl->gl_lockref.lock)) {
1338
add_back_to_lru:
S
Steven Whitehouse 已提交
1339 1340 1341 1342
			list_add(&gl->gl_lru, &lru_list);
			atomic_inc(&lru_count);
			continue;
		}
1343
		if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
A
Andreas Gruenbacher 已提交
1344
			spin_unlock(&gl->gl_lockref.lock);
1345 1346
			goto add_back_to_lru;
		}
1347
		clear_bit(GLF_LRU, &gl->gl_flags);
S
Steven Whitehouse 已提交
1348
		gl->gl_lockref.count++;
1349
		if (demote_ok(gl))
1350
			handle_callback(gl, LM_ST_UNLOCKED, 0, false);
1351 1352
		WARN_ON(!test_and_clear_bit(GLF_LOCK, &gl->gl_flags));
		if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
S
Steven Whitehouse 已提交
1353
			gl->gl_lockref.count--;
A
Andreas Gruenbacher 已提交
1354
		spin_unlock(&gl->gl_lockref.lock);
1355
		cond_resched_lock(&lru_lock);
1356 1357 1358
	}
}

1359 1360 1361 1362
/**
 * gfs2_scan_glock_lru - Scan the LRU looking for locks to demote
 * @nr: The number of entries to scan
 *
1363 1364 1365
 * This function selects the entries on the LRU which are able to
 * be demoted, and then kicks off the process by calling
 * gfs2_dispose_glock_lru() above.
1366
 */
D
David Teigland 已提交
1367

1368
static long gfs2_scan_glock_lru(int nr)
D
David Teigland 已提交
1369 1370
{
	struct gfs2_glock *gl;
1371
	LIST_HEAD(skipped);
1372
	LIST_HEAD(dispose);
1373
	long freed = 0;
D
David Teigland 已提交
1374

1375
	spin_lock(&lru_lock);
1376
	while ((nr-- >= 0) && !list_empty(&lru_list)) {
1377 1378 1379
		gl = list_entry(lru_list.next, struct gfs2_glock, gl_lru);

		/* Test for being demotable */
1380
		if (!test_bit(GLF_LOCK, &gl->gl_flags)) {
1381 1382
			list_move(&gl->gl_lru, &dispose);
			atomic_dec(&lru_count);
1383
			freed++;
S
Steven Whitehouse 已提交
1384
			continue;
1385
		}
1386 1387

		list_move(&gl->gl_lru, &skipped);
D
David Teigland 已提交
1388
	}
1389
	list_splice(&skipped, &lru_list);
1390 1391
	if (!list_empty(&dispose))
		gfs2_dispose_glock_lru(&dispose);
1392
	spin_unlock(&lru_lock);
1393 1394

	return freed;
1395 1396
}

1397 1398
static unsigned long gfs2_glock_shrink_scan(struct shrinker *shrink,
					    struct shrink_control *sc)
1399
{
1400 1401 1402 1403
	if (!(sc->gfp_mask & __GFP_FS))
		return SHRINK_STOP;
	return gfs2_scan_glock_lru(sc->nr_to_scan);
}
1404

1405 1406 1407
static unsigned long gfs2_glock_shrink_count(struct shrinker *shrink,
					     struct shrink_control *sc)
{
1408
	return vfs_pressure_ratio(atomic_read(&lru_count));
D
David Teigland 已提交
1409 1410
}

1411 1412
static struct shrinker glock_shrinker = {
	.seeks = DEFAULT_SEEKS,
1413 1414
	.count_objects = gfs2_glock_shrink_count,
	.scan_objects = gfs2_glock_shrink_scan,
1415 1416
};

D
David Teigland 已提交
1417 1418 1419 1420 1421 1422
/**
 * examine_bucket - Call a function for glock in a hash bucket
 * @examiner: the function
 * @sdp: the filesystem
 * @bucket: the bucket
 *
1423 1424 1425
 * Note that the function can be called multiple times on the same
 * object.  So the user must ensure that the function can cope with
 * that.
D
David Teigland 已提交
1426 1427
 */

1428
static void glock_hash_walk(glock_examiner examiner, const struct gfs2_sbd *sdp)
D
David Teigland 已提交
1429
{
1430
	struct gfs2_glock *gl;
1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
	struct rhashtable_iter iter;

	rhashtable_walk_enter(&gl_hash_table, &iter);

	do {
		gl = ERR_PTR(rhashtable_walk_start(&iter));
		if (gl)
			continue;

		while ((gl = rhashtable_walk_next(&iter)) && !IS_ERR(gl))
1441 1442 1443
			if ((gl->gl_name.ln_sbd == sdp) &&
			    lockref_get_not_dead(&gl->gl_lockref))
				examiner(gl);
1444 1445 1446 1447 1448

		rhashtable_walk_stop(&iter);
	} while (cond_resched(), gl == ERR_PTR(-EAGAIN));

	rhashtable_walk_exit(&iter);
1449 1450
}

1451 1452 1453 1454 1455 1456 1457 1458 1459
/**
 * thaw_glock - thaw out a glock which has an unprocessed reply waiting
 * @gl: The glock to thaw
 *
 */

static void thaw_glock(struct gfs2_glock *gl)
{
	if (!test_and_clear_bit(GLF_FROZEN, &gl->gl_flags))
1460
		goto out;
1461
	set_bit(GLF_REPLY_PENDING, &gl->gl_flags);
1462 1463
	if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0) {
out:
1464
		gfs2_glock_put(gl);
1465
	}
1466 1467
}

D
David Teigland 已提交
1468 1469 1470 1471 1472 1473 1474 1475
/**
 * clear_glock - look at a glock and see if we can free it from glock cache
 * @gl: the glock to look at
 *
 */

static void clear_glock(struct gfs2_glock *gl)
{
1476
	gfs2_glock_remove_from_lru(gl);
D
David Teigland 已提交
1477

A
Andreas Gruenbacher 已提交
1478
	spin_lock(&gl->gl_lockref.lock);
1479
	if (gl->gl_state != LM_ST_UNLOCKED)
1480
		handle_callback(gl, LM_ST_UNLOCKED, 0, false);
A
Andreas Gruenbacher 已提交
1481
	spin_unlock(&gl->gl_lockref.lock);
1482 1483
	if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
		gfs2_glock_put(gl);
D
David Teigland 已提交
1484 1485
}

1486 1487 1488 1489 1490 1491 1492 1493
/**
 * gfs2_glock_thaw - Thaw any frozen glocks
 * @sdp: The super block
 *
 */

void gfs2_glock_thaw(struct gfs2_sbd *sdp)
{
1494 1495
	glock_hash_walk(thaw_glock, sdp);
}
1496

1497
static void dump_glock(struct seq_file *seq, struct gfs2_glock *gl)
1498
{
A
Andreas Gruenbacher 已提交
1499
	spin_lock(&gl->gl_lockref.lock);
1500
	gfs2_dump_glock(seq, gl);
A
Andreas Gruenbacher 已提交
1501
	spin_unlock(&gl->gl_lockref.lock);
1502 1503 1504 1505 1506
}

static void dump_glock_func(struct gfs2_glock *gl)
{
	dump_glock(NULL, gl);
1507 1508
}

D
David Teigland 已提交
1509 1510 1511 1512 1513
/**
 * gfs2_gl_hash_clear - Empty out the glock hash table
 * @sdp: the filesystem
 * @wait: wait until it's all gone
 *
1514
 * Called when unmounting the filesystem.
D
David Teigland 已提交
1515 1516
 */

1517
void gfs2_gl_hash_clear(struct gfs2_sbd *sdp)
D
David Teigland 已提交
1518
{
1519
	set_bit(SDF_SKIP_DLM_UNLOCK, &sdp->sd_flags);
1520
	flush_workqueue(glock_workqueue);
1521
	glock_hash_walk(clear_glock, sdp);
1522
	flush_workqueue(glock_workqueue);
1523 1524 1525
	wait_event_timeout(sdp->sd_glock_wait,
			   atomic_read(&sdp->sd_glock_disposal) == 0,
			   HZ * 600);
1526
	glock_hash_walk(dump_glock_func, sdp);
D
David Teigland 已提交
1527 1528
}

1529 1530 1531 1532 1533 1534
void gfs2_glock_finish_truncate(struct gfs2_inode *ip)
{
	struct gfs2_glock *gl = ip->i_gl;
	int ret;

	ret = gfs2_truncatei_resume(ip);
1535
	gfs2_assert_withdraw(gl->gl_name.ln_sbd, ret == 0);
1536

A
Andreas Gruenbacher 已提交
1537
	spin_lock(&gl->gl_lockref.lock);
1538 1539
	clear_bit(GLF_LOCK, &gl->gl_flags);
	run_queue(gl, 1);
A
Andreas Gruenbacher 已提交
1540
	spin_unlock(&gl->gl_lockref.lock);
1541 1542
}

1543
static const char *state2str(unsigned state)
1544
{
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
	switch(state) {
	case LM_ST_UNLOCKED:
		return "UN";
	case LM_ST_SHARED:
		return "SH";
	case LM_ST_DEFERRED:
		return "DF";
	case LM_ST_EXCLUSIVE:
		return "EX";
	}
	return "??";
}

B
Bob Peterson 已提交
1558
static const char *hflags2str(char *buf, u16 flags, unsigned long iflags)
1559 1560 1561 1562 1563 1564 1565 1566 1567
{
	char *p = buf;
	if (flags & LM_FLAG_TRY)
		*p++ = 't';
	if (flags & LM_FLAG_TRY_1CB)
		*p++ = 'T';
	if (flags & LM_FLAG_NOEXP)
		*p++ = 'e';
	if (flags & LM_FLAG_ANY)
1568
		*p++ = 'A';
1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
	if (flags & LM_FLAG_PRIORITY)
		*p++ = 'p';
	if (flags & GL_ASYNC)
		*p++ = 'a';
	if (flags & GL_EXACT)
		*p++ = 'E';
	if (flags & GL_NOCACHE)
		*p++ = 'c';
	if (test_bit(HIF_HOLDER, &iflags))
		*p++ = 'H';
	if (test_bit(HIF_WAIT, &iflags))
		*p++ = 'W';
	if (test_bit(HIF_FIRST, &iflags))
		*p++ = 'F';
	*p = 0;
	return buf;
1585 1586
}

D
David Teigland 已提交
1587 1588
/**
 * dump_holder - print information about a glock holder
1589
 * @seq: the seq_file struct
D
David Teigland 已提交
1590 1591 1592 1593
 * @gh: the glock holder
 *
 */

1594
static void dump_holder(struct seq_file *seq, const struct gfs2_holder *gh)
D
David Teigland 已提交
1595
{
1596 1597
	struct task_struct *gh_owner = NULL;
	char flags_buf[32];
D
David Teigland 已提交
1598

1599
	rcu_read_lock();
1600
	if (gh->gh_owner_pid)
1601
		gh_owner = pid_task(gh->gh_owner_pid, PIDTYPE_PID);
1602 1603 1604 1605 1606 1607 1608
	gfs2_print_dbg(seq, " H: s:%s f:%s e:%d p:%ld [%s] %pS\n",
		       state2str(gh->gh_state),
		       hflags2str(flags_buf, gh->gh_flags, gh->gh_iflags),
		       gh->gh_error,
		       gh->gh_owner_pid ? (long)pid_nr(gh->gh_owner_pid) : -1,
		       gh_owner ? gh_owner->comm : "(ended)",
		       (void *)gh->gh_ip);
1609
	rcu_read_unlock();
D
David Teigland 已提交
1610 1611
}

1612
static const char *gflags2str(char *buf, const struct gfs2_glock *gl)
1613
{
1614
	const unsigned long *gflags = &gl->gl_flags;
1615
	char *p = buf;
1616

1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632
	if (test_bit(GLF_LOCK, gflags))
		*p++ = 'l';
	if (test_bit(GLF_DEMOTE, gflags))
		*p++ = 'D';
	if (test_bit(GLF_PENDING_DEMOTE, gflags))
		*p++ = 'd';
	if (test_bit(GLF_DEMOTE_IN_PROGRESS, gflags))
		*p++ = 'p';
	if (test_bit(GLF_DIRTY, gflags))
		*p++ = 'y';
	if (test_bit(GLF_LFLUSH, gflags))
		*p++ = 'f';
	if (test_bit(GLF_INVALIDATE_IN_PROGRESS, gflags))
		*p++ = 'i';
	if (test_bit(GLF_REPLY_PENDING, gflags))
		*p++ = 'r';
1633
	if (test_bit(GLF_INITIAL, gflags))
1634
		*p++ = 'I';
1635 1636
	if (test_bit(GLF_FROZEN, gflags))
		*p++ = 'F';
1637 1638
	if (test_bit(GLF_QUEUED, gflags))
		*p++ = 'q';
1639 1640 1641 1642
	if (test_bit(GLF_LRU, gflags))
		*p++ = 'L';
	if (gl->gl_object)
		*p++ = 'o';
1643 1644
	if (test_bit(GLF_BLOCKING, gflags))
		*p++ = 'b';
1645 1646
	*p = 0;
	return buf;
D
David Teigland 已提交
1647 1648 1649
}

/**
1650
 * gfs2_dump_glock - print information about a glock
1651
 * @seq: The seq_file struct
D
David Teigland 已提交
1652
 * @gl: the glock
1653 1654 1655 1656 1657 1658 1659 1660 1661 1662
 *
 * The file format is as follows:
 * One line per object, capital letters are used to indicate objects
 * G = glock, I = Inode, R = rgrp, H = holder. Glocks are not indented,
 * other objects are indented by a single space and follow the glock to
 * which they are related. Fields are indicated by lower case letters
 * followed by a colon and the field value, except for strings which are in
 * [] so that its possible to see if they are composed of spaces for
 * example. The field's are n = number (id of the object), f = flags,
 * t = type, s = state, r = refcount, e = error, p = pid.
D
David Teigland 已提交
1663 1664 1665
 *
 */

1666
void gfs2_dump_glock(struct seq_file *seq, const struct gfs2_glock *gl)
D
David Teigland 已提交
1667
{
1668 1669 1670 1671
	const struct gfs2_glock_operations *glops = gl->gl_ops;
	unsigned long long dtime;
	const struct gfs2_holder *gh;
	char gflags_buf[32];
D
David Teigland 已提交
1672

1673 1674 1675 1676
	dtime = jiffies - gl->gl_demote_time;
	dtime *= 1000000/HZ; /* demote time in uSec */
	if (!test_bit(GLF_DEMOTE, &gl->gl_flags))
		dtime = 0;
1677
	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",
1678 1679 1680
		  state2str(gl->gl_state),
		  gl->gl_name.ln_type,
		  (unsigned long long)gl->gl_name.ln_number,
1681
		  gflags2str(gflags_buf, gl),
1682 1683 1684
		  state2str(gl->gl_target),
		  state2str(gl->gl_demote_state), dtime,
		  atomic_read(&gl->gl_ail_count),
1685
		  atomic_read(&gl->gl_revokes),
S
Steven Whitehouse 已提交
1686
		  (int)gl->gl_lockref.count, gl->gl_hold_time);
D
David Teigland 已提交
1687

1688 1689 1690
	list_for_each_entry(gh, &gl->gl_holders, gh_list)
		dump_holder(seq, gh);

1691
	if (gl->gl_state != LM_ST_UNLOCKED && glops->go_dump)
1692
		glops->go_dump(seq, gl);
D
David Teigland 已提交
1693 1694
}

1695 1696 1697 1698
static int gfs2_glstats_seq_show(struct seq_file *seq, void *iter_ptr)
{
	struct gfs2_glock *gl = iter_ptr;

1699
	seq_printf(seq, "G: n:%u/%llx rtt:%llu/%llu rttb:%llu/%llu irt:%llu/%llu dcnt: %llu qcnt: %llu\n",
1700 1701
		   gl->gl_name.ln_type,
		   (unsigned long long)gl->gl_name.ln_number,
1702 1703 1704 1705 1706 1707 1708 1709
		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTT],
		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTVAR],
		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTB],
		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTVARB],
		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SIRT],
		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SIRTVAR],
		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_DCOUNT],
		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_QCOUNT]);
1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741
	return 0;
}

static const char *gfs2_gltype[] = {
	"type",
	"reserved",
	"nondisk",
	"inode",
	"rgrp",
	"meta",
	"iopen",
	"flock",
	"plock",
	"quota",
	"journal",
};

static const char *gfs2_stype[] = {
	[GFS2_LKS_SRTT]		= "srtt",
	[GFS2_LKS_SRTTVAR]	= "srttvar",
	[GFS2_LKS_SRTTB]	= "srttb",
	[GFS2_LKS_SRTTVARB]	= "srttvarb",
	[GFS2_LKS_SIRT]		= "sirt",
	[GFS2_LKS_SIRTVAR]	= "sirtvar",
	[GFS2_LKS_DCOUNT]	= "dlm",
	[GFS2_LKS_QCOUNT]	= "queue",
};

#define GFS2_NR_SBSTATS (ARRAY_SIZE(gfs2_gltype) * ARRAY_SIZE(gfs2_stype))

static int gfs2_sbstats_seq_show(struct seq_file *seq, void *iter_ptr)
{
1742 1743 1744 1745
	struct gfs2_sbd *sdp = seq->private;
	loff_t pos = *(loff_t *)iter_ptr;
	unsigned index = pos >> 3;
	unsigned subindex = pos & 0x07;
1746 1747 1748 1749
	int i;

	if (index == 0 && subindex != 0)
		return 0;
1750

1751 1752
	seq_printf(seq, "%-10s %8s:", gfs2_gltype[index],
		   (index == 0) ? "cpu": gfs2_stype[subindex]);
D
David Teigland 已提交
1753

1754 1755
	for_each_possible_cpu(i) {
                const struct gfs2_pcpu_lkstats *lkstats = per_cpu_ptr(sdp->sd_lkstats, i);
1756 1757 1758 1759 1760 1761

		if (index == 0)
			seq_printf(seq, " %15u", i);
		else
			seq_printf(seq, " %15llu", (unsigned long long)lkstats->
				   lkstats[index - 1].stats[subindex]);
1762 1763 1764 1765
	}
	seq_putc(seq, '\n');
	return 0;
}
1766

1767 1768
int __init gfs2_glock_init(void)
{
1769 1770 1771 1772 1773
	int ret;

	ret = rhashtable_init(&gl_hash_table, &ht_parms);
	if (ret < 0)
		return ret;
1774

1775
	glock_workqueue = alloc_workqueue("glock_workqueue", WQ_MEM_RECLAIM |
1776
					  WQ_HIGHPRI | WQ_FREEZABLE, 0);
1777 1778
	if (!glock_workqueue) {
		rhashtable_destroy(&gl_hash_table);
1779
		return -ENOMEM;
1780
	}
1781
	gfs2_delete_workqueue = alloc_workqueue("delete_workqueue",
1782
						WQ_MEM_RECLAIM | WQ_FREEZABLE,
1783
						0);
1784
	if (!gfs2_delete_workqueue) {
1785
		destroy_workqueue(glock_workqueue);
1786
		rhashtable_destroy(&gl_hash_table);
1787
		return -ENOMEM;
1788
	}
1789

1790 1791 1792 1793 1794 1795 1796
	ret = register_shrinker(&glock_shrinker);
	if (ret) {
		destroy_workqueue(gfs2_delete_workqueue);
		destroy_workqueue(glock_workqueue);
		rhashtable_destroy(&gl_hash_table);
		return ret;
	}
1797

1798 1799 1800
	return 0;
}

1801 1802
void gfs2_glock_exit(void)
{
1803
	unregister_shrinker(&glock_shrinker);
1804
	rhashtable_destroy(&gl_hash_table);
1805
	destroy_workqueue(glock_workqueue);
1806
	destroy_workqueue(gfs2_delete_workqueue);
1807 1808
}

1809
static void gfs2_glock_iter_next(struct gfs2_glock_iter *gi)
1810 1811
{
	do {
1812 1813 1814 1815 1816
		gi->gl = rhashtable_walk_next(&gi->hti);
		if (IS_ERR(gi->gl)) {
			if (PTR_ERR(gi->gl) == -EAGAIN)
				continue;
			gi->gl = NULL;
1817 1818
		}
	/* Skip entries for other sb and dead entries */
1819 1820
	} while ((gi->gl) && ((gi->sdp != gi->gl->gl_name.ln_sbd) ||
			      __lockref_is_dead(&gi->gl->gl_lockref)));
1821 1822
}

1823
static void *gfs2_glock_seq_start(struct seq_file *seq, loff_t *pos)
1824
{
1825
	struct gfs2_glock_iter *gi = seq->private;
1826
	loff_t n = *pos;
1827
	int ret;
1828

1829
	if (gi->last_pos <= *pos)
1830
		n = (*pos - gi->last_pos);
1831

1832 1833 1834
	ret = rhashtable_walk_start(&gi->hti);
	if (ret)
		return NULL;
1835

1836
	do {
1837 1838
		gfs2_glock_iter_next(gi);
	} while (gi->gl && n--);
1839

1840
	gi->last_pos = *pos;
1841
	return gi->gl;
1842 1843
}

1844
static void *gfs2_glock_seq_next(struct seq_file *seq, void *iter_ptr,
1845 1846
				 loff_t *pos)
{
1847
	struct gfs2_glock_iter *gi = seq->private;
1848 1849

	(*pos)++;
1850
	gi->last_pos = *pos;
1851
	gfs2_glock_iter_next(gi);
1852
	return gi->gl;
1853 1854
}

1855
static void gfs2_glock_seq_stop(struct seq_file *seq, void *iter_ptr)
1856
{
1857
	struct gfs2_glock_iter *gi = seq->private;
1858 1859

	gi->gl = NULL;
1860
	rhashtable_walk_stop(&gi->hti);
1861 1862
}

1863
static int gfs2_glock_seq_show(struct seq_file *seq, void *iter_ptr)
1864
{
1865 1866
	dump_glock(seq, iter_ptr);
	return 0;
1867 1868
}

1869 1870
static void *gfs2_sbstats_seq_start(struct seq_file *seq, loff_t *pos)
{
1871
	preempt_disable();
1872 1873
	if (*pos >= GFS2_NR_SBSTATS)
		return NULL;
1874
	return pos;
1875 1876 1877 1878 1879 1880
}

static void *gfs2_sbstats_seq_next(struct seq_file *seq, void *iter_ptr,
				   loff_t *pos)
{
	(*pos)++;
1881
	if (*pos >= GFS2_NR_SBSTATS)
1882
		return NULL;
1883
	return pos;
1884 1885 1886 1887 1888 1889 1890
}

static void gfs2_sbstats_seq_stop(struct seq_file *seq, void *iter_ptr)
{
	preempt_enable();
}

1891
static const struct seq_operations gfs2_glock_seq_ops = {
1892 1893 1894 1895 1896 1897
	.start = gfs2_glock_seq_start,
	.next  = gfs2_glock_seq_next,
	.stop  = gfs2_glock_seq_stop,
	.show  = gfs2_glock_seq_show,
};

1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
static const struct seq_operations gfs2_glstats_seq_ops = {
	.start = gfs2_glock_seq_start,
	.next  = gfs2_glock_seq_next,
	.stop  = gfs2_glock_seq_stop,
	.show  = gfs2_glstats_seq_show,
};

static const struct seq_operations gfs2_sbstats_seq_ops = {
	.start = gfs2_sbstats_seq_start,
	.next  = gfs2_sbstats_seq_next,
	.stop  = gfs2_sbstats_seq_stop,
	.show  = gfs2_sbstats_seq_show,
};

1912 1913
#define GFS2_SEQ_GOODSIZE min(PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER, 65536UL)

1914
static int gfs2_glocks_open(struct inode *inode, struct file *file)
1915
{
1916 1917 1918 1919 1920
	int ret = seq_open_private(file, &gfs2_glock_seq_ops,
				   sizeof(struct gfs2_glock_iter));
	if (ret == 0) {
		struct seq_file *seq = file->private_data;
		struct gfs2_glock_iter *gi = seq->private;
1921

1922
		gi->sdp = inode->i_private;
1923
		gi->last_pos = 0;
1924
		seq->buf = kmalloc(GFS2_SEQ_GOODSIZE, GFP_KERNEL | __GFP_NOWARN);
1925
		if (seq->buf)
1926
			seq->size = GFS2_SEQ_GOODSIZE;
1927
		gi->gl = NULL;
1928
		ret = rhashtable_walk_init(&gl_hash_table, &gi->hti, GFP_KERNEL);
1929 1930
	}
	return ret;
1931 1932
}

1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
static int gfs2_glocks_release(struct inode *inode, struct file *file)
{
	struct seq_file *seq = file->private_data;
	struct gfs2_glock_iter *gi = seq->private;

	gi->gl = NULL;
	rhashtable_walk_exit(&gi->hti);
	return seq_release_private(inode, file);
}

1943 1944 1945 1946 1947 1948 1949 1950
static int gfs2_glstats_open(struct inode *inode, struct file *file)
{
	int ret = seq_open_private(file, &gfs2_glstats_seq_ops,
				   sizeof(struct gfs2_glock_iter));
	if (ret == 0) {
		struct seq_file *seq = file->private_data;
		struct gfs2_glock_iter *gi = seq->private;
		gi->sdp = inode->i_private;
1951
		gi->last_pos = 0;
1952
		seq->buf = kmalloc(GFS2_SEQ_GOODSIZE, GFP_KERNEL | __GFP_NOWARN);
1953
		if (seq->buf)
1954
			seq->size = GFS2_SEQ_GOODSIZE;
1955
		gi->gl = NULL;
1956
		ret = rhashtable_walk_init(&gl_hash_table, &gi->hti, GFP_KERNEL);
1957 1958 1959 1960 1961 1962
	}
	return ret;
}

static int gfs2_sbstats_open(struct inode *inode, struct file *file)
{
1963
	int ret = seq_open(file, &gfs2_sbstats_seq_ops);
1964 1965
	if (ret == 0) {
		struct seq_file *seq = file->private_data;
1966
		seq->private = inode->i_private;  /* sdp */
1967 1968 1969 1970 1971 1972 1973 1974 1975
	}
	return ret;
}

static const struct file_operations gfs2_glocks_fops = {
	.owner   = THIS_MODULE,
	.open    = gfs2_glocks_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
1976
	.release = gfs2_glocks_release,
1977 1978 1979
};

static const struct file_operations gfs2_glstats_fops = {
1980
	.owner   = THIS_MODULE,
1981 1982 1983
	.open    = gfs2_glstats_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
1984
	.release = gfs2_glocks_release,
1985 1986 1987 1988 1989
};

static const struct file_operations gfs2_sbstats_fops = {
	.owner   = THIS_MODULE,
	.open	 = gfs2_sbstats_open,
1990 1991
	.read    = seq_read,
	.llseek  = seq_lseek,
1992
	.release = seq_release,
1993 1994 1995 1996
};

int gfs2_create_debugfs_file(struct gfs2_sbd *sdp)
{
1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008
	struct dentry *dent;

	dent = debugfs_create_dir(sdp->sd_table_name, gfs2_root);
	if (IS_ERR_OR_NULL(dent))
		goto fail;
	sdp->debugfs_dir = dent;

	dent = debugfs_create_file("glocks",
				   S_IFREG | S_IRUGO,
				   sdp->debugfs_dir, sdp,
				   &gfs2_glocks_fops);
	if (IS_ERR_OR_NULL(dent))
2009
		goto fail;
2010
	sdp->debugfs_dentry_glocks = dent;
2011

2012 2013 2014 2015 2016
	dent = debugfs_create_file("glstats",
				   S_IFREG | S_IRUGO,
				   sdp->debugfs_dir, sdp,
				   &gfs2_glstats_fops);
	if (IS_ERR_OR_NULL(dent))
2017
		goto fail;
2018
	sdp->debugfs_dentry_glstats = dent;
2019

2020 2021 2022 2023 2024
	dent = debugfs_create_file("sbstats",
				   S_IFREG | S_IRUGO,
				   sdp->debugfs_dir, sdp,
				   &gfs2_sbstats_fops);
	if (IS_ERR_OR_NULL(dent))
2025
		goto fail;
2026
	sdp->debugfs_dentry_sbstats = dent;
2027 2028

	return 0;
2029 2030
fail:
	gfs2_delete_debugfs_file(sdp);
2031
	return dent ? PTR_ERR(dent) : -ENOMEM;
2032 2033 2034 2035
}

void gfs2_delete_debugfs_file(struct gfs2_sbd *sdp)
{
2036
	if (sdp->debugfs_dir) {
R
Robert Peterson 已提交
2037 2038 2039 2040
		if (sdp->debugfs_dentry_glocks) {
			debugfs_remove(sdp->debugfs_dentry_glocks);
			sdp->debugfs_dentry_glocks = NULL;
		}
2041 2042 2043 2044 2045 2046 2047 2048
		if (sdp->debugfs_dentry_glstats) {
			debugfs_remove(sdp->debugfs_dentry_glstats);
			sdp->debugfs_dentry_glstats = NULL;
		}
		if (sdp->debugfs_dentry_sbstats) {
			debugfs_remove(sdp->debugfs_dentry_sbstats);
			sdp->debugfs_dentry_sbstats = NULL;
		}
R
Robert Peterson 已提交
2049 2050 2051
		debugfs_remove(sdp->debugfs_dir);
		sdp->debugfs_dir = NULL;
	}
2052 2053 2054 2055 2056
}

int gfs2_register_debugfs(void)
{
	gfs2_root = debugfs_create_dir("gfs2", NULL);
2057 2058
	if (IS_ERR(gfs2_root))
		return PTR_ERR(gfs2_root);
2059 2060 2061 2062 2063 2064
	return gfs2_root ? 0 : -ENOMEM;
}

void gfs2_unregister_debugfs(void)
{
	debugfs_remove(gfs2_root);
R
Robert Peterson 已提交
2065
	gfs2_root = NULL;
2066
}