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 } 2232