1 /* 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3 * Copyright (C) 2004-2006 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/sched.h> 11 #include <linux/slab.h> 12 #include <linux/spinlock.h> 13 #include <linux/completion.h> 14 #include <linux/buffer_head.h> 15 #include <linux/gfs2_ondisk.h> 16 #include <linux/lm_interface.h> 17 18 #include "gfs2.h" 19 #include "incore.h" 20 #include "bmap.h" 21 #include "glock.h" 22 #include "glops.h" 23 #include "inode.h" 24 #include "log.h" 25 #include "meta_io.h" 26 #include "recovery.h" 27 #include "rgrp.h" 28 #include "util.h" 29 #include "trans.h" 30 31 /** 32 * ail_empty_gl - remove all buffers for a given lock from the AIL 33 * @gl: the glock 34 * 35 * None of the buffers should be dirty, locked, or pinned. 36 */ 37 38 static void gfs2_ail_empty_gl(struct gfs2_glock *gl) 39 { 40 struct gfs2_sbd *sdp = gl->gl_sbd; 41 unsigned int blocks; 42 struct list_head *head = &gl->gl_ail_list; 43 struct gfs2_bufdata *bd; 44 struct buffer_head *bh; 45 u64 blkno; 46 int error; 47 48 blocks = atomic_read(&gl->gl_ail_count); 49 if (!blocks) 50 return; 51 52 error = gfs2_trans_begin(sdp, 0, blocks); 53 if (gfs2_assert_withdraw(sdp, !error)) 54 return; 55 56 gfs2_log_lock(sdp); 57 while (!list_empty(head)) { 58 bd = list_entry(head->next, struct gfs2_bufdata, 59 bd_ail_gl_list); 60 bh = bd->bd_bh; 61 blkno = bh->b_blocknr; 62 gfs2_assert_withdraw(sdp, !buffer_busy(bh)); 63 64 bd->bd_ail = NULL; 65 list_del(&bd->bd_ail_st_list); 66 list_del(&bd->bd_ail_gl_list); 67 atomic_dec(&gl->gl_ail_count); 68 brelse(bh); 69 gfs2_log_unlock(sdp); 70 71 gfs2_trans_add_revoke(sdp, blkno); 72 73 gfs2_log_lock(sdp); 74 } 75 gfs2_assert_withdraw(sdp, !atomic_read(&gl->gl_ail_count)); 76 gfs2_log_unlock(sdp); 77 78 gfs2_trans_end(sdp); 79 gfs2_log_flush(sdp, NULL); 80 } 81 82 /** 83 * gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock 84 * @gl: the glock 85 * 86 */ 87 88 static void gfs2_pte_inval(struct gfs2_glock *gl) 89 { 90 struct gfs2_inode *ip; 91 struct inode *inode; 92 93 ip = gl->gl_object; 94 inode = &ip->i_inode; 95 if (!ip || !S_ISREG(inode->i_mode)) 96 return; 97 98 if (!test_bit(GIF_PAGED, &ip->i_flags)) 99 return; 100 101 unmap_shared_mapping_range(inode->i_mapping, 0, 0); 102 103 if (test_bit(GIF_SW_PAGED, &ip->i_flags)) 104 set_bit(GLF_DIRTY, &gl->gl_flags); 105 106 clear_bit(GIF_SW_PAGED, &ip->i_flags); 107 } 108 109 /** 110 * gfs2_page_inval - Invalidate all pages associated with a glock 111 * @gl: the glock 112 * 113 */ 114 115 static void gfs2_page_inval(struct gfs2_glock *gl) 116 { 117 struct gfs2_inode *ip; 118 struct inode *inode; 119 120 ip = gl->gl_object; 121 inode = &ip->i_inode; 122 if (!ip || !S_ISREG(inode->i_mode)) 123 return; 124 125 truncate_inode_pages(inode->i_mapping, 0); 126 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), !inode->i_mapping->nrpages); 127 clear_bit(GIF_PAGED, &ip->i_flags); 128 } 129 130 /** 131 * gfs2_page_wait - Wait for writeback of data 132 * @gl: the glock 133 * 134 * Syncs data (not metadata) for a regular file. 135 * No-op for all other types. 136 */ 137 138 static void gfs2_page_wait(struct gfs2_glock *gl) 139 { 140 struct gfs2_inode *ip = gl->gl_object; 141 struct inode *inode = &ip->i_inode; 142 struct address_space *mapping = inode->i_mapping; 143 int error; 144 145 if (!S_ISREG(inode->i_mode)) 146 return; 147 148 error = filemap_fdatawait(mapping); 149 150 /* Put back any errors cleared by filemap_fdatawait() 151 so they can be caught by someone who can pass them 152 up to user space. */ 153 154 if (error == -ENOSPC) 155 set_bit(AS_ENOSPC, &mapping->flags); 156 else if (error) 157 set_bit(AS_EIO, &mapping->flags); 158 159 } 160 161 static void gfs2_page_writeback(struct gfs2_glock *gl) 162 { 163 struct gfs2_inode *ip = gl->gl_object; 164 struct inode *inode = &ip->i_inode; 165 struct address_space *mapping = inode->i_mapping; 166 167 if (!S_ISREG(inode->i_mode)) 168 return; 169 170 filemap_fdatawrite(mapping); 171 } 172 173 /** 174 * meta_go_sync - sync out the metadata for this glock 175 * @gl: the glock 176 * 177 * Called when demoting or unlocking an EX glock. We must flush 178 * to disk all dirty buffers/pages relating to this glock, and must not 179 * not return to caller to demote/unlock the glock until I/O is complete. 180 */ 181 182 static void meta_go_sync(struct gfs2_glock *gl) 183 { 184 if (test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) { 185 gfs2_log_flush(gl->gl_sbd, gl); 186 gfs2_meta_sync(gl); 187 gfs2_ail_empty_gl(gl); 188 } 189 190 } 191 192 /** 193 * meta_go_inval - invalidate the metadata for this glock 194 * @gl: the glock 195 * @flags: 196 * 197 */ 198 199 static void meta_go_inval(struct gfs2_glock *gl, int flags) 200 { 201 if (!(flags & DIO_METADATA)) 202 return; 203 204 gfs2_meta_inval(gl); 205 gl->gl_vn++; 206 } 207 208 /** 209 * inode_go_xmote_th - promote/demote a glock 210 * @gl: the glock 211 * @state: the requested state 212 * @flags: 213 * 214 */ 215 216 static void inode_go_xmote_th(struct gfs2_glock *gl, unsigned int state, 217 int flags) 218 { 219 if (gl->gl_state != LM_ST_UNLOCKED) 220 gfs2_pte_inval(gl); 221 gfs2_glock_xmote_th(gl, state, flags); 222 } 223 224 /** 225 * inode_go_xmote_bh - After promoting/demoting a glock 226 * @gl: the glock 227 * 228 */ 229 230 static void inode_go_xmote_bh(struct gfs2_glock *gl) 231 { 232 struct gfs2_holder *gh = gl->gl_req_gh; 233 struct buffer_head *bh; 234 int error; 235 236 if (gl->gl_state != LM_ST_UNLOCKED && 237 (!gh || !(gh->gh_flags & GL_SKIP))) { 238 error = gfs2_meta_read(gl, gl->gl_name.ln_number, 0, &bh); 239 if (!error) 240 brelse(bh); 241 } 242 } 243 244 /** 245 * inode_go_drop_th - unlock a glock 246 * @gl: the glock 247 * 248 * Invoked from rq_demote(). 249 * Another node needs the lock in EXCLUSIVE mode, or lock (unused for too long) 250 * is being purged from our node's glock cache; we're dropping lock. 251 */ 252 253 static void inode_go_drop_th(struct gfs2_glock *gl) 254 { 255 gfs2_pte_inval(gl); 256 gfs2_glock_drop_th(gl); 257 } 258 259 /** 260 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock 261 * @gl: the glock protecting the inode 262 * 263 */ 264 265 static void inode_go_sync(struct gfs2_glock *gl) 266 { 267 if (test_bit(GLF_DIRTY, &gl->gl_flags)) { 268 gfs2_page_writeback(gl); 269 gfs2_log_flush(gl->gl_sbd, gl); 270 gfs2_meta_sync(gl); 271 gfs2_page_wait(gl); 272 clear_bit(GLF_DIRTY, &gl->gl_flags); 273 gfs2_ail_empty_gl(gl); 274 } 275 } 276 277 /** 278 * inode_go_inval - prepare a inode glock to be released 279 * @gl: the glock 280 * @flags: 281 * 282 */ 283 284 static void inode_go_inval(struct gfs2_glock *gl, int flags) 285 { 286 int meta = (flags & DIO_METADATA); 287 288 if (meta) { 289 struct gfs2_inode *ip = gl->gl_object; 290 gfs2_meta_inval(gl); 291 set_bit(GIF_INVALID, &ip->i_flags); 292 } 293 gfs2_page_inval(gl); 294 } 295 296 /** 297 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock 298 * @gl: the glock 299 * 300 * Returns: 1 if it's ok 301 */ 302 303 static int inode_go_demote_ok(struct gfs2_glock *gl) 304 { 305 struct gfs2_sbd *sdp = gl->gl_sbd; 306 int demote = 0; 307 308 if (!gl->gl_object && !gl->gl_aspace->i_mapping->nrpages) 309 demote = 1; 310 else if (!sdp->sd_args.ar_localcaching && 311 time_after_eq(jiffies, gl->gl_stamp + 312 gfs2_tune_get(sdp, gt_demote_secs) * HZ)) 313 demote = 1; 314 315 return demote; 316 } 317 318 /** 319 * inode_go_lock - operation done after an inode lock is locked by a process 320 * @gl: the glock 321 * @flags: 322 * 323 * Returns: errno 324 */ 325 326 static int inode_go_lock(struct gfs2_holder *gh) 327 { 328 struct gfs2_glock *gl = gh->gh_gl; 329 struct gfs2_inode *ip = gl->gl_object; 330 int error = 0; 331 332 if (!ip) 333 return 0; 334 335 if (test_bit(GIF_INVALID, &ip->i_flags)) { 336 error = gfs2_inode_refresh(ip); 337 if (error) 338 return error; 339 } 340 341 if ((ip->i_di.di_flags & GFS2_DIF_TRUNC_IN_PROG) && 342 (gl->gl_state == LM_ST_EXCLUSIVE) && 343 (gh->gh_flags & GL_LOCAL_EXCL)) 344 error = gfs2_truncatei_resume(ip); 345 346 return error; 347 } 348 349 /** 350 * inode_go_unlock - operation done before an inode lock is unlocked by a 351 * process 352 * @gl: the glock 353 * @flags: 354 * 355 */ 356 357 static void inode_go_unlock(struct gfs2_holder *gh) 358 { 359 struct gfs2_glock *gl = gh->gh_gl; 360 struct gfs2_inode *ip = gl->gl_object; 361 362 if (ip) 363 gfs2_meta_cache_flush(ip); 364 } 365 366 /** 367 * inode_greedy - 368 * @gl: the glock 369 * 370 */ 371 372 static void inode_greedy(struct gfs2_glock *gl) 373 { 374 struct gfs2_sbd *sdp = gl->gl_sbd; 375 struct gfs2_inode *ip = gl->gl_object; 376 unsigned int quantum = gfs2_tune_get(sdp, gt_greedy_quantum); 377 unsigned int max = gfs2_tune_get(sdp, gt_greedy_max); 378 unsigned int new_time; 379 380 spin_lock(&ip->i_spin); 381 382 if (time_after(ip->i_last_pfault + quantum, jiffies)) { 383 new_time = ip->i_greedy + quantum; 384 if (new_time > max) 385 new_time = max; 386 } else { 387 new_time = ip->i_greedy - quantum; 388 if (!new_time || new_time > max) 389 new_time = 1; 390 } 391 392 ip->i_greedy = new_time; 393 394 spin_unlock(&ip->i_spin); 395 396 iput(&ip->i_inode); 397 } 398 399 /** 400 * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock 401 * @gl: the glock 402 * 403 * Returns: 1 if it's ok 404 */ 405 406 static int rgrp_go_demote_ok(struct gfs2_glock *gl) 407 { 408 return !gl->gl_aspace->i_mapping->nrpages; 409 } 410 411 /** 412 * rgrp_go_lock - operation done after an rgrp lock is locked by 413 * a first holder on this node. 414 * @gl: the glock 415 * @flags: 416 * 417 * Returns: errno 418 */ 419 420 static int rgrp_go_lock(struct gfs2_holder *gh) 421 { 422 return gfs2_rgrp_bh_get(gh->gh_gl->gl_object); 423 } 424 425 /** 426 * rgrp_go_unlock - operation done before an rgrp lock is unlocked by 427 * a last holder on this node. 428 * @gl: the glock 429 * @flags: 430 * 431 */ 432 433 static void rgrp_go_unlock(struct gfs2_holder *gh) 434 { 435 gfs2_rgrp_bh_put(gh->gh_gl->gl_object); 436 } 437 438 /** 439 * trans_go_xmote_th - promote/demote the transaction glock 440 * @gl: the glock 441 * @state: the requested state 442 * @flags: 443 * 444 */ 445 446 static void trans_go_xmote_th(struct gfs2_glock *gl, unsigned int state, 447 int flags) 448 { 449 struct gfs2_sbd *sdp = gl->gl_sbd; 450 451 if (gl->gl_state != LM_ST_UNLOCKED && 452 test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) { 453 gfs2_meta_syncfs(sdp); 454 gfs2_log_shutdown(sdp); 455 } 456 457 gfs2_glock_xmote_th(gl, state, flags); 458 } 459 460 /** 461 * trans_go_xmote_bh - After promoting/demoting the transaction glock 462 * @gl: the glock 463 * 464 */ 465 466 static void trans_go_xmote_bh(struct gfs2_glock *gl) 467 { 468 struct gfs2_sbd *sdp = gl->gl_sbd; 469 struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode); 470 struct gfs2_glock *j_gl = ip->i_gl; 471 struct gfs2_log_header_host head; 472 int error; 473 474 if (gl->gl_state != LM_ST_UNLOCKED && 475 test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) { 476 gfs2_meta_cache_flush(GFS2_I(sdp->sd_jdesc->jd_inode)); 477 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA); 478 479 error = gfs2_find_jhead(sdp->sd_jdesc, &head); 480 if (error) 481 gfs2_consist(sdp); 482 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) 483 gfs2_consist(sdp); 484 485 /* Initialize some head of the log stuff */ 486 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) { 487 sdp->sd_log_sequence = head.lh_sequence + 1; 488 gfs2_log_pointers_init(sdp, head.lh_blkno); 489 } 490 } 491 } 492 493 /** 494 * trans_go_drop_th - unlock the transaction glock 495 * @gl: the glock 496 * 497 * We want to sync the device even with localcaching. Remember 498 * that localcaching journal replay only marks buffers dirty. 499 */ 500 501 static void trans_go_drop_th(struct gfs2_glock *gl) 502 { 503 struct gfs2_sbd *sdp = gl->gl_sbd; 504 505 if (test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) { 506 gfs2_meta_syncfs(sdp); 507 gfs2_log_shutdown(sdp); 508 } 509 510 gfs2_glock_drop_th(gl); 511 } 512 513 /** 514 * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock 515 * @gl: the glock 516 * 517 * Returns: 1 if it's ok 518 */ 519 520 static int quota_go_demote_ok(struct gfs2_glock *gl) 521 { 522 return !atomic_read(&gl->gl_lvb_count); 523 } 524 525 const struct gfs2_glock_operations gfs2_meta_glops = { 526 .go_xmote_th = gfs2_glock_xmote_th, 527 .go_drop_th = gfs2_glock_drop_th, 528 .go_type = LM_TYPE_META, 529 }; 530 531 const struct gfs2_glock_operations gfs2_inode_glops = { 532 .go_xmote_th = inode_go_xmote_th, 533 .go_xmote_bh = inode_go_xmote_bh, 534 .go_drop_th = inode_go_drop_th, 535 .go_sync = inode_go_sync, 536 .go_inval = inode_go_inval, 537 .go_demote_ok = inode_go_demote_ok, 538 .go_lock = inode_go_lock, 539 .go_unlock = inode_go_unlock, 540 .go_greedy = inode_greedy, 541 .go_type = LM_TYPE_INODE, 542 }; 543 544 const struct gfs2_glock_operations gfs2_rgrp_glops = { 545 .go_xmote_th = gfs2_glock_xmote_th, 546 .go_drop_th = gfs2_glock_drop_th, 547 .go_sync = meta_go_sync, 548 .go_inval = meta_go_inval, 549 .go_demote_ok = rgrp_go_demote_ok, 550 .go_lock = rgrp_go_lock, 551 .go_unlock = rgrp_go_unlock, 552 .go_type = LM_TYPE_RGRP, 553 }; 554 555 const struct gfs2_glock_operations gfs2_trans_glops = { 556 .go_xmote_th = trans_go_xmote_th, 557 .go_xmote_bh = trans_go_xmote_bh, 558 .go_drop_th = trans_go_drop_th, 559 .go_type = LM_TYPE_NONDISK, 560 }; 561 562 const struct gfs2_glock_operations gfs2_iopen_glops = { 563 .go_xmote_th = gfs2_glock_xmote_th, 564 .go_drop_th = gfs2_glock_drop_th, 565 .go_type = LM_TYPE_IOPEN, 566 }; 567 568 const struct gfs2_glock_operations gfs2_flock_glops = { 569 .go_xmote_th = gfs2_glock_xmote_th, 570 .go_drop_th = gfs2_glock_drop_th, 571 .go_type = LM_TYPE_FLOCK, 572 }; 573 574 const struct gfs2_glock_operations gfs2_nondisk_glops = { 575 .go_xmote_th = gfs2_glock_xmote_th, 576 .go_drop_th = gfs2_glock_drop_th, 577 .go_type = LM_TYPE_NONDISK, 578 }; 579 580 const struct gfs2_glock_operations gfs2_quota_glops = { 581 .go_xmote_th = gfs2_glock_xmote_th, 582 .go_drop_th = gfs2_glock_drop_th, 583 .go_demote_ok = quota_go_demote_ok, 584 .go_type = LM_TYPE_QUOTA, 585 }; 586 587 const struct gfs2_glock_operations gfs2_journal_glops = { 588 .go_xmote_th = gfs2_glock_xmote_th, 589 .go_drop_th = gfs2_glock_drop_th, 590 .go_type = LM_TYPE_JOURNAL, 591 }; 592 593