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