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 * meta_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 meta_go_sync(struct gfs2_glock *gl) 119 { 120 if (test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) { 121 gfs2_log_flush(gl->gl_sbd, gl); 122 gfs2_meta_sync(gl); 123 gfs2_ail_empty_gl(gl); 124 } 125 126 } 127 128 /** 129 * meta_go_inval - invalidate the metadata for this glock 130 * @gl: the glock 131 * @flags: 132 * 133 */ 134 135 static void meta_go_inval(struct gfs2_glock *gl, int flags) 136 { 137 if (!(flags & DIO_METADATA)) 138 return; 139 140 gfs2_meta_inval(gl); 141 gl->gl_vn++; 142 } 143 144 /** 145 * inode_go_xmote_th - promote/demote a glock 146 * @gl: the glock 147 * @state: the requested state 148 * @flags: 149 * 150 */ 151 152 static void inode_go_xmote_th(struct gfs2_glock *gl, unsigned int state, 153 int flags) 154 { 155 if (gl->gl_state != LM_ST_UNLOCKED) 156 gfs2_pte_inval(gl); 157 gfs2_glock_xmote_th(gl, state, flags); 158 } 159 160 /** 161 * inode_go_xmote_bh - After promoting/demoting a glock 162 * @gl: the glock 163 * 164 */ 165 166 static void inode_go_xmote_bh(struct gfs2_glock *gl) 167 { 168 struct gfs2_holder *gh = gl->gl_req_gh; 169 struct buffer_head *bh; 170 int error; 171 172 if (gl->gl_state != LM_ST_UNLOCKED && 173 (!gh || !(gh->gh_flags & GL_SKIP))) { 174 error = gfs2_meta_read(gl, gl->gl_name.ln_number, 0, &bh); 175 if (!error) 176 brelse(bh); 177 } 178 } 179 180 /** 181 * inode_go_drop_th - unlock a glock 182 * @gl: the glock 183 * 184 * Invoked from rq_demote(). 185 * Another node needs the lock in EXCLUSIVE mode, or lock (unused for too long) 186 * is being purged from our node's glock cache; we're dropping lock. 187 */ 188 189 static void inode_go_drop_th(struct gfs2_glock *gl) 190 { 191 gfs2_pte_inval(gl); 192 gfs2_glock_drop_th(gl); 193 } 194 195 /** 196 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock 197 * @gl: the glock protecting the inode 198 * 199 */ 200 201 static void inode_go_sync(struct gfs2_glock *gl) 202 { 203 struct gfs2_inode *ip = gl->gl_object; 204 205 if (ip && !S_ISREG(ip->i_inode.i_mode)) 206 ip = NULL; 207 208 if (test_bit(GLF_DIRTY, &gl->gl_flags)) { 209 gfs2_log_flush(gl->gl_sbd, gl); 210 if (ip) 211 filemap_fdatawrite(ip->i_inode.i_mapping); 212 gfs2_meta_sync(gl); 213 if (ip) { 214 struct address_space *mapping = ip->i_inode.i_mapping; 215 int error = filemap_fdatawait(mapping); 216 if (error == -ENOSPC) 217 set_bit(AS_ENOSPC, &mapping->flags); 218 else if (error) 219 set_bit(AS_EIO, &mapping->flags); 220 } 221 clear_bit(GLF_DIRTY, &gl->gl_flags); 222 gfs2_ail_empty_gl(gl); 223 } 224 } 225 226 /** 227 * inode_go_inval - prepare a inode glock to be released 228 * @gl: the glock 229 * @flags: 230 * 231 */ 232 233 static void inode_go_inval(struct gfs2_glock *gl, int flags) 234 { 235 struct gfs2_inode *ip = gl->gl_object; 236 int meta = (flags & DIO_METADATA); 237 238 if (meta) { 239 gfs2_meta_inval(gl); 240 if (ip) 241 set_bit(GIF_INVALID, &ip->i_flags); 242 } 243 244 if (ip && S_ISREG(ip->i_inode.i_mode)) { 245 truncate_inode_pages(ip->i_inode.i_mapping, 0); 246 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), !ip->i_inode.i_mapping->nrpages); 247 clear_bit(GIF_PAGED, &ip->i_flags); 248 } 249 } 250 251 /** 252 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock 253 * @gl: the glock 254 * 255 * Returns: 1 if it's ok 256 */ 257 258 static int inode_go_demote_ok(struct gfs2_glock *gl) 259 { 260 struct gfs2_sbd *sdp = gl->gl_sbd; 261 int demote = 0; 262 263 if (!gl->gl_object && !gl->gl_aspace->i_mapping->nrpages) 264 demote = 1; 265 else if (!sdp->sd_args.ar_localcaching && 266 time_after_eq(jiffies, gl->gl_stamp + 267 gfs2_tune_get(sdp, gt_demote_secs) * HZ)) 268 demote = 1; 269 270 return demote; 271 } 272 273 /** 274 * inode_go_lock - operation done after an inode lock is locked by a process 275 * @gl: the glock 276 * @flags: 277 * 278 * Returns: errno 279 */ 280 281 static int inode_go_lock(struct gfs2_holder *gh) 282 { 283 struct gfs2_glock *gl = gh->gh_gl; 284 struct gfs2_inode *ip = gl->gl_object; 285 int error = 0; 286 287 if (!ip) 288 return 0; 289 290 if (test_bit(GIF_INVALID, &ip->i_flags)) { 291 error = gfs2_inode_refresh(ip); 292 if (error) 293 return error; 294 } 295 296 if ((ip->i_di.di_flags & GFS2_DIF_TRUNC_IN_PROG) && 297 (gl->gl_state == LM_ST_EXCLUSIVE) && 298 (gh->gh_flags & GL_LOCAL_EXCL)) 299 error = gfs2_truncatei_resume(ip); 300 301 return error; 302 } 303 304 /** 305 * inode_go_unlock - operation done before an inode lock is unlocked by a 306 * process 307 * @gl: the glock 308 * @flags: 309 * 310 */ 311 312 static void inode_go_unlock(struct gfs2_holder *gh) 313 { 314 struct gfs2_glock *gl = gh->gh_gl; 315 struct gfs2_inode *ip = gl->gl_object; 316 317 if (ip) 318 gfs2_meta_cache_flush(ip); 319 } 320 321 /** 322 * inode_greedy - 323 * @gl: the glock 324 * 325 */ 326 327 static void inode_greedy(struct gfs2_glock *gl) 328 { 329 struct gfs2_sbd *sdp = gl->gl_sbd; 330 struct gfs2_inode *ip = gl->gl_object; 331 unsigned int quantum = gfs2_tune_get(sdp, gt_greedy_quantum); 332 unsigned int max = gfs2_tune_get(sdp, gt_greedy_max); 333 unsigned int new_time; 334 335 spin_lock(&ip->i_spin); 336 337 if (time_after(ip->i_last_pfault + quantum, jiffies)) { 338 new_time = ip->i_greedy + quantum; 339 if (new_time > max) 340 new_time = max; 341 } else { 342 new_time = ip->i_greedy - quantum; 343 if (!new_time || new_time > max) 344 new_time = 1; 345 } 346 347 ip->i_greedy = new_time; 348 349 spin_unlock(&ip->i_spin); 350 351 iput(&ip->i_inode); 352 } 353 354 /** 355 * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock 356 * @gl: the glock 357 * 358 * Returns: 1 if it's ok 359 */ 360 361 static int rgrp_go_demote_ok(struct gfs2_glock *gl) 362 { 363 return !gl->gl_aspace->i_mapping->nrpages; 364 } 365 366 /** 367 * rgrp_go_lock - operation done after an rgrp lock is locked by 368 * a first holder on this node. 369 * @gl: the glock 370 * @flags: 371 * 372 * Returns: errno 373 */ 374 375 static int rgrp_go_lock(struct gfs2_holder *gh) 376 { 377 return gfs2_rgrp_bh_get(gh->gh_gl->gl_object); 378 } 379 380 /** 381 * rgrp_go_unlock - operation done before an rgrp lock is unlocked by 382 * a last holder on this node. 383 * @gl: the glock 384 * @flags: 385 * 386 */ 387 388 static void rgrp_go_unlock(struct gfs2_holder *gh) 389 { 390 gfs2_rgrp_bh_put(gh->gh_gl->gl_object); 391 } 392 393 /** 394 * trans_go_xmote_th - promote/demote the transaction glock 395 * @gl: the glock 396 * @state: the requested state 397 * @flags: 398 * 399 */ 400 401 static void trans_go_xmote_th(struct gfs2_glock *gl, unsigned int state, 402 int flags) 403 { 404 struct gfs2_sbd *sdp = gl->gl_sbd; 405 406 if (gl->gl_state != LM_ST_UNLOCKED && 407 test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) { 408 gfs2_meta_syncfs(sdp); 409 gfs2_log_shutdown(sdp); 410 } 411 412 gfs2_glock_xmote_th(gl, state, flags); 413 } 414 415 /** 416 * trans_go_xmote_bh - After promoting/demoting the transaction glock 417 * @gl: the glock 418 * 419 */ 420 421 static void trans_go_xmote_bh(struct gfs2_glock *gl) 422 { 423 struct gfs2_sbd *sdp = gl->gl_sbd; 424 struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode); 425 struct gfs2_glock *j_gl = ip->i_gl; 426 struct gfs2_log_header_host head; 427 int error; 428 429 if (gl->gl_state != LM_ST_UNLOCKED && 430 test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) { 431 gfs2_meta_cache_flush(GFS2_I(sdp->sd_jdesc->jd_inode)); 432 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA); 433 434 error = gfs2_find_jhead(sdp->sd_jdesc, &head); 435 if (error) 436 gfs2_consist(sdp); 437 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) 438 gfs2_consist(sdp); 439 440 /* Initialize some head of the log stuff */ 441 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) { 442 sdp->sd_log_sequence = head.lh_sequence + 1; 443 gfs2_log_pointers_init(sdp, head.lh_blkno); 444 } 445 } 446 } 447 448 /** 449 * trans_go_drop_th - unlock the transaction glock 450 * @gl: the glock 451 * 452 * We want to sync the device even with localcaching. Remember 453 * that localcaching journal replay only marks buffers dirty. 454 */ 455 456 static void trans_go_drop_th(struct gfs2_glock *gl) 457 { 458 struct gfs2_sbd *sdp = gl->gl_sbd; 459 460 if (test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) { 461 gfs2_meta_syncfs(sdp); 462 gfs2_log_shutdown(sdp); 463 } 464 465 gfs2_glock_drop_th(gl); 466 } 467 468 /** 469 * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock 470 * @gl: the glock 471 * 472 * Returns: 1 if it's ok 473 */ 474 475 static int quota_go_demote_ok(struct gfs2_glock *gl) 476 { 477 return !atomic_read(&gl->gl_lvb_count); 478 } 479 480 const struct gfs2_glock_operations gfs2_meta_glops = { 481 .go_xmote_th = gfs2_glock_xmote_th, 482 .go_drop_th = gfs2_glock_drop_th, 483 .go_type = LM_TYPE_META, 484 }; 485 486 const struct gfs2_glock_operations gfs2_inode_glops = { 487 .go_xmote_th = inode_go_xmote_th, 488 .go_xmote_bh = inode_go_xmote_bh, 489 .go_drop_th = inode_go_drop_th, 490 .go_sync = inode_go_sync, 491 .go_inval = inode_go_inval, 492 .go_demote_ok = inode_go_demote_ok, 493 .go_lock = inode_go_lock, 494 .go_unlock = inode_go_unlock, 495 .go_greedy = inode_greedy, 496 .go_type = LM_TYPE_INODE, 497 }; 498 499 const struct gfs2_glock_operations gfs2_rgrp_glops = { 500 .go_xmote_th = gfs2_glock_xmote_th, 501 .go_drop_th = gfs2_glock_drop_th, 502 .go_sync = meta_go_sync, 503 .go_inval = meta_go_inval, 504 .go_demote_ok = rgrp_go_demote_ok, 505 .go_lock = rgrp_go_lock, 506 .go_unlock = rgrp_go_unlock, 507 .go_type = LM_TYPE_RGRP, 508 }; 509 510 const struct gfs2_glock_operations gfs2_trans_glops = { 511 .go_xmote_th = trans_go_xmote_th, 512 .go_xmote_bh = trans_go_xmote_bh, 513 .go_drop_th = trans_go_drop_th, 514 .go_type = LM_TYPE_NONDISK, 515 }; 516 517 const struct gfs2_glock_operations gfs2_iopen_glops = { 518 .go_xmote_th = gfs2_glock_xmote_th, 519 .go_drop_th = gfs2_glock_drop_th, 520 .go_type = LM_TYPE_IOPEN, 521 }; 522 523 const struct gfs2_glock_operations gfs2_flock_glops = { 524 .go_xmote_th = gfs2_glock_xmote_th, 525 .go_drop_th = gfs2_glock_drop_th, 526 .go_type = LM_TYPE_FLOCK, 527 }; 528 529 const struct gfs2_glock_operations gfs2_nondisk_glops = { 530 .go_xmote_th = gfs2_glock_xmote_th, 531 .go_drop_th = gfs2_glock_drop_th, 532 .go_type = LM_TYPE_NONDISK, 533 }; 534 535 const struct gfs2_glock_operations gfs2_quota_glops = { 536 .go_xmote_th = gfs2_glock_xmote_th, 537 .go_drop_th = gfs2_glock_drop_th, 538 .go_demote_ok = quota_go_demote_ok, 539 .go_type = LM_TYPE_QUOTA, 540 }; 541 542 const struct gfs2_glock_operations gfs2_journal_glops = { 543 .go_xmote_th = gfs2_glock_xmote_th, 544 .go_drop_th = gfs2_glock_drop_th, 545 .go_type = LM_TYPE_JOURNAL, 546 }; 547 548