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