fs/gfs2/glock.c

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