1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 4 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved. 5 */ 6 7#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8 9#include <linux/sched.h> 10#include <linux/slab.h> 11#include <linux/spinlock.h> 12#include <linux/buffer_head.h> 13#include <linux/delay.h> 14#include <linux/sort.h> 15#include <linux/hash.h> 16#include <linux/jhash.h> 17#include <linux/kallsyms.h> 18#include <linux/gfs2_ondisk.h> 19#include <linux/list.h> 20#include <linux/wait.h> 21#include <linux/module.h> 22#include <linux/uaccess.h> 23#include <linux/seq_file.h> 24#include <linux/debugfs.h> 25#include <linux/kthread.h> 26#include <linux/freezer.h> 27#include <linux/workqueue.h> 28#include <linux/jiffies.h> 29#include <linux/rcupdate.h> 30#include <linux/rculist_bl.h> 31#include <linux/bit_spinlock.h> 32#include <linux/percpu.h> 33#include <linux/list_sort.h> 34#include <linux/lockref.h> 35#include <linux/rhashtable.h> 36 37#include "gfs2.h" 38#include "incore.h" 39#include "glock.h" 40#include "glops.h" 41#include "inode.h" 42#include "lops.h" 43#include "meta_io.h" 44#include "quota.h" 45#include "super.h" 46#include "util.h" 47#include "bmap.h" 48#define CREATE_TRACE_POINTS 49#include "trace_gfs2.h" 50 51struct gfs2_glock_iter { 52 struct gfs2_sbd *sdp; /* incore superblock */ 53 struct rhashtable_iter hti; /* rhashtable iterator */ 54 struct gfs2_glock *gl; /* current glock struct */ 55 loff_t last_pos; /* last position */ 56}; 57 58typedef void (*glock_examiner) (struct gfs2_glock * gl); 59 60static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target); 61 62static struct dentry *gfs2_root; 63static struct workqueue_struct *glock_workqueue; 64struct workqueue_struct *gfs2_delete_workqueue; 65static LIST_HEAD(lru_list); 66static atomic_t lru_count = ATOMIC_INIT(0); 67static DEFINE_SPINLOCK(lru_lock); 68 69#define GFS2_GL_HASH_SHIFT 15 70#define GFS2_GL_HASH_SIZE BIT(GFS2_GL_HASH_SHIFT) 71 72static const struct rhashtable_params ht_parms = { 73 .nelem_hint = GFS2_GL_HASH_SIZE * 3 / 4, 74 .key_len = offsetofend(struct lm_lockname, ln_type), 75 .key_offset = offsetof(struct gfs2_glock, gl_name), 76 .head_offset = offsetof(struct gfs2_glock, gl_node), 77}; 78 79static struct rhashtable gl_hash_table; 80 81#define GLOCK_WAIT_TABLE_BITS 12 82#define GLOCK_WAIT_TABLE_SIZE (1 << GLOCK_WAIT_TABLE_BITS) 83static wait_queue_head_t glock_wait_table[GLOCK_WAIT_TABLE_SIZE] __cacheline_aligned; 84 85struct wait_glock_queue { 86 struct lm_lockname *name; 87 wait_queue_entry_t wait; 88}; 89 90static int glock_wake_function(wait_queue_entry_t *wait, unsigned int mode, 91 int sync, void *key) 92{ 93 struct wait_glock_queue *wait_glock = 94 container_of(wait, struct wait_glock_queue, wait); 95 struct lm_lockname *wait_name = wait_glock->name; 96 struct lm_lockname *wake_name = key; 97 98 if (wake_name->ln_sbd != wait_name->ln_sbd || 99 wake_name->ln_number != wait_name->ln_number || 100 wake_name->ln_type != wait_name->ln_type) 101 return 0; 102 return autoremove_wake_function(wait, mode, sync, key); 103} 104 105static wait_queue_head_t *glock_waitqueue(struct lm_lockname *name) 106{ 107 u32 hash = jhash2((u32 *)name, ht_parms.key_len / 4, 0); 108 109 return glock_wait_table + hash_32(hash, GLOCK_WAIT_TABLE_BITS); 110} 111 112/** 113 * wake_up_glock - Wake up waiters on a glock 114 * @gl: the glock 115 */ 116static void wake_up_glock(struct gfs2_glock *gl) 117{ 118 wait_queue_head_t *wq = glock_waitqueue(&gl->gl_name); 119 120 if (waitqueue_active(wq)) 121 __wake_up(wq, TASK_NORMAL, 1, &gl->gl_name); 122} 123 124static void gfs2_glock_dealloc(struct rcu_head *rcu) 125{ 126 struct gfs2_glock *gl = container_of(rcu, struct gfs2_glock, gl_rcu); 127 128 kfree(gl->gl_lksb.sb_lvbptr); 129 if (gl->gl_ops->go_flags & GLOF_ASPACE) 130 kmem_cache_free(gfs2_glock_aspace_cachep, gl); 131 else 132 kmem_cache_free(gfs2_glock_cachep, gl); 133} 134 135/** 136 * glock_blocked_by_withdraw - determine if we can still use a glock 137 * @gl: the glock 138 * 139 * We need to allow some glocks to be enqueued, dequeued, promoted, and demoted 140 * when we're withdrawn. For example, to maintain metadata integrity, we should 141 * disallow the use of inode and rgrp glocks when withdrawn. Other glocks, like 142 * iopen or the transaction glocks may be safely used because none of their 143 * metadata goes through the journal. So in general, we should disallow all 144 * glocks that are journaled, and allow all the others. One exception is: 145 * we need to allow our active journal to be promoted and demoted so others 146 * may recover it and we can reacquire it when they're done. 147 */ 148static bool glock_blocked_by_withdraw(struct gfs2_glock *gl) 149{ 150 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 151 152 if (likely(!gfs2_withdrawn(sdp))) 153 return false; 154 if (gl->gl_ops->go_flags & GLOF_NONDISK) 155 return false; 156 if (!sdp->sd_jdesc || 157 gl->gl_name.ln_number == sdp->sd_jdesc->jd_no_addr) 158 return false; 159 return true; 160} 161 162void gfs2_glock_free(struct gfs2_glock *gl) 163{ 164 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 165 166 gfs2_glock_assert_withdraw(gl, atomic_read(&gl->gl_revokes) == 0); 167 rhashtable_remove_fast(&gl_hash_table, &gl->gl_node, ht_parms); 168 smp_mb(); 169 wake_up_glock(gl); 170 call_rcu(&gl->gl_rcu, gfs2_glock_dealloc); 171 if (atomic_dec_and_test(&sdp->sd_glock_disposal)) 172 wake_up(&sdp->sd_glock_wait); 173} 174 175/** 176 * gfs2_glock_hold() - increment reference count on glock 177 * @gl: The glock to hold 178 * 179 */ 180 181void gfs2_glock_hold(struct gfs2_glock *gl) 182{ 183 GLOCK_BUG_ON(gl, __lockref_is_dead(&gl->gl_lockref)); 184 lockref_get(&gl->gl_lockref); 185} 186 187/** 188 * demote_ok - Check to see if it's ok to unlock a glock 189 * @gl: the glock 190 * 191 * Returns: 1 if it's ok 192 */ 193 194static int demote_ok(const struct gfs2_glock *gl) 195{ 196 const struct gfs2_glock_operations *glops = gl->gl_ops; 197 198 if (gl->gl_state == LM_ST_UNLOCKED) 199 return 0; 200 if (!list_empty(&gl->gl_holders)) 201 return 0; 202 if (glops->go_demote_ok) 203 return glops->go_demote_ok(gl); 204 return 1; 205} 206 207 208void gfs2_glock_add_to_lru(struct gfs2_glock *gl) 209{ 210 if (!(gl->gl_ops->go_flags & GLOF_LRU)) 211 return; 212 213 spin_lock(&lru_lock); 214 215 list_del(&gl->gl_lru); 216 list_add_tail(&gl->gl_lru, &lru_list); 217 218 if (!test_bit(GLF_LRU, &gl->gl_flags)) { 219 set_bit(GLF_LRU, &gl->gl_flags); 220 atomic_inc(&lru_count); 221 } 222 223 spin_unlock(&lru_lock); 224} 225 226static void gfs2_glock_remove_from_lru(struct gfs2_glock *gl) 227{ 228 if (!(gl->gl_ops->go_flags & GLOF_LRU)) 229 return; 230 231 spin_lock(&lru_lock); 232 if (test_bit(GLF_LRU, &gl->gl_flags)) { 233 list_del_init(&gl->gl_lru); 234 atomic_dec(&lru_count); 235 clear_bit(GLF_LRU, &gl->gl_flags); 236 } 237 spin_unlock(&lru_lock); 238} 239 240/* 241 * Enqueue the glock on the work queue. Passes one glock reference on to the 242 * work queue. 243 */ 244static void __gfs2_glock_queue_work(struct gfs2_glock *gl, unsigned long delay) { 245 if (!queue_delayed_work(glock_workqueue, &gl->gl_work, delay)) { 246 /* 247 * We are holding the lockref spinlock, and the work was still 248 * queued above. The queued work (glock_work_func) takes that 249 * spinlock before dropping its glock reference(s), so it 250 * cannot have dropped them in the meantime. 251 */ 252 GLOCK_BUG_ON(gl, gl->gl_lockref.count < 2); 253 gl->gl_lockref.count--; 254 } 255} 256 257static void gfs2_glock_queue_work(struct gfs2_glock *gl, unsigned long delay) { 258 spin_lock(&gl->gl_lockref.lock); 259 __gfs2_glock_queue_work(gl, delay); 260 spin_unlock(&gl->gl_lockref.lock); 261} 262 263static void __gfs2_glock_put(struct gfs2_glock *gl) 264{ 265 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 266 struct address_space *mapping = gfs2_glock2aspace(gl); 267 268 lockref_mark_dead(&gl->gl_lockref); 269 270 gfs2_glock_remove_from_lru(gl); 271 spin_unlock(&gl->gl_lockref.lock); 272 GLOCK_BUG_ON(gl, !list_empty(&gl->gl_holders)); 273 if (mapping) { 274 truncate_inode_pages_final(mapping); 275 if (!gfs2_withdrawn(sdp)) 276 GLOCK_BUG_ON(gl, mapping->nrpages || 277 mapping->nrexceptional); 278 } 279 trace_gfs2_glock_put(gl); 280 sdp->sd_lockstruct.ls_ops->lm_put_lock(gl); 281} 282 283/* 284 * Cause the glock to be put in work queue context. 285 */ 286void gfs2_glock_queue_put(struct gfs2_glock *gl) 287{ 288 gfs2_glock_queue_work(gl, 0); 289} 290 291/** 292 * gfs2_glock_put() - Decrement reference count on glock 293 * @gl: The glock to put 294 * 295 */ 296 297void gfs2_glock_put(struct gfs2_glock *gl) 298{ 299 if (lockref_put_or_lock(&gl->gl_lockref)) 300 return; 301 302 __gfs2_glock_put(gl); 303} 304 305/** 306 * may_grant - check if its ok to grant a new lock 307 * @gl: The glock 308 * @gh: The lock request which we wish to grant 309 * 310 * Returns: true if its ok to grant the lock 311 */ 312 313static inline int may_grant(const struct gfs2_glock *gl, const struct gfs2_holder *gh) 314{ 315 const struct gfs2_holder *gh_head = list_first_entry(&gl->gl_holders, const struct gfs2_holder, gh_list); 316 if ((gh->gh_state == LM_ST_EXCLUSIVE || 317 gh_head->gh_state == LM_ST_EXCLUSIVE) && gh != gh_head) 318 return 0; 319 if (gl->gl_state == gh->gh_state) 320 return 1; 321 if (gh->gh_flags & GL_EXACT) 322 return 0; 323 if (gl->gl_state == LM_ST_EXCLUSIVE) { 324 if (gh->gh_state == LM_ST_SHARED && gh_head->gh_state == LM_ST_SHARED) 325 return 1; 326 if (gh->gh_state == LM_ST_DEFERRED && gh_head->gh_state == LM_ST_DEFERRED) 327 return 1; 328 } 329 if (gl->gl_state != LM_ST_UNLOCKED && (gh->gh_flags & LM_FLAG_ANY)) 330 return 1; 331 return 0; 332} 333 334static void gfs2_holder_wake(struct gfs2_holder *gh) 335{ 336 clear_bit(HIF_WAIT, &gh->gh_iflags); 337 smp_mb__after_atomic(); 338 wake_up_bit(&gh->gh_iflags, HIF_WAIT); 339 if (gh->gh_flags & GL_ASYNC) { 340 struct gfs2_sbd *sdp = gh->gh_gl->gl_name.ln_sbd; 341 342 wake_up(&sdp->sd_async_glock_wait); 343 } 344} 345 346/** 347 * do_error - Something unexpected has happened during a lock request 348 * 349 */ 350 351static void do_error(struct gfs2_glock *gl, const int ret) 352{ 353 struct gfs2_holder *gh, *tmp; 354 355 list_for_each_entry_safe(gh, tmp, &gl->gl_holders, gh_list) { 356 if (test_bit(HIF_HOLDER, &gh->gh_iflags)) 357 continue; 358 if (ret & LM_OUT_ERROR) 359 gh->gh_error = -EIO; 360 else if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)) 361 gh->gh_error = GLR_TRYFAILED; 362 else 363 continue; 364 list_del_init(&gh->gh_list); 365 trace_gfs2_glock_queue(gh, 0); 366 gfs2_holder_wake(gh); 367 } 368} 369 370/** 371 * do_promote - promote as many requests as possible on the current queue 372 * @gl: The glock 373 * 374 * Returns: 1 if there is a blocked holder at the head of the list, or 2 375 * if a type specific operation is underway. 376 */ 377 378static int do_promote(struct gfs2_glock *gl) 379__releases(&gl->gl_lockref.lock) 380__acquires(&gl->gl_lockref.lock) 381{ 382 const struct gfs2_glock_operations *glops = gl->gl_ops; 383 struct gfs2_holder *gh, *tmp; 384 int ret; 385 386restart: 387 list_for_each_entry_safe(gh, tmp, &gl->gl_holders, gh_list) { 388 if (test_bit(HIF_HOLDER, &gh->gh_iflags)) 389 continue; 390 if (may_grant(gl, gh)) { 391 if (gh->gh_list.prev == &gl->gl_holders && 392 glops->go_lock) { 393 spin_unlock(&gl->gl_lockref.lock); 394 /* FIXME: eliminate this eventually */ 395 ret = glops->go_lock(gh); 396 spin_lock(&gl->gl_lockref.lock); 397 if (ret) { 398 if (ret == 1) 399 return 2; 400 gh->gh_error = ret; 401 list_del_init(&gh->gh_list); 402 trace_gfs2_glock_queue(gh, 0); 403 gfs2_holder_wake(gh); 404 goto restart; 405 } 406 set_bit(HIF_HOLDER, &gh->gh_iflags); 407 trace_gfs2_promote(gh, 1); 408 gfs2_holder_wake(gh); 409 goto restart; 410 } 411 set_bit(HIF_HOLDER, &gh->gh_iflags); 412 trace_gfs2_promote(gh, 0); 413 gfs2_holder_wake(gh); 414 continue; 415 } 416 if (gh->gh_list.prev == &gl->gl_holders) 417 return 1; 418 do_error(gl, 0); 419 break; 420 } 421 return 0; 422} 423 424/** 425 * find_first_waiter - find the first gh that's waiting for the glock 426 * @gl: the glock 427 */ 428 429static inline struct gfs2_holder *find_first_waiter(const struct gfs2_glock *gl) 430{ 431 struct gfs2_holder *gh; 432 433 list_for_each_entry(gh, &gl->gl_holders, gh_list) { 434 if (!test_bit(HIF_HOLDER, &gh->gh_iflags)) 435 return gh; 436 } 437 return NULL; 438} 439 440/** 441 * state_change - record that the glock is now in a different state 442 * @gl: the glock 443 * @new_state the new state 444 * 445 */ 446 447static void state_change(struct gfs2_glock *gl, unsigned int new_state) 448{ 449 int held1, held2; 450 451 held1 = (gl->gl_state != LM_ST_UNLOCKED); 452 held2 = (new_state != LM_ST_UNLOCKED); 453 454 if (held1 != held2) { 455 GLOCK_BUG_ON(gl, __lockref_is_dead(&gl->gl_lockref)); 456 if (held2) 457 gl->gl_lockref.count++; 458 else 459 gl->gl_lockref.count--; 460 } 461 if (new_state != gl->gl_target) 462 /* shorten our minimum hold time */ 463 gl->gl_hold_time = max(gl->gl_hold_time - GL_GLOCK_HOLD_DECR, 464 GL_GLOCK_MIN_HOLD); 465 gl->gl_state = new_state; 466 gl->gl_tchange = jiffies; 467} 468 469static void gfs2_set_demote(struct gfs2_glock *gl) 470{ 471 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 472 473 set_bit(GLF_DEMOTE, &gl->gl_flags); 474 smp_mb(); 475 wake_up(&sdp->sd_async_glock_wait); 476} 477 478static void gfs2_demote_wake(struct gfs2_glock *gl) 479{ 480 gl->gl_demote_state = LM_ST_EXCLUSIVE; 481 clear_bit(GLF_DEMOTE, &gl->gl_flags); 482 smp_mb__after_atomic(); 483 wake_up_bit(&gl->gl_flags, GLF_DEMOTE); 484} 485 486/** 487 * finish_xmote - The DLM has replied to one of our lock requests 488 * @gl: The glock 489 * @ret: The status from the DLM 490 * 491 */ 492 493static void finish_xmote(struct gfs2_glock *gl, unsigned int ret) 494{ 495 const struct gfs2_glock_operations *glops = gl->gl_ops; 496 struct gfs2_holder *gh; 497 unsigned state = ret & LM_OUT_ST_MASK; 498 int rv; 499 500 spin_lock(&gl->gl_lockref.lock); 501 trace_gfs2_glock_state_change(gl, state); 502 state_change(gl, state); 503 gh = find_first_waiter(gl); 504 505 /* Demote to UN request arrived during demote to SH or DF */ 506 if (test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags) && 507 state != LM_ST_UNLOCKED && gl->gl_demote_state == LM_ST_UNLOCKED) 508 gl->gl_target = LM_ST_UNLOCKED; 509 510 /* Check for state != intended state */ 511 if (unlikely(state != gl->gl_target)) { 512 if (gh && !test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags)) { 513 /* move to back of queue and try next entry */ 514 if (ret & LM_OUT_CANCELED) { 515 if ((gh->gh_flags & LM_FLAG_PRIORITY) == 0) 516 list_move_tail(&gh->gh_list, &gl->gl_holders); 517 gh = find_first_waiter(gl); 518 gl->gl_target = gh->gh_state; 519 goto retry; 520 } 521 /* Some error or failed "try lock" - report it */ 522 if ((ret & LM_OUT_ERROR) || 523 (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) { 524 gl->gl_target = gl->gl_state; 525 do_error(gl, ret); 526 goto out; 527 } 528 } 529 switch(state) { 530 /* Unlocked due to conversion deadlock, try again */ 531 case LM_ST_UNLOCKED: 532retry: 533 do_xmote(gl, gh, gl->gl_target); 534 break; 535 /* Conversion fails, unlock and try again */ 536 case LM_ST_SHARED: 537 case LM_ST_DEFERRED: 538 do_xmote(gl, gh, LM_ST_UNLOCKED); 539 break; 540 default: /* Everything else */ 541 fs_err(gl->gl_name.ln_sbd, "wanted %u got %u\n", 542 gl->gl_target, state); 543 GLOCK_BUG_ON(gl, 1); 544 } 545 spin_unlock(&gl->gl_lockref.lock); 546 return; 547 } 548 549 /* Fast path - we got what we asked for */ 550 if (test_and_clear_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags)) 551 gfs2_demote_wake(gl); 552 if (state != LM_ST_UNLOCKED) { 553 if (glops->go_xmote_bh) { 554 spin_unlock(&gl->gl_lockref.lock); 555 rv = glops->go_xmote_bh(gl, gh); 556 spin_lock(&gl->gl_lockref.lock); 557 if (rv) { 558 do_error(gl, rv); 559 goto out; 560 } 561 } 562 rv = do_promote(gl); 563 if (rv == 2) 564 goto out_locked; 565 } 566out: 567 clear_bit(GLF_LOCK, &gl->gl_flags); 568out_locked: 569 spin_unlock(&gl->gl_lockref.lock); 570} 571 572static bool is_system_glock(struct gfs2_glock *gl) 573{ 574 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 575 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 576 577 if (gl == m_ip->i_gl) 578 return true; 579 return false; 580} 581 582/** 583 * do_xmote - Calls the DLM to change the state of a lock 584 * @gl: The lock state 585 * @gh: The holder (only for promotes) 586 * @target: The target lock state 587 * 588 */ 589 590static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target) 591__releases(&gl->gl_lockref.lock) 592__acquires(&gl->gl_lockref.lock) 593{ 594 const struct gfs2_glock_operations *glops = gl->gl_ops; 595 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 596 unsigned int lck_flags = (unsigned int)(gh ? gh->gh_flags : 0); 597 int ret; 598 599 if (target != LM_ST_UNLOCKED && glock_blocked_by_withdraw(gl) && 600 gh && !(gh->gh_flags & LM_FLAG_NOEXP)) 601 return; 602 lck_flags &= (LM_FLAG_TRY | LM_FLAG_TRY_1CB | LM_FLAG_NOEXP | 603 LM_FLAG_PRIORITY); 604 GLOCK_BUG_ON(gl, gl->gl_state == target); 605 GLOCK_BUG_ON(gl, gl->gl_state == gl->gl_target); 606 if ((target == LM_ST_UNLOCKED || target == LM_ST_DEFERRED) && 607 glops->go_inval) { 608 /* 609 * If another process is already doing the invalidate, let that 610 * finish first. The glock state machine will get back to this 611 * holder again later. 612 */ 613 if (test_and_set_bit(GLF_INVALIDATE_IN_PROGRESS, 614 &gl->gl_flags)) 615 return; 616 do_error(gl, 0); /* Fail queued try locks */ 617 } 618 gl->gl_req = target; 619 set_bit(GLF_BLOCKING, &gl->gl_flags); 620 if ((gl->gl_req == LM_ST_UNLOCKED) || 621 (gl->gl_state == LM_ST_EXCLUSIVE) || 622 (lck_flags & (LM_FLAG_TRY|LM_FLAG_TRY_1CB))) 623 clear_bit(GLF_BLOCKING, &gl->gl_flags); 624 spin_unlock(&gl->gl_lockref.lock); 625 if (glops->go_sync) { 626 ret = glops->go_sync(gl); 627 /* If we had a problem syncing (due to io errors or whatever, 628 * we should not invalidate the metadata or tell dlm to 629 * release the glock to other nodes. 630 */ 631 if (ret) { 632 if (cmpxchg(&sdp->sd_log_error, 0, ret)) { 633 fs_err(sdp, "Error %d syncing glock \n", ret); 634 gfs2_dump_glock(NULL, gl, true); 635 } 636 goto skip_inval; 637 } 638 } 639 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags)) { 640 /* 641 * The call to go_sync should have cleared out the ail list. 642 * If there are still items, we have a problem. We ought to 643 * withdraw, but we can't because the withdraw code also uses 644 * glocks. Warn about the error, dump the glock, then fall 645 * through and wait for logd to do the withdraw for us. 646 */ 647 if ((atomic_read(&gl->gl_ail_count) != 0) && 648 (!cmpxchg(&sdp->sd_log_error, 0, -EIO))) { 649 gfs2_glock_assert_warn(gl, 650 !atomic_read(&gl->gl_ail_count)); 651 gfs2_dump_glock(NULL, gl, true); 652 } 653 glops->go_inval(gl, target == LM_ST_DEFERRED ? 0 : DIO_METADATA); 654 clear_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags); 655 } 656 657skip_inval: 658 gfs2_glock_hold(gl); 659 /* 660 * Check for an error encountered since we called go_sync and go_inval. 661 * If so, we can't withdraw from the glock code because the withdraw 662 * code itself uses glocks (see function signal_our_withdraw) to 663 * change the mount to read-only. Most importantly, we must not call 664 * dlm to unlock the glock until the journal is in a known good state 665 * (after journal replay) otherwise other nodes may use the object 666 * (rgrp or dinode) and then later, journal replay will corrupt the 667 * file system. The best we can do here is wait for the logd daemon 668 * to see sd_log_error and withdraw, and in the meantime, requeue the 669 * work for later. 670 * 671 * We make a special exception for some system glocks, such as the 672 * system statfs inode glock, which needs to be granted before the 673 * gfs2_quotad daemon can exit, and that exit needs to finish before 674 * we can unmount the withdrawn file system. 675 * 676 * However, if we're just unlocking the lock (say, for unmount, when 677 * gfs2_gl_hash_clear calls clear_glock) and recovery is complete 678 * then it's okay to tell dlm to unlock it. 679 */ 680 if (unlikely(sdp->sd_log_error && !gfs2_withdrawn(sdp))) 681 gfs2_withdraw_delayed(sdp); 682 if (glock_blocked_by_withdraw(gl) && 683 (target != LM_ST_UNLOCKED || 684 test_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags))) { 685 if (!is_system_glock(gl)) { 686 gfs2_glock_queue_work(gl, GL_GLOCK_DFT_HOLD); 687 goto out; 688 } else { 689 clear_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags); 690 } 691 } 692 693 if (sdp->sd_lockstruct.ls_ops->lm_lock) { 694 /* lock_dlm */ 695 ret = sdp->sd_lockstruct.ls_ops->lm_lock(gl, target, lck_flags); 696 if (ret == -EINVAL && gl->gl_target == LM_ST_UNLOCKED && 697 target == LM_ST_UNLOCKED && 698 test_bit(SDF_SKIP_DLM_UNLOCK, &sdp->sd_flags)) { 699 finish_xmote(gl, target); 700 gfs2_glock_queue_work(gl, 0); 701 } else if (ret) { 702 fs_err(sdp, "lm_lock ret %d\n", ret); 703 GLOCK_BUG_ON(gl, !gfs2_withdrawn(sdp)); 704 } 705 } else { /* lock_nolock */ 706 finish_xmote(gl, target); 707 gfs2_glock_queue_work(gl, 0); 708 } 709out: 710 spin_lock(&gl->gl_lockref.lock); 711} 712 713/** 714 * find_first_holder - find the first "holder" gh 715 * @gl: the glock 716 */ 717 718static inline struct gfs2_holder *find_first_holder(const struct gfs2_glock *gl) 719{ 720 struct gfs2_holder *gh; 721 722 if (!list_empty(&gl->gl_holders)) { 723 gh = list_first_entry(&gl->gl_holders, struct gfs2_holder, gh_list); 724 if (test_bit(HIF_HOLDER, &gh->gh_iflags)) 725 return gh; 726 } 727 return NULL; 728} 729 730/** 731 * run_queue - do all outstanding tasks related to a glock 732 * @gl: The glock in question 733 * @nonblock: True if we must not block in run_queue 734 * 735 */ 736 737static void run_queue(struct gfs2_glock *gl, const int nonblock) 738__releases(&gl->gl_lockref.lock) 739__acquires(&gl->gl_lockref.lock) 740{ 741 struct gfs2_holder *gh = NULL; 742 int ret; 743 744 if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) 745 return; 746 747 GLOCK_BUG_ON(gl, test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags)); 748 749 if (test_bit(GLF_DEMOTE, &gl->gl_flags) && 750 gl->gl_demote_state != gl->gl_state) { 751 if (find_first_holder(gl)) 752 goto out_unlock; 753 if (nonblock) 754 goto out_sched; 755 set_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags); 756 GLOCK_BUG_ON(gl, gl->gl_demote_state == LM_ST_EXCLUSIVE); 757 gl->gl_target = gl->gl_demote_state; 758 } else { 759 if (test_bit(GLF_DEMOTE, &gl->gl_flags)) 760 gfs2_demote_wake(gl); 761 ret = do_promote(gl); 762 if (ret == 0) 763 goto out_unlock; 764 if (ret == 2) 765 goto out; 766 gh = find_first_waiter(gl); 767 gl->gl_target = gh->gh_state; 768 if (!(gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) 769 do_error(gl, 0); /* Fail queued try locks */ 770 } 771 do_xmote(gl, gh, gl->gl_target); 772out: 773 return; 774 775out_sched: 776 clear_bit(GLF_LOCK, &gl->gl_flags); 777 smp_mb__after_atomic(); 778 gl->gl_lockref.count++; 779 __gfs2_glock_queue_work(gl, 0); 780 return; 781 782out_unlock: 783 clear_bit(GLF_LOCK, &gl->gl_flags); 784 smp_mb__after_atomic(); 785 return; 786} 787 788void gfs2_inode_remember_delete(struct gfs2_glock *gl, u64 generation) 789{ 790 struct gfs2_inode_lvb *ri = (void *)gl->gl_lksb.sb_lvbptr; 791 792 if (ri->ri_magic == 0) 793 ri->ri_magic = cpu_to_be32(GFS2_MAGIC); 794 if (ri->ri_magic == cpu_to_be32(GFS2_MAGIC)) 795 ri->ri_generation_deleted = cpu_to_be64(generation); 796} 797 798bool gfs2_inode_already_deleted(struct gfs2_glock *gl, u64 generation) 799{ 800 struct gfs2_inode_lvb *ri = (void *)gl->gl_lksb.sb_lvbptr; 801 802 if (ri->ri_magic != cpu_to_be32(GFS2_MAGIC)) 803 return false; 804 return generation <= be64_to_cpu(ri->ri_generation_deleted); 805} 806 807static void gfs2_glock_poke(struct gfs2_glock *gl) 808{ 809 int flags = LM_FLAG_TRY_1CB | LM_FLAG_ANY | GL_SKIP; 810 struct gfs2_holder gh; 811 int error; 812 813 gfs2_holder_init(gl, LM_ST_SHARED, flags, &gh); 814 error = gfs2_glock_nq(&gh); 815 if (!error) 816 gfs2_glock_dq(&gh); 817 gfs2_holder_uninit(&gh); 818} 819 820static bool gfs2_try_evict(struct gfs2_glock *gl) 821{ 822 struct gfs2_inode *ip; 823 bool evicted = false; 824 825 /* 826 * If there is contention on the iopen glock and we have an inode, try 827 * to grab and release the inode so that it can be evicted. This will 828 * allow the remote node to go ahead and delete the inode without us 829 * having to do it, which will avoid rgrp glock thrashing. 830 * 831 * The remote node is likely still holding the corresponding inode 832 * glock, so it will run before we get to verify that the delete has 833 * happened below. 834 */ 835 spin_lock(&gl->gl_lockref.lock); 836 ip = gl->gl_object; 837 if (ip && !igrab(&ip->i_inode)) 838 ip = NULL; 839 spin_unlock(&gl->gl_lockref.lock); 840 if (ip) { 841 struct gfs2_glock *inode_gl = NULL; 842 843 gl->gl_no_formal_ino = ip->i_no_formal_ino; 844 set_bit(GIF_DEFERRED_DELETE, &ip->i_flags); 845 d_prune_aliases(&ip->i_inode); 846 iput(&ip->i_inode); 847 848 /* If the inode was evicted, gl->gl_object will now be NULL. */ 849 spin_lock(&gl->gl_lockref.lock); 850 ip = gl->gl_object; 851 if (ip) { 852 inode_gl = ip->i_gl; 853 lockref_get(&inode_gl->gl_lockref); 854 clear_bit(GIF_DEFERRED_DELETE, &ip->i_flags); 855 } 856 spin_unlock(&gl->gl_lockref.lock); 857 if (inode_gl) { 858 gfs2_glock_poke(inode_gl); 859 gfs2_glock_put(inode_gl); 860 } 861 evicted = !ip; 862 } 863 return evicted; 864} 865 866static void delete_work_func(struct work_struct *work) 867{ 868 struct delayed_work *dwork = to_delayed_work(work); 869 struct gfs2_glock *gl = container_of(dwork, struct gfs2_glock, gl_delete); 870 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 871 struct inode *inode; 872 u64 no_addr = gl->gl_name.ln_number; 873 874 spin_lock(&gl->gl_lockref.lock); 875 clear_bit(GLF_PENDING_DELETE, &gl->gl_flags); 876 spin_unlock(&gl->gl_lockref.lock); 877 878 /* If someone's using this glock to create a new dinode, the block must 879 have been freed by another node, then re-used, in which case our 880 iopen callback is too late after the fact. Ignore it. */ 881 if (test_bit(GLF_INODE_CREATING, &gl->gl_flags)) 882 goto out; 883 884 if (test_bit(GLF_DEMOTE, &gl->gl_flags)) { 885 /* 886 * If we can evict the inode, give the remote node trying to 887 * delete the inode some time before verifying that the delete 888 * has happened. Otherwise, if we cause contention on the inode glock 889 * immediately, the remote node will think that we still have 890 * the inode in use, and so it will give up waiting. 891 * 892 * If we can't evict the inode, signal to the remote node that 893 * the inode is still in use. We'll later try to delete the 894 * inode locally in gfs2_evict_inode. 895 * 896 * FIXME: We only need to verify that the remote node has 897 * deleted the inode because nodes before this remote delete 898 * rework won't cooperate. At a later time, when we no longer 899 * care about compatibility with such nodes, we can skip this 900 * step entirely. 901 */ 902 if (gfs2_try_evict(gl)) { 903 if (gfs2_queue_delete_work(gl, 5 * HZ)) 904 return; 905 } 906 goto out; 907 } 908 909 inode = gfs2_lookup_by_inum(sdp, no_addr, gl->gl_no_formal_ino, 910 GFS2_BLKST_UNLINKED); 911 if (!IS_ERR_OR_NULL(inode)) { 912 d_prune_aliases(inode); 913 iput(inode); 914 } 915out: 916 gfs2_glock_put(gl); 917} 918 919static void glock_work_func(struct work_struct *work) 920{ 921 unsigned long delay = 0; 922 struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_work.work); 923 unsigned int drop_refs = 1; 924 925 if (test_and_clear_bit(GLF_REPLY_PENDING, &gl->gl_flags)) { 926 finish_xmote(gl, gl->gl_reply); 927 drop_refs++; 928 } 929 spin_lock(&gl->gl_lockref.lock); 930 if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) && 931 gl->gl_state != LM_ST_UNLOCKED && 932 gl->gl_demote_state != LM_ST_EXCLUSIVE) { 933 unsigned long holdtime, now = jiffies; 934 935 holdtime = gl->gl_tchange + gl->gl_hold_time; 936 if (time_before(now, holdtime)) 937 delay = holdtime - now; 938 939 if (!delay) { 940 clear_bit(GLF_PENDING_DEMOTE, &gl->gl_flags); 941 gfs2_set_demote(gl); 942 } 943 } 944 run_queue(gl, 0); 945 if (delay) { 946 /* Keep one glock reference for the work we requeue. */ 947 drop_refs--; 948 if (gl->gl_name.ln_type != LM_TYPE_INODE) 949 delay = 0; 950 __gfs2_glock_queue_work(gl, delay); 951 } 952 953 /* 954 * Drop the remaining glock references manually here. (Mind that 955 * __gfs2_glock_queue_work depends on the lockref spinlock begin held 956 * here as well.) 957 */ 958 gl->gl_lockref.count -= drop_refs; 959 if (!gl->gl_lockref.count) { 960 __gfs2_glock_put(gl); 961 return; 962 } 963 spin_unlock(&gl->gl_lockref.lock); 964} 965 966static struct gfs2_glock *find_insert_glock(struct lm_lockname *name, 967 struct gfs2_glock *new) 968{ 969 struct wait_glock_queue wait; 970 wait_queue_head_t *wq = glock_waitqueue(name); 971 struct gfs2_glock *gl; 972 973 wait.name = name; 974 init_wait(&wait.wait); 975 wait.wait.func = glock_wake_function; 976 977again: 978 prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE); 979 rcu_read_lock(); 980 if (new) { 981 gl = rhashtable_lookup_get_insert_fast(&gl_hash_table, 982 &new->gl_node, ht_parms); 983 if (IS_ERR(gl)) 984 goto out; 985 } else { 986 gl = rhashtable_lookup_fast(&gl_hash_table, 987 name, ht_parms); 988 } 989 if (gl && !lockref_get_not_dead(&gl->gl_lockref)) { 990 rcu_read_unlock(); 991 schedule(); 992 goto again; 993 } 994out: 995 rcu_read_unlock(); 996 finish_wait(wq, &wait.wait); 997 return gl; 998} 999 1000/** 1001 * gfs2_glock_get() - Get a glock, or create one if one doesn't exist 1002 * @sdp: The GFS2 superblock 1003 * @number: the lock number 1004 * @glops: The glock_operations to use 1005 * @create: If 0, don't create the glock if it doesn't exist 1006 * @glp: the glock is returned here 1007 * 1008 * This does not lock a glock, just finds/creates structures for one. 1009 * 1010 * Returns: errno 1011 */ 1012 1013int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 1014 const struct gfs2_glock_operations *glops, int create, 1015 struct gfs2_glock **glp) 1016{ 1017 struct super_block *s = sdp->sd_vfs; 1018 struct lm_lockname name = { .ln_number = number, 1019 .ln_type = glops->go_type, 1020 .ln_sbd = sdp }; 1021 struct gfs2_glock *gl, *tmp; 1022 struct address_space *mapping; 1023 struct kmem_cache *cachep; 1024 int ret = 0; 1025 1026 gl = find_insert_glock(&name, NULL); 1027 if (gl) { 1028 *glp = gl; 1029 return 0; 1030 } 1031 if (!create) 1032 return -ENOENT; 1033 1034 if (glops->go_flags & GLOF_ASPACE) 1035 cachep = gfs2_glock_aspace_cachep; 1036 else 1037 cachep = gfs2_glock_cachep; 1038 gl = kmem_cache_alloc(cachep, GFP_NOFS); 1039 if (!gl) 1040 return -ENOMEM; 1041 1042 memset(&gl->gl_lksb, 0, sizeof(struct dlm_lksb)); 1043 1044 if (glops->go_flags & GLOF_LVB) { 1045 gl->gl_lksb.sb_lvbptr = kzalloc(GDLM_LVB_SIZE, GFP_NOFS); 1046 if (!gl->gl_lksb.sb_lvbptr) { 1047 kmem_cache_free(cachep, gl); 1048 return -ENOMEM; 1049 } 1050 } 1051 1052 atomic_inc(&sdp->sd_glock_disposal); 1053 gl->gl_node.next = NULL; 1054 gl->gl_flags = 0; 1055 gl->gl_name = name; 1056 lockdep_set_subclass(&gl->gl_lockref.lock, glops->go_subclass); 1057 gl->gl_lockref.count = 1; 1058 gl->gl_state = LM_ST_UNLOCKED; 1059 gl->gl_target = LM_ST_UNLOCKED; 1060 gl->gl_demote_state = LM_ST_EXCLUSIVE; 1061 gl->gl_ops = glops; 1062 gl->gl_dstamp = 0; 1063 preempt_disable(); 1064 /* We use the global stats to estimate the initial per-glock stats */ 1065 gl->gl_stats = this_cpu_ptr(sdp->sd_lkstats)->lkstats[glops->go_type]; 1066 preempt_enable(); 1067 gl->gl_stats.stats[GFS2_LKS_DCOUNT] = 0; 1068 gl->gl_stats.stats[GFS2_LKS_QCOUNT] = 0; 1069 gl->gl_tchange = jiffies; 1070 gl->gl_object = NULL; 1071 gl->gl_hold_time = GL_GLOCK_DFT_HOLD; 1072 INIT_DELAYED_WORK(&gl->gl_work, glock_work_func); 1073 if (gl->gl_name.ln_type == LM_TYPE_IOPEN) 1074 INIT_DELAYED_WORK(&gl->gl_delete, delete_work_func); 1075 1076 mapping = gfs2_glock2aspace(gl); 1077 if (mapping) { 1078 mapping->a_ops = &gfs2_meta_aops; 1079 mapping->host = s->s_bdev->bd_inode; 1080 mapping->flags = 0; 1081 mapping_set_gfp_mask(mapping, GFP_NOFS); 1082 mapping->private_data = NULL; 1083 mapping->writeback_index = 0; 1084 } 1085 1086 tmp = find_insert_glock(&name, gl); 1087 if (!tmp) { 1088 *glp = gl; 1089 goto out; 1090 } 1091 if (IS_ERR(tmp)) { 1092 ret = PTR_ERR(tmp); 1093 goto out_free; 1094 } 1095 *glp = tmp; 1096 1097out_free: 1098 kfree(gl->gl_lksb.sb_lvbptr); 1099 kmem_cache_free(cachep, gl); 1100 if (atomic_dec_and_test(&sdp->sd_glock_disposal)) 1101 wake_up(&sdp->sd_glock_wait); 1102 1103out: 1104 return ret; 1105} 1106 1107/** 1108 * gfs2_holder_init - initialize a struct gfs2_holder in the default way 1109 * @gl: the glock 1110 * @state: the state we're requesting 1111 * @flags: the modifier flags 1112 * @gh: the holder structure 1113 * 1114 */ 1115 1116void gfs2_holder_init(struct gfs2_glock *gl, unsigned int state, u16 flags, 1117 struct gfs2_holder *gh) 1118{ 1119 INIT_LIST_HEAD(&gh->gh_list); 1120 gh->gh_gl = gl; 1121 gh->gh_ip = _RET_IP_; 1122 gh->gh_owner_pid = get_pid(task_pid(current)); 1123 gh->gh_state = state; 1124 gh->gh_flags = flags; 1125 gh->gh_error = 0; 1126 gh->gh_iflags = 0; 1127 gfs2_glock_hold(gl); 1128} 1129 1130/** 1131 * gfs2_holder_reinit - reinitialize a struct gfs2_holder so we can requeue it 1132 * @state: the state we're requesting 1133 * @flags: the modifier flags 1134 * @gh: the holder structure 1135 * 1136 * Don't mess with the glock. 1137 * 1138 */ 1139 1140void gfs2_holder_reinit(unsigned int state, u16 flags, struct gfs2_holder *gh) 1141{ 1142 gh->gh_state = state; 1143 gh->gh_flags = flags; 1144 gh->gh_iflags = 0; 1145 gh->gh_ip = _RET_IP_; 1146 put_pid(gh->gh_owner_pid); 1147 gh->gh_owner_pid = get_pid(task_pid(current)); 1148} 1149 1150/** 1151 * gfs2_holder_uninit - uninitialize a holder structure (drop glock reference) 1152 * @gh: the holder structure 1153 * 1154 */ 1155 1156void gfs2_holder_uninit(struct gfs2_holder *gh) 1157{ 1158 put_pid(gh->gh_owner_pid); 1159 gfs2_glock_put(gh->gh_gl); 1160 gfs2_holder_mark_uninitialized(gh); 1161 gh->gh_ip = 0; 1162} 1163 1164static void gfs2_glock_update_hold_time(struct gfs2_glock *gl, 1165 unsigned long start_time) 1166{ 1167 /* Have we waited longer that a second? */ 1168 if (time_after(jiffies, start_time + HZ)) { 1169 /* Lengthen the minimum hold time. */ 1170 gl->gl_hold_time = min(gl->gl_hold_time + GL_GLOCK_HOLD_INCR, 1171 GL_GLOCK_MAX_HOLD); 1172 } 1173} 1174 1175/** 1176 * gfs2_glock_wait - wait on a glock acquisition 1177 * @gh: the glock holder 1178 * 1179 * Returns: 0 on success 1180 */ 1181 1182int gfs2_glock_wait(struct gfs2_holder *gh) 1183{ 1184 unsigned long start_time = jiffies; 1185 1186 might_sleep(); 1187 wait_on_bit(&gh->gh_iflags, HIF_WAIT, TASK_UNINTERRUPTIBLE); 1188 gfs2_glock_update_hold_time(gh->gh_gl, start_time); 1189 return gh->gh_error; 1190} 1191 1192static int glocks_pending(unsigned int num_gh, struct gfs2_holder *ghs) 1193{ 1194 int i; 1195 1196 for (i = 0; i < num_gh; i++) 1197 if (test_bit(HIF_WAIT, &ghs[i].gh_iflags)) 1198 return 1; 1199 return 0; 1200} 1201 1202/** 1203 * gfs2_glock_async_wait - wait on multiple asynchronous glock acquisitions 1204 * @num_gh: the number of holders in the array 1205 * @ghs: the glock holder array 1206 * 1207 * Returns: 0 on success, meaning all glocks have been granted and are held. 1208 * -ESTALE if the request timed out, meaning all glocks were released, 1209 * and the caller should retry the operation. 1210 */ 1211 1212int gfs2_glock_async_wait(unsigned int num_gh, struct gfs2_holder *ghs) 1213{ 1214 struct gfs2_sbd *sdp = ghs[0].gh_gl->gl_name.ln_sbd; 1215 int i, ret = 0, timeout = 0; 1216 unsigned long start_time = jiffies; 1217 bool keep_waiting; 1218 1219 might_sleep(); 1220 /* 1221 * Total up the (minimum hold time * 2) of all glocks and use that to 1222 * determine the max amount of time we should wait. 1223 */ 1224 for (i = 0; i < num_gh; i++) 1225 timeout += ghs[i].gh_gl->gl_hold_time << 1; 1226 1227wait_for_dlm: 1228 if (!wait_event_timeout(sdp->sd_async_glock_wait, 1229 !glocks_pending(num_gh, ghs), timeout)) 1230 ret = -ESTALE; /* request timed out. */ 1231 1232 /* 1233 * If dlm granted all our requests, we need to adjust the glock 1234 * minimum hold time values according to how long we waited. 1235 * 1236 * If our request timed out, we need to repeatedly release any held 1237 * glocks we acquired thus far to allow dlm to acquire the remaining 1238 * glocks without deadlocking. We cannot currently cancel outstanding 1239 * glock acquisitions. 1240 * 1241 * The HIF_WAIT bit tells us which requests still need a response from 1242 * dlm. 1243 * 1244 * If dlm sent us any errors, we return the first error we find. 1245 */ 1246 keep_waiting = false; 1247 for (i = 0; i < num_gh; i++) { 1248 /* Skip holders we have already dequeued below. */ 1249 if (!gfs2_holder_queued(&ghs[i])) 1250 continue; 1251 /* Skip holders with a pending DLM response. */ 1252 if (test_bit(HIF_WAIT, &ghs[i].gh_iflags)) { 1253 keep_waiting = true; 1254 continue; 1255 } 1256 1257 if (test_bit(HIF_HOLDER, &ghs[i].gh_iflags)) { 1258 if (ret == -ESTALE) 1259 gfs2_glock_dq(&ghs[i]); 1260 else 1261 gfs2_glock_update_hold_time(ghs[i].gh_gl, 1262 start_time); 1263 } 1264 if (!ret) 1265 ret = ghs[i].gh_error; 1266 } 1267 1268 if (keep_waiting) 1269 goto wait_for_dlm; 1270 1271 /* 1272 * At this point, we've either acquired all locks or released them all. 1273 */ 1274 return ret; 1275} 1276 1277/** 1278 * handle_callback - process a demote request 1279 * @gl: the glock 1280 * @state: the state the caller wants us to change to 1281 * 1282 * There are only two requests that we are going to see in actual 1283 * practise: LM_ST_SHARED and LM_ST_UNLOCKED 1284 */ 1285 1286static void handle_callback(struct gfs2_glock *gl, unsigned int state, 1287 unsigned long delay, bool remote) 1288{ 1289 if (delay) 1290 set_bit(GLF_PENDING_DEMOTE, &gl->gl_flags); 1291 else 1292 gfs2_set_demote(gl); 1293 if (gl->gl_demote_state == LM_ST_EXCLUSIVE) { 1294 gl->gl_demote_state = state; 1295 gl->gl_demote_time = jiffies; 1296 } else if (gl->gl_demote_state != LM_ST_UNLOCKED && 1297 gl->gl_demote_state != state) { 1298 gl->gl_demote_state = LM_ST_UNLOCKED; 1299 } 1300 if (gl->gl_ops->go_callback) 1301 gl->gl_ops->go_callback(gl, remote); 1302 trace_gfs2_demote_rq(gl, remote); 1303} 1304 1305void gfs2_print_dbg(struct seq_file *seq, const char *fmt, ...) 1306{ 1307 struct va_format vaf; 1308 va_list args; 1309 1310 va_start(args, fmt); 1311 1312 if (seq) { 1313 seq_vprintf(seq, fmt, args); 1314 } else { 1315 vaf.fmt = fmt; 1316 vaf.va = &args; 1317 1318 pr_err("%pV", &vaf); 1319 } 1320 1321 va_end(args); 1322} 1323 1324/** 1325 * add_to_queue - Add a holder to the wait queue (but look for recursion) 1326 * @gh: the holder structure to add 1327 * 1328 * Eventually we should move the recursive locking trap to a 1329 * debugging option or something like that. This is the fast 1330 * path and needs to have the minimum number of distractions. 1331 * 1332 */ 1333 1334static inline void add_to_queue(struct gfs2_holder *gh) 1335__releases(&gl->gl_lockref.lock) 1336__acquires(&gl->gl_lockref.lock) 1337{ 1338 struct gfs2_glock *gl = gh->gh_gl; 1339 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 1340 struct list_head *insert_pt = NULL; 1341 struct gfs2_holder *gh2; 1342 int try_futile = 0; 1343 1344 GLOCK_BUG_ON(gl, gh->gh_owner_pid == NULL); 1345 if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags)) 1346 GLOCK_BUG_ON(gl, true); 1347 1348 if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)) { 1349 if (test_bit(GLF_LOCK, &gl->gl_flags)) 1350 try_futile = !may_grant(gl, gh); 1351 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags)) 1352 goto fail; 1353 } 1354 1355 list_for_each_entry(gh2, &gl->gl_holders, gh_list) { 1356 if (unlikely(gh2->gh_owner_pid == gh->gh_owner_pid && 1357 (gh->gh_gl->gl_ops->go_type != LM_TYPE_FLOCK))) 1358 goto trap_recursive; 1359 if (try_futile && 1360 !(gh2->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) { 1361fail: 1362 gh->gh_error = GLR_TRYFAILED; 1363 gfs2_holder_wake(gh); 1364 return; 1365 } 1366 if (test_bit(HIF_HOLDER, &gh2->gh_iflags)) 1367 continue; 1368 if (unlikely((gh->gh_flags & LM_FLAG_PRIORITY) && !insert_pt)) 1369 insert_pt = &gh2->gh_list; 1370 } 1371 trace_gfs2_glock_queue(gh, 1); 1372 gfs2_glstats_inc(gl, GFS2_LKS_QCOUNT); 1373 gfs2_sbstats_inc(gl, GFS2_LKS_QCOUNT); 1374 if (likely(insert_pt == NULL)) { 1375 list_add_tail(&gh->gh_list, &gl->gl_holders); 1376 if (unlikely(gh->gh_flags & LM_FLAG_PRIORITY)) 1377 goto do_cancel; 1378 return; 1379 } 1380 list_add_tail(&gh->gh_list, insert_pt); 1381do_cancel: 1382 gh = list_first_entry(&gl->gl_holders, struct gfs2_holder, gh_list); 1383 if (!(gh->gh_flags & LM_FLAG_PRIORITY)) { 1384 spin_unlock(&gl->gl_lockref.lock); 1385 if (sdp->sd_lockstruct.ls_ops->lm_cancel) 1386 sdp->sd_lockstruct.ls_ops->lm_cancel(gl); 1387 spin_lock(&gl->gl_lockref.lock); 1388 } 1389 return; 1390 1391trap_recursive: 1392 fs_err(sdp, "original: %pSR\n", (void *)gh2->gh_ip); 1393 fs_err(sdp, "pid: %d\n", pid_nr(gh2->gh_owner_pid)); 1394 fs_err(sdp, "lock type: %d req lock state : %d\n", 1395 gh2->gh_gl->gl_name.ln_type, gh2->gh_state); 1396 fs_err(sdp, "new: %pSR\n", (void *)gh->gh_ip); 1397 fs_err(sdp, "pid: %d\n", pid_nr(gh->gh_owner_pid)); 1398 fs_err(sdp, "lock type: %d req lock state : %d\n", 1399 gh->gh_gl->gl_name.ln_type, gh->gh_state); 1400 gfs2_dump_glock(NULL, gl, true); 1401 BUG(); 1402} 1403 1404/** 1405 * gfs2_glock_nq - enqueue a struct gfs2_holder onto a glock (acquire a glock) 1406 * @gh: the holder structure 1407 * 1408 * if (gh->gh_flags & GL_ASYNC), this never returns an error 1409 * 1410 * Returns: 0, GLR_TRYFAILED, or errno on failure 1411 */ 1412 1413int gfs2_glock_nq(struct gfs2_holder *gh) 1414{ 1415 struct gfs2_glock *gl = gh->gh_gl; 1416 int error = 0; 1417 1418 if (glock_blocked_by_withdraw(gl) && !(gh->gh_flags & LM_FLAG_NOEXP)) 1419 return -EIO; 1420 1421 if (test_bit(GLF_LRU, &gl->gl_flags)) 1422 gfs2_glock_remove_from_lru(gl); 1423 1424 spin_lock(&gl->gl_lockref.lock); 1425 add_to_queue(gh); 1426 if (unlikely((LM_FLAG_NOEXP & gh->gh_flags) && 1427 test_and_clear_bit(GLF_FROZEN, &gl->gl_flags))) { 1428 set_bit(GLF_REPLY_PENDING, &gl->gl_flags); 1429 gl->gl_lockref.count++; 1430 __gfs2_glock_queue_work(gl, 0); 1431 } 1432 run_queue(gl, 1); 1433 spin_unlock(&gl->gl_lockref.lock); 1434 1435 if (!(gh->gh_flags & GL_ASYNC)) 1436 error = gfs2_glock_wait(gh); 1437 1438 return error; 1439} 1440 1441/** 1442 * gfs2_glock_poll - poll to see if an async request has been completed 1443 * @gh: the holder 1444 * 1445 * Returns: 1 if the request is ready to be gfs2_glock_wait()ed on 1446 */ 1447 1448int gfs2_glock_poll(struct gfs2_holder *gh) 1449{ 1450 return test_bit(HIF_WAIT, &gh->gh_iflags) ? 0 : 1; 1451} 1452 1453/** 1454 * gfs2_glock_dq - dequeue a struct gfs2_holder from a glock (release a glock) 1455 * @gh: the glock holder 1456 * 1457 */ 1458 1459void gfs2_glock_dq(struct gfs2_holder *gh) 1460{ 1461 struct gfs2_glock *gl = gh->gh_gl; 1462 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 1463 unsigned delay = 0; 1464 int fast_path = 0; 1465 1466 spin_lock(&gl->gl_lockref.lock); 1467 /* 1468 * If we're in the process of file system withdraw, we cannot just 1469 * dequeue any glocks until our journal is recovered, lest we 1470 * introduce file system corruption. We need two exceptions to this 1471 * rule: We need to allow unlocking of nondisk glocks and the glock 1472 * for our own journal that needs recovery. 1473 */ 1474 if (test_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags) && 1475 glock_blocked_by_withdraw(gl) && 1476 gh->gh_gl != sdp->sd_jinode_gl) { 1477 sdp->sd_glock_dqs_held++; 1478 spin_unlock(&gl->gl_lockref.lock); 1479 might_sleep(); 1480 wait_on_bit(&sdp->sd_flags, SDF_WITHDRAW_RECOVERY, 1481 TASK_UNINTERRUPTIBLE); 1482 spin_lock(&gl->gl_lockref.lock); 1483 } 1484 if (gh->gh_flags & GL_NOCACHE) 1485 handle_callback(gl, LM_ST_UNLOCKED, 0, false); 1486 1487 list_del_init(&gh->gh_list); 1488 clear_bit(HIF_HOLDER, &gh->gh_iflags); 1489 if (find_first_holder(gl) == NULL) { 1490 if (list_empty(&gl->gl_holders) && 1491 !test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) && 1492 !test_bit(GLF_DEMOTE, &gl->gl_flags)) 1493 fast_path = 1; 1494 } 1495 if (!test_bit(GLF_LFLUSH, &gl->gl_flags) && demote_ok(gl)) 1496 gfs2_glock_add_to_lru(gl); 1497 1498 trace_gfs2_glock_queue(gh, 0); 1499 if (unlikely(!fast_path)) { 1500 gl->gl_lockref.count++; 1501 if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) && 1502 !test_bit(GLF_DEMOTE, &gl->gl_flags) && 1503 gl->gl_name.ln_type == LM_TYPE_INODE) 1504 delay = gl->gl_hold_time; 1505 __gfs2_glock_queue_work(gl, delay); 1506 } 1507 spin_unlock(&gl->gl_lockref.lock); 1508} 1509 1510void gfs2_glock_dq_wait(struct gfs2_holder *gh) 1511{ 1512 struct gfs2_glock *gl = gh->gh_gl; 1513 gfs2_glock_dq(gh); 1514 might_sleep(); 1515 wait_on_bit(&gl->gl_flags, GLF_DEMOTE, TASK_UNINTERRUPTIBLE); 1516} 1517 1518/** 1519 * gfs2_glock_dq_uninit - dequeue a holder from a glock and initialize it 1520 * @gh: the holder structure 1521 * 1522 */ 1523 1524void gfs2_glock_dq_uninit(struct gfs2_holder *gh) 1525{ 1526 gfs2_glock_dq(gh); 1527 gfs2_holder_uninit(gh); 1528} 1529 1530/** 1531 * gfs2_glock_nq_num - acquire a glock based on lock number 1532 * @sdp: the filesystem 1533 * @number: the lock number 1534 * @glops: the glock operations for the type of glock 1535 * @state: the state to acquire the glock in 1536 * @flags: modifier flags for the acquisition 1537 * @gh: the struct gfs2_holder 1538 * 1539 * Returns: errno 1540 */ 1541 1542int gfs2_glock_nq_num(struct gfs2_sbd *sdp, u64 number, 1543 const struct gfs2_glock_operations *glops, 1544 unsigned int state, u16 flags, struct gfs2_holder *gh) 1545{ 1546 struct gfs2_glock *gl; 1547 int error; 1548 1549 error = gfs2_glock_get(sdp, number, glops, CREATE, &gl); 1550 if (!error) { 1551 error = gfs2_glock_nq_init(gl, state, flags, gh); 1552 gfs2_glock_put(gl); 1553 } 1554 1555 return error; 1556} 1557 1558/** 1559 * glock_compare - Compare two struct gfs2_glock structures for sorting 1560 * @arg_a: the first structure 1561 * @arg_b: the second structure 1562 * 1563 */ 1564 1565static int glock_compare(const void *arg_a, const void *arg_b) 1566{ 1567 const struct gfs2_holder *gh_a = *(const struct gfs2_holder **)arg_a; 1568 const struct gfs2_holder *gh_b = *(const struct gfs2_holder **)arg_b; 1569 const struct lm_lockname *a = &gh_a->gh_gl->gl_name; 1570 const struct lm_lockname *b = &gh_b->gh_gl->gl_name; 1571 1572 if (a->ln_number > b->ln_number) 1573 return 1; 1574 if (a->ln_number < b->ln_number) 1575 return -1; 1576 BUG_ON(gh_a->gh_gl->gl_ops->go_type == gh_b->gh_gl->gl_ops->go_type); 1577 return 0; 1578} 1579 1580/** 1581 * nq_m_sync - synchonously acquire more than one glock in deadlock free order 1582 * @num_gh: the number of structures 1583 * @ghs: an array of struct gfs2_holder structures 1584 * 1585 * Returns: 0 on success (all glocks acquired), 1586 * errno on failure (no glocks acquired) 1587 */ 1588 1589static int nq_m_sync(unsigned int num_gh, struct gfs2_holder *ghs, 1590 struct gfs2_holder **p) 1591{ 1592 unsigned int x; 1593 int error = 0; 1594 1595 for (x = 0; x < num_gh; x++) 1596 p[x] = &ghs[x]; 1597 1598 sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare, NULL); 1599 1600 for (x = 0; x < num_gh; x++) { 1601 p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC); 1602 1603 error = gfs2_glock_nq(p[x]); 1604 if (error) { 1605 while (x--) 1606 gfs2_glock_dq(p[x]); 1607 break; 1608 } 1609 } 1610 1611 return error; 1612} 1613 1614/** 1615 * gfs2_glock_nq_m - acquire multiple glocks 1616 * @num_gh: the number of structures 1617 * @ghs: an array of struct gfs2_holder structures 1618 * 1619 * 1620 * Returns: 0 on success (all glocks acquired), 1621 * errno on failure (no glocks acquired) 1622 */ 1623 1624int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs) 1625{ 1626 struct gfs2_holder *tmp[4]; 1627 struct gfs2_holder **pph = tmp; 1628 int error = 0; 1629 1630 switch(num_gh) { 1631 case 0: 1632 return 0; 1633 case 1: 1634 ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC); 1635 return gfs2_glock_nq(ghs); 1636 default: 1637 if (num_gh <= 4) 1638 break; 1639 pph = kmalloc_array(num_gh, sizeof(struct gfs2_holder *), 1640 GFP_NOFS); 1641 if (!pph) 1642 return -ENOMEM; 1643 } 1644 1645 error = nq_m_sync(num_gh, ghs, pph); 1646 1647 if (pph != tmp) 1648 kfree(pph); 1649 1650 return error; 1651} 1652 1653/** 1654 * gfs2_glock_dq_m - release multiple glocks 1655 * @num_gh: the number of structures 1656 * @ghs: an array of struct gfs2_holder structures 1657 * 1658 */ 1659 1660void gfs2_glock_dq_m(unsigned int num_gh, struct gfs2_holder *ghs) 1661{ 1662 while (num_gh--) 1663 gfs2_glock_dq(&ghs[num_gh]); 1664} 1665 1666void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state) 1667{ 1668 unsigned long delay = 0; 1669 unsigned long holdtime; 1670 unsigned long now = jiffies; 1671 1672 gfs2_glock_hold(gl); 1673 spin_lock(&gl->gl_lockref.lock); 1674 holdtime = gl->gl_tchange + gl->gl_hold_time; 1675 if (!list_empty(&gl->gl_holders) && 1676 gl->gl_name.ln_type == LM_TYPE_INODE) { 1677 if (time_before(now, holdtime)) 1678 delay = holdtime - now; 1679 if (test_bit(GLF_REPLY_PENDING, &gl->gl_flags)) 1680 delay = gl->gl_hold_time; 1681 } 1682 handle_callback(gl, state, delay, true); 1683 __gfs2_glock_queue_work(gl, delay); 1684 spin_unlock(&gl->gl_lockref.lock); 1685} 1686 1687/** 1688 * gfs2_should_freeze - Figure out if glock should be frozen 1689 * @gl: The glock in question 1690 * 1691 * Glocks are not frozen if (a) the result of the dlm operation is 1692 * an error, (b) the locking operation was an unlock operation or 1693 * (c) if there is a "noexp" flagged request anywhere in the queue 1694 * 1695 * Returns: 1 if freezing should occur, 0 otherwise 1696 */ 1697 1698static int gfs2_should_freeze(const struct gfs2_glock *gl) 1699{ 1700 const struct gfs2_holder *gh; 1701 1702 if (gl->gl_reply & ~LM_OUT_ST_MASK) 1703 return 0; 1704 if (gl->gl_target == LM_ST_UNLOCKED) 1705 return 0; 1706 1707 list_for_each_entry(gh, &gl->gl_holders, gh_list) { 1708 if (test_bit(HIF_HOLDER, &gh->gh_iflags)) 1709 continue; 1710 if (LM_FLAG_NOEXP & gh->gh_flags) 1711 return 0; 1712 } 1713 1714 return 1; 1715} 1716 1717/** 1718 * gfs2_glock_complete - Callback used by locking 1719 * @gl: Pointer to the glock 1720 * @ret: The return value from the dlm 1721 * 1722 * The gl_reply field is under the gl_lockref.lock lock so that it is ok 1723 * to use a bitfield shared with other glock state fields. 1724 */ 1725 1726void gfs2_glock_complete(struct gfs2_glock *gl, int ret) 1727{ 1728 struct lm_lockstruct *ls = &gl->gl_name.ln_sbd->sd_lockstruct; 1729 1730 spin_lock(&gl->gl_lockref.lock); 1731 gl->gl_reply = ret; 1732 1733 if (unlikely(test_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags))) { 1734 if (gfs2_should_freeze(gl)) { 1735 set_bit(GLF_FROZEN, &gl->gl_flags); 1736 spin_unlock(&gl->gl_lockref.lock); 1737 return; 1738 } 1739 } 1740 1741 gl->gl_lockref.count++; 1742 set_bit(GLF_REPLY_PENDING, &gl->gl_flags); 1743 __gfs2_glock_queue_work(gl, 0); 1744 spin_unlock(&gl->gl_lockref.lock); 1745} 1746 1747static int glock_cmp(void *priv, const struct list_head *a, 1748 const struct list_head *b) 1749{ 1750 struct gfs2_glock *gla, *glb; 1751 1752 gla = list_entry(a, struct gfs2_glock, gl_lru); 1753 glb = list_entry(b, struct gfs2_glock, gl_lru); 1754 1755 if (gla->gl_name.ln_number > glb->gl_name.ln_number) 1756 return 1; 1757 if (gla->gl_name.ln_number < glb->gl_name.ln_number) 1758 return -1; 1759 1760 return 0; 1761} 1762 1763/** 1764 * gfs2_dispose_glock_lru - Demote a list of glocks 1765 * @list: The list to dispose of 1766 * 1767 * Disposing of glocks may involve disk accesses, so that here we sort 1768 * the glocks by number (i.e. disk location of the inodes) so that if 1769 * there are any such accesses, they'll be sent in order (mostly). 1770 * 1771 * Must be called under the lru_lock, but may drop and retake this 1772 * lock. While the lru_lock is dropped, entries may vanish from the 1773 * list, but no new entries will appear on the list (since it is 1774 * private) 1775 */ 1776 1777static void gfs2_dispose_glock_lru(struct list_head *list) 1778__releases(&lru_lock) 1779__acquires(&lru_lock) 1780{ 1781 struct gfs2_glock *gl; 1782 1783 list_sort(NULL, list, glock_cmp); 1784 1785 while(!list_empty(list)) { 1786 gl = list_first_entry(list, struct gfs2_glock, gl_lru); 1787 list_del_init(&gl->gl_lru); 1788 clear_bit(GLF_LRU, &gl->gl_flags); 1789 if (!spin_trylock(&gl->gl_lockref.lock)) { 1790add_back_to_lru: 1791 list_add(&gl->gl_lru, &lru_list); 1792 set_bit(GLF_LRU, &gl->gl_flags); 1793 atomic_inc(&lru_count); 1794 continue; 1795 } 1796 if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) { 1797 spin_unlock(&gl->gl_lockref.lock); 1798 goto add_back_to_lru; 1799 } 1800 gl->gl_lockref.count++; 1801 if (demote_ok(gl)) 1802 handle_callback(gl, LM_ST_UNLOCKED, 0, false); 1803 WARN_ON(!test_and_clear_bit(GLF_LOCK, &gl->gl_flags)); 1804 __gfs2_glock_queue_work(gl, 0); 1805 spin_unlock(&gl->gl_lockref.lock); 1806 cond_resched_lock(&lru_lock); 1807 } 1808} 1809 1810/** 1811 * gfs2_scan_glock_lru - Scan the LRU looking for locks to demote 1812 * @nr: The number of entries to scan 1813 * 1814 * This function selects the entries on the LRU which are able to 1815 * be demoted, and then kicks off the process by calling 1816 * gfs2_dispose_glock_lru() above. 1817 */ 1818 1819static long gfs2_scan_glock_lru(int nr) 1820{ 1821 struct gfs2_glock *gl; 1822 LIST_HEAD(skipped); 1823 LIST_HEAD(dispose); 1824 long freed = 0; 1825 1826 spin_lock(&lru_lock); 1827 while ((nr-- >= 0) && !list_empty(&lru_list)) { 1828 gl = list_first_entry(&lru_list, struct gfs2_glock, gl_lru); 1829 1830 /* Test for being demotable */ 1831 if (!test_bit(GLF_LOCK, &gl->gl_flags)) { 1832 list_move(&gl->gl_lru, &dispose); 1833 atomic_dec(&lru_count); 1834 freed++; 1835 continue; 1836 } 1837 1838 list_move(&gl->gl_lru, &skipped); 1839 } 1840 list_splice(&skipped, &lru_list); 1841 if (!list_empty(&dispose)) 1842 gfs2_dispose_glock_lru(&dispose); 1843 spin_unlock(&lru_lock); 1844 1845 return freed; 1846} 1847 1848static unsigned long gfs2_glock_shrink_scan(struct shrinker *shrink, 1849 struct shrink_control *sc) 1850{ 1851 if (!(sc->gfp_mask & __GFP_FS)) 1852 return SHRINK_STOP; 1853 return gfs2_scan_glock_lru(sc->nr_to_scan); 1854} 1855 1856static unsigned long gfs2_glock_shrink_count(struct shrinker *shrink, 1857 struct shrink_control *sc) 1858{ 1859 return vfs_pressure_ratio(atomic_read(&lru_count)); 1860} 1861 1862static struct shrinker glock_shrinker = { 1863 .seeks = DEFAULT_SEEKS, 1864 .count_objects = gfs2_glock_shrink_count, 1865 .scan_objects = gfs2_glock_shrink_scan, 1866}; 1867 1868/** 1869 * glock_hash_walk - Call a function for glock in a hash bucket 1870 * @examiner: the function 1871 * @sdp: the filesystem 1872 * 1873 * Note that the function can be called multiple times on the same 1874 * object. So the user must ensure that the function can cope with 1875 * that. 1876 */ 1877 1878static void glock_hash_walk(glock_examiner examiner, const struct gfs2_sbd *sdp) 1879{ 1880 struct gfs2_glock *gl; 1881 struct rhashtable_iter iter; 1882 1883 rhashtable_walk_enter(&gl_hash_table, &iter); 1884 1885 do { 1886 rhashtable_walk_start(&iter); 1887 1888 while ((gl = rhashtable_walk_next(&iter)) && !IS_ERR(gl)) { 1889 if (gl->gl_name.ln_sbd == sdp) 1890 examiner(gl); 1891 } 1892 1893 rhashtable_walk_stop(&iter); 1894 } while (cond_resched(), gl == ERR_PTR(-EAGAIN)); 1895 1896 rhashtable_walk_exit(&iter); 1897} 1898 1899bool gfs2_queue_delete_work(struct gfs2_glock *gl, unsigned long delay) 1900{ 1901 bool queued; 1902 1903 spin_lock(&gl->gl_lockref.lock); 1904 queued = queue_delayed_work(gfs2_delete_workqueue, 1905 &gl->gl_delete, delay); 1906 if (queued) 1907 set_bit(GLF_PENDING_DELETE, &gl->gl_flags); 1908 spin_unlock(&gl->gl_lockref.lock); 1909 return queued; 1910} 1911 1912void gfs2_cancel_delete_work(struct gfs2_glock *gl) 1913{ 1914 if (cancel_delayed_work(&gl->gl_delete)) { 1915 clear_bit(GLF_PENDING_DELETE, &gl->gl_flags); 1916 gfs2_glock_put(gl); 1917 } 1918} 1919 1920bool gfs2_delete_work_queued(const struct gfs2_glock *gl) 1921{ 1922 return test_bit(GLF_PENDING_DELETE, &gl->gl_flags); 1923} 1924 1925static void flush_delete_work(struct gfs2_glock *gl) 1926{ 1927 if (gl->gl_name.ln_type == LM_TYPE_IOPEN) { 1928 if (cancel_delayed_work(&gl->gl_delete)) { 1929 queue_delayed_work(gfs2_delete_workqueue, 1930 &gl->gl_delete, 0); 1931 } 1932 } 1933} 1934 1935void gfs2_flush_delete_work(struct gfs2_sbd *sdp) 1936{ 1937 glock_hash_walk(flush_delete_work, sdp); 1938 flush_workqueue(gfs2_delete_workqueue); 1939} 1940 1941/** 1942 * thaw_glock - thaw out a glock which has an unprocessed reply waiting 1943 * @gl: The glock to thaw 1944 * 1945 */ 1946 1947static void thaw_glock(struct gfs2_glock *gl) 1948{ 1949 if (!test_and_clear_bit(GLF_FROZEN, &gl->gl_flags)) 1950 return; 1951 if (!lockref_get_not_dead(&gl->gl_lockref)) 1952 return; 1953 set_bit(GLF_REPLY_PENDING, &gl->gl_flags); 1954 gfs2_glock_queue_work(gl, 0); 1955} 1956 1957/** 1958 * clear_glock - look at a glock and see if we can free it from glock cache 1959 * @gl: the glock to look at 1960 * 1961 */ 1962 1963static void clear_glock(struct gfs2_glock *gl) 1964{ 1965 gfs2_glock_remove_from_lru(gl); 1966 1967 spin_lock(&gl->gl_lockref.lock); 1968 if (!__lockref_is_dead(&gl->gl_lockref)) { 1969 gl->gl_lockref.count++; 1970 if (gl->gl_state != LM_ST_UNLOCKED) 1971 handle_callback(gl, LM_ST_UNLOCKED, 0, false); 1972 __gfs2_glock_queue_work(gl, 0); 1973 } 1974 spin_unlock(&gl->gl_lockref.lock); 1975} 1976 1977/** 1978 * gfs2_glock_thaw - Thaw any frozen glocks 1979 * @sdp: The super block 1980 * 1981 */ 1982 1983void gfs2_glock_thaw(struct gfs2_sbd *sdp) 1984{ 1985 glock_hash_walk(thaw_glock, sdp); 1986} 1987 1988static void dump_glock(struct seq_file *seq, struct gfs2_glock *gl, bool fsid) 1989{ 1990 spin_lock(&gl->gl_lockref.lock); 1991 gfs2_dump_glock(seq, gl, fsid); 1992 spin_unlock(&gl->gl_lockref.lock); 1993} 1994 1995static void dump_glock_func(struct gfs2_glock *gl) 1996{ 1997 dump_glock(NULL, gl, true); 1998} 1999 2000/** 2001 * gfs2_gl_hash_clear - Empty out the glock hash table 2002 * @sdp: the filesystem 2003 * @wait: wait until it's all gone 2004 * 2005 * Called when unmounting the filesystem. 2006 */ 2007 2008void gfs2_gl_hash_clear(struct gfs2_sbd *sdp) 2009{ 2010 set_bit(SDF_SKIP_DLM_UNLOCK, &sdp->sd_flags); 2011 flush_workqueue(glock_workqueue); 2012 glock_hash_walk(clear_glock, sdp); 2013 flush_workqueue(glock_workqueue); 2014 wait_event_timeout(sdp->sd_glock_wait, 2015 atomic_read(&sdp->sd_glock_disposal) == 0, 2016 HZ * 600); 2017 glock_hash_walk(dump_glock_func, sdp); 2018} 2019 2020void gfs2_glock_finish_truncate(struct gfs2_inode *ip) 2021{ 2022 struct gfs2_glock *gl = ip->i_gl; 2023 int ret; 2024 2025 ret = gfs2_truncatei_resume(ip); 2026 gfs2_glock_assert_withdraw(gl, ret == 0); 2027 2028 spin_lock(&gl->gl_lockref.lock); 2029 clear_bit(GLF_LOCK, &gl->gl_flags); 2030 run_queue(gl, 1); 2031 spin_unlock(&gl->gl_lockref.lock); 2032} 2033 2034static const char *state2str(unsigned state) 2035{ 2036 switch(state) { 2037 case LM_ST_UNLOCKED: 2038 return "UN"; 2039 case LM_ST_SHARED: 2040 return "SH"; 2041 case LM_ST_DEFERRED: 2042 return "DF"; 2043 case LM_ST_EXCLUSIVE: 2044 return "EX"; 2045 } 2046 return "??"; 2047} 2048 2049static const char *hflags2str(char *buf, u16 flags, unsigned long iflags) 2050{ 2051 char *p = buf; 2052 if (flags & LM_FLAG_TRY) 2053 *p++ = 't'; 2054 if (flags & LM_FLAG_TRY_1CB) 2055 *p++ = 'T'; 2056 if (flags & LM_FLAG_NOEXP) 2057 *p++ = 'e'; 2058 if (flags & LM_FLAG_ANY) 2059 *p++ = 'A'; 2060 if (flags & LM_FLAG_PRIORITY) 2061 *p++ = 'p'; 2062 if (flags & GL_ASYNC) 2063 *p++ = 'a'; 2064 if (flags & GL_EXACT) 2065 *p++ = 'E'; 2066 if (flags & GL_NOCACHE) 2067 *p++ = 'c'; 2068 if (test_bit(HIF_HOLDER, &iflags)) 2069 *p++ = 'H'; 2070 if (test_bit(HIF_WAIT, &iflags)) 2071 *p++ = 'W'; 2072 if (test_bit(HIF_FIRST, &iflags)) 2073 *p++ = 'F'; 2074 *p = 0; 2075 return buf; 2076} 2077 2078/** 2079 * dump_holder - print information about a glock holder 2080 * @seq: the seq_file struct 2081 * @gh: the glock holder 2082 * @fs_id_buf: pointer to file system id (if requested) 2083 * 2084 */ 2085 2086static void dump_holder(struct seq_file *seq, const struct gfs2_holder *gh, 2087 const char *fs_id_buf) 2088{ 2089 struct task_struct *gh_owner = NULL; 2090 char flags_buf[32]; 2091 2092 rcu_read_lock(); 2093 if (gh->gh_owner_pid) 2094 gh_owner = pid_task(gh->gh_owner_pid, PIDTYPE_PID); 2095 gfs2_print_dbg(seq, "%s H: s:%s f:%s e:%d p:%ld [%s] %pS\n", 2096 fs_id_buf, state2str(gh->gh_state), 2097 hflags2str(flags_buf, gh->gh_flags, gh->gh_iflags), 2098 gh->gh_error, 2099 gh->gh_owner_pid ? (long)pid_nr(gh->gh_owner_pid) : -1, 2100 gh_owner ? gh_owner->comm : "(ended)", 2101 (void *)gh->gh_ip); 2102 rcu_read_unlock(); 2103} 2104 2105static const char *gflags2str(char *buf, const struct gfs2_glock *gl) 2106{ 2107 const unsigned long *gflags = &gl->gl_flags; 2108 char *p = buf; 2109 2110 if (test_bit(GLF_LOCK, gflags)) 2111 *p++ = 'l'; 2112 if (test_bit(GLF_DEMOTE, gflags)) 2113 *p++ = 'D'; 2114 if (test_bit(GLF_PENDING_DEMOTE, gflags)) 2115 *p++ = 'd'; 2116 if (test_bit(GLF_DEMOTE_IN_PROGRESS, gflags)) 2117 *p++ = 'p'; 2118 if (test_bit(GLF_DIRTY, gflags)) 2119 *p++ = 'y'; 2120 if (test_bit(GLF_LFLUSH, gflags)) 2121 *p++ = 'f'; 2122 if (test_bit(GLF_INVALIDATE_IN_PROGRESS, gflags)) 2123 *p++ = 'i'; 2124 if (test_bit(GLF_REPLY_PENDING, gflags)) 2125 *p++ = 'r'; 2126 if (test_bit(GLF_INITIAL, gflags)) 2127 *p++ = 'I'; 2128 if (test_bit(GLF_FROZEN, gflags)) 2129 *p++ = 'F'; 2130 if (!list_empty(&gl->gl_holders)) 2131 *p++ = 'q'; 2132 if (test_bit(GLF_LRU, gflags)) 2133 *p++ = 'L'; 2134 if (gl->gl_object) 2135 *p++ = 'o'; 2136 if (test_bit(GLF_BLOCKING, gflags)) 2137 *p++ = 'b'; 2138 if (test_bit(GLF_INODE_CREATING, gflags)) 2139 *p++ = 'c'; 2140 if (test_bit(GLF_PENDING_DELETE, gflags)) 2141 *p++ = 'P'; 2142 if (test_bit(GLF_FREEING, gflags)) 2143 *p++ = 'x'; 2144 *p = 0; 2145 return buf; 2146} 2147 2148/** 2149 * gfs2_dump_glock - print information about a glock 2150 * @seq: The seq_file struct 2151 * @gl: the glock 2152 * @fsid: If true, also dump the file system id 2153 * 2154 * The file format is as follows: 2155 * One line per object, capital letters are used to indicate objects 2156 * G = glock, I = Inode, R = rgrp, H = holder. Glocks are not indented, 2157 * other objects are indented by a single space and follow the glock to 2158 * which they are related. Fields are indicated by lower case letters 2159 * followed by a colon and the field value, except for strings which are in 2160 * [] so that its possible to see if they are composed of spaces for 2161 * example. The field's are n = number (id of the object), f = flags, 2162 * t = type, s = state, r = refcount, e = error, p = pid. 2163 * 2164 */ 2165 2166void gfs2_dump_glock(struct seq_file *seq, struct gfs2_glock *gl, bool fsid) 2167{ 2168 const struct gfs2_glock_operations *glops = gl->gl_ops; 2169 unsigned long long dtime; 2170 const struct gfs2_holder *gh; 2171 char gflags_buf[32]; 2172 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 2173 char fs_id_buf[sizeof(sdp->sd_fsname) + 7]; 2174 unsigned long nrpages = 0; 2175 2176 if (gl->gl_ops->go_flags & GLOF_ASPACE) { 2177 struct address_space *mapping = gfs2_glock2aspace(gl); 2178 2179 nrpages = mapping->nrpages; 2180 } 2181 memset(fs_id_buf, 0, sizeof(fs_id_buf)); 2182 if (fsid && sdp) /* safety precaution */ 2183 sprintf(fs_id_buf, "fsid=%s: ", sdp->sd_fsname); 2184 dtime = jiffies - gl->gl_demote_time; 2185 dtime *= 1000000/HZ; /* demote time in uSec */ 2186 if (!test_bit(GLF_DEMOTE, &gl->gl_flags)) 2187 dtime = 0; 2188 gfs2_print_dbg(seq, "%sG: s:%s n:%u/%llx f:%s t:%s d:%s/%llu a:%d " 2189 "v:%d r:%d m:%ld p:%lu\n", 2190 fs_id_buf, state2str(gl->gl_state), 2191 gl->gl_name.ln_type, 2192 (unsigned long long)gl->gl_name.ln_number, 2193 gflags2str(gflags_buf, gl), 2194 state2str(gl->gl_target), 2195 state2str(gl->gl_demote_state), dtime, 2196 atomic_read(&gl->gl_ail_count), 2197 atomic_read(&gl->gl_revokes), 2198 (int)gl->gl_lockref.count, gl->gl_hold_time, nrpages); 2199 2200 list_for_each_entry(gh, &gl->gl_holders, gh_list) 2201 dump_holder(seq, gh, fs_id_buf); 2202 2203 if (gl->gl_state != LM_ST_UNLOCKED && glops->go_dump) 2204 glops->go_dump(seq, gl, fs_id_buf); 2205} 2206 2207static int gfs2_glstats_seq_show(struct seq_file *seq, void *iter_ptr) 2208{ 2209 struct gfs2_glock *gl = iter_ptr; 2210 2211 seq_printf(seq, "G: n:%u/%llx rtt:%llu/%llu rttb:%llu/%llu irt:%llu/%llu dcnt: %llu qcnt: %llu\n", 2212 gl->gl_name.ln_type, 2213 (unsigned long long)gl->gl_name.ln_number, 2214 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTT], 2215 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTVAR], 2216 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTB], 2217 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTVARB], 2218 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SIRT], 2219 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SIRTVAR], 2220 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_DCOUNT], 2221 (unsigned long long)gl->gl_stats.stats[GFS2_LKS_QCOUNT]); 2222 return 0; 2223} 2224 2225static const char *gfs2_gltype[] = { 2226 "type", 2227 "reserved", 2228 "nondisk", 2229 "inode", 2230 "rgrp", 2231 "meta", 2232 "iopen", 2233 "flock", 2234 "plock", 2235 "quota", 2236 "journal", 2237}; 2238 2239static const char *gfs2_stype[] = { 2240 [GFS2_LKS_SRTT] = "srtt", 2241 [GFS2_LKS_SRTTVAR] = "srttvar", 2242 [GFS2_LKS_SRTTB] = "srttb", 2243 [GFS2_LKS_SRTTVARB] = "srttvarb", 2244 [GFS2_LKS_SIRT] = "sirt", 2245 [GFS2_LKS_SIRTVAR] = "sirtvar", 2246 [GFS2_LKS_DCOUNT] = "dlm", 2247 [GFS2_LKS_QCOUNT] = "queue", 2248}; 2249 2250#define GFS2_NR_SBSTATS (ARRAY_SIZE(gfs2_gltype) * ARRAY_SIZE(gfs2_stype)) 2251 2252static int gfs2_sbstats_seq_show(struct seq_file *seq, void *iter_ptr) 2253{ 2254 struct gfs2_sbd *sdp = seq->private; 2255 loff_t pos = *(loff_t *)iter_ptr; 2256 unsigned index = pos >> 3; 2257 unsigned subindex = pos & 0x07; 2258 int i; 2259 2260 if (index == 0 && subindex != 0) 2261 return 0; 2262 2263 seq_printf(seq, "%-10s %8s:", gfs2_gltype[index], 2264 (index == 0) ? "cpu": gfs2_stype[subindex]); 2265 2266 for_each_possible_cpu(i) { 2267 const struct gfs2_pcpu_lkstats *lkstats = per_cpu_ptr(sdp->sd_lkstats, i); 2268 2269 if (index == 0) 2270 seq_printf(seq, " %15u", i); 2271 else 2272 seq_printf(seq, " %15llu", (unsigned long long)lkstats-> 2273 lkstats[index - 1].stats[subindex]); 2274 } 2275 seq_putc(seq, '\n'); 2276 return 0; 2277} 2278 2279int __init gfs2_glock_init(void) 2280{ 2281 int i, ret; 2282 2283 ret = rhashtable_init(&gl_hash_table, &ht_parms); 2284 if (ret < 0) 2285 return ret; 2286 2287 glock_workqueue = alloc_workqueue("glock_workqueue", WQ_MEM_RECLAIM | 2288 WQ_HIGHPRI | WQ_FREEZABLE, 0); 2289 if (!glock_workqueue) { 2290 rhashtable_destroy(&gl_hash_table); 2291 return -ENOMEM; 2292 } 2293 gfs2_delete_workqueue = alloc_workqueue("delete_workqueue", 2294 WQ_MEM_RECLAIM | WQ_FREEZABLE, 2295 0); 2296 if (!gfs2_delete_workqueue) { 2297 destroy_workqueue(glock_workqueue); 2298 rhashtable_destroy(&gl_hash_table); 2299 return -ENOMEM; 2300 } 2301 2302 ret = register_shrinker(&glock_shrinker); 2303 if (ret) { 2304 destroy_workqueue(gfs2_delete_workqueue); 2305 destroy_workqueue(glock_workqueue); 2306 rhashtable_destroy(&gl_hash_table); 2307 return ret; 2308 } 2309 2310 for (i = 0; i < GLOCK_WAIT_TABLE_SIZE; i++) 2311 init_waitqueue_head(glock_wait_table + i); 2312 2313 return 0; 2314} 2315 2316void gfs2_glock_exit(void) 2317{ 2318 unregister_shrinker(&glock_shrinker); 2319 rhashtable_destroy(&gl_hash_table); 2320 destroy_workqueue(glock_workqueue); 2321 destroy_workqueue(gfs2_delete_workqueue); 2322} 2323 2324static void gfs2_glock_iter_next(struct gfs2_glock_iter *gi, loff_t n) 2325{ 2326 struct gfs2_glock *gl = gi->gl; 2327 2328 if (gl) { 2329 if (n == 0) 2330 return; 2331 if (!lockref_put_not_zero(&gl->gl_lockref)) 2332 gfs2_glock_queue_put(gl); 2333 } 2334 for (;;) { 2335 gl = rhashtable_walk_next(&gi->hti); 2336 if (IS_ERR_OR_NULL(gl)) { 2337 if (gl == ERR_PTR(-EAGAIN)) { 2338 n = 1; 2339 continue; 2340 } 2341 gl = NULL; 2342 break; 2343 } 2344 if (gl->gl_name.ln_sbd != gi->sdp) 2345 continue; 2346 if (n <= 1) { 2347 if (!lockref_get_not_dead(&gl->gl_lockref)) 2348 continue; 2349 break; 2350 } else { 2351 if (__lockref_is_dead(&gl->gl_lockref)) 2352 continue; 2353 n--; 2354 } 2355 } 2356 gi->gl = gl; 2357} 2358 2359static void *gfs2_glock_seq_start(struct seq_file *seq, loff_t *pos) 2360 __acquires(RCU) 2361{ 2362 struct gfs2_glock_iter *gi = seq->private; 2363 loff_t n; 2364 2365 /* 2366 * We can either stay where we are, skip to the next hash table 2367 * entry, or start from the beginning. 2368 */ 2369 if (*pos < gi->last_pos) { 2370 rhashtable_walk_exit(&gi->hti); 2371 rhashtable_walk_enter(&gl_hash_table, &gi->hti); 2372 n = *pos + 1; 2373 } else { 2374 n = *pos - gi->last_pos; 2375 } 2376 2377 rhashtable_walk_start(&gi->hti); 2378 2379 gfs2_glock_iter_next(gi, n); 2380 gi->last_pos = *pos; 2381 return gi->gl; 2382} 2383 2384static void *gfs2_glock_seq_next(struct seq_file *seq, void *iter_ptr, 2385 loff_t *pos) 2386{ 2387 struct gfs2_glock_iter *gi = seq->private; 2388 2389 (*pos)++; 2390 gi->last_pos = *pos; 2391 gfs2_glock_iter_next(gi, 1); 2392 return gi->gl; 2393} 2394 2395static void gfs2_glock_seq_stop(struct seq_file *seq, void *iter_ptr) 2396 __releases(RCU) 2397{ 2398 struct gfs2_glock_iter *gi = seq->private; 2399 2400 rhashtable_walk_stop(&gi->hti); 2401} 2402 2403static int gfs2_glock_seq_show(struct seq_file *seq, void *iter_ptr) 2404{ 2405 dump_glock(seq, iter_ptr, false); 2406 return 0; 2407} 2408 2409static void *gfs2_sbstats_seq_start(struct seq_file *seq, loff_t *pos) 2410{ 2411 preempt_disable(); 2412 if (*pos >= GFS2_NR_SBSTATS) 2413 return NULL; 2414 return pos; 2415} 2416 2417static void *gfs2_sbstats_seq_next(struct seq_file *seq, void *iter_ptr, 2418 loff_t *pos) 2419{ 2420 (*pos)++; 2421 if (*pos >= GFS2_NR_SBSTATS) 2422 return NULL; 2423 return pos; 2424} 2425 2426static void gfs2_sbstats_seq_stop(struct seq_file *seq, void *iter_ptr) 2427{ 2428 preempt_enable(); 2429} 2430 2431static const struct seq_operations gfs2_glock_seq_ops = { 2432 .start = gfs2_glock_seq_start, 2433 .next = gfs2_glock_seq_next, 2434 .stop = gfs2_glock_seq_stop, 2435 .show = gfs2_glock_seq_show, 2436}; 2437 2438static const struct seq_operations gfs2_glstats_seq_ops = { 2439 .start = gfs2_glock_seq_start, 2440 .next = gfs2_glock_seq_next, 2441 .stop = gfs2_glock_seq_stop, 2442 .show = gfs2_glstats_seq_show, 2443}; 2444 2445static const struct seq_operations gfs2_sbstats_sops = { 2446 .start = gfs2_sbstats_seq_start, 2447 .next = gfs2_sbstats_seq_next, 2448 .stop = gfs2_sbstats_seq_stop, 2449 .show = gfs2_sbstats_seq_show, 2450}; 2451 2452#define GFS2_SEQ_GOODSIZE min(PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER, 65536UL) 2453 2454static int __gfs2_glocks_open(struct inode *inode, struct file *file, 2455 const struct seq_operations *ops) 2456{ 2457 int ret = seq_open_private(file, ops, sizeof(struct gfs2_glock_iter)); 2458 if (ret == 0) { 2459 struct seq_file *seq = file->private_data; 2460 struct gfs2_glock_iter *gi = seq->private; 2461 2462 gi->sdp = inode->i_private; 2463 seq->buf = kmalloc(GFS2_SEQ_GOODSIZE, GFP_KERNEL | __GFP_NOWARN); 2464 if (seq->buf) 2465 seq->size = GFS2_SEQ_GOODSIZE; 2466 /* 2467 * Initially, we are "before" the first hash table entry; the 2468 * first call to rhashtable_walk_next gets us the first entry. 2469 */ 2470 gi->last_pos = -1; 2471 gi->gl = NULL; 2472 rhashtable_walk_enter(&gl_hash_table, &gi->hti); 2473 } 2474 return ret; 2475} 2476 2477static int gfs2_glocks_open(struct inode *inode, struct file *file) 2478{ 2479 return __gfs2_glocks_open(inode, file, &gfs2_glock_seq_ops); 2480} 2481 2482static int gfs2_glocks_release(struct inode *inode, struct file *file) 2483{ 2484 struct seq_file *seq = file->private_data; 2485 struct gfs2_glock_iter *gi = seq->private; 2486 2487 if (gi->gl) 2488 gfs2_glock_put(gi->gl); 2489 rhashtable_walk_exit(&gi->hti); 2490 return seq_release_private(inode, file); 2491} 2492 2493static int gfs2_glstats_open(struct inode *inode, struct file *file) 2494{ 2495 return __gfs2_glocks_open(inode, file, &gfs2_glstats_seq_ops); 2496} 2497 2498static const struct file_operations gfs2_glocks_fops = { 2499 .owner = THIS_MODULE, 2500 .open = gfs2_glocks_open, 2501 .read = seq_read, 2502 .llseek = seq_lseek, 2503 .release = gfs2_glocks_release, 2504}; 2505 2506static const struct file_operations gfs2_glstats_fops = { 2507 .owner = THIS_MODULE, 2508 .open = gfs2_glstats_open, 2509 .read = seq_read, 2510 .llseek = seq_lseek, 2511 .release = gfs2_glocks_release, 2512}; 2513 2514DEFINE_SEQ_ATTRIBUTE(gfs2_sbstats); 2515 2516void gfs2_create_debugfs_file(struct gfs2_sbd *sdp) 2517{ 2518 sdp->debugfs_dir = debugfs_create_dir(sdp->sd_table_name, gfs2_root); 2519 2520 debugfs_create_file("glocks", S_IFREG | S_IRUGO, sdp->debugfs_dir, sdp, 2521 &gfs2_glocks_fops); 2522 2523 debugfs_create_file("glstats", S_IFREG | S_IRUGO, sdp->debugfs_dir, sdp, 2524 &gfs2_glstats_fops); 2525 2526 debugfs_create_file("sbstats", S_IFREG | S_IRUGO, sdp->debugfs_dir, sdp, 2527 &gfs2_sbstats_fops); 2528} 2529 2530void gfs2_delete_debugfs_file(struct gfs2_sbd *sdp) 2531{ 2532 debugfs_remove_recursive(sdp->debugfs_dir); 2533 sdp->debugfs_dir = NULL; 2534} 2535 2536void gfs2_register_debugfs(void) 2537{ 2538 gfs2_root = debugfs_create_dir("gfs2", NULL); 2539} 2540 2541void gfs2_unregister_debugfs(void) 2542{ 2543 debugfs_remove(gfs2_root); 2544 gfs2_root = NULL; 2545} 2546