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 #include <linux/spinlock.h> 8 #include <linux/completion.h> 9 #include <linux/buffer_head.h> 10 #include <linux/gfs2_ondisk.h> 11 #include <linux/bio.h> 12 #include <linux/posix_acl.h> 13 #include <linux/security.h> 14 15 #include "gfs2.h" 16 #include "incore.h" 17 #include "bmap.h" 18 #include "glock.h" 19 #include "glops.h" 20 #include "inode.h" 21 #include "log.h" 22 #include "meta_io.h" 23 #include "recovery.h" 24 #include "rgrp.h" 25 #include "util.h" 26 #include "trans.h" 27 #include "dir.h" 28 #include "lops.h" 29 30 struct workqueue_struct *gfs2_freeze_wq; 31 32 extern struct workqueue_struct *gfs2_control_wq; 33 34 static void gfs2_ail_error(struct gfs2_glock *gl, const struct buffer_head *bh) 35 { 36 fs_err(gl->gl_name.ln_sbd, 37 "AIL buffer %p: blocknr %llu state 0x%08lx mapping %p page " 38 "state 0x%lx\n", 39 bh, (unsigned long long)bh->b_blocknr, bh->b_state, 40 bh->b_page->mapping, bh->b_page->flags); 41 fs_err(gl->gl_name.ln_sbd, "AIL glock %u:%llu mapping %p\n", 42 gl->gl_name.ln_type, gl->gl_name.ln_number, 43 gfs2_glock2aspace(gl)); 44 gfs2_lm(gl->gl_name.ln_sbd, "AIL error\n"); 45 gfs2_withdraw(gl->gl_name.ln_sbd); 46 } 47 48 /** 49 * __gfs2_ail_flush - remove all buffers for a given lock from the AIL 50 * @gl: the glock 51 * @fsync: set when called from fsync (not all buffers will be clean) 52 * 53 * None of the buffers should be dirty, locked, or pinned. 54 */ 55 56 static void __gfs2_ail_flush(struct gfs2_glock *gl, bool fsync, 57 unsigned int nr_revokes) 58 { 59 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 60 struct list_head *head = &gl->gl_ail_list; 61 struct gfs2_bufdata *bd, *tmp; 62 struct buffer_head *bh; 63 const unsigned long b_state = (1UL << BH_Dirty)|(1UL << BH_Pinned)|(1UL << BH_Lock); 64 65 gfs2_log_lock(sdp); 66 spin_lock(&sdp->sd_ail_lock); 67 list_for_each_entry_safe_reverse(bd, tmp, head, bd_ail_gl_list) { 68 if (nr_revokes == 0) 69 break; 70 bh = bd->bd_bh; 71 if (bh->b_state & b_state) { 72 if (fsync) 73 continue; 74 gfs2_ail_error(gl, bh); 75 } 76 gfs2_trans_add_revoke(sdp, bd); 77 nr_revokes--; 78 } 79 GLOCK_BUG_ON(gl, !fsync && atomic_read(&gl->gl_ail_count)); 80 spin_unlock(&sdp->sd_ail_lock); 81 gfs2_log_unlock(sdp); 82 } 83 84 85 static int gfs2_ail_empty_gl(struct gfs2_glock *gl) 86 { 87 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 88 struct gfs2_trans tr; 89 int ret; 90 91 memset(&tr, 0, sizeof(tr)); 92 INIT_LIST_HEAD(&tr.tr_buf); 93 INIT_LIST_HEAD(&tr.tr_databuf); 94 INIT_LIST_HEAD(&tr.tr_ail1_list); 95 INIT_LIST_HEAD(&tr.tr_ail2_list); 96 tr.tr_revokes = atomic_read(&gl->gl_ail_count); 97 98 if (!tr.tr_revokes) { 99 bool have_revokes; 100 bool log_in_flight; 101 102 /* 103 * We have nothing on the ail, but there could be revokes on 104 * the sdp revoke queue, in which case, we still want to flush 105 * the log and wait for it to finish. 106 * 107 * If the sdp revoke list is empty too, we might still have an 108 * io outstanding for writing revokes, so we should wait for 109 * it before returning. 110 * 111 * If none of these conditions are true, our revokes are all 112 * flushed and we can return. 113 */ 114 gfs2_log_lock(sdp); 115 have_revokes = !list_empty(&sdp->sd_log_revokes); 116 log_in_flight = atomic_read(&sdp->sd_log_in_flight); 117 gfs2_log_unlock(sdp); 118 if (have_revokes) 119 goto flush; 120 if (log_in_flight) 121 log_flush_wait(sdp); 122 return 0; 123 } 124 125 /* A shortened, inline version of gfs2_trans_begin() 126 * tr->alloced is not set since the transaction structure is 127 * on the stack */ 128 tr.tr_reserved = 1 + gfs2_struct2blk(sdp, tr.tr_revokes); 129 tr.tr_ip = _RET_IP_; 130 ret = gfs2_log_reserve(sdp, tr.tr_reserved); 131 if (ret < 0) 132 return ret; 133 WARN_ON_ONCE(current->journal_info); 134 current->journal_info = &tr; 135 136 __gfs2_ail_flush(gl, 0, tr.tr_revokes); 137 138 gfs2_trans_end(sdp); 139 flush: 140 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 141 GFS2_LFC_AIL_EMPTY_GL); 142 return 0; 143 } 144 145 void gfs2_ail_flush(struct gfs2_glock *gl, bool fsync) 146 { 147 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 148 unsigned int revokes = atomic_read(&gl->gl_ail_count); 149 unsigned int max_revokes = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / sizeof(u64); 150 int ret; 151 152 if (!revokes) 153 return; 154 155 while (revokes > max_revokes) 156 max_revokes += (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header)) / sizeof(u64); 157 158 ret = gfs2_trans_begin(sdp, 0, max_revokes); 159 if (ret) 160 return; 161 __gfs2_ail_flush(gl, fsync, max_revokes); 162 gfs2_trans_end(sdp); 163 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 164 GFS2_LFC_AIL_FLUSH); 165 } 166 167 /** 168 * rgrp_go_sync - sync out the metadata for this glock 169 * @gl: the glock 170 * 171 * Called when demoting or unlocking an EX glock. We must flush 172 * to disk all dirty buffers/pages relating to this glock, and must not 173 * return to caller to demote/unlock the glock until I/O is complete. 174 */ 175 176 static int rgrp_go_sync(struct gfs2_glock *gl) 177 { 178 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 179 struct address_space *mapping = &sdp->sd_aspace; 180 struct gfs2_rgrpd *rgd = gfs2_glock2rgrp(gl); 181 const unsigned bsize = sdp->sd_sb.sb_bsize; 182 loff_t start = (rgd->rd_addr * bsize) & PAGE_MASK; 183 loff_t end = PAGE_ALIGN((rgd->rd_addr + rgd->rd_length) * bsize) - 1; 184 int error; 185 186 if (!test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) 187 return 0; 188 GLOCK_BUG_ON(gl, gl->gl_state != LM_ST_EXCLUSIVE); 189 190 gfs2_log_flush(sdp, gl, GFS2_LOG_HEAD_FLUSH_NORMAL | 191 GFS2_LFC_RGRP_GO_SYNC); 192 filemap_fdatawrite_range(mapping, start, end); 193 error = filemap_fdatawait_range(mapping, start, end); 194 WARN_ON_ONCE(error && !gfs2_withdrawn(sdp)); 195 mapping_set_error(mapping, error); 196 if (!error) 197 error = gfs2_ail_empty_gl(gl); 198 gfs2_free_clones(rgd); 199 return error; 200 } 201 202 /** 203 * rgrp_go_inval - invalidate the metadata for this glock 204 * @gl: the glock 205 * @flags: 206 * 207 * We never used LM_ST_DEFERRED with resource groups, so that we 208 * should always see the metadata flag set here. 209 * 210 */ 211 212 static void rgrp_go_inval(struct gfs2_glock *gl, int flags) 213 { 214 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 215 struct address_space *mapping = &sdp->sd_aspace; 216 struct gfs2_rgrpd *rgd = gfs2_glock2rgrp(gl); 217 const unsigned bsize = sdp->sd_sb.sb_bsize; 218 loff_t start = (rgd->rd_addr * bsize) & PAGE_MASK; 219 loff_t end = PAGE_ALIGN((rgd->rd_addr + rgd->rd_length) * bsize) - 1; 220 221 gfs2_rgrp_brelse(rgd); 222 WARN_ON_ONCE(!(flags & DIO_METADATA)); 223 truncate_inode_pages_range(mapping, start, end); 224 rgd->rd_flags &= ~GFS2_RDF_UPTODATE; 225 } 226 227 static void gfs2_rgrp_go_dump(struct seq_file *seq, struct gfs2_glock *gl, 228 const char *fs_id_buf) 229 { 230 struct gfs2_rgrpd *rgd = gfs2_glock2rgrp(gl); 231 232 if (rgd) 233 gfs2_rgrp_dump(seq, rgd, fs_id_buf); 234 } 235 236 static struct gfs2_inode *gfs2_glock2inode(struct gfs2_glock *gl) 237 { 238 struct gfs2_inode *ip; 239 240 spin_lock(&gl->gl_lockref.lock); 241 ip = gl->gl_object; 242 if (ip) 243 set_bit(GIF_GLOP_PENDING, &ip->i_flags); 244 spin_unlock(&gl->gl_lockref.lock); 245 return ip; 246 } 247 248 struct gfs2_rgrpd *gfs2_glock2rgrp(struct gfs2_glock *gl) 249 { 250 struct gfs2_rgrpd *rgd; 251 252 spin_lock(&gl->gl_lockref.lock); 253 rgd = gl->gl_object; 254 spin_unlock(&gl->gl_lockref.lock); 255 256 return rgd; 257 } 258 259 static void gfs2_clear_glop_pending(struct gfs2_inode *ip) 260 { 261 if (!ip) 262 return; 263 264 clear_bit_unlock(GIF_GLOP_PENDING, &ip->i_flags); 265 wake_up_bit(&ip->i_flags, GIF_GLOP_PENDING); 266 } 267 268 /** 269 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock 270 * @gl: the glock protecting the inode 271 * 272 */ 273 274 static int inode_go_sync(struct gfs2_glock *gl) 275 { 276 struct gfs2_inode *ip = gfs2_glock2inode(gl); 277 int isreg = ip && S_ISREG(ip->i_inode.i_mode); 278 struct address_space *metamapping = gfs2_glock2aspace(gl); 279 int error = 0, ret; 280 281 if (isreg) { 282 if (test_and_clear_bit(GIF_SW_PAGED, &ip->i_flags)) 283 unmap_shared_mapping_range(ip->i_inode.i_mapping, 0, 0); 284 inode_dio_wait(&ip->i_inode); 285 } 286 if (!test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) 287 goto out; 288 289 GLOCK_BUG_ON(gl, gl->gl_state != LM_ST_EXCLUSIVE); 290 291 gfs2_log_flush(gl->gl_name.ln_sbd, gl, GFS2_LOG_HEAD_FLUSH_NORMAL | 292 GFS2_LFC_INODE_GO_SYNC); 293 filemap_fdatawrite(metamapping); 294 if (isreg) { 295 struct address_space *mapping = ip->i_inode.i_mapping; 296 filemap_fdatawrite(mapping); 297 error = filemap_fdatawait(mapping); 298 mapping_set_error(mapping, error); 299 } 300 ret = filemap_fdatawait(metamapping); 301 mapping_set_error(metamapping, ret); 302 if (!error) 303 error = ret; 304 gfs2_ail_empty_gl(gl); 305 /* 306 * Writeback of the data mapping may cause the dirty flag to be set 307 * so we have to clear it again here. 308 */ 309 smp_mb__before_atomic(); 310 clear_bit(GLF_DIRTY, &gl->gl_flags); 311 312 out: 313 gfs2_clear_glop_pending(ip); 314 return error; 315 } 316 317 /** 318 * inode_go_inval - prepare a inode glock to be released 319 * @gl: the glock 320 * @flags: 321 * 322 * Normally we invalidate everything, but if we are moving into 323 * LM_ST_DEFERRED from LM_ST_SHARED or LM_ST_EXCLUSIVE then we 324 * can keep hold of the metadata, since it won't have changed. 325 * 326 */ 327 328 static void inode_go_inval(struct gfs2_glock *gl, int flags) 329 { 330 struct gfs2_inode *ip = gfs2_glock2inode(gl); 331 332 if (flags & DIO_METADATA) { 333 struct address_space *mapping = gfs2_glock2aspace(gl); 334 truncate_inode_pages(mapping, 0); 335 if (ip) { 336 set_bit(GIF_INVALID, &ip->i_flags); 337 forget_all_cached_acls(&ip->i_inode); 338 security_inode_invalidate_secctx(&ip->i_inode); 339 gfs2_dir_hash_inval(ip); 340 } 341 } 342 343 if (ip == GFS2_I(gl->gl_name.ln_sbd->sd_rindex)) { 344 gfs2_log_flush(gl->gl_name.ln_sbd, NULL, 345 GFS2_LOG_HEAD_FLUSH_NORMAL | 346 GFS2_LFC_INODE_GO_INVAL); 347 gl->gl_name.ln_sbd->sd_rindex_uptodate = 0; 348 } 349 if (ip && S_ISREG(ip->i_inode.i_mode)) 350 truncate_inode_pages(ip->i_inode.i_mapping, 0); 351 352 gfs2_clear_glop_pending(ip); 353 } 354 355 /** 356 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock 357 * @gl: the glock 358 * 359 * Returns: 1 if it's ok 360 */ 361 362 static int inode_go_demote_ok(const struct gfs2_glock *gl) 363 { 364 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 365 366 if (sdp->sd_jindex == gl->gl_object || sdp->sd_rindex == gl->gl_object) 367 return 0; 368 369 return 1; 370 } 371 372 static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf) 373 { 374 const struct gfs2_dinode *str = buf; 375 struct timespec64 atime; 376 u16 height, depth; 377 378 if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr))) 379 goto corrupt; 380 ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino); 381 ip->i_inode.i_mode = be32_to_cpu(str->di_mode); 382 ip->i_inode.i_rdev = 0; 383 switch (ip->i_inode.i_mode & S_IFMT) { 384 case S_IFBLK: 385 case S_IFCHR: 386 ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major), 387 be32_to_cpu(str->di_minor)); 388 break; 389 } 390 391 i_uid_write(&ip->i_inode, be32_to_cpu(str->di_uid)); 392 i_gid_write(&ip->i_inode, be32_to_cpu(str->di_gid)); 393 set_nlink(&ip->i_inode, be32_to_cpu(str->di_nlink)); 394 i_size_write(&ip->i_inode, be64_to_cpu(str->di_size)); 395 gfs2_set_inode_blocks(&ip->i_inode, be64_to_cpu(str->di_blocks)); 396 atime.tv_sec = be64_to_cpu(str->di_atime); 397 atime.tv_nsec = be32_to_cpu(str->di_atime_nsec); 398 if (timespec64_compare(&ip->i_inode.i_atime, &atime) < 0) 399 ip->i_inode.i_atime = atime; 400 ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime); 401 ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec); 402 ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime); 403 ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec); 404 405 ip->i_goal = be64_to_cpu(str->di_goal_meta); 406 ip->i_generation = be64_to_cpu(str->di_generation); 407 408 ip->i_diskflags = be32_to_cpu(str->di_flags); 409 ip->i_eattr = be64_to_cpu(str->di_eattr); 410 /* i_diskflags and i_eattr must be set before gfs2_set_inode_flags() */ 411 gfs2_set_inode_flags(&ip->i_inode); 412 height = be16_to_cpu(str->di_height); 413 if (unlikely(height > GFS2_MAX_META_HEIGHT)) 414 goto corrupt; 415 ip->i_height = (u8)height; 416 417 depth = be16_to_cpu(str->di_depth); 418 if (unlikely(depth > GFS2_DIR_MAX_DEPTH)) 419 goto corrupt; 420 ip->i_depth = (u8)depth; 421 ip->i_entries = be32_to_cpu(str->di_entries); 422 423 if (S_ISREG(ip->i_inode.i_mode)) 424 gfs2_set_aops(&ip->i_inode); 425 426 return 0; 427 corrupt: 428 gfs2_consist_inode(ip); 429 return -EIO; 430 } 431 432 /** 433 * gfs2_inode_refresh - Refresh the incore copy of the dinode 434 * @ip: The GFS2 inode 435 * 436 * Returns: errno 437 */ 438 439 int gfs2_inode_refresh(struct gfs2_inode *ip) 440 { 441 struct buffer_head *dibh; 442 int error; 443 444 error = gfs2_meta_inode_buffer(ip, &dibh); 445 if (error) 446 return error; 447 448 error = gfs2_dinode_in(ip, dibh->b_data); 449 brelse(dibh); 450 clear_bit(GIF_INVALID, &ip->i_flags); 451 452 return error; 453 } 454 455 /** 456 * inode_go_lock - operation done after an inode lock is locked by a process 457 * @gl: the glock 458 * @flags: 459 * 460 * Returns: errno 461 */ 462 463 static int inode_go_lock(struct gfs2_holder *gh) 464 { 465 struct gfs2_glock *gl = gh->gh_gl; 466 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 467 struct gfs2_inode *ip = gl->gl_object; 468 int error = 0; 469 470 if (!ip || (gh->gh_flags & GL_SKIP)) 471 return 0; 472 473 if (test_bit(GIF_INVALID, &ip->i_flags)) { 474 error = gfs2_inode_refresh(ip); 475 if (error) 476 return error; 477 } 478 479 if (gh->gh_state != LM_ST_DEFERRED) 480 inode_dio_wait(&ip->i_inode); 481 482 if ((ip->i_diskflags & GFS2_DIF_TRUNC_IN_PROG) && 483 (gl->gl_state == LM_ST_EXCLUSIVE) && 484 (gh->gh_state == LM_ST_EXCLUSIVE)) { 485 spin_lock(&sdp->sd_trunc_lock); 486 if (list_empty(&ip->i_trunc_list)) 487 list_add(&ip->i_trunc_list, &sdp->sd_trunc_list); 488 spin_unlock(&sdp->sd_trunc_lock); 489 wake_up(&sdp->sd_quota_wait); 490 return 1; 491 } 492 493 return error; 494 } 495 496 /** 497 * inode_go_dump - print information about an inode 498 * @seq: The iterator 499 * @ip: the inode 500 * @fs_id_buf: file system id (may be empty) 501 * 502 */ 503 504 static void inode_go_dump(struct seq_file *seq, struct gfs2_glock *gl, 505 const char *fs_id_buf) 506 { 507 struct gfs2_inode *ip = gl->gl_object; 508 struct inode *inode = &ip->i_inode; 509 unsigned long nrpages; 510 511 if (ip == NULL) 512 return; 513 514 xa_lock_irq(&inode->i_data.i_pages); 515 nrpages = inode->i_data.nrpages; 516 xa_unlock_irq(&inode->i_data.i_pages); 517 518 gfs2_print_dbg(seq, "%s I: n:%llu/%llu t:%u f:0x%02lx d:0x%08x s:%llu " 519 "p:%lu\n", fs_id_buf, 520 (unsigned long long)ip->i_no_formal_ino, 521 (unsigned long long)ip->i_no_addr, 522 IF2DT(ip->i_inode.i_mode), ip->i_flags, 523 (unsigned int)ip->i_diskflags, 524 (unsigned long long)i_size_read(inode), nrpages); 525 } 526 527 /** 528 * freeze_go_sync - promote/demote the freeze glock 529 * @gl: the glock 530 * @state: the requested state 531 * @flags: 532 * 533 */ 534 535 static int freeze_go_sync(struct gfs2_glock *gl) 536 { 537 int error = 0; 538 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 539 540 if (gl->gl_req == LM_ST_EXCLUSIVE && !gfs2_withdrawn(sdp)) { 541 atomic_set(&sdp->sd_freeze_state, SFS_STARTING_FREEZE); 542 error = freeze_super(sdp->sd_vfs); 543 if (error) { 544 fs_info(sdp, "GFS2: couldn't freeze filesystem: %d\n", 545 error); 546 if (gfs2_withdrawn(sdp)) { 547 atomic_set(&sdp->sd_freeze_state, SFS_UNFROZEN); 548 return 0; 549 } 550 gfs2_assert_withdraw(sdp, 0); 551 } 552 queue_work(gfs2_freeze_wq, &sdp->sd_freeze_work); 553 if (test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) 554 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_FREEZE | 555 GFS2_LFC_FREEZE_GO_SYNC); 556 else /* read-only mounts */ 557 atomic_set(&sdp->sd_freeze_state, SFS_FROZEN); 558 } 559 return 0; 560 } 561 562 /** 563 * freeze_go_xmote_bh - After promoting/demoting the freeze glock 564 * @gl: the glock 565 * 566 */ 567 568 static int freeze_go_xmote_bh(struct gfs2_glock *gl, struct gfs2_holder *gh) 569 { 570 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 571 struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode); 572 struct gfs2_glock *j_gl = ip->i_gl; 573 struct gfs2_log_header_host head; 574 int error; 575 576 if (test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) { 577 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA); 578 579 error = gfs2_find_jhead(sdp->sd_jdesc, &head, false); 580 if (error) 581 gfs2_consist(sdp); 582 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) 583 gfs2_consist(sdp); 584 585 /* Initialize some head of the log stuff */ 586 if (!gfs2_withdrawn(sdp)) { 587 sdp->sd_log_sequence = head.lh_sequence + 1; 588 gfs2_log_pointers_init(sdp, head.lh_blkno); 589 } 590 } 591 return 0; 592 } 593 594 /** 595 * trans_go_demote_ok 596 * @gl: the glock 597 * 598 * Always returns 0 599 */ 600 601 static int freeze_go_demote_ok(const struct gfs2_glock *gl) 602 { 603 return 0; 604 } 605 606 /** 607 * iopen_go_callback - schedule the dcache entry for the inode to be deleted 608 * @gl: the glock 609 * 610 * gl_lockref.lock lock is held while calling this 611 */ 612 static void iopen_go_callback(struct gfs2_glock *gl, bool remote) 613 { 614 struct gfs2_inode *ip = gl->gl_object; 615 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 616 617 if (!remote || sb_rdonly(sdp->sd_vfs)) 618 return; 619 620 if (gl->gl_demote_state == LM_ST_UNLOCKED && 621 gl->gl_state == LM_ST_SHARED && ip) { 622 gl->gl_lockref.count++; 623 if (!queue_delayed_work(gfs2_delete_workqueue, 624 &gl->gl_delete, 0)) 625 gl->gl_lockref.count--; 626 } 627 } 628 629 static int iopen_go_demote_ok(const struct gfs2_glock *gl) 630 { 631 return !gfs2_delete_work_queued(gl); 632 } 633 634 /** 635 * inode_go_free - wake up anyone waiting for dlm's unlock ast to free it 636 * @gl: glock being freed 637 * 638 * For now, this is only used for the journal inode glock. In withdraw 639 * situations, we need to wait for the glock to be freed so that we know 640 * other nodes may proceed with recovery / journal replay. 641 */ 642 static void inode_go_free(struct gfs2_glock *gl) 643 { 644 /* Note that we cannot reference gl_object because it's already set 645 * to NULL by this point in its lifecycle. */ 646 if (!test_bit(GLF_FREEING, &gl->gl_flags)) 647 return; 648 clear_bit_unlock(GLF_FREEING, &gl->gl_flags); 649 wake_up_bit(&gl->gl_flags, GLF_FREEING); 650 } 651 652 /** 653 * nondisk_go_callback - used to signal when a node did a withdraw 654 * @gl: the nondisk glock 655 * @remote: true if this came from a different cluster node 656 * 657 */ 658 static void nondisk_go_callback(struct gfs2_glock *gl, bool remote) 659 { 660 struct gfs2_sbd *sdp = gl->gl_name.ln_sbd; 661 662 /* Ignore the callback unless it's from another node, and it's the 663 live lock. */ 664 if (!remote || gl->gl_name.ln_number != GFS2_LIVE_LOCK) 665 return; 666 667 /* First order of business is to cancel the demote request. We don't 668 * really want to demote a nondisk glock. At best it's just to inform 669 * us of another node's withdraw. We'll keep it in SH mode. */ 670 clear_bit(GLF_DEMOTE, &gl->gl_flags); 671 clear_bit(GLF_PENDING_DEMOTE, &gl->gl_flags); 672 673 /* Ignore the unlock if we're withdrawn, unmounting, or in recovery. */ 674 if (test_bit(SDF_NORECOVERY, &sdp->sd_flags) || 675 test_bit(SDF_WITHDRAWN, &sdp->sd_flags) || 676 test_bit(SDF_REMOTE_WITHDRAW, &sdp->sd_flags)) 677 return; 678 679 /* We only care when a node wants us to unlock, because that means 680 * they want a journal recovered. */ 681 if (gl->gl_demote_state != LM_ST_UNLOCKED) 682 return; 683 684 if (sdp->sd_args.ar_spectator) { 685 fs_warn(sdp, "Spectator node cannot recover journals.\n"); 686 return; 687 } 688 689 fs_warn(sdp, "Some node has withdrawn; checking for recovery.\n"); 690 set_bit(SDF_REMOTE_WITHDRAW, &sdp->sd_flags); 691 /* 692 * We can't call remote_withdraw directly here or gfs2_recover_journal 693 * because this is called from the glock unlock function and the 694 * remote_withdraw needs to enqueue and dequeue the same "live" glock 695 * we were called from. So we queue it to the control work queue in 696 * lock_dlm. 697 */ 698 queue_delayed_work(gfs2_control_wq, &sdp->sd_control_work, 0); 699 } 700 701 const struct gfs2_glock_operations gfs2_meta_glops = { 702 .go_type = LM_TYPE_META, 703 .go_flags = GLOF_NONDISK, 704 }; 705 706 const struct gfs2_glock_operations gfs2_inode_glops = { 707 .go_sync = inode_go_sync, 708 .go_inval = inode_go_inval, 709 .go_demote_ok = inode_go_demote_ok, 710 .go_lock = inode_go_lock, 711 .go_dump = inode_go_dump, 712 .go_type = LM_TYPE_INODE, 713 .go_flags = GLOF_ASPACE | GLOF_LRU | GLOF_LVB, 714 .go_free = inode_go_free, 715 }; 716 717 const struct gfs2_glock_operations gfs2_rgrp_glops = { 718 .go_sync = rgrp_go_sync, 719 .go_inval = rgrp_go_inval, 720 .go_lock = gfs2_rgrp_go_lock, 721 .go_dump = gfs2_rgrp_go_dump, 722 .go_type = LM_TYPE_RGRP, 723 .go_flags = GLOF_LVB, 724 }; 725 726 const struct gfs2_glock_operations gfs2_freeze_glops = { 727 .go_sync = freeze_go_sync, 728 .go_xmote_bh = freeze_go_xmote_bh, 729 .go_demote_ok = freeze_go_demote_ok, 730 .go_type = LM_TYPE_NONDISK, 731 .go_flags = GLOF_NONDISK, 732 }; 733 734 const struct gfs2_glock_operations gfs2_iopen_glops = { 735 .go_type = LM_TYPE_IOPEN, 736 .go_callback = iopen_go_callback, 737 .go_demote_ok = iopen_go_demote_ok, 738 .go_flags = GLOF_LRU | GLOF_NONDISK, 739 }; 740 741 const struct gfs2_glock_operations gfs2_flock_glops = { 742 .go_type = LM_TYPE_FLOCK, 743 .go_flags = GLOF_LRU | GLOF_NONDISK, 744 }; 745 746 const struct gfs2_glock_operations gfs2_nondisk_glops = { 747 .go_type = LM_TYPE_NONDISK, 748 .go_flags = GLOF_NONDISK, 749 .go_callback = nondisk_go_callback, 750 }; 751 752 const struct gfs2_glock_operations gfs2_quota_glops = { 753 .go_type = LM_TYPE_QUOTA, 754 .go_flags = GLOF_LVB | GLOF_LRU | GLOF_NONDISK, 755 }; 756 757 const struct gfs2_glock_operations gfs2_journal_glops = { 758 .go_type = LM_TYPE_JOURNAL, 759 .go_flags = GLOF_NONDISK, 760 }; 761 762 const struct gfs2_glock_operations *gfs2_glops_list[] = { 763 [LM_TYPE_META] = &gfs2_meta_glops, 764 [LM_TYPE_INODE] = &gfs2_inode_glops, 765 [LM_TYPE_RGRP] = &gfs2_rgrp_glops, 766 [LM_TYPE_IOPEN] = &gfs2_iopen_glops, 767 [LM_TYPE_FLOCK] = &gfs2_flock_glops, 768 [LM_TYPE_NONDISK] = &gfs2_nondisk_glops, 769 [LM_TYPE_QUOTA] = &gfs2_quota_glops, 770 [LM_TYPE_JOURNAL] = &gfs2_journal_glops, 771 }; 772 773