1 /* 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved. 4 * 5 * This copyrighted material is made available to anyone wishing to use, 6 * modify, copy, or redistribute it subject to the terms and conditions 7 * of the GNU General Public License version 2. 8 */ 9 10 #include <linux/spinlock.h> 11 #include <linux/completion.h> 12 #include <linux/buffer_head.h> 13 #include <linux/gfs2_ondisk.h> 14 #include <linux/bio.h> 15 #include <linux/posix_acl.h> 16 17 #include "gfs2.h" 18 #include "incore.h" 19 #include "bmap.h" 20 #include "glock.h" 21 #include "glops.h" 22 #include "inode.h" 23 #include "log.h" 24 #include "meta_io.h" 25 #include "recovery.h" 26 #include "rgrp.h" 27 #include "util.h" 28 #include "trans.h" 29 30 /** 31 * __gfs2_ail_flush - remove all buffers for a given lock from the AIL 32 * @gl: the glock 33 * 34 * None of the buffers should be dirty, locked, or pinned. 35 */ 36 37 static void __gfs2_ail_flush(struct gfs2_glock *gl) 38 { 39 struct gfs2_sbd *sdp = gl->gl_sbd; 40 struct list_head *head = &gl->gl_ail_list; 41 struct gfs2_bufdata *bd; 42 struct buffer_head *bh; 43 44 spin_lock(&sdp->sd_ail_lock); 45 while (!list_empty(head)) { 46 bd = list_entry(head->next, struct gfs2_bufdata, 47 bd_ail_gl_list); 48 bh = bd->bd_bh; 49 gfs2_remove_from_ail(bd); 50 bd->bd_bh = NULL; 51 bh->b_private = NULL; 52 spin_unlock(&sdp->sd_ail_lock); 53 54 bd->bd_blkno = bh->b_blocknr; 55 gfs2_log_lock(sdp); 56 gfs2_assert_withdraw(sdp, !buffer_busy(bh)); 57 gfs2_trans_add_revoke(sdp, bd); 58 gfs2_log_unlock(sdp); 59 60 spin_lock(&sdp->sd_ail_lock); 61 } 62 gfs2_assert_withdraw(sdp, !atomic_read(&gl->gl_ail_count)); 63 spin_unlock(&sdp->sd_ail_lock); 64 } 65 66 67 static void gfs2_ail_empty_gl(struct gfs2_glock *gl) 68 { 69 struct gfs2_sbd *sdp = gl->gl_sbd; 70 struct gfs2_trans tr; 71 72 memset(&tr, 0, sizeof(tr)); 73 tr.tr_revokes = atomic_read(&gl->gl_ail_count); 74 75 if (!tr.tr_revokes) 76 return; 77 78 /* A shortened, inline version of gfs2_trans_begin() */ 79 tr.tr_reserved = 1 + gfs2_struct2blk(sdp, tr.tr_revokes, sizeof(u64)); 80 tr.tr_ip = (unsigned long)__builtin_return_address(0); 81 INIT_LIST_HEAD(&tr.tr_list_buf); 82 gfs2_log_reserve(sdp, tr.tr_reserved); 83 BUG_ON(current->journal_info); 84 current->journal_info = &tr; 85 86 __gfs2_ail_flush(gl); 87 88 gfs2_trans_end(sdp); 89 gfs2_log_flush(sdp, NULL); 90 } 91 92 void gfs2_ail_flush(struct gfs2_glock *gl) 93 { 94 struct gfs2_sbd *sdp = gl->gl_sbd; 95 unsigned int revokes = atomic_read(&gl->gl_ail_count); 96 int ret; 97 98 if (!revokes) 99 return; 100 101 ret = gfs2_trans_begin(sdp, 0, revokes); 102 if (ret) 103 return; 104 __gfs2_ail_flush(gl); 105 gfs2_trans_end(sdp); 106 gfs2_log_flush(sdp, NULL); 107 } 108 109 /** 110 * rgrp_go_sync - sync out the metadata for this glock 111 * @gl: the glock 112 * 113 * Called when demoting or unlocking an EX glock. We must flush 114 * to disk all dirty buffers/pages relating to this glock, and must not 115 * not return to caller to demote/unlock the glock until I/O is complete. 116 */ 117 118 static void rgrp_go_sync(struct gfs2_glock *gl) 119 { 120 struct address_space *metamapping = gfs2_glock2aspace(gl); 121 int error; 122 123 if (!test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) 124 return; 125 BUG_ON(gl->gl_state != LM_ST_EXCLUSIVE); 126 127 gfs2_log_flush(gl->gl_sbd, gl); 128 filemap_fdatawrite(metamapping); 129 error = filemap_fdatawait(metamapping); 130 mapping_set_error(metamapping, error); 131 gfs2_ail_empty_gl(gl); 132 } 133 134 /** 135 * rgrp_go_inval - invalidate the metadata for this glock 136 * @gl: the glock 137 * @flags: 138 * 139 * We never used LM_ST_DEFERRED with resource groups, so that we 140 * should always see the metadata flag set here. 141 * 142 */ 143 144 static void rgrp_go_inval(struct gfs2_glock *gl, int flags) 145 { 146 struct address_space *mapping = gfs2_glock2aspace(gl); 147 148 BUG_ON(!(flags & DIO_METADATA)); 149 gfs2_assert_withdraw(gl->gl_sbd, !atomic_read(&gl->gl_ail_count)); 150 truncate_inode_pages(mapping, 0); 151 152 if (gl->gl_object) { 153 struct gfs2_rgrpd *rgd = (struct gfs2_rgrpd *)gl->gl_object; 154 rgd->rd_flags &= ~GFS2_RDF_UPTODATE; 155 } 156 } 157 158 /** 159 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock 160 * @gl: the glock protecting the inode 161 * 162 */ 163 164 static void inode_go_sync(struct gfs2_glock *gl) 165 { 166 struct gfs2_inode *ip = gl->gl_object; 167 struct address_space *metamapping = gfs2_glock2aspace(gl); 168 int error; 169 170 if (ip && !S_ISREG(ip->i_inode.i_mode)) 171 ip = NULL; 172 if (ip && test_and_clear_bit(GIF_SW_PAGED, &ip->i_flags)) 173 unmap_shared_mapping_range(ip->i_inode.i_mapping, 0, 0); 174 if (!test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) 175 return; 176 177 BUG_ON(gl->gl_state != LM_ST_EXCLUSIVE); 178 179 gfs2_log_flush(gl->gl_sbd, gl); 180 filemap_fdatawrite(metamapping); 181 if (ip) { 182 struct address_space *mapping = ip->i_inode.i_mapping; 183 filemap_fdatawrite(mapping); 184 error = filemap_fdatawait(mapping); 185 mapping_set_error(mapping, error); 186 } 187 error = filemap_fdatawait(metamapping); 188 mapping_set_error(metamapping, error); 189 gfs2_ail_empty_gl(gl); 190 /* 191 * Writeback of the data mapping may cause the dirty flag to be set 192 * so we have to clear it again here. 193 */ 194 smp_mb__before_clear_bit(); 195 clear_bit(GLF_DIRTY, &gl->gl_flags); 196 } 197 198 /** 199 * inode_go_inval - prepare a inode glock to be released 200 * @gl: the glock 201 * @flags: 202 * 203 * Normally we invlidate everything, but if we are moving into 204 * LM_ST_DEFERRED from LM_ST_SHARED or LM_ST_EXCLUSIVE then we 205 * can keep hold of the metadata, since it won't have changed. 206 * 207 */ 208 209 static void inode_go_inval(struct gfs2_glock *gl, int flags) 210 { 211 struct gfs2_inode *ip = gl->gl_object; 212 213 gfs2_assert_withdraw(gl->gl_sbd, !atomic_read(&gl->gl_ail_count)); 214 215 if (flags & DIO_METADATA) { 216 struct address_space *mapping = gfs2_glock2aspace(gl); 217 truncate_inode_pages(mapping, 0); 218 if (ip) { 219 set_bit(GIF_INVALID, &ip->i_flags); 220 forget_all_cached_acls(&ip->i_inode); 221 } 222 } 223 224 if (ip == GFS2_I(gl->gl_sbd->sd_rindex)) { 225 gfs2_log_flush(gl->gl_sbd, NULL); 226 gl->gl_sbd->sd_rindex_uptodate = 0; 227 } 228 if (ip && S_ISREG(ip->i_inode.i_mode)) 229 truncate_inode_pages(ip->i_inode.i_mapping, 0); 230 } 231 232 /** 233 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock 234 * @gl: the glock 235 * 236 * Returns: 1 if it's ok 237 */ 238 239 static int inode_go_demote_ok(const struct gfs2_glock *gl) 240 { 241 struct gfs2_sbd *sdp = gl->gl_sbd; 242 struct gfs2_holder *gh; 243 244 if (sdp->sd_jindex == gl->gl_object || sdp->sd_rindex == gl->gl_object) 245 return 0; 246 247 if (!list_empty(&gl->gl_holders)) { 248 gh = list_entry(gl->gl_holders.next, struct gfs2_holder, gh_list); 249 if (gh->gh_list.next != &gl->gl_holders) 250 return 0; 251 } 252 253 return 1; 254 } 255 256 /** 257 * gfs2_set_nlink - Set the inode's link count based on on-disk info 258 * @inode: The inode in question 259 * @nlink: The link count 260 * 261 * If the link count has hit zero, it must never be raised, whatever the 262 * on-disk inode might say. When new struct inodes are created the link 263 * count is set to 1, so that we can safely use this test even when reading 264 * in on disk information for the first time. 265 */ 266 267 static void gfs2_set_nlink(struct inode *inode, u32 nlink) 268 { 269 /* 270 * We will need to review setting the nlink count here in the 271 * light of the forthcoming ro bind mount work. This is a reminder 272 * to do that. 273 */ 274 if ((inode->i_nlink != nlink) && (inode->i_nlink != 0)) { 275 if (nlink == 0) 276 clear_nlink(inode); 277 else 278 inode->i_nlink = nlink; 279 } 280 } 281 282 static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf) 283 { 284 const struct gfs2_dinode *str = buf; 285 struct timespec atime; 286 u16 height, depth; 287 288 if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr))) 289 goto corrupt; 290 ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino); 291 ip->i_inode.i_mode = be32_to_cpu(str->di_mode); 292 ip->i_inode.i_rdev = 0; 293 switch (ip->i_inode.i_mode & S_IFMT) { 294 case S_IFBLK: 295 case S_IFCHR: 296 ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major), 297 be32_to_cpu(str->di_minor)); 298 break; 299 }; 300 301 ip->i_inode.i_uid = be32_to_cpu(str->di_uid); 302 ip->i_inode.i_gid = be32_to_cpu(str->di_gid); 303 gfs2_set_nlink(&ip->i_inode, be32_to_cpu(str->di_nlink)); 304 i_size_write(&ip->i_inode, be64_to_cpu(str->di_size)); 305 gfs2_set_inode_blocks(&ip->i_inode, be64_to_cpu(str->di_blocks)); 306 atime.tv_sec = be64_to_cpu(str->di_atime); 307 atime.tv_nsec = be32_to_cpu(str->di_atime_nsec); 308 if (timespec_compare(&ip->i_inode.i_atime, &atime) < 0) 309 ip->i_inode.i_atime = atime; 310 ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime); 311 ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec); 312 ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime); 313 ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec); 314 315 ip->i_goal = be64_to_cpu(str->di_goal_meta); 316 ip->i_generation = be64_to_cpu(str->di_generation); 317 318 ip->i_diskflags = be32_to_cpu(str->di_flags); 319 gfs2_set_inode_flags(&ip->i_inode); 320 height = be16_to_cpu(str->di_height); 321 if (unlikely(height > GFS2_MAX_META_HEIGHT)) 322 goto corrupt; 323 ip->i_height = (u8)height; 324 325 depth = be16_to_cpu(str->di_depth); 326 if (unlikely(depth > GFS2_DIR_MAX_DEPTH)) 327 goto corrupt; 328 ip->i_depth = (u8)depth; 329 ip->i_entries = be32_to_cpu(str->di_entries); 330 331 ip->i_eattr = be64_to_cpu(str->di_eattr); 332 if (S_ISREG(ip->i_inode.i_mode)) 333 gfs2_set_aops(&ip->i_inode); 334 335 return 0; 336 corrupt: 337 gfs2_consist_inode(ip); 338 return -EIO; 339 } 340 341 /** 342 * gfs2_inode_refresh - Refresh the incore copy of the dinode 343 * @ip: The GFS2 inode 344 * 345 * Returns: errno 346 */ 347 348 int gfs2_inode_refresh(struct gfs2_inode *ip) 349 { 350 struct buffer_head *dibh; 351 int error; 352 353 error = gfs2_meta_inode_buffer(ip, &dibh); 354 if (error) 355 return error; 356 357 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) { 358 brelse(dibh); 359 return -EIO; 360 } 361 362 error = gfs2_dinode_in(ip, dibh->b_data); 363 brelse(dibh); 364 clear_bit(GIF_INVALID, &ip->i_flags); 365 366 return error; 367 } 368 369 /** 370 * inode_go_lock - operation done after an inode lock is locked by a process 371 * @gl: the glock 372 * @flags: 373 * 374 * Returns: errno 375 */ 376 377 static int inode_go_lock(struct gfs2_holder *gh) 378 { 379 struct gfs2_glock *gl = gh->gh_gl; 380 struct gfs2_sbd *sdp = gl->gl_sbd; 381 struct gfs2_inode *ip = gl->gl_object; 382 int error = 0; 383 384 if (!ip || (gh->gh_flags & GL_SKIP)) 385 return 0; 386 387 if (test_bit(GIF_INVALID, &ip->i_flags)) { 388 error = gfs2_inode_refresh(ip); 389 if (error) 390 return error; 391 } 392 393 if ((ip->i_diskflags & GFS2_DIF_TRUNC_IN_PROG) && 394 (gl->gl_state == LM_ST_EXCLUSIVE) && 395 (gh->gh_state == LM_ST_EXCLUSIVE)) { 396 spin_lock(&sdp->sd_trunc_lock); 397 if (list_empty(&ip->i_trunc_list)) 398 list_add(&sdp->sd_trunc_list, &ip->i_trunc_list); 399 spin_unlock(&sdp->sd_trunc_lock); 400 wake_up(&sdp->sd_quota_wait); 401 return 1; 402 } 403 404 return error; 405 } 406 407 /** 408 * inode_go_dump - print information about an inode 409 * @seq: The iterator 410 * @ip: the inode 411 * 412 * Returns: 0 on success, -ENOBUFS when we run out of space 413 */ 414 415 static int inode_go_dump(struct seq_file *seq, const struct gfs2_glock *gl) 416 { 417 const struct gfs2_inode *ip = gl->gl_object; 418 if (ip == NULL) 419 return 0; 420 gfs2_print_dbg(seq, " I: n:%llu/%llu t:%u f:0x%02lx d:0x%08x s:%llu\n", 421 (unsigned long long)ip->i_no_formal_ino, 422 (unsigned long long)ip->i_no_addr, 423 IF2DT(ip->i_inode.i_mode), ip->i_flags, 424 (unsigned int)ip->i_diskflags, 425 (unsigned long long)i_size_read(&ip->i_inode)); 426 return 0; 427 } 428 429 /** 430 * rgrp_go_lock - operation done after an rgrp lock is locked by 431 * a first holder on this node. 432 * @gl: the glock 433 * @flags: 434 * 435 * Returns: errno 436 */ 437 438 static int rgrp_go_lock(struct gfs2_holder *gh) 439 { 440 return gfs2_rgrp_bh_get(gh->gh_gl->gl_object); 441 } 442 443 /** 444 * rgrp_go_unlock - operation done before an rgrp lock is unlocked by 445 * a last holder on this node. 446 * @gl: the glock 447 * @flags: 448 * 449 */ 450 451 static void rgrp_go_unlock(struct gfs2_holder *gh) 452 { 453 gfs2_rgrp_bh_put(gh->gh_gl->gl_object); 454 } 455 456 /** 457 * trans_go_sync - promote/demote the transaction glock 458 * @gl: the glock 459 * @state: the requested state 460 * @flags: 461 * 462 */ 463 464 static void trans_go_sync(struct gfs2_glock *gl) 465 { 466 struct gfs2_sbd *sdp = gl->gl_sbd; 467 468 if (gl->gl_state != LM_ST_UNLOCKED && 469 test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) { 470 gfs2_meta_syncfs(sdp); 471 gfs2_log_shutdown(sdp); 472 } 473 } 474 475 /** 476 * trans_go_xmote_bh - After promoting/demoting the transaction glock 477 * @gl: the glock 478 * 479 */ 480 481 static int trans_go_xmote_bh(struct gfs2_glock *gl, struct gfs2_holder *gh) 482 { 483 struct gfs2_sbd *sdp = gl->gl_sbd; 484 struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode); 485 struct gfs2_glock *j_gl = ip->i_gl; 486 struct gfs2_log_header_host head; 487 int error; 488 489 if (test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) { 490 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA); 491 492 error = gfs2_find_jhead(sdp->sd_jdesc, &head); 493 if (error) 494 gfs2_consist(sdp); 495 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) 496 gfs2_consist(sdp); 497 498 /* Initialize some head of the log stuff */ 499 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) { 500 sdp->sd_log_sequence = head.lh_sequence + 1; 501 gfs2_log_pointers_init(sdp, head.lh_blkno); 502 } 503 } 504 return 0; 505 } 506 507 /** 508 * trans_go_demote_ok 509 * @gl: the glock 510 * 511 * Always returns 0 512 */ 513 514 static int trans_go_demote_ok(const struct gfs2_glock *gl) 515 { 516 return 0; 517 } 518 519 /** 520 * iopen_go_callback - schedule the dcache entry for the inode to be deleted 521 * @gl: the glock 522 * 523 * gl_spin lock is held while calling this 524 */ 525 static void iopen_go_callback(struct gfs2_glock *gl) 526 { 527 struct gfs2_inode *ip = (struct gfs2_inode *)gl->gl_object; 528 struct gfs2_sbd *sdp = gl->gl_sbd; 529 530 if (sdp->sd_vfs->s_flags & MS_RDONLY) 531 return; 532 533 if (gl->gl_demote_state == LM_ST_UNLOCKED && 534 gl->gl_state == LM_ST_SHARED && ip) { 535 gfs2_glock_hold(gl); 536 if (queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0) 537 gfs2_glock_put_nolock(gl); 538 } 539 } 540 541 const struct gfs2_glock_operations gfs2_meta_glops = { 542 .go_type = LM_TYPE_META, 543 }; 544 545 const struct gfs2_glock_operations gfs2_inode_glops = { 546 .go_xmote_th = inode_go_sync, 547 .go_inval = inode_go_inval, 548 .go_demote_ok = inode_go_demote_ok, 549 .go_lock = inode_go_lock, 550 .go_dump = inode_go_dump, 551 .go_type = LM_TYPE_INODE, 552 .go_min_hold_time = HZ / 5, 553 .go_flags = GLOF_ASPACE, 554 }; 555 556 const struct gfs2_glock_operations gfs2_rgrp_glops = { 557 .go_xmote_th = rgrp_go_sync, 558 .go_inval = rgrp_go_inval, 559 .go_lock = rgrp_go_lock, 560 .go_unlock = rgrp_go_unlock, 561 .go_dump = gfs2_rgrp_dump, 562 .go_type = LM_TYPE_RGRP, 563 .go_min_hold_time = HZ / 5, 564 .go_flags = GLOF_ASPACE, 565 }; 566 567 const struct gfs2_glock_operations gfs2_trans_glops = { 568 .go_xmote_th = trans_go_sync, 569 .go_xmote_bh = trans_go_xmote_bh, 570 .go_demote_ok = trans_go_demote_ok, 571 .go_type = LM_TYPE_NONDISK, 572 }; 573 574 const struct gfs2_glock_operations gfs2_iopen_glops = { 575 .go_type = LM_TYPE_IOPEN, 576 .go_callback = iopen_go_callback, 577 }; 578 579 const struct gfs2_glock_operations gfs2_flock_glops = { 580 .go_type = LM_TYPE_FLOCK, 581 }; 582 583 const struct gfs2_glock_operations gfs2_nondisk_glops = { 584 .go_type = LM_TYPE_NONDISK, 585 }; 586 587 const struct gfs2_glock_operations gfs2_quota_glops = { 588 .go_type = LM_TYPE_QUOTA, 589 }; 590 591 const struct gfs2_glock_operations gfs2_journal_glops = { 592 .go_type = LM_TYPE_JOURNAL, 593 }; 594 595 const struct gfs2_glock_operations *gfs2_glops_list[] = { 596 [LM_TYPE_META] = &gfs2_meta_glops, 597 [LM_TYPE_INODE] = &gfs2_inode_glops, 598 [LM_TYPE_RGRP] = &gfs2_rgrp_glops, 599 [LM_TYPE_IOPEN] = &gfs2_iopen_glops, 600 [LM_TYPE_FLOCK] = &gfs2_flock_glops, 601 [LM_TYPE_NONDISK] = &gfs2_nondisk_glops, 602 [LM_TYPE_QUOTA] = &gfs2_quota_glops, 603 [LM_TYPE_JOURNAL] = &gfs2_journal_glops, 604 }; 605 606