fs/gfs2/glock.c

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