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