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