fs/gfs2/glops.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2005 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 v.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 <asm/semaphore.h>
  16
  17 #include "gfs2.h"
  18 #include "bmap.h"
  19 #include "glock.h"
  20 #include "glops.h"
  21 #include "inode.h"
  22 #include "log.h"
  23 #include "meta_io.h"
  24 #include "page.h"
  25 #include "recovery.h"
  26 #include "rgrp.h"
  27
  28 /**
  29  * meta_go_sync - sync out the metadata for this glock
  30  * @gl: the glock
  31  * @flags: DIO_*
  32  *
  33  * Called when demoting or unlocking an EX glock.  We must flush
  34  * to disk all dirty buffers/pages relating to this glock, and must not
  35  * not return to caller to demote/unlock the glock until I/O is complete.
  36  */
  37
  38 static void meta_go_sync(struct gfs2_glock *gl, int flags)
  39 {
  40         if (!(flags & DIO_METADATA))
  41                 return;
  42
  43         if (test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) {
  44                 gfs2_log_flush_glock(gl);
  45                 gfs2_meta_sync(gl, flags | DIO_START | DIO_WAIT);
  46                 if (flags & DIO_RELEASE)
  47                         gfs2_ail_empty_gl(gl);
  48         }
  49
  50         clear_bit(GLF_SYNC, &gl->gl_flags);
  51 }
  52
  53 /**
  54  * meta_go_inval - invalidate the metadata for this glock
  55  * @gl: the glock
  56  * @flags:
  57  *
  58  */
  59
  60 static void meta_go_inval(struct gfs2_glock *gl, int flags)
  61 {
  62         if (!(flags & DIO_METADATA))
  63                 return;
  64
  65         gfs2_meta_inval(gl);
  66         gl->gl_vn++;
  67 }
  68
  69 /**
  70  * meta_go_demote_ok - Check to see if it's ok to unlock a glock
  71  * @gl: the glock
  72  *
  73  * Returns: 1 if we have no cached data; ok to demote meta glock
  74  */
  75
  76 static int meta_go_demote_ok(struct gfs2_glock *gl)
  77 {
  78         return !gl->gl_aspace->i_mapping->nrpages;
  79 }
  80
  81 /**
  82  * inode_go_xmote_th - promote/demote a glock
  83  * @gl: the glock
  84  * @state: the requested state
  85  * @flags:
  86  *
  87  */
  88
  89 static void inode_go_xmote_th(struct gfs2_glock *gl, unsigned int state,
  90                               int flags)
  91 {
  92         if (gl->gl_state != LM_ST_UNLOCKED)
  93                 gfs2_pte_inval(gl);
  94         gfs2_glock_xmote_th(gl, state, flags);
  95 }
  96
  97 /**
  98  * inode_go_xmote_bh - After promoting/demoting a glock
  99  * @gl: the glock
 100  *
 101  */
 102
 103 static void inode_go_xmote_bh(struct gfs2_glock *gl)
 104 {
 105         struct gfs2_holder *gh = gl->gl_req_gh;
 106         struct buffer_head *bh;
 107         int error;
 108
 109         if (gl->gl_state != LM_ST_UNLOCKED &&
 110             (!gh || !(gh->gh_flags & GL_SKIP))) {
 111                 error = gfs2_meta_read(gl, gl->gl_name.ln_number, DIO_START,
 112                                        &bh);
 113                 if (!error)
 114                         brelse(bh);
 115         }
 116 }
 117
 118 /**
 119  * inode_go_drop_th - unlock a glock
 120  * @gl: the glock
 121  *
 122  * Invoked from rq_demote().
 123  * Another node needs the lock in EXCLUSIVE mode, or lock (unused for too long)
 124  * is being purged from our node's glock cache; we're dropping lock.
 125  */
 126
 127 static void inode_go_drop_th(struct gfs2_glock *gl)
 128 {
 129         gfs2_pte_inval(gl);
 130         gfs2_glock_drop_th(gl);
 131 }
 132
 133 /**
 134  * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
 135  * @gl: the glock protecting the inode
 136  * @flags:
 137  *
 138  */
 139
 140 static void inode_go_sync(struct gfs2_glock *gl, int flags)
 141 {
 142         int meta = (flags & DIO_METADATA);
 143         int data = (flags & DIO_DATA);
 144
 145         if (test_bit(GLF_DIRTY, &gl->gl_flags)) {
 146                 if (meta && data) {
 147                         gfs2_page_sync(gl, flags | DIO_START);
 148                         gfs2_log_flush_glock(gl);
 149                         gfs2_meta_sync(gl, flags | DIO_START | DIO_WAIT);
 150                         gfs2_page_sync(gl, flags | DIO_WAIT);
 151                         clear_bit(GLF_DIRTY, &gl->gl_flags);
 152                 } else if (meta) {
 153                         gfs2_log_flush_glock(gl);
 154                         gfs2_meta_sync(gl, flags | DIO_START | DIO_WAIT);
 155                 } else if (data)
 156                         gfs2_page_sync(gl, flags | DIO_START | DIO_WAIT);
 157                 if (flags & DIO_RELEASE)
 158                         gfs2_ail_empty_gl(gl);
 159         }
 160
 161         clear_bit(GLF_SYNC, &gl->gl_flags);
 162 }
 163
 164 /**
 165  * inode_go_inval - prepare a inode glock to be released
 166  * @gl: the glock
 167  * @flags:
 168  *
 169  */
 170
 171 static void inode_go_inval(struct gfs2_glock *gl, int flags)
 172 {
 173         int meta = (flags & DIO_METADATA);
 174         int data = (flags & DIO_DATA);
 175
 176         if (meta) {
 177                 gfs2_meta_inval(gl);
 178                 gl->gl_vn++;
 179         }
 180         if (data)
 181                 gfs2_page_inval(gl);
 182 }
 183
 184 /**
 185  * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
 186  * @gl: the glock
 187  *
 188  * Returns: 1 if it's ok
 189  */
 190
 191 static int inode_go_demote_ok(struct gfs2_glock *gl)
 192 {
 193         struct gfs2_sbd *sdp = gl->gl_sbd;
 194         int demote = 0;
 195
 196         if (!get_gl2ip(gl) && !gl->gl_aspace->i_mapping->nrpages)
 197                 demote = 1;
 198         else if (!sdp->sd_args.ar_localcaching &&
 199                  time_after_eq(jiffies, gl->gl_stamp +
 200                                gfs2_tune_get(sdp, gt_demote_secs) * HZ))
 201                 demote = 1;
 202
 203         return demote;
 204 }
 205
 206 /**
 207  * inode_go_lock - operation done after an inode lock is locked by a process
 208  * @gl: the glock
 209  * @flags:
 210  *
 211  * Returns: errno
 212  */
 213
 214 static int inode_go_lock(struct gfs2_holder *gh)
 215 {
 216         struct gfs2_glock *gl = gh->gh_gl;
 217         struct gfs2_inode *ip = get_gl2ip(gl);
 218         int error = 0;
 219
 220         if (!ip)
 221                 return 0;
 222
 223         if (ip->i_vn != gl->gl_vn) {
 224                 error = gfs2_inode_refresh(ip);
 225                 if (error)
 226                         return error;
 227                 gfs2_inode_attr_in(ip);
 228         }
 229
 230         if ((ip->i_di.di_flags & GFS2_DIF_TRUNC_IN_PROG) &&
 231             (gl->gl_state == LM_ST_EXCLUSIVE) &&
 232             (gh->gh_flags & GL_LOCAL_EXCL))
 233                 error = gfs2_truncatei_resume(ip);
 234
 235         return error;
 236 }
 237
 238 /**
 239  * inode_go_unlock - operation done before an inode lock is unlocked by a
 240  *                   process
 241  * @gl: the glock
 242  * @flags:
 243  *
 244  */
 245
 246 static void inode_go_unlock(struct gfs2_holder *gh)
 247 {
 248         struct gfs2_glock *gl = gh->gh_gl;
 249         struct gfs2_inode *ip = get_gl2ip(gl);
 250
 251         if (ip && test_bit(GLF_DIRTY, &gl->gl_flags))
 252                 gfs2_inode_attr_in(ip);
 253
 254         if (ip)
 255                 gfs2_meta_cache_flush(ip);
 256 }
 257
 258 /**
 259  * inode_greedy -
 260  * @gl: the glock
 261  *
 262  */
 263
 264 static void inode_greedy(struct gfs2_glock *gl)
 265 {
 266         struct gfs2_sbd *sdp = gl->gl_sbd;
 267         struct gfs2_inode *ip = get_gl2ip(gl);
 268         unsigned int quantum = gfs2_tune_get(sdp, gt_greedy_quantum);
 269         unsigned int max = gfs2_tune_get(sdp, gt_greedy_max);
 270         unsigned int new_time;
 271
 272         spin_lock(&ip->i_spin);
 273
 274         if (time_after(ip->i_last_pfault + quantum, jiffies)) {
 275                 new_time = ip->i_greedy + quantum;
 276                 if (new_time > max)
 277                         new_time = max;
 278         } else {
 279                 new_time = ip->i_greedy - quantum;
 280                 if (!new_time || new_time > max)
 281                         new_time = 1;
 282         }
 283
 284         ip->i_greedy = new_time;
 285
 286         spin_unlock(&ip->i_spin);
 287
 288         gfs2_inode_put(ip);
 289 }
 290
 291 /**
 292  * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock
 293  * @gl: the glock
 294  *
 295  * Returns: 1 if it's ok
 296  */
 297
 298 static int rgrp_go_demote_ok(struct gfs2_glock *gl)
 299 {
 300         return !gl->gl_aspace->i_mapping->nrpages;
 301 }
 302
 303 /**
 304  * rgrp_go_lock - operation done after an rgrp lock is locked by
 305  *    a first holder on this node.
 306  * @gl: the glock
 307  * @flags:
 308  *
 309  * Returns: errno
 310  */
 311
 312 static int rgrp_go_lock(struct gfs2_holder *gh)
 313 {
 314         return gfs2_rgrp_bh_get(get_gl2rgd(gh->gh_gl));
 315 }
 316
 317 /**
 318  * rgrp_go_unlock - operation done before an rgrp lock is unlocked by
 319  *    a last holder on this node.
 320  * @gl: the glock
 321  * @flags:
 322  *
 323  */
 324
 325 static void rgrp_go_unlock(struct gfs2_holder *gh)
 326 {
 327         gfs2_rgrp_bh_put(get_gl2rgd(gh->gh_gl));
 328 }
 329
 330 /**
 331  * trans_go_xmote_th - promote/demote the transaction glock
 332  * @gl: the glock
 333  * @state: the requested state
 334  * @flags:
 335  *
 336  */
 337
 338 static void trans_go_xmote_th(struct gfs2_glock *gl, unsigned int state,
 339                               int flags)
 340 {
 341         struct gfs2_sbd *sdp = gl->gl_sbd;
 342
 343         if (gl->gl_state != LM_ST_UNLOCKED &&
 344             test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
 345                 gfs2_meta_syncfs(sdp);
 346                 gfs2_log_shutdown(sdp);
 347         }
 348
 349         gfs2_glock_xmote_th(gl, state, flags);
 350 }
 351
 352 /**
 353  * trans_go_xmote_bh - After promoting/demoting the transaction glock
 354  * @gl: the glock
 355  *
 356  */
 357
 358 static void trans_go_xmote_bh(struct gfs2_glock *gl)
 359 {
 360         struct gfs2_sbd *sdp = gl->gl_sbd;
 361         struct gfs2_glock *j_gl = sdp->sd_jdesc->jd_inode->i_gl;
 362         struct gfs2_log_header head;
 363         int error;
 364
 365         if (gl->gl_state != LM_ST_UNLOCKED &&
 366             test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
 367                 gfs2_meta_cache_flush(sdp->sd_jdesc->jd_inode);
 368                 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA | DIO_DATA);
 369
 370                 error = gfs2_find_jhead(sdp->sd_jdesc, &head);
 371                 if (error)
 372                         gfs2_consist(sdp);
 373                 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT))
 374                         gfs2_consist(sdp);
 375
 376                 /*  Initialize some head of the log stuff  */
 377                 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) {
 378                         sdp->sd_log_sequence = head.lh_sequence + 1;
 379                         gfs2_log_pointers_init(sdp, head.lh_blkno);
 380                 }
 381         }
 382 }
 383
 384 /**
 385  * trans_go_drop_th - unlock the transaction glock
 386  * @gl: the glock
 387  *
 388  * We want to sync the device even with localcaching.  Remember
 389  * that localcaching journal replay only marks buffers dirty.
 390  */
 391
 392 static void trans_go_drop_th(struct gfs2_glock *gl)
 393 {
 394         struct gfs2_sbd *sdp = gl->gl_sbd;
 395
 396         if (test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
 397                 gfs2_meta_syncfs(sdp);
 398                 gfs2_log_shutdown(sdp);
 399         }
 400
 401         gfs2_glock_drop_th(gl);
 402 }
 403
 404 /**
 405  * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
 406  * @gl: the glock
 407  *
 408  * Returns: 1 if it's ok
 409  */
 410
 411 static int quota_go_demote_ok(struct gfs2_glock *gl)
 412 {
 413         return !atomic_read(&gl->gl_lvb_count);
 414 }
 415
 416 struct gfs2_glock_operations gfs2_meta_glops = {
 417         .go_xmote_th = gfs2_glock_xmote_th,
 418         .go_drop_th = gfs2_glock_drop_th,
 419         .go_sync = meta_go_sync,
 420         .go_inval = meta_go_inval,
 421         .go_demote_ok = meta_go_demote_ok,
 422         .go_type = LM_TYPE_META
 423 };
 424
 425 struct gfs2_glock_operations gfs2_inode_glops = {
 426         .go_xmote_th = inode_go_xmote_th,
 427         .go_xmote_bh = inode_go_xmote_bh,
 428         .go_drop_th = inode_go_drop_th,
 429         .go_sync = inode_go_sync,
 430         .go_inval = inode_go_inval,
 431         .go_demote_ok = inode_go_demote_ok,
 432         .go_lock = inode_go_lock,
 433         .go_unlock = inode_go_unlock,
 434         .go_greedy = inode_greedy,
 435         .go_type = LM_TYPE_INODE
 436 };
 437
 438 struct gfs2_glock_operations gfs2_rgrp_glops = {
 439         .go_xmote_th = gfs2_glock_xmote_th,
 440         .go_drop_th = gfs2_glock_drop_th,
 441         .go_sync = meta_go_sync,
 442         .go_inval = meta_go_inval,
 443         .go_demote_ok = rgrp_go_demote_ok,
 444         .go_lock = rgrp_go_lock,
 445         .go_unlock = rgrp_go_unlock,
 446         .go_type = LM_TYPE_RGRP
 447 };
 448
 449 struct gfs2_glock_operations gfs2_trans_glops = {
 450         .go_xmote_th = trans_go_xmote_th,
 451         .go_xmote_bh = trans_go_xmote_bh,
 452         .go_drop_th = trans_go_drop_th,
 453         .go_type = LM_TYPE_NONDISK
 454 };
 455
 456 struct gfs2_glock_operations gfs2_iopen_glops = {
 457         .go_xmote_th = gfs2_glock_xmote_th,
 458         .go_drop_th = gfs2_glock_drop_th,
 459         .go_callback = gfs2_iopen_go_callback,
 460         .go_type = LM_TYPE_IOPEN
 461 };
 462
 463 struct gfs2_glock_operations gfs2_flock_glops = {
 464         .go_xmote_th = gfs2_glock_xmote_th,
 465         .go_drop_th = gfs2_glock_drop_th,
 466         .go_type = LM_TYPE_FLOCK
 467 };
 468
 469 struct gfs2_glock_operations gfs2_nondisk_glops = {
 470         .go_xmote_th = gfs2_glock_xmote_th,
 471         .go_drop_th = gfs2_glock_drop_th,
 472         .go_type = LM_TYPE_NONDISK
 473 };
 474
 475 struct gfs2_glock_operations gfs2_quota_glops = {
 476         .go_xmote_th = gfs2_glock_xmote_th,
 477         .go_drop_th = gfs2_glock_drop_th,
 478         .go_demote_ok = quota_go_demote_ok,
 479         .go_type = LM_TYPE_QUOTA
 480 };
 481
 482 struct gfs2_glock_operations gfs2_journal_glops = {
 483         .go_xmote_th = gfs2_glock_xmote_th,
 484         .go_drop_th = gfs2_glock_drop_th,
 485         .go_type = LM_TYPE_JOURNAL
 486 };
 487