err.no Git - linux-2.6/blob - fs/gfs2/glock.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
   4  *
   5  * This copyrighted material is made available to anyone wishing to use,
   6  * modify, copy, or redistribute it subject to the terms and conditions
   7  * of the GNU General Public License version 2.
   8  */
   9
  10 #include <linux/sched.h>
  11 #include <linux/slab.h>
  12 #include <linux/spinlock.h>
  13 #include <linux/completion.h>
  14 #include <linux/buffer_head.h>
  15 #include <linux/delay.h>
  16 #include <linux/sort.h>
  17 #include <linux/jhash.h>
  18 #include <linux/kallsyms.h>
  19 #include <linux/gfs2_ondisk.h>
  20 #include <linux/list.h>
  21 #include <linux/lm_interface.h>
  22 #include <linux/wait.h>
  23 #include <linux/module.h>
  24 #include <linux/rwsem.h>
  25 #include <asm/uaccess.h>
  26 #include <linux/seq_file.h>
  27 #include <linux/debugfs.h>
  28 #include <linux/kthread.h>
  29 #include <linux/freezer.h>
  30 #include <linux/workqueue.h>
  31 #include <linux/jiffies.h>
  32
  33 #include "gfs2.h"
  34 #include "incore.h"
  35 #include "glock.h"
  36 #include "glops.h"
  37 #include "inode.h"
  38 #include "lops.h"
  39 #include "meta_io.h"
  40 #include "quota.h"
  41 #include "super.h"
  42 #include "util.h"
  43
  44 struct gfs2_gl_hash_bucket {
  45         struct hlist_head hb_list;
  46 };
  47
  48 struct glock_iter {
  49         int hash;                     /* hash bucket index         */
  50         struct gfs2_sbd *sdp;         /* incore superblock         */
  51         struct gfs2_glock *gl;        /* current glock struct      */
  52         struct seq_file *seq;         /* sequence file for debugfs */
  53         char string[512];             /* scratch space             */
  54 };
  55
  56 typedef void (*glock_examiner) (struct gfs2_glock * gl);
  57
  58 static int gfs2_dump_lockstate(struct gfs2_sbd *sdp);
  59 static int dump_glock(struct glock_iter *gi, struct gfs2_glock *gl);
  60 static void gfs2_glock_xmote_th(struct gfs2_glock *gl, struct gfs2_holder *gh);
  61 static void gfs2_glock_drop_th(struct gfs2_glock *gl);
  62 static void run_queue(struct gfs2_glock *gl);
  63
  64 static DECLARE_RWSEM(gfs2_umount_flush_sem);
  65 static struct dentry *gfs2_root;
  66 static struct task_struct *scand_process;
  67 static unsigned int scand_secs = 5;
  68 static struct workqueue_struct *glock_workqueue;
  69
  70 #define GFS2_GL_HASH_SHIFT      15
  71 #define GFS2_GL_HASH_SIZE       (1 << GFS2_GL_HASH_SHIFT)
  72 #define GFS2_GL_HASH_MASK       (GFS2_GL_HASH_SIZE - 1)
  73
  74 static struct gfs2_gl_hash_bucket gl_hash_table[GFS2_GL_HASH_SIZE];
  75 static struct dentry *gfs2_root;
  76
  77 /*
  78  * Despite what you might think, the numbers below are not arbitrary :-)
  79  * They are taken from the ipv4 routing hash code, which is well tested
  80  * and thus should be nearly optimal. Later on we might tweek the numbers
  81  * but for now this should be fine.
  82  *
  83  * The reason for putting the locks in a separate array from the list heads
  84  * is that we can have fewer locks than list heads and save memory. We use
  85  * the same hash function for both, but with a different hash mask.
  86  */
  87 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) || \
  88         defined(CONFIG_PROVE_LOCKING)
  89
  90 #ifdef CONFIG_LOCKDEP
  91 # define GL_HASH_LOCK_SZ        256
  92 #else
  93 # if NR_CPUS >= 32
  94 #  define GL_HASH_LOCK_SZ       4096
  95 # elif NR_CPUS >= 16
  96 #  define GL_HASH_LOCK_SZ       2048
  97 # elif NR_CPUS >= 8
  98 #  define GL_HASH_LOCK_SZ       1024
  99 # elif NR_CPUS >= 4
 100 #  define GL_HASH_LOCK_SZ       512
 101 # else
 102 #  define GL_HASH_LOCK_SZ       256
 103 # endif
 104 #endif
 105
 106 /* We never want more locks than chains */
 107 #if GFS2_GL_HASH_SIZE < GL_HASH_LOCK_SZ
 108 # undef GL_HASH_LOCK_SZ
 109 # define GL_HASH_LOCK_SZ GFS2_GL_HASH_SIZE
 110 #endif
 111
 112 static rwlock_t gl_hash_locks[GL_HASH_LOCK_SZ];
 113
 114 static inline rwlock_t *gl_lock_addr(unsigned int x)
 115 {
 116         return &gl_hash_locks[x & (GL_HASH_LOCK_SZ-1)];
 117 }
 118 #else /* not SMP, so no spinlocks required */
 119 static inline rwlock_t *gl_lock_addr(unsigned int x)
 120 {
 121         return NULL;
 122 }
 123 #endif
 124
 125 /**
 126  * relaxed_state_ok - is a requested lock compatible with the current lock mode?
 127  * @actual: the current state of the lock
 128  * @requested: the lock state that was requested by the caller
 129  * @flags: the modifier flags passed in by the caller
 130  *
 131  * Returns: 1 if the locks are compatible, 0 otherwise
 132  */
 133
 134 static inline int relaxed_state_ok(unsigned int actual, unsigned requested,
 135                                    int flags)
 136 {
 137         if (actual == requested)
 138                 return 1;
 139
 140         if (flags & GL_EXACT)
 141                 return 0;
 142
 143         if (actual == LM_ST_EXCLUSIVE && requested == LM_ST_SHARED)
 144                 return 1;
 145
 146         if (actual != LM_ST_UNLOCKED && (flags & LM_FLAG_ANY))
 147                 return 1;
 148
 149         return 0;
 150 }
 151
 152 /**
 153  * gl_hash() - Turn glock number into hash bucket number
 154  * @lock: The glock number
 155  *
 156  * Returns: The number of the corresponding hash bucket
 157  */
 158
 159 static unsigned int gl_hash(const struct gfs2_sbd *sdp,
 160                             const struct lm_lockname *name)
 161 {
 162         unsigned int h;
 163
 164         h = jhash(&name->ln_number, sizeof(u64), 0);
 165         h = jhash(&name->ln_type, sizeof(unsigned int), h);
 166         h = jhash(&sdp, sizeof(struct gfs2_sbd *), h);
 167         h &= GFS2_GL_HASH_MASK;
 168
 169         return h;
 170 }
 171
 172 /**
 173  * glock_free() - Perform a few checks and then release struct gfs2_glock
 174  * @gl: The glock to release
 175  *
 176  * Also calls lock module to release its internal structure for this glock.
 177  *
 178  */
 179
 180 static void glock_free(struct gfs2_glock *gl)
 181 {
 182         struct gfs2_sbd *sdp = gl->gl_sbd;
 183         struct inode *aspace = gl->gl_aspace;
 184
 185         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 186                 sdp->sd_lockstruct.ls_ops->lm_put_lock(gl->gl_lock);
 187
 188         if (aspace)
 189                 gfs2_aspace_put(aspace);
 190
 191         kmem_cache_free(gfs2_glock_cachep, gl);
 192 }
 193
 194 /**
 195  * gfs2_glock_hold() - increment reference count on glock
 196  * @gl: The glock to hold
 197  *
 198  */
 199
 200 static void gfs2_glock_hold(struct gfs2_glock *gl)
 201 {
 202         atomic_inc(&gl->gl_ref);
 203 }
 204
 205 /**
 206  * gfs2_glock_put() - Decrement reference count on glock
 207  * @gl: The glock to put
 208  *
 209  */
 210
 211 int gfs2_glock_put(struct gfs2_glock *gl)
 212 {
 213         int rv = 0;
 214         struct gfs2_sbd *sdp = gl->gl_sbd;
 215
 216         write_lock(gl_lock_addr(gl->gl_hash));
 217         if (atomic_dec_and_test(&gl->gl_ref)) {
 218                 hlist_del(&gl->gl_list);
 219                 write_unlock(gl_lock_addr(gl->gl_hash));
 220                 gfs2_assert(sdp, gl->gl_state == LM_ST_UNLOCKED);
 221                 gfs2_assert(sdp, list_empty(&gl->gl_reclaim));
 222                 gfs2_assert(sdp, list_empty(&gl->gl_holders));
 223                 gfs2_assert(sdp, list_empty(&gl->gl_waiters1));
 224                 gfs2_assert(sdp, list_empty(&gl->gl_waiters3));
 225                 glock_free(gl);
 226                 rv = 1;
 227                 goto out;
 228         }
 229         write_unlock(gl_lock_addr(gl->gl_hash));
 230 out:
 231         return rv;
 232 }
 233
 234 /**
 235  * search_bucket() - Find struct gfs2_glock by lock number
 236  * @bucket: the bucket to search
 237  * @name: The lock name
 238  *
 239  * Returns: NULL, or the struct gfs2_glock with the requested number
 240  */
 241
 242 static struct gfs2_glock *search_bucket(unsigned int hash,
 243                                         const struct gfs2_sbd *sdp,
 244                                         const struct lm_lockname *name)
 245 {
 246         struct gfs2_glock *gl;
 247         struct hlist_node *h;
 248
 249         hlist_for_each_entry(gl, h, &gl_hash_table[hash].hb_list, gl_list) {
 250                 if (!lm_name_equal(&gl->gl_name, name))
 251                         continue;
 252                 if (gl->gl_sbd != sdp)
 253                         continue;
 254
 255                 atomic_inc(&gl->gl_ref);
 256
 257                 return gl;
 258         }
 259
 260         return NULL;
 261 }
 262
 263 /**
 264  * gfs2_glock_find() - Find glock by lock number
 265  * @sdp: The GFS2 superblock
 266  * @name: The lock name
 267  *
 268  * Returns: NULL, or the struct gfs2_glock with the requested number
 269  */
 270
 271 static struct gfs2_glock *gfs2_glock_find(const struct gfs2_sbd *sdp,
 272                                           const struct lm_lockname *name)
 273 {
 274         unsigned int hash = gl_hash(sdp, name);
 275         struct gfs2_glock *gl;
 276
 277         read_lock(gl_lock_addr(hash));
 278         gl = search_bucket(hash, sdp, name);
 279         read_unlock(gl_lock_addr(hash));
 280
 281         return gl;
 282 }
 283
 284 static void glock_work_func(struct work_struct *work)
 285 {
 286         struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_work.work);
 287
 288         spin_lock(&gl->gl_spin);
 289         if (test_and_clear_bit(GLF_PENDING_DEMOTE, &gl->gl_flags))
 290                 set_bit(GLF_DEMOTE, &gl->gl_flags);
 291         run_queue(gl);
 292         spin_unlock(&gl->gl_spin);
 293         gfs2_glock_put(gl);
 294 }
 295
 296 static int gfs2_lm_get_lock(struct gfs2_sbd *sdp, struct lm_lockname *name,
 297                      void **lockp)
 298 {
 299         int error = -EIO;
 300         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 301                 error = sdp->sd_lockstruct.ls_ops->lm_get_lock(
 302                                 sdp->sd_lockstruct.ls_lockspace, name, lockp);
 303         return error;
 304 }
 305
 306 /**
 307  * gfs2_glock_get() - Get a glock, or create one if one doesn't exist
 308  * @sdp: The GFS2 superblock
 309  * @number: the lock number
 310  * @glops: The glock_operations to use
 311  * @create: If 0, don't create the glock if it doesn't exist
 312  * @glp: the glock is returned here
 313  *
 314  * This does not lock a glock, just finds/creates structures for one.
 315  *
 316  * Returns: errno
 317  */
 318
 319 int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
 320                    const struct gfs2_glock_operations *glops, int create,
 321                    struct gfs2_glock **glp)
 322 {
 323         struct lm_lockname name = { .ln_number = number, .ln_type = glops->go_type };
 324         struct gfs2_glock *gl, *tmp;
 325         unsigned int hash = gl_hash(sdp, &name);
 326         int error;
 327
 328         read_lock(gl_lock_addr(hash));
 329         gl = search_bucket(hash, sdp, &name);
 330         read_unlock(gl_lock_addr(hash));
 331
 332         if (gl || !create) {
 333                 *glp = gl;
 334                 return 0;
 335         }
 336
 337         gl = kmem_cache_alloc(gfs2_glock_cachep, GFP_KERNEL);
 338         if (!gl)
 339                 return -ENOMEM;
 340
 341         gl->gl_flags = 0;
 342         gl->gl_name = name;
 343         atomic_set(&gl->gl_ref, 1);
 344         gl->gl_state = LM_ST_UNLOCKED;
 345         gl->gl_demote_state = LM_ST_EXCLUSIVE;
 346         gl->gl_hash = hash;
 347         gl->gl_owner_pid = NULL;
 348         gl->gl_ip = 0;
 349         gl->gl_ops = glops;
 350         gl->gl_req_gh = NULL;
 351         gl->gl_stamp = jiffies;
 352         gl->gl_tchange = jiffies;
 353         gl->gl_object = NULL;
 354         gl->gl_sbd = sdp;
 355         gl->gl_aspace = NULL;
 356         INIT_DELAYED_WORK(&gl->gl_work, glock_work_func);
 357
 358         /* If this glock protects actual on-disk data or metadata blocks,
 359            create a VFS inode to manage the pages/buffers holding them. */
 360         if (glops == &gfs2_inode_glops || glops == &gfs2_rgrp_glops) {
 361                 gl->gl_aspace = gfs2_aspace_get(sdp);
 362                 if (!gl->gl_aspace) {
 363                         error = -ENOMEM;
 364                         goto fail;
 365                 }
 366         }
 367
 368         error = gfs2_lm_get_lock(sdp, &name, &gl->gl_lock);
 369         if (error)
 370                 goto fail_aspace;
 371
 372         write_lock(gl_lock_addr(hash));
 373         tmp = search_bucket(hash, sdp, &name);
 374         if (tmp) {
 375                 write_unlock(gl_lock_addr(hash));
 376                 glock_free(gl);
 377                 gl = tmp;
 378         } else {
 379                 hlist_add_head(&gl->gl_list, &gl_hash_table[hash].hb_list);
 380                 write_unlock(gl_lock_addr(hash));
 381         }
 382
 383         *glp = gl;
 384
 385         return 0;
 386
 387 fail_aspace:
 388         if (gl->gl_aspace)
 389                 gfs2_aspace_put(gl->gl_aspace);
 390 fail:
 391         kmem_cache_free(gfs2_glock_cachep, gl);
 392         return error;
 393 }
 394
 395 /**
 396  * gfs2_holder_init - initialize a struct gfs2_holder in the default way
 397  * @gl: the glock
 398  * @state: the state we're requesting
 399  * @flags: the modifier flags
 400  * @gh: the holder structure
 401  *
 402  */
 403
 404 void gfs2_holder_init(struct gfs2_glock *gl, unsigned int state, unsigned flags,
 405                       struct gfs2_holder *gh)
 406 {
 407         INIT_LIST_HEAD(&gh->gh_list);
 408         gh->gh_gl = gl;
 409         gh->gh_ip = (unsigned long)__builtin_return_address(0);
 410         gh->gh_owner_pid = get_pid(task_pid(current));
 411         gh->gh_state = state;
 412         gh->gh_flags = flags;
 413         gh->gh_error = 0;
 414         gh->gh_iflags = 0;
 415         gfs2_glock_hold(gl);
 416 }
 417
 418 /**
 419  * gfs2_holder_reinit - reinitialize a struct gfs2_holder so we can requeue it
 420  * @state: the state we're requesting
 421  * @flags: the modifier flags
 422  * @gh: the holder structure
 423  *
 424  * Don't mess with the glock.
 425  *
 426  */
 427
 428 void gfs2_holder_reinit(unsigned int state, unsigned flags, struct gfs2_holder *gh)
 429 {
 430         gh->gh_state = state;
 431         gh->gh_flags = flags;
 432         gh->gh_iflags = 0;
 433         gh->gh_ip = (unsigned long)__builtin_return_address(0);
 434 }
 435
 436 /**
 437  * gfs2_holder_uninit - uninitialize a holder structure (drop glock reference)
 438  * @gh: the holder structure
 439  *
 440  */
 441
 442 void gfs2_holder_uninit(struct gfs2_holder *gh)
 443 {
 444         put_pid(gh->gh_owner_pid);
 445         gfs2_glock_put(gh->gh_gl);
 446         gh->gh_gl = NULL;
 447         gh->gh_ip = 0;
 448 }
 449
 450 static void gfs2_holder_wake(struct gfs2_holder *gh)
 451 {
 452         clear_bit(HIF_WAIT, &gh->gh_iflags);
 453         smp_mb__after_clear_bit();
 454         wake_up_bit(&gh->gh_iflags, HIF_WAIT);
 455 }
 456
 457 static int just_schedule(void *word)
 458 {
 459         schedule();
 460         return 0;
 461 }
 462
 463 static void wait_on_holder(struct gfs2_holder *gh)
 464 {
 465         might_sleep();
 466         wait_on_bit(&gh->gh_iflags, HIF_WAIT, just_schedule, TASK_UNINTERRUPTIBLE);
 467 }
 468
 469 static void gfs2_demote_wake(struct gfs2_glock *gl)
 470 {
 471         gl->gl_demote_state = LM_ST_EXCLUSIVE;
 472         clear_bit(GLF_DEMOTE, &gl->gl_flags);
 473         smp_mb__after_clear_bit();
 474         wake_up_bit(&gl->gl_flags, GLF_DEMOTE);
 475 }
 476
 477 static void wait_on_demote(struct gfs2_glock *gl)
 478 {
 479         might_sleep();
 480         wait_on_bit(&gl->gl_flags, GLF_DEMOTE, just_schedule, TASK_UNINTERRUPTIBLE);
 481 }
 482
 483 /**
 484  * rq_mutex - process a mutex request in the queue
 485  * @gh: the glock holder
 486  *
 487  * Returns: 1 if the queue is blocked
 488  */
 489
 490 static int rq_mutex(struct gfs2_holder *gh)
 491 {
 492         struct gfs2_glock *gl = gh->gh_gl;
 493
 494         list_del_init(&gh->gh_list);
 495         /*  gh->gh_error never examined.  */
 496         set_bit(GLF_LOCK, &gl->gl_flags);
 497         clear_bit(HIF_WAIT, &gh->gh_iflags);
 498         smp_mb();
 499         wake_up_bit(&gh->gh_iflags, HIF_WAIT);
 500
 501         return 1;
 502 }
 503
 504 /**
 505  * rq_promote - process a promote request in the queue
 506  * @gh: the glock holder
 507  *
 508  * Acquire a new inter-node lock, or change a lock state to more restrictive.
 509  *
 510  * Returns: 1 if the queue is blocked
 511  */
 512
 513 static int rq_promote(struct gfs2_holder *gh)
 514 {
 515         struct gfs2_glock *gl = gh->gh_gl;
 516
 517         if (!relaxed_state_ok(gl->gl_state, gh->gh_state, gh->gh_flags)) {
 518                 if (list_empty(&gl->gl_holders)) {
 519                         gl->gl_req_gh = gh;
 520                         set_bit(GLF_LOCK, &gl->gl_flags);
 521                         spin_unlock(&gl->gl_spin);
 522                         gfs2_glock_xmote_th(gh->gh_gl, gh);
 523                         spin_lock(&gl->gl_spin);
 524                 }
 525                 return 1;
 526         }
 527
 528         if (list_empty(&gl->gl_holders)) {
 529                 set_bit(HIF_FIRST, &gh->gh_iflags);
 530                 set_bit(GLF_LOCK, &gl->gl_flags);
 531         } else {
 532                 struct gfs2_holder *next_gh;
 533                 if (gh->gh_state == LM_ST_EXCLUSIVE)
 534                         return 1;
 535                 next_gh = list_entry(gl->gl_holders.next, struct gfs2_holder,
 536                                      gh_list);
 537                 if (next_gh->gh_state == LM_ST_EXCLUSIVE)
 538                          return 1;
 539         }
 540
 541         list_move_tail(&gh->gh_list, &gl->gl_holders);
 542         gh->gh_error = 0;
 543         set_bit(HIF_HOLDER, &gh->gh_iflags);
 544
 545         gfs2_holder_wake(gh);
 546
 547         return 0;
 548 }
 549
 550 /**
 551  * rq_demote - process a demote request in the queue
 552  * @gh: the glock holder
 553  *
 554  * Returns: 1 if the queue is blocked
 555  */
 556
 557 static int rq_demote(struct gfs2_glock *gl)
 558 {
 559         if (!list_empty(&gl->gl_holders))
 560                 return 1;
 561
 562         if (gl->gl_state == gl->gl_demote_state ||
 563             gl->gl_state == LM_ST_UNLOCKED) {
 564                 gfs2_demote_wake(gl);
 565                 return 0;
 566         }
 567
 568         set_bit(GLF_LOCK, &gl->gl_flags);
 569         set_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags);
 570
 571         if (gl->gl_demote_state == LM_ST_UNLOCKED ||
 572             gl->gl_state != LM_ST_EXCLUSIVE) {
 573                 spin_unlock(&gl->gl_spin);
 574                 gfs2_glock_drop_th(gl);
 575         } else {
 576                 spin_unlock(&gl->gl_spin);
 577                 gfs2_glock_xmote_th(gl, NULL);
 578         }
 579
 580         spin_lock(&gl->gl_spin);
 581         clear_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags);
 582
 583         return 0;
 584 }
 585
 586 /**
 587  * run_queue - process holder structures on a glock
 588  * @gl: the glock
 589  *
 590  */
 591 static void run_queue(struct gfs2_glock *gl)
 592 {
 593         struct gfs2_holder *gh;
 594         int blocked = 1;
 595
 596         for (;;) {
 597                 if (test_bit(GLF_LOCK, &gl->gl_flags))
 598                         break;
 599
 600                 if (!list_empty(&gl->gl_waiters1)) {
 601                         gh = list_entry(gl->gl_waiters1.next,
 602                                         struct gfs2_holder, gh_list);
 603                         blocked = rq_mutex(gh);
 604                 } else if (test_bit(GLF_DEMOTE, &gl->gl_flags)) {
 605                         blocked = rq_demote(gl);
 606                         if (test_bit(GLF_WAITERS2, &gl->gl_flags) &&
 607                                      !blocked) {
 608                                 set_bit(GLF_DEMOTE, &gl->gl_flags);
 609                                 gl->gl_demote_state = LM_ST_UNLOCKED;
 610                         }
 611                         clear_bit(GLF_WAITERS2, &gl->gl_flags);
 612                 } else if (!list_empty(&gl->gl_waiters3)) {
 613                         gh = list_entry(gl->gl_waiters3.next,
 614                                         struct gfs2_holder, gh_list);
 615                         blocked = rq_promote(gh);
 616                 } else
 617                         break;
 618
 619                 if (blocked)
 620                         break;
 621         }
 622 }
 623
 624 /**
 625  * gfs2_glmutex_lock - acquire a local lock on a glock
 626  * @gl: the glock
 627  *
 628  * Gives caller exclusive access to manipulate a glock structure.
 629  */
 630
 631 static void gfs2_glmutex_lock(struct gfs2_glock *gl)
 632 {
 633         spin_lock(&gl->gl_spin);
 634         if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
 635                 struct gfs2_holder gh;
 636
 637                 gfs2_holder_init(gl, 0, 0, &gh);
 638                 set_bit(HIF_WAIT, &gh.gh_iflags);
 639                 list_add_tail(&gh.gh_list, &gl->gl_waiters1);
 640                 spin_unlock(&gl->gl_spin);
 641                 wait_on_holder(&gh);
 642                 gfs2_holder_uninit(&gh);
 643         } else {
 644                 gl->gl_owner_pid = get_pid(task_pid(current));
 645                 gl->gl_ip = (unsigned long)__builtin_return_address(0);
 646                 spin_unlock(&gl->gl_spin);
 647         }
 648 }
 649
 650 /**
 651  * gfs2_glmutex_trylock - try to acquire a local lock on a glock
 652  * @gl: the glock
 653  *
 654  * Returns: 1 if the glock is acquired
 655  */
 656
 657 static int gfs2_glmutex_trylock(struct gfs2_glock *gl)
 658 {
 659         int acquired = 1;
 660
 661         spin_lock(&gl->gl_spin);
 662         if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
 663                 acquired = 0;
 664         } else {
 665                 gl->gl_owner_pid = get_pid(task_pid(current));
 666                 gl->gl_ip = (unsigned long)__builtin_return_address(0);
 667         }
 668         spin_unlock(&gl->gl_spin);
 669
 670         return acquired;
 671 }
 672
 673 /**
 674  * gfs2_glmutex_unlock - release a local lock on a glock
 675  * @gl: the glock
 676  *
 677  */
 678
 679 static void gfs2_glmutex_unlock(struct gfs2_glock *gl)
 680 {
 681         struct pid *pid;
 682
 683         spin_lock(&gl->gl_spin);
 684         clear_bit(GLF_LOCK, &gl->gl_flags);
 685         pid = gl->gl_owner_pid;
 686         gl->gl_owner_pid = NULL;
 687         gl->gl_ip = 0;
 688         run_queue(gl);
 689         spin_unlock(&gl->gl_spin);
 690
 691         put_pid(pid);
 692 }
 693
 694 /**
 695  * handle_callback - process a demote request
 696  * @gl: the glock
 697  * @state: the state the caller wants us to change to
 698  *
 699  * There are only two requests that we are going to see in actual
 700  * practise: LM_ST_SHARED and LM_ST_UNLOCKED
 701  */
 702
 703 static void handle_callback(struct gfs2_glock *gl, unsigned int state,
 704                             int remote, unsigned long delay)
 705 {
 706         int bit = delay ? GLF_PENDING_DEMOTE : GLF_DEMOTE;
 707
 708         spin_lock(&gl->gl_spin);
 709         set_bit(bit, &gl->gl_flags);
 710         if (gl->gl_demote_state == LM_ST_EXCLUSIVE) {
 711                 gl->gl_demote_state = state;
 712                 gl->gl_demote_time = jiffies;
 713                 if (remote && gl->gl_ops->go_type == LM_TYPE_IOPEN &&
 714                     gl->gl_object) {
 715                         gfs2_glock_schedule_for_reclaim(gl);
 716                         spin_unlock(&gl->gl_spin);
 717                         return;
 718                 }
 719         } else if (gl->gl_demote_state != LM_ST_UNLOCKED &&
 720                         gl->gl_demote_state != state) {
 721                 if (test_bit(GLF_DEMOTE_IN_PROGRESS,  &gl->gl_flags))
 722                         set_bit(GLF_WAITERS2, &gl->gl_flags);
 723                 else
 724                         gl->gl_demote_state = LM_ST_UNLOCKED;
 725         }
 726         spin_unlock(&gl->gl_spin);
 727 }
 728
 729 /**
 730  * state_change - record that the glock is now in a different state
 731  * @gl: the glock
 732  * @new_state the new state
 733  *
 734  */
 735
 736 static void state_change(struct gfs2_glock *gl, unsigned int new_state)
 737 {
 738         int held1, held2;
 739
 740         held1 = (gl->gl_state != LM_ST_UNLOCKED);
 741         held2 = (new_state != LM_ST_UNLOCKED);
 742
 743         if (held1 != held2) {
 744                 if (held2)
 745                         gfs2_glock_hold(gl);
 746                 else
 747                         gfs2_glock_put(gl);
 748         }
 749
 750         gl->gl_state = new_state;
 751         gl->gl_tchange = jiffies;
 752 }
 753
 754 /**
 755  * drop_bh - Called after a lock module unlock completes
 756  * @gl: the glock
 757  * @ret: the return status
 758  *
 759  * Doesn't wake up the process waiting on the struct gfs2_holder (if any)
 760  * Doesn't drop the reference on the glock the top half took out
 761  *
 762  */
 763
 764 static void drop_bh(struct gfs2_glock *gl, unsigned int ret)
 765 {
 766         struct gfs2_sbd *sdp = gl->gl_sbd;
 767         const struct gfs2_glock_operations *glops = gl->gl_ops;
 768         struct gfs2_holder *gh = gl->gl_req_gh;
 769
 770         gfs2_assert_warn(sdp, test_bit(GLF_LOCK, &gl->gl_flags));
 771         gfs2_assert_warn(sdp, list_empty(&gl->gl_holders));
 772         gfs2_assert_warn(sdp, !ret);
 773
 774         state_change(gl, LM_ST_UNLOCKED);
 775
 776         if (glops->go_inval)
 777                 glops->go_inval(gl, DIO_METADATA);
 778
 779         if (gh) {
 780                 spin_lock(&gl->gl_spin);
 781                 list_del_init(&gh->gh_list);
 782                 gh->gh_error = 0;
 783                 spin_unlock(&gl->gl_spin);
 784         }
 785
 786         spin_lock(&gl->gl_spin);
 787         gfs2_demote_wake(gl);
 788         gl->gl_req_gh = NULL;
 789         clear_bit(GLF_LOCK, &gl->gl_flags);
 790         spin_unlock(&gl->gl_spin);
 791
 792         gfs2_glock_put(gl);
 793
 794         if (gh)
 795                 gfs2_holder_wake(gh);
 796 }
 797
 798 /**
 799  * xmote_bh - Called after the lock module is done acquiring a lock
 800  * @gl: The glock in question
 801  * @ret: the int returned from the lock module
 802  *
 803  */
 804
 805 static void xmote_bh(struct gfs2_glock *gl, unsigned int ret)
 806 {
 807         struct gfs2_sbd *sdp = gl->gl_sbd;
 808         const struct gfs2_glock_operations *glops = gl->gl_ops;
 809         struct gfs2_holder *gh = gl->gl_req_gh;
 810         int prev_state = gl->gl_state;
 811         int op_done = 1;
 812
 813         if ((ret & LM_OUT_ST_MASK) == LM_ST_UNLOCKED) {
 814                 drop_bh(gl, ret);
 815                 return;
 816         }
 817
 818         gfs2_assert_warn(sdp, test_bit(GLF_LOCK, &gl->gl_flags));
 819         gfs2_assert_warn(sdp, list_empty(&gl->gl_holders));
 820         gfs2_assert_warn(sdp, !(ret & LM_OUT_ASYNC));
 821
 822         state_change(gl, ret & LM_OUT_ST_MASK);
 823
 824         if (prev_state != LM_ST_UNLOCKED && !(ret & LM_OUT_CACHEABLE)) {
 825                 if (glops->go_inval)
 826                         glops->go_inval(gl, DIO_METADATA);
 827         } else if (gl->gl_state == LM_ST_DEFERRED) {
 828                 /* We might not want to do this here.
 829                    Look at moving to the inode glops. */
 830                 if (glops->go_inval)
 831                         glops->go_inval(gl, 0);
 832         }
 833
 834         /*  Deal with each possible exit condition  */
 835
 836         if (!gh) {
 837                 gl->gl_stamp = jiffies;
 838                 if (ret & LM_OUT_CANCELED) {
 839                         op_done = 0;
 840                 } else {
 841                         spin_lock(&gl->gl_spin);
 842                         if (gl->gl_state != gl->gl_demote_state) {
 843                                 spin_unlock(&gl->gl_spin);
 844                                 gfs2_glock_drop_th(gl);
 845                                 gfs2_glock_put(gl);
 846                                 return;
 847                         }
 848                         gfs2_demote_wake(gl);
 849                         spin_unlock(&gl->gl_spin);
 850                 }
 851         } else {
 852                 spin_lock(&gl->gl_spin);
 853                 list_del_init(&gh->gh_list);
 854                 gh->gh_error = -EIO;
 855                 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 856                         goto out;
 857                 gh->gh_error = GLR_CANCELED;
 858                 if (ret & LM_OUT_CANCELED)
 859                         goto out;
 860                 if (relaxed_state_ok(gl->gl_state, gh->gh_state, gh->gh_flags)) {
 861                         list_add_tail(&gh->gh_list, &gl->gl_holders);
 862                         gh->gh_error = 0;
 863                         set_bit(HIF_HOLDER, &gh->gh_iflags);
 864                         set_bit(HIF_FIRST, &gh->gh_iflags);
 865                         op_done = 0;
 866                         goto out;
 867                 }
 868                 gh->gh_error = GLR_TRYFAILED;
 869                 if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))
 870                         goto out;
 871                 gh->gh_error = -EINVAL;
 872                 if (gfs2_assert_withdraw(sdp, 0) == -1)
 873                         fs_err(sdp, "ret = 0x%.8X\n", ret);
 874 out:
 875                 spin_unlock(&gl->gl_spin);
 876         }
 877
 878         if (glops->go_xmote_bh)
 879                 glops->go_xmote_bh(gl);
 880
 881         if (op_done) {
 882                 spin_lock(&gl->gl_spin);
 883                 gl->gl_req_gh = NULL;
 884                 clear_bit(GLF_LOCK, &gl->gl_flags);
 885                 spin_unlock(&gl->gl_spin);
 886         }
 887
 888         gfs2_glock_put(gl);
 889
 890         if (gh)
 891                 gfs2_holder_wake(gh);
 892 }
 893
 894 static unsigned int gfs2_lm_lock(struct gfs2_sbd *sdp, void *lock,
 895                                  unsigned int cur_state, unsigned int req_state,
 896                                  unsigned int flags)
 897 {
 898         int ret = 0;
 899         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 900                 ret = sdp->sd_lockstruct.ls_ops->lm_lock(lock, cur_state,
 901                                                          req_state, flags);
 902         return ret;
 903 }
 904
 905 /**
 906  * gfs2_glock_xmote_th - Call into the lock module to acquire or change a glock
 907  * @gl: The glock in question
 908  * @state: the requested state
 909  * @flags: modifier flags to the lock call
 910  *
 911  */
 912
 913 static void gfs2_glock_xmote_th(struct gfs2_glock *gl, struct gfs2_holder *gh)
 914 {
 915         struct gfs2_sbd *sdp = gl->gl_sbd;
 916         int flags = gh ? gh->gh_flags : 0;
 917         unsigned state = gh ? gh->gh_state : gl->gl_demote_state;
 918         const struct gfs2_glock_operations *glops = gl->gl_ops;
 919         int lck_flags = flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB |
 920                                  LM_FLAG_NOEXP | LM_FLAG_ANY |
 921                                  LM_FLAG_PRIORITY);
 922         unsigned int lck_ret;
 923
 924         if (glops->go_xmote_th)
 925                 glops->go_xmote_th(gl);
 926
 927         gfs2_assert_warn(sdp, test_bit(GLF_LOCK, &gl->gl_flags));
 928         gfs2_assert_warn(sdp, list_empty(&gl->gl_holders));
 929         gfs2_assert_warn(sdp, state != LM_ST_UNLOCKED);
 930         gfs2_assert_warn(sdp, state != gl->gl_state);
 931
 932         gfs2_glock_hold(gl);
 933
 934         lck_ret = gfs2_lm_lock(sdp, gl->gl_lock, gl->gl_state, state, lck_flags);
 935
 936         if (gfs2_assert_withdraw(sdp, !(lck_ret & LM_OUT_ERROR)))
 937                 return;
 938
 939         if (lck_ret & LM_OUT_ASYNC)
 940                 gfs2_assert_warn(sdp, lck_ret == LM_OUT_ASYNC);
 941         else
 942                 xmote_bh(gl, lck_ret);
 943 }
 944
 945 static unsigned int gfs2_lm_unlock(struct gfs2_sbd *sdp, void *lock,
 946                                    unsigned int cur_state)
 947 {
 948         int ret = 0;
 949         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 950                 ret =  sdp->sd_lockstruct.ls_ops->lm_unlock(lock, cur_state);
 951         return ret;
 952 }
 953
 954 /**
 955  * gfs2_glock_drop_th - call into the lock module to unlock a lock
 956  * @gl: the glock
 957  *
 958  */
 959
 960 static void gfs2_glock_drop_th(struct gfs2_glock *gl)
 961 {
 962         struct gfs2_sbd *sdp = gl->gl_sbd;
 963         const struct gfs2_glock_operations *glops = gl->gl_ops;
 964         unsigned int ret;
 965
 966         if (glops->go_xmote_th)
 967                 glops->go_xmote_th(gl);
 968
 969         gfs2_assert_warn(sdp, test_bit(GLF_LOCK, &gl->gl_flags));
 970         gfs2_assert_warn(sdp, list_empty(&gl->gl_holders));
 971         gfs2_assert_warn(sdp, gl->gl_state != LM_ST_UNLOCKED);
 972
 973         gfs2_glock_hold(gl);
 974
 975         ret = gfs2_lm_unlock(sdp, gl->gl_lock, gl->gl_state);
 976
 977         if (gfs2_assert_withdraw(sdp, !(ret & LM_OUT_ERROR)))
 978                 return;
 979
 980         if (!ret)
 981                 drop_bh(gl, ret);
 982         else
 983                 gfs2_assert_warn(sdp, ret == LM_OUT_ASYNC);
 984 }
 985
 986 /**
 987  * do_cancels - cancel requests for locks stuck waiting on an expire flag
 988  * @gh: the LM_FLAG_PRIORITY holder waiting to acquire the lock
 989  *
 990  * Don't cancel GL_NOCANCEL requests.
 991  */
 992
 993 static void do_cancels(struct gfs2_holder *gh)
 994 {
 995         struct gfs2_glock *gl = gh->gh_gl;
 996         struct gfs2_sbd *sdp = gl->gl_sbd;
 997
 998         spin_lock(&gl->gl_spin);
 999
1000         while (gl->gl_req_gh != gh &&
1001                !test_bit(HIF_HOLDER, &gh->gh_iflags) &&
1002                !list_empty(&gh->gh_list)) {
1003                 if (!(gl->gl_req_gh && (gl->gl_req_gh->gh_flags & GL_NOCANCEL))) {
1004                         spin_unlock(&gl->gl_spin);
1005                         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
1006                                 sdp->sd_lockstruct.ls_ops->lm_cancel(gl->gl_lock);
1007                         msleep(100);
1008                         spin_lock(&gl->gl_spin);
1009                 } else {
1010                         spin_unlock(&gl->gl_spin);
1011                         msleep(100);
1012                         spin_lock(&gl->gl_spin);
1013                 }
1014         }
1015
1016         spin_unlock(&gl->gl_spin);
1017 }
1018
1019 /**
1020  * glock_wait_internal - wait on a glock acquisition
1021  * @gh: the glock holder
1022  *
1023  * Returns: 0 on success
1024  */
1025
1026 static int glock_wait_internal(struct gfs2_holder *gh)
1027 {
1028         struct gfs2_glock *gl = gh->gh_gl;
1029         struct gfs2_sbd *sdp = gl->gl_sbd;
1030         const struct gfs2_glock_operations *glops = gl->gl_ops;
1031
1032         if (test_bit(HIF_ABORTED, &gh->gh_iflags))
1033                 return -EIO;
1034
1035         if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)) {
1036                 spin_lock(&gl->gl_spin);
1037                 if (gl->gl_req_gh != gh &&
1038                     !test_bit(HIF_HOLDER, &gh->gh_iflags) &&
1039                     !list_empty(&gh->gh_list)) {
1040                         list_del_init(&gh->gh_list);
1041                         gh->gh_error = GLR_TRYFAILED;
1042                         run_queue(gl);
1043                         spin_unlock(&gl->gl_spin);
1044                         return gh->gh_error;
1045                 }
1046                 spin_unlock(&gl->gl_spin);
1047         }
1048
1049         if (gh->gh_flags & LM_FLAG_PRIORITY)
1050                 do_cancels(gh);
1051
1052         wait_on_holder(gh);
1053         if (gh->gh_error)
1054                 return gh->gh_error;
1055
1056         gfs2_assert_withdraw(sdp, test_bit(HIF_HOLDER, &gh->gh_iflags));
1057         gfs2_assert_withdraw(sdp, relaxed_state_ok(gl->gl_state, gh->gh_state,
1058                                                    gh->gh_flags));
1059
1060         if (test_bit(HIF_FIRST, &gh->gh_iflags)) {
1061                 gfs2_assert_warn(sdp, test_bit(GLF_LOCK, &gl->gl_flags));
1062
1063                 if (glops->go_lock) {
1064                         gh->gh_error = glops->go_lock(gh);
1065                         if (gh->gh_error) {
1066                                 spin_lock(&gl->gl_spin);
1067                                 list_del_init(&gh->gh_list);
1068                                 spin_unlock(&gl->gl_spin);
1069                         }
1070                 }
1071
1072                 spin_lock(&gl->gl_spin);
1073                 gl->gl_req_gh = NULL;
1074                 clear_bit(GLF_LOCK, &gl->gl_flags);
1075                 run_queue(gl);
1076                 spin_unlock(&gl->gl_spin);
1077         }
1078
1079         return gh->gh_error;
1080 }
1081
1082 static inline struct gfs2_holder *
1083 find_holder_by_owner(struct list_head *head, struct pid *pid)
1084 {
1085         struct gfs2_holder *gh;
1086
1087         list_for_each_entry(gh, head, gh_list) {
1088                 if (gh->gh_owner_pid == pid)
1089                         return gh;
1090         }
1091
1092         return NULL;
1093 }
1094
1095 static void print_dbg(struct glock_iter *gi, const char *fmt, ...)
1096 {
1097         va_list args;
1098
1099         va_start(args, fmt);
1100         if (gi) {
1101                 vsprintf(gi->string, fmt, args);
1102                 seq_printf(gi->seq, gi->string);
1103         }
1104         else
1105                 vprintk(fmt, args);
1106         va_end(args);
1107 }
1108
1109 /**
1110  * add_to_queue - Add a holder to the wait queue (but look for recursion)
1111  * @gh: the holder structure to add
1112  *
1113  */
1114
1115 static void add_to_queue(struct gfs2_holder *gh)
1116 {
1117         struct gfs2_glock *gl = gh->gh_gl;
1118         struct gfs2_holder *existing;
1119
1120         BUG_ON(gh->gh_owner_pid == NULL);
1121         if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags))
1122                 BUG();
1123
1124         if (!(gh->gh_flags & GL_FLOCK)) {
1125                 existing = find_holder_by_owner(&gl->gl_holders,
1126                                                 gh->gh_owner_pid);
1127                 if (existing) {
1128                         print_symbol(KERN_WARNING "original: %s\n",
1129                                      existing->gh_ip);
1130                         printk(KERN_INFO "pid : %d\n",
1131                                         pid_nr(existing->gh_owner_pid));
1132                         printk(KERN_INFO "lock type : %d lock state : %d\n",
1133                                existing->gh_gl->gl_name.ln_type,
1134                                existing->gh_gl->gl_state);
1135                         print_symbol(KERN_WARNING "new: %s\n", gh->gh_ip);
1136                         printk(KERN_INFO "pid : %d\n",
1137                                         pid_nr(gh->gh_owner_pid));
1138                         printk(KERN_INFO "lock type : %d lock state : %d\n",
1139                                gl->gl_name.ln_type, gl->gl_state);
1140                         BUG();
1141                 }
1142
1143                 existing = find_holder_by_owner(&gl->gl_waiters3,
1144                                                 gh->gh_owner_pid);
1145                 if (existing) {
1146                         print_symbol(KERN_WARNING "original: %s\n",
1147                                      existing->gh_ip);
1148                         print_symbol(KERN_WARNING "new: %s\n", gh->gh_ip);
1149                         BUG();
1150                 }
1151         }
1152
1153         if (gh->gh_flags & LM_FLAG_PRIORITY)
1154                 list_add(&gh->gh_list, &gl->gl_waiters3);
1155         else
1156                 list_add_tail(&gh->gh_list, &gl->gl_waiters3);
1157 }
1158
1159 /**
1160  * gfs2_glock_nq - enqueue a struct gfs2_holder onto a glock (acquire a glock)
1161  * @gh: the holder structure
1162  *
1163  * if (gh->gh_flags & GL_ASYNC), this never returns an error
1164  *
1165  * Returns: 0, GLR_TRYFAILED, or errno on failure
1166  */
1167
1168 int gfs2_glock_nq(struct gfs2_holder *gh)
1169 {
1170         struct gfs2_glock *gl = gh->gh_gl;
1171         struct gfs2_sbd *sdp = gl->gl_sbd;
1172         int error = 0;
1173
1174 restart:
1175         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) {
1176                 set_bit(HIF_ABORTED, &gh->gh_iflags);
1177                 return -EIO;
1178         }
1179
1180         spin_lock(&gl->gl_spin);
1181         add_to_queue(gh);
1182         run_queue(gl);
1183         spin_unlock(&gl->gl_spin);
1184
1185         if (!(gh->gh_flags & GL_ASYNC)) {
1186                 error = glock_wait_internal(gh);
1187                 if (error == GLR_CANCELED) {
1188                         msleep(100);
1189                         goto restart;
1190                 }
1191         }
1192
1193         return error;
1194 }
1195
1196 /**
1197  * gfs2_glock_poll - poll to see if an async request has been completed
1198  * @gh: the holder
1199  *
1200  * Returns: 1 if the request is ready to be gfs2_glock_wait()ed on
1201  */
1202
1203 int gfs2_glock_poll(struct gfs2_holder *gh)
1204 {
1205         struct gfs2_glock *gl = gh->gh_gl;
1206         int ready = 0;
1207
1208         spin_lock(&gl->gl_spin);
1209
1210         if (test_bit(HIF_HOLDER, &gh->gh_iflags))
1211                 ready = 1;
1212         else if (list_empty(&gh->gh_list)) {
1213                 if (gh->gh_error == GLR_CANCELED) {
1214                         spin_unlock(&gl->gl_spin);
1215                         msleep(100);
1216                         if (gfs2_glock_nq(gh))
1217                                 return 1;
1218                         return 0;
1219                 } else
1220                         ready = 1;
1221         }
1222
1223         spin_unlock(&gl->gl_spin);
1224
1225         return ready;
1226 }
1227
1228 /**
1229  * gfs2_glock_wait - wait for a lock acquisition that ended in a GLR_ASYNC
1230  * @gh: the holder structure
1231  *
1232  * Returns: 0, GLR_TRYFAILED, or errno on failure
1233  */
1234
1235 int gfs2_glock_wait(struct gfs2_holder *gh)
1236 {
1237         int error;
1238
1239         error = glock_wait_internal(gh);
1240         if (error == GLR_CANCELED) {
1241                 msleep(100);
1242                 gh->gh_flags &= ~GL_ASYNC;
1243                 error = gfs2_glock_nq(gh);
1244         }
1245
1246         return error;
1247 }
1248
1249 /**
1250  * gfs2_glock_dq - dequeue a struct gfs2_holder from a glock (release a glock)
1251  * @gh: the glock holder
1252  *
1253  */
1254
1255 void gfs2_glock_dq(struct gfs2_holder *gh)
1256 {
1257         struct gfs2_glock *gl = gh->gh_gl;
1258         const struct gfs2_glock_operations *glops = gl->gl_ops;
1259         unsigned delay = 0;
1260
1261         if (gh->gh_flags & GL_NOCACHE)
1262                 handle_callback(gl, LM_ST_UNLOCKED, 0, 0);
1263
1264         gfs2_glmutex_lock(gl);
1265
1266         spin_lock(&gl->gl_spin);
1267         list_del_init(&gh->gh_list);
1268
1269         if (list_empty(&gl->gl_holders)) {
1270                 if (glops->go_unlock) {
1271                         spin_unlock(&gl->gl_spin);
1272                         glops->go_unlock(gh);
1273                         spin_lock(&gl->gl_spin);
1274                 }
1275                 gl->gl_stamp = jiffies;
1276         }
1277
1278         clear_bit(GLF_LOCK, &gl->gl_flags);
1279         spin_unlock(&gl->gl_spin);
1280
1281         gfs2_glock_hold(gl);
1282         if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
1283             !test_bit(GLF_DEMOTE, &gl->gl_flags))
1284                 delay = gl->gl_ops->go_min_hold_time;
1285         if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
1286                 gfs2_glock_put(gl);
1287 }
1288
1289 void gfs2_glock_dq_wait(struct gfs2_holder *gh)
1290 {
1291         struct gfs2_glock *gl = gh->gh_gl;
1292         gfs2_glock_dq(gh);
1293         wait_on_demote(gl);
1294 }
1295
1296 /**
1297  * gfs2_glock_dq_uninit - dequeue a holder from a glock and initialize it
1298  * @gh: the holder structure
1299  *
1300  */
1301
1302 void gfs2_glock_dq_uninit(struct gfs2_holder *gh)
1303 {
1304         gfs2_glock_dq(gh);
1305         gfs2_holder_uninit(gh);
1306 }
1307
1308 /**
1309  * gfs2_glock_nq_num - acquire a glock based on lock number
1310  * @sdp: the filesystem
1311  * @number: the lock number
1312  * @glops: the glock operations for the type of glock
1313  * @state: the state to acquire the glock in
1314  * @flags: modifier flags for the aquisition
1315  * @gh: the struct gfs2_holder
1316  *
1317  * Returns: errno
1318  */
1319
1320 int gfs2_glock_nq_num(struct gfs2_sbd *sdp, u64 number,
1321                       const struct gfs2_glock_operations *glops,
1322                       unsigned int state, int flags, struct gfs2_holder *gh)
1323 {
1324         struct gfs2_glock *gl;
1325         int error;
1326
1327         error = gfs2_glock_get(sdp, number, glops, CREATE, &gl);
1328         if (!error) {
1329                 error = gfs2_glock_nq_init(gl, state, flags, gh);
1330                 gfs2_glock_put(gl);
1331         }
1332
1333         return error;
1334 }
1335
1336 /**
1337  * glock_compare - Compare two struct gfs2_glock structures for sorting
1338  * @arg_a: the first structure
1339  * @arg_b: the second structure
1340  *
1341  */
1342
1343 static int glock_compare(const void *arg_a, const void *arg_b)
1344 {
1345         const struct gfs2_holder *gh_a = *(const struct gfs2_holder **)arg_a;
1346         const struct gfs2_holder *gh_b = *(const struct gfs2_holder **)arg_b;
1347         const struct lm_lockname *a = &gh_a->gh_gl->gl_name;
1348         const struct lm_lockname *b = &gh_b->gh_gl->gl_name;
1349
1350         if (a->ln_number > b->ln_number)
1351                 return 1;
1352         if (a->ln_number < b->ln_number)
1353                 return -1;
1354         BUG_ON(gh_a->gh_gl->gl_ops->go_type == gh_b->gh_gl->gl_ops->go_type);
1355         return 0;
1356 }
1357
1358 /**
1359  * nq_m_sync - synchonously acquire more than one glock in deadlock free order
1360  * @num_gh: the number of structures
1361  * @ghs: an array of struct gfs2_holder structures
1362  *
1363  * Returns: 0 on success (all glocks acquired),
1364  *          errno on failure (no glocks acquired)
1365  */
1366
1367 static int nq_m_sync(unsigned int num_gh, struct gfs2_holder *ghs,
1368                      struct gfs2_holder **p)
1369 {
1370         unsigned int x;
1371         int error = 0;
1372
1373         for (x = 0; x < num_gh; x++)
1374                 p[x] = &ghs[x];
1375
1376         sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare, NULL);
1377
1378         for (x = 0; x < num_gh; x++) {
1379                 p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1380
1381                 error = gfs2_glock_nq(p[x]);
1382                 if (error) {
1383                         while (x--)
1384                                 gfs2_glock_dq(p[x]);
1385                         break;
1386                 }
1387         }
1388
1389         return error;
1390 }
1391
1392 /**
1393  * gfs2_glock_nq_m - acquire multiple glocks
1394  * @num_gh: the number of structures
1395  * @ghs: an array of struct gfs2_holder structures
1396  *
1397  *
1398  * Returns: 0 on success (all glocks acquired),
1399  *          errno on failure (no glocks acquired)
1400  */
1401
1402 int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs)
1403 {
1404         struct gfs2_holder *tmp[4];
1405         struct gfs2_holder **pph = tmp;
1406         int error = 0;
1407
1408         switch(num_gh) {
1409         case 0:
1410                 return 0;
1411         case 1:
1412                 ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1413                 return gfs2_glock_nq(ghs);
1414         default:
1415                 if (num_gh <= 4)
1416                         break;
1417                 pph = kmalloc(num_gh * sizeof(struct gfs2_holder *), GFP_NOFS);
1418                 if (!pph)
1419                         return -ENOMEM;
1420         }
1421
1422         error = nq_m_sync(num_gh, ghs, pph);
1423
1424         if (pph != tmp)
1425                 kfree(pph);
1426
1427         return error;
1428 }
1429
1430 /**
1431  * gfs2_glock_dq_m - release multiple glocks
1432  * @num_gh: the number of structures
1433  * @ghs: an array of struct gfs2_holder structures
1434  *
1435  */
1436
1437 void gfs2_glock_dq_m(unsigned int num_gh, struct gfs2_holder *ghs)
1438 {
1439         unsigned int x;
1440
1441         for (x = 0; x < num_gh; x++)
1442                 gfs2_glock_dq(&ghs[x]);
1443 }
1444
1445 /**
1446  * gfs2_glock_dq_uninit_m - release multiple glocks
1447  * @num_gh: the number of structures
1448  * @ghs: an array of struct gfs2_holder structures
1449  *
1450  */
1451
1452 void gfs2_glock_dq_uninit_m(unsigned int num_gh, struct gfs2_holder *ghs)
1453 {
1454         unsigned int x;
1455
1456         for (x = 0; x < num_gh; x++)
1457                 gfs2_glock_dq_uninit(&ghs[x]);
1458 }
1459
1460 static int gfs2_lm_hold_lvb(struct gfs2_sbd *sdp, void *lock, char **lvbp)
1461 {
1462         int error = -EIO;
1463         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
1464                 error = sdp->sd_lockstruct.ls_ops->lm_hold_lvb(lock, lvbp);
1465         return error;
1466 }
1467
1468 /**
1469  * gfs2_lvb_hold - attach a LVB from a glock
1470  * @gl: The glock in question
1471  *
1472  */
1473
1474 int gfs2_lvb_hold(struct gfs2_glock *gl)
1475 {
1476         int error;
1477
1478         gfs2_glmutex_lock(gl);
1479
1480         if (!atomic_read(&gl->gl_lvb_count)) {
1481                 error = gfs2_lm_hold_lvb(gl->gl_sbd, gl->gl_lock, &gl->gl_lvb);
1482                 if (error) {
1483                         gfs2_glmutex_unlock(gl);
1484                         return error;
1485                 }
1486                 gfs2_glock_hold(gl);
1487         }
1488         atomic_inc(&gl->gl_lvb_count);
1489
1490         gfs2_glmutex_unlock(gl);
1491
1492         return 0;
1493 }
1494
1495 /**
1496  * gfs2_lvb_unhold - detach a LVB from a glock
1497  * @gl: The glock in question
1498  *
1499  */
1500
1501 void gfs2_lvb_unhold(struct gfs2_glock *gl)
1502 {
1503         struct gfs2_sbd *sdp = gl->gl_sbd;
1504
1505         gfs2_glock_hold(gl);
1506         gfs2_glmutex_lock(gl);
1507
1508         gfs2_assert(gl->gl_sbd, atomic_read(&gl->gl_lvb_count) > 0);
1509         if (atomic_dec_and_test(&gl->gl_lvb_count)) {
1510                 if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
1511                         sdp->sd_lockstruct.ls_ops->lm_unhold_lvb(gl->gl_lock, gl->gl_lvb);
1512                 gl->gl_lvb = NULL;
1513                 gfs2_glock_put(gl);
1514         }
1515
1516         gfs2_glmutex_unlock(gl);
1517         gfs2_glock_put(gl);
1518 }
1519
1520 static void blocking_cb(struct gfs2_sbd *sdp, struct lm_lockname *name,
1521                         unsigned int state)
1522 {
1523         struct gfs2_glock *gl;
1524         unsigned long delay = 0;
1525         unsigned long holdtime;
1526         unsigned long now = jiffies;
1527
1528         gl = gfs2_glock_find(sdp, name);
1529         if (!gl)
1530                 return;
1531
1532         holdtime = gl->gl_tchange + gl->gl_ops->go_min_hold_time;
1533         if (time_before(now, holdtime))
1534                 delay = holdtime - now;
1535
1536         handle_callback(gl, state, 1, delay);
1537         if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
1538                 gfs2_glock_put(gl);
1539 }
1540
1541 /**
1542  * gfs2_glock_cb - Callback used by locking module
1543  * @sdp: Pointer to the superblock
1544  * @type: Type of callback
1545  * @data: Type dependent data pointer
1546  *
1547  * Called by the locking module when it wants to tell us something.
1548  * Either we need to drop a lock, one of our ASYNC requests completed, or
1549  * a journal from another client needs to be recovered.
1550  */
1551
1552 void gfs2_glock_cb(void *cb_data, unsigned int type, void *data)
1553 {
1554         struct gfs2_sbd *sdp = cb_data;
1555
1556         switch (type) {
1557         case LM_CB_NEED_E:
1558                 blocking_cb(sdp, data, LM_ST_UNLOCKED);
1559                 return;
1560
1561         case LM_CB_NEED_D:
1562                 blocking_cb(sdp, data, LM_ST_DEFERRED);
1563                 return;
1564
1565         case LM_CB_NEED_S:
1566                 blocking_cb(sdp, data, LM_ST_SHARED);
1567                 return;
1568
1569         case LM_CB_ASYNC: {
1570                 struct lm_async_cb *async = data;
1571                 struct gfs2_glock *gl;
1572
1573                 down_read(&gfs2_umount_flush_sem);
1574                 gl = gfs2_glock_find(sdp, &async->lc_name);
1575                 if (gfs2_assert_warn(sdp, gl))
1576                         return;
1577                 xmote_bh(gl, async->lc_ret);
1578                 if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
1579                         gfs2_glock_put(gl);
1580                 up_read(&gfs2_umount_flush_sem);
1581                 return;
1582         }
1583
1584         case LM_CB_NEED_RECOVERY:
1585                 gfs2_jdesc_make_dirty(sdp, *(unsigned int *)data);
1586                 if (sdp->sd_recoverd_process)
1587                         wake_up_process(sdp->sd_recoverd_process);
1588                 return;
1589
1590         case LM_CB_DROPLOCKS:
1591                 gfs2_gl_hash_clear(sdp, NO_WAIT);
1592                 gfs2_quota_scan(sdp);
1593                 return;
1594
1595         default:
1596                 gfs2_assert_warn(sdp, 0);
1597                 return;
1598         }
1599 }
1600
1601 /**
1602  * demote_ok - Check to see if it's ok to unlock a glock
1603  * @gl: the glock
1604  *
1605  * Returns: 1 if it's ok
1606  */
1607
1608 static int demote_ok(struct gfs2_glock *gl)
1609 {
1610         const struct gfs2_glock_operations *glops = gl->gl_ops;
1611         int demote = 1;
1612
1613         if (test_bit(GLF_STICKY, &gl->gl_flags))
1614                 demote = 0;
1615         else if (glops->go_demote_ok)
1616                 demote = glops->go_demote_ok(gl);
1617
1618         return demote;
1619 }
1620
1621 /**
1622  * gfs2_glock_schedule_for_reclaim - Add a glock to the reclaim list
1623  * @gl: the glock
1624  *
1625  */
1626
1627 void gfs2_glock_schedule_for_reclaim(struct gfs2_glock *gl)
1628 {
1629         struct gfs2_sbd *sdp = gl->gl_sbd;
1630
1631         spin_lock(&sdp->sd_reclaim_lock);
1632         if (list_empty(&gl->gl_reclaim)) {
1633                 gfs2_glock_hold(gl);
1634                 list_add(&gl->gl_reclaim, &sdp->sd_reclaim_list);
1635                 atomic_inc(&sdp->sd_reclaim_count);
1636                 spin_unlock(&sdp->sd_reclaim_lock);
1637                 wake_up(&sdp->sd_reclaim_wq);
1638         } else
1639                 spin_unlock(&sdp->sd_reclaim_lock);
1640 }
1641
1642 /**
1643  * gfs2_reclaim_glock - process the next glock on the filesystem's reclaim list
1644  * @sdp: the filesystem
1645  *
1646  * Called from gfs2_glockd() glock reclaim daemon, or when promoting a
1647  * different glock and we notice that there are a lot of glocks in the
1648  * reclaim list.
1649  *
1650  */
1651
1652 void gfs2_reclaim_glock(struct gfs2_sbd *sdp)
1653 {
1654         struct gfs2_glock *gl;
1655
1656         spin_lock(&sdp->sd_reclaim_lock);
1657         if (list_empty(&sdp->sd_reclaim_list)) {
1658                 spin_unlock(&sdp->sd_reclaim_lock);
1659                 return;
1660         }
1661         gl = list_entry(sdp->sd_reclaim_list.next,
1662                         struct gfs2_glock, gl_reclaim);
1663         list_del_init(&gl->gl_reclaim);
1664         spin_unlock(&sdp->sd_reclaim_lock);
1665
1666         atomic_dec(&sdp->sd_reclaim_count);
1667         atomic_inc(&sdp->sd_reclaimed);
1668
1669         if (gfs2_glmutex_trylock(gl)) {
1670                 if (list_empty(&gl->gl_holders) &&
1671                     gl->gl_state != LM_ST_UNLOCKED && demote_ok(gl))
1672                         handle_callback(gl, LM_ST_UNLOCKED, 0, 0);
1673                 gfs2_glmutex_unlock(gl);
1674         }
1675
1676         gfs2_glock_put(gl);
1677 }
1678
1679 /**
1680  * examine_bucket - Call a function for glock in a hash bucket
1681  * @examiner: the function
1682  * @sdp: the filesystem
1683  * @bucket: the bucket
1684  *
1685  * Returns: 1 if the bucket has entries
1686  */
1687
1688 static int examine_bucket(glock_examiner examiner, struct gfs2_sbd *sdp,
1689                           unsigned int hash)
1690 {
1691         struct gfs2_glock *gl, *prev = NULL;
1692         int has_entries = 0;
1693         struct hlist_head *head = &gl_hash_table[hash].hb_list;
1694
1695         read_lock(gl_lock_addr(hash));
1696         /* Can't use hlist_for_each_entry - don't want prefetch here */
1697         if (hlist_empty(head))
1698                 goto out;
1699         gl = list_entry(head->first, struct gfs2_glock, gl_list);
1700         while(1) {
1701                 if (!sdp || gl->gl_sbd == sdp) {
1702                         gfs2_glock_hold(gl);
1703                         read_unlock(gl_lock_addr(hash));
1704                         if (prev)
1705                                 gfs2_glock_put(prev);
1706                         prev = gl;
1707                         examiner(gl);
1708                         has_entries = 1;
1709                         read_lock(gl_lock_addr(hash));
1710                 }
1711                 if (gl->gl_list.next == NULL)
1712                         break;
1713                 gl = list_entry(gl->gl_list.next, struct gfs2_glock, gl_list);
1714         }
1715 out:
1716         read_unlock(gl_lock_addr(hash));
1717         if (prev)
1718                 gfs2_glock_put(prev);
1719         cond_resched();
1720         return has_entries;
1721 }
1722
1723 /**
1724  * scan_glock - look at a glock and see if we can reclaim it
1725  * @gl: the glock to look at
1726  *
1727  */
1728
1729 static void scan_glock(struct gfs2_glock *gl)
1730 {
1731         if (gl->gl_ops == &gfs2_inode_glops && gl->gl_object)
1732                 return;
1733
1734         if (gfs2_glmutex_trylock(gl)) {
1735                 if (list_empty(&gl->gl_holders) &&
1736                     gl->gl_state != LM_ST_UNLOCKED && demote_ok(gl))
1737                         goto out_schedule;
1738                 gfs2_glmutex_unlock(gl);
1739         }
1740         return;
1741
1742 out_schedule:
1743         gfs2_glmutex_unlock(gl);
1744         gfs2_glock_schedule_for_reclaim(gl);
1745 }
1746
1747 /**
1748  * clear_glock - look at a glock and see if we can free it from glock cache
1749  * @gl: the glock to look at
1750  *
1751  */
1752
1753 static void clear_glock(struct gfs2_glock *gl)
1754 {
1755         struct gfs2_sbd *sdp = gl->gl_sbd;
1756         int released;
1757
1758         spin_lock(&sdp->sd_reclaim_lock);
1759         if (!list_empty(&gl->gl_reclaim)) {
1760                 list_del_init(&gl->gl_reclaim);
1761                 atomic_dec(&sdp->sd_reclaim_count);
1762                 spin_unlock(&sdp->sd_reclaim_lock);
1763                 released = gfs2_glock_put(gl);
1764                 gfs2_assert(sdp, !released);
1765         } else {
1766                 spin_unlock(&sdp->sd_reclaim_lock);
1767         }
1768
1769         if (gfs2_glmutex_trylock(gl)) {
1770                 if (list_empty(&gl->gl_holders) &&
1771                     gl->gl_state != LM_ST_UNLOCKED)
1772                         handle_callback(gl, LM_ST_UNLOCKED, 0, 0);
1773                 gfs2_glmutex_unlock(gl);
1774         }
1775 }
1776
1777 /**
1778  * gfs2_gl_hash_clear - Empty out the glock hash table
1779  * @sdp: the filesystem
1780  * @wait: wait until it's all gone
1781  *
1782  * Called when unmounting the filesystem, or when inter-node lock manager
1783  * requests DROPLOCKS because it is running out of capacity.
1784  */
1785
1786 void gfs2_gl_hash_clear(struct gfs2_sbd *sdp, int wait)
1787 {
1788         unsigned long t;
1789         unsigned int x;
1790         int cont;
1791
1792         t = jiffies;
1793
1794         for (;;) {
1795                 cont = 0;
1796                 for (x = 0; x < GFS2_GL_HASH_SIZE; x++) {
1797                         if (examine_bucket(clear_glock, sdp, x))
1798                                 cont = 1;
1799                 }
1800
1801                 if (!wait || !cont)
1802                         break;
1803
1804                 if (time_after_eq(jiffies,
1805                                   t + gfs2_tune_get(sdp, gt_stall_secs) * HZ)) {
1806                         fs_warn(sdp, "Unmount seems to be stalled. "
1807                                      "Dumping lock state...\n");
1808                         gfs2_dump_lockstate(sdp);
1809                         t = jiffies;
1810                 }
1811
1812                 down_write(&gfs2_umount_flush_sem);
1813                 invalidate_inodes(sdp->sd_vfs);
1814                 up_write(&gfs2_umount_flush_sem);
1815                 msleep(10);
1816         }
1817 }
1818
1819 /*
1820  *  Diagnostic routines to help debug distributed deadlock
1821  */
1822
1823 static void gfs2_print_symbol(struct glock_iter *gi, const char *fmt,
1824                               unsigned long address)
1825 {
1826         char buffer[KSYM_SYMBOL_LEN];
1827
1828         sprint_symbol(buffer, address);
1829         print_dbg(gi, fmt, buffer);
1830 }
1831
1832 /**
1833  * dump_holder - print information about a glock holder
1834  * @str: a string naming the type of holder
1835  * @gh: the glock holder
1836  *
1837  * Returns: 0 on success, -ENOBUFS when we run out of space
1838  */
1839
1840 static int dump_holder(struct glock_iter *gi, char *str,
1841                        struct gfs2_holder *gh)
1842 {
1843         unsigned int x;
1844         struct task_struct *gh_owner;
1845
1846         print_dbg(gi, "  %s\n", str);
1847         if (gh->gh_owner_pid) {
1848                 print_dbg(gi, "    owner = %ld ",
1849                                 (long)pid_nr(gh->gh_owner_pid));
1850                 gh_owner = pid_task(gh->gh_owner_pid, PIDTYPE_PID);
1851                 if (gh_owner)
1852                         print_dbg(gi, "(%s)\n", gh_owner->comm);
1853                 else
1854                         print_dbg(gi, "(ended)\n");
1855         } else
1856                 print_dbg(gi, "    owner = -1\n");
1857         print_dbg(gi, "    gh_state = %u\n", gh->gh_state);
1858         print_dbg(gi, "    gh_flags =");
1859         for (x = 0; x < 32; x++)
1860                 if (gh->gh_flags & (1 << x))
1861                         print_dbg(gi, " %u", x);
1862         print_dbg(gi, " \n");
1863         print_dbg(gi, "    error = %d\n", gh->gh_error);
1864         print_dbg(gi, "    gh_iflags =");
1865         for (x = 0; x < 32; x++)
1866                 if (test_bit(x, &gh->gh_iflags))
1867                         print_dbg(gi, " %u", x);
1868         print_dbg(gi, " \n");
1869         gfs2_print_symbol(gi, "    initialized at: %s\n", gh->gh_ip);
1870
1871         return 0;
1872 }
1873
1874 /**
1875  * dump_inode - print information about an inode
1876  * @ip: the inode
1877  *
1878  * Returns: 0 on success, -ENOBUFS when we run out of space
1879  */
1880
1881 static int dump_inode(struct glock_iter *gi, struct gfs2_inode *ip)
1882 {
1883         unsigned int x;
1884
1885         print_dbg(gi, "  Inode:\n");
1886         print_dbg(gi, "    num = %llu/%llu\n",
1887                   (unsigned long long)ip->i_no_formal_ino,
1888                   (unsigned long long)ip->i_no_addr);
1889         print_dbg(gi, "    type = %u\n", IF2DT(ip->i_inode.i_mode));
1890         print_dbg(gi, "    i_flags =");
1891         for (x = 0; x < 32; x++)
1892                 if (test_bit(x, &ip->i_flags))
1893                         print_dbg(gi, " %u", x);
1894         print_dbg(gi, " \n");
1895         return 0;
1896 }
1897
1898 /**
1899  * dump_glock - print information about a glock
1900  * @gl: the glock
1901  * @count: where we are in the buffer
1902  *
1903  * Returns: 0 on success, -ENOBUFS when we run out of space
1904  */
1905
1906 static int dump_glock(struct glock_iter *gi, struct gfs2_glock *gl)
1907 {
1908         struct gfs2_holder *gh;
1909         unsigned int x;
1910         int error = -ENOBUFS;
1911         struct task_struct *gl_owner;
1912
1913         spin_lock(&gl->gl_spin);
1914
1915         print_dbg(gi, "Glock 0x%p (%u, 0x%llx)\n", gl, gl->gl_name.ln_type,
1916                    (unsigned long long)gl->gl_name.ln_number);
1917         print_dbg(gi, "  gl_flags =");
1918         for (x = 0; x < 32; x++) {
1919                 if (test_bit(x, &gl->gl_flags))
1920                         print_dbg(gi, " %u", x);
1921         }
1922         if (!test_bit(GLF_LOCK, &gl->gl_flags))
1923                 print_dbg(gi, " (unlocked)");
1924         print_dbg(gi, " \n");
1925         print_dbg(gi, "  gl_ref = %d\n", atomic_read(&gl->gl_ref));
1926         print_dbg(gi, "  gl_state = %u\n", gl->gl_state);
1927         if (gl->gl_owner_pid) {
1928                 gl_owner = pid_task(gl->gl_owner_pid, PIDTYPE_PID);
1929                 if (gl_owner)
1930                         print_dbg(gi, "  gl_owner = pid %d (%s)\n",
1931                                   pid_nr(gl->gl_owner_pid), gl_owner->comm);
1932                 else
1933                         print_dbg(gi, "  gl_owner = %d (ended)\n",
1934                                   pid_nr(gl->gl_owner_pid));
1935         } else
1936                 print_dbg(gi, "  gl_owner = -1\n");
1937         print_dbg(gi, "  gl_ip = %lu\n", gl->gl_ip);
1938         print_dbg(gi, "  req_gh = %s\n", (gl->gl_req_gh) ? "yes" : "no");
1939         print_dbg(gi, "  lvb_count = %d\n", atomic_read(&gl->gl_lvb_count));
1940         print_dbg(gi, "  object = %s\n", (gl->gl_object) ? "yes" : "no");
1941         print_dbg(gi, "  reclaim = %s\n",
1942                    (list_empty(&gl->gl_reclaim)) ? "no" : "yes");
1943         if (gl->gl_aspace)
1944                 print_dbg(gi, "  aspace = 0x%p nrpages = %lu\n", gl->gl_aspace,
1945                            gl->gl_aspace->i_mapping->nrpages);
1946         else
1947                 print_dbg(gi, "  aspace = no\n");
1948         print_dbg(gi, "  ail = %d\n", atomic_read(&gl->gl_ail_count));
1949         if (gl->gl_req_gh) {
1950                 error = dump_holder(gi, "Request", gl->gl_req_gh);
1951                 if (error)
1952                         goto out;
1953         }
1954         list_for_each_entry(gh, &gl->gl_holders, gh_list) {
1955                 error = dump_holder(gi, "Holder", gh);
1956                 if (error)
1957                         goto out;
1958         }
1959         list_for_each_entry(gh, &gl->gl_waiters1, gh_list) {
1960                 error = dump_holder(gi, "Waiter1", gh);
1961                 if (error)
1962                         goto out;
1963         }
1964         list_for_each_entry(gh, &gl->gl_waiters3, gh_list) {
1965                 error = dump_holder(gi, "Waiter3", gh);
1966                 if (error)
1967                         goto out;
1968         }
1969         if (test_bit(GLF_DEMOTE, &gl->gl_flags)) {
1970                 print_dbg(gi, "  Demotion req to state %u (%llu uS ago)\n",
1971                           gl->gl_demote_state, (unsigned long long)
1972                           (jiffies - gl->gl_demote_time)*(1000000/HZ));
1973         }
1974         if (gl->gl_ops == &gfs2_inode_glops && gl->gl_object) {
1975                 if (!test_bit(GLF_LOCK, &gl->gl_flags) &&
1976                         list_empty(&gl->gl_holders)) {
1977                         error = dump_inode(gi, gl->gl_object);
1978                         if (error)
1979                                 goto out;
1980                 } else {
1981                         error = -ENOBUFS;
1982                         print_dbg(gi, "  Inode: busy\n");
1983                 }
1984         }
1985
1986         error = 0;
1987
1988 out:
1989         spin_unlock(&gl->gl_spin);
1990         return error;
1991 }
1992
1993 /**
1994  * gfs2_dump_lockstate - print out the current lockstate
1995  * @sdp: the filesystem
1996  * @ub: the buffer to copy the information into
1997  *
1998  * If @ub is NULL, dump the lockstate to the console.
1999  *
2000  */
2001
2002 static int gfs2_dump_lockstate(struct gfs2_sbd *sdp)
2003 {
2004         struct gfs2_glock *gl;
2005         struct hlist_node *h;
2006         unsigned int x;
2007         int error = 0;
2008
2009         for (x = 0; x < GFS2_GL_HASH_SIZE; x++) {
2010
2011                 read_lock(gl_lock_addr(x));
2012
2013                 hlist_for_each_entry(gl, h, &gl_hash_table[x].hb_list, gl_list) {
2014                         if (gl->gl_sbd != sdp)
2015                                 continue;
2016
2017                         error = dump_glock(NULL, gl);
2018                         if (error)
2019                                 break;
2020                 }
2021
2022                 read_unlock(gl_lock_addr(x));
2023
2024                 if (error)
2025                         break;
2026         }
2027
2028
2029         return error;
2030 }
2031
2032 /**
2033  * gfs2_scand - Look for cached glocks and inodes to toss from memory
2034  * @sdp: Pointer to GFS2 superblock
2035  *
2036  * One of these daemons runs, finding candidates to add to sd_reclaim_list.
2037  * See gfs2_glockd()
2038  */
2039
2040 static int gfs2_scand(void *data)
2041 {
2042         unsigned x;
2043         unsigned delay;
2044
2045         while (!kthread_should_stop()) {
2046                 for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
2047                         examine_bucket(scan_glock, NULL, x);
2048                 if (freezing(current))
2049                         refrigerator();
2050                 delay = scand_secs;
2051                 if (delay < 1)
2052                         delay = 1;
2053                 schedule_timeout_interruptible(delay * HZ);
2054         }
2055
2056         return 0;
2057 }
2058
2059
2060
2061 int __init gfs2_glock_init(void)
2062 {
2063         unsigned i;
2064         for(i = 0; i < GFS2_GL_HASH_SIZE; i++) {
2065                 INIT_HLIST_HEAD(&gl_hash_table[i].hb_list);
2066         }
2067 #ifdef GL_HASH_LOCK_SZ
2068         for(i = 0; i < GL_HASH_LOCK_SZ; i++) {
2069                 rwlock_init(&gl_hash_locks[i]);
2070         }
2071 #endif
2072
2073         scand_process = kthread_run(gfs2_scand, NULL, "gfs2_scand");
2074         if (IS_ERR(scand_process))
2075                 return PTR_ERR(scand_process);
2076
2077         glock_workqueue = create_workqueue("glock_workqueue");
2078         if (IS_ERR(glock_workqueue)) {
2079                 kthread_stop(scand_process);
2080                 return PTR_ERR(glock_workqueue);
2081         }
2082
2083         return 0;
2084 }
2085
2086 void gfs2_glock_exit(void)
2087 {
2088         destroy_workqueue(glock_workqueue);
2089         kthread_stop(scand_process);
2090 }
2091
2092 module_param(scand_secs, uint, S_IRUGO|S_IWUSR);
2093 MODULE_PARM_DESC(scand_secs, "The number of seconds between scand runs");
2094
2095 static int gfs2_glock_iter_next(struct glock_iter *gi)
2096 {
2097         struct gfs2_glock *gl;
2098
2099 restart:
2100         read_lock(gl_lock_addr(gi->hash));
2101         gl = gi->gl;
2102         if (gl) {
2103                 gi->gl = hlist_entry(gl->gl_list.next,
2104                                      struct gfs2_glock, gl_list);
2105                 if (gi->gl)
2106                         gfs2_glock_hold(gi->gl);
2107         }
2108         read_unlock(gl_lock_addr(gi->hash));
2109         if (gl)
2110                 gfs2_glock_put(gl);
2111         if (gl && gi->gl == NULL)
2112                 gi->hash++;
2113         while(gi->gl == NULL) {
2114                 if (gi->hash >= GFS2_GL_HASH_SIZE)
2115                         return 1;
2116                 read_lock(gl_lock_addr(gi->hash));
2117                 gi->gl = hlist_entry(gl_hash_table[gi->hash].hb_list.first,
2118                                      struct gfs2_glock, gl_list);
2119                 if (gi->gl)
2120                         gfs2_glock_hold(gi->gl);
2121                 read_unlock(gl_lock_addr(gi->hash));
2122                 gi->hash++;
2123         }
2124
2125         if (gi->sdp != gi->gl->gl_sbd)
2126                 goto restart;
2127
2128         return 0;
2129 }
2130
2131 static void gfs2_glock_iter_free(struct glock_iter *gi)
2132 {
2133         if (gi->gl)
2134                 gfs2_glock_put(gi->gl);
2135         kfree(gi);
2136 }
2137
2138 static struct glock_iter *gfs2_glock_iter_init(struct gfs2_sbd *sdp)
2139 {
2140         struct glock_iter *gi;
2141
2142         gi = kmalloc(sizeof (*gi), GFP_KERNEL);
2143         if (!gi)
2144                 return NULL;
2145
2146         gi->sdp = sdp;
2147         gi->hash = 0;
2148         gi->seq = NULL;
2149         gi->gl = NULL;
2150         memset(gi->string, 0, sizeof(gi->string));
2151
2152         if (gfs2_glock_iter_next(gi)) {
2153                 gfs2_glock_iter_free(gi);
2154                 return NULL;
2155         }
2156
2157         return gi;
2158 }
2159
2160 static void *gfs2_glock_seq_start(struct seq_file *file, loff_t *pos)
2161 {
2162         struct glock_iter *gi;
2163         loff_t n = *pos;
2164
2165         gi = gfs2_glock_iter_init(file->private);
2166         if (!gi)
2167                 return NULL;
2168
2169         while(n--) {
2170                 if (gfs2_glock_iter_next(gi)) {
2171                         gfs2_glock_iter_free(gi);
2172                         return NULL;
2173                 }
2174         }
2175
2176         return gi;
2177 }
2178
2179 static void *gfs2_glock_seq_next(struct seq_file *file, void *iter_ptr,
2180                                  loff_t *pos)
2181 {
2182         struct glock_iter *gi = iter_ptr;
2183
2184         (*pos)++;
2185
2186         if (gfs2_glock_iter_next(gi)) {
2187                 gfs2_glock_iter_free(gi);
2188                 return NULL;
2189         }
2190
2191         return gi;
2192 }
2193
2194 static void gfs2_glock_seq_stop(struct seq_file *file, void *iter_ptr)
2195 {
2196         struct glock_iter *gi = iter_ptr;
2197         if (gi)
2198                 gfs2_glock_iter_free(gi);
2199 }
2200
2201 static int gfs2_glock_seq_show(struct seq_file *file, void *iter_ptr)
2202 {
2203         struct glock_iter *gi = iter_ptr;
2204
2205         gi->seq = file;
2206         dump_glock(gi, gi->gl);
2207
2208         return 0;
2209 }
2210
2211 static const struct seq_operations gfs2_glock_seq_ops = {
2212         .start = gfs2_glock_seq_start,
2213         .next  = gfs2_glock_seq_next,
2214         .stop  = gfs2_glock_seq_stop,
2215         .show  = gfs2_glock_seq_show,
2216 };
2217
2218 static int gfs2_debugfs_open(struct inode *inode, struct file *file)
2219 {
2220         struct seq_file *seq;
2221         int ret;
2222
2223         ret = seq_open(file, &gfs2_glock_seq_ops);
2224         if (ret)
2225                 return ret;
2226
2227         seq = file->private_data;
2228         seq->private = inode->i_private;
2229
2230         return 0;
2231 }
2232
2233 static const struct file_operations gfs2_debug_fops = {
2234         .owner   = THIS_MODULE,
2235         .open    = gfs2_debugfs_open,
2236         .read    = seq_read,
2237         .llseek  = seq_lseek,
2238         .release = seq_release
2239 };
2240
2241 int gfs2_create_debugfs_file(struct gfs2_sbd *sdp)
2242 {
2243         sdp->debugfs_dir = debugfs_create_dir(sdp->sd_table_name, gfs2_root);
2244         if (!sdp->debugfs_dir)
2245                 return -ENOMEM;
2246         sdp->debugfs_dentry_glocks = debugfs_create_file("glocks",
2247                                                          S_IFREG | S_IRUGO,
2248                                                          sdp->debugfs_dir, sdp,
2249                                                          &gfs2_debug_fops);
2250         if (!sdp->debugfs_dentry_glocks)
2251                 return -ENOMEM;
2252
2253         return 0;
2254 }
2255
2256 void gfs2_delete_debugfs_file(struct gfs2_sbd *sdp)
2257 {
2258         if (sdp && sdp->debugfs_dir) {
2259                 if (sdp->debugfs_dentry_glocks) {
2260                         debugfs_remove(sdp->debugfs_dentry_glocks);
2261                         sdp->debugfs_dentry_glocks = NULL;
2262                 }
2263                 debugfs_remove(sdp->debugfs_dir);
2264                 sdp->debugfs_dir = NULL;
2265         }
2266 }
2267
2268 int gfs2_register_debugfs(void)
2269 {
2270         gfs2_root = debugfs_create_dir("gfs2", NULL);
2271         return gfs2_root ? 0 : -ENOMEM;
2272 }
2273
2274 void gfs2_unregister_debugfs(void)
2275 {
2276         debugfs_remove(gfs2_root);
2277         gfs2_root = NULL;
2278 }