2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
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.
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>
32 * ail_empty_gl - remove all buffers for a given lock from the AIL
35 * None of the buffers should be dirty, locked, or pinned.
38 static void gfs2_ail_empty_gl(struct gfs2_glock
*gl
)
40 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
42 struct list_head
*head
= &gl
->gl_ail_list
;
43 struct gfs2_bufdata
*bd
;
44 struct buffer_head
*bh
;
48 blocks
= atomic_read(&gl
->gl_ail_count
);
52 error
= gfs2_trans_begin(sdp
, 0, blocks
);
53 if (gfs2_assert_withdraw(sdp
, !error
))
57 while (!list_empty(head
)) {
58 bd
= list_entry(head
->next
, struct gfs2_bufdata
,
61 blkno
= bh
->b_blocknr
;
62 gfs2_assert_withdraw(sdp
, !buffer_busy(bh
));
65 list_del(&bd
->bd_ail_st_list
);
66 list_del(&bd
->bd_ail_gl_list
);
67 atomic_dec(&gl
->gl_ail_count
);
71 gfs2_trans_add_revoke(sdp
, blkno
);
75 gfs2_assert_withdraw(sdp
, !atomic_read(&gl
->gl_ail_count
));
79 gfs2_log_flush(sdp
, NULL
);
83 * gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock
88 static void gfs2_pte_inval(struct gfs2_glock
*gl
)
90 struct gfs2_inode
*ip
;
95 if (!ip
|| !S_ISREG(inode
->i_mode
))
98 if (!test_bit(GIF_PAGED
, &ip
->i_flags
))
101 unmap_shared_mapping_range(inode
->i_mapping
, 0, 0);
103 if (test_bit(GIF_SW_PAGED
, &ip
->i_flags
))
104 set_bit(GLF_DIRTY
, &gl
->gl_flags
);
106 clear_bit(GIF_SW_PAGED
, &ip
->i_flags
);
110 * meta_go_sync - sync out the metadata for this glock
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.
118 static void meta_go_sync(struct gfs2_glock
*gl
)
120 if (gl
->gl_state
!= LM_ST_EXCLUSIVE
)
123 if (test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
)) {
124 gfs2_log_flush(gl
->gl_sbd
, gl
);
126 gfs2_ail_empty_gl(gl
);
131 * meta_go_inval - invalidate the metadata for this glock
137 static void meta_go_inval(struct gfs2_glock
*gl
, int flags
)
139 if (!(flags
& DIO_METADATA
))
147 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
148 * @gl: the glock protecting the inode
152 static void inode_go_sync(struct gfs2_glock
*gl
)
154 struct gfs2_inode
*ip
= gl
->gl_object
;
156 if (ip
&& !S_ISREG(ip
->i_inode
.i_mode
))
159 if (test_bit(GLF_DIRTY
, &gl
->gl_flags
)) {
160 gfs2_log_flush(gl
->gl_sbd
, gl
);
162 filemap_fdatawrite(ip
->i_inode
.i_mapping
);
165 struct address_space
*mapping
= ip
->i_inode
.i_mapping
;
166 int error
= filemap_fdatawait(mapping
);
167 if (error
== -ENOSPC
)
168 set_bit(AS_ENOSPC
, &mapping
->flags
);
170 set_bit(AS_EIO
, &mapping
->flags
);
172 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
173 gfs2_ail_empty_gl(gl
);
178 * inode_go_xmote_th - promote/demote a glock
180 * @state: the requested state
185 static void inode_go_xmote_th(struct gfs2_glock
*gl
)
187 if (gl
->gl_state
!= LM_ST_UNLOCKED
)
189 if (gl
->gl_state
== LM_ST_EXCLUSIVE
)
194 * inode_go_xmote_bh - After promoting/demoting a glock
199 static void inode_go_xmote_bh(struct gfs2_glock
*gl
)
201 struct gfs2_holder
*gh
= gl
->gl_req_gh
;
202 struct buffer_head
*bh
;
205 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
206 (!gh
|| !(gh
->gh_flags
& GL_SKIP
))) {
207 error
= gfs2_meta_read(gl
, gl
->gl_name
.ln_number
, 0, &bh
);
214 * inode_go_drop_th - unlock a glock
217 * Invoked from rq_demote().
218 * Another node needs the lock in EXCLUSIVE mode, or lock (unused for too long)
219 * is being purged from our node's glock cache; we're dropping lock.
222 static void inode_go_drop_th(struct gfs2_glock
*gl
)
225 if (gl
->gl_state
== LM_ST_EXCLUSIVE
)
230 * inode_go_inval - prepare a inode glock to be released
236 static void inode_go_inval(struct gfs2_glock
*gl
, int flags
)
238 struct gfs2_inode
*ip
= gl
->gl_object
;
239 int meta
= (flags
& DIO_METADATA
);
244 set_bit(GIF_INVALID
, &ip
->i_flags
);
247 if (ip
&& S_ISREG(ip
->i_inode
.i_mode
)) {
248 truncate_inode_pages(ip
->i_inode
.i_mapping
, 0);
249 gfs2_assert_withdraw(GFS2_SB(&ip
->i_inode
), !ip
->i_inode
.i_mapping
->nrpages
);
250 clear_bit(GIF_PAGED
, &ip
->i_flags
);
255 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
258 * Returns: 1 if it's ok
261 static int inode_go_demote_ok(struct gfs2_glock
*gl
)
263 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
266 if (!gl
->gl_object
&& !gl
->gl_aspace
->i_mapping
->nrpages
)
268 else if (!sdp
->sd_args
.ar_localcaching
&&
269 time_after_eq(jiffies
, gl
->gl_stamp
+
270 gfs2_tune_get(sdp
, gt_demote_secs
) * HZ
))
277 * inode_go_lock - operation done after an inode lock is locked by a process
284 static int inode_go_lock(struct gfs2_holder
*gh
)
286 struct gfs2_glock
*gl
= gh
->gh_gl
;
287 struct gfs2_inode
*ip
= gl
->gl_object
;
293 if (test_bit(GIF_INVALID
, &ip
->i_flags
)) {
294 error
= gfs2_inode_refresh(ip
);
299 if ((ip
->i_di
.di_flags
& GFS2_DIF_TRUNC_IN_PROG
) &&
300 (gl
->gl_state
== LM_ST_EXCLUSIVE
) &&
301 (gh
->gh_state
== LM_ST_EXCLUSIVE
))
302 error
= gfs2_truncatei_resume(ip
);
308 * inode_go_unlock - operation done before an inode lock is unlocked by a
315 static void inode_go_unlock(struct gfs2_holder
*gh
)
317 struct gfs2_glock
*gl
= gh
->gh_gl
;
318 struct gfs2_inode
*ip
= gl
->gl_object
;
321 gfs2_meta_cache_flush(ip
);
325 * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock
328 * Returns: 1 if it's ok
331 static int rgrp_go_demote_ok(struct gfs2_glock
*gl
)
333 return !gl
->gl_aspace
->i_mapping
->nrpages
;
337 * rgrp_go_lock - operation done after an rgrp lock is locked by
338 * a first holder on this node.
345 static int rgrp_go_lock(struct gfs2_holder
*gh
)
347 return gfs2_rgrp_bh_get(gh
->gh_gl
->gl_object
);
351 * rgrp_go_unlock - operation done before an rgrp lock is unlocked by
352 * a last holder on this node.
358 static void rgrp_go_unlock(struct gfs2_holder
*gh
)
360 gfs2_rgrp_bh_put(gh
->gh_gl
->gl_object
);
364 * trans_go_xmote_th - promote/demote the transaction glock
366 * @state: the requested state
371 static void trans_go_xmote_th(struct gfs2_glock
*gl
)
373 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
375 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
376 test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
377 gfs2_meta_syncfs(sdp
);
378 gfs2_log_shutdown(sdp
);
383 * trans_go_xmote_bh - After promoting/demoting the transaction glock
388 static void trans_go_xmote_bh(struct gfs2_glock
*gl
)
390 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
391 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
392 struct gfs2_glock
*j_gl
= ip
->i_gl
;
393 struct gfs2_log_header_host head
;
396 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
397 test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
398 gfs2_meta_cache_flush(GFS2_I(sdp
->sd_jdesc
->jd_inode
));
399 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
401 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
);
404 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
))
407 /* Initialize some head of the log stuff */
408 if (!test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
)) {
409 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
410 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
416 * trans_go_drop_th - unlock the transaction glock
419 * We want to sync the device even with localcaching. Remember
420 * that localcaching journal replay only marks buffers dirty.
423 static void trans_go_drop_th(struct gfs2_glock
*gl
)
425 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
427 if (test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
428 gfs2_meta_syncfs(sdp
);
429 gfs2_log_shutdown(sdp
);
434 * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
437 * Returns: 1 if it's ok
440 static int quota_go_demote_ok(struct gfs2_glock
*gl
)
442 return !atomic_read(&gl
->gl_lvb_count
);
445 const struct gfs2_glock_operations gfs2_meta_glops
= {
446 .go_xmote_th
= meta_go_sync
,
447 .go_drop_th
= meta_go_sync
,
448 .go_type
= LM_TYPE_META
,
451 const struct gfs2_glock_operations gfs2_inode_glops
= {
452 .go_xmote_th
= inode_go_xmote_th
,
453 .go_xmote_bh
= inode_go_xmote_bh
,
454 .go_drop_th
= inode_go_drop_th
,
455 .go_inval
= inode_go_inval
,
456 .go_demote_ok
= inode_go_demote_ok
,
457 .go_lock
= inode_go_lock
,
458 .go_unlock
= inode_go_unlock
,
459 .go_type
= LM_TYPE_INODE
,
462 const struct gfs2_glock_operations gfs2_rgrp_glops
= {
463 .go_inval
= meta_go_inval
,
464 .go_demote_ok
= rgrp_go_demote_ok
,
465 .go_lock
= rgrp_go_lock
,
466 .go_unlock
= rgrp_go_unlock
,
467 .go_type
= LM_TYPE_RGRP
,
470 const struct gfs2_glock_operations gfs2_trans_glops
= {
471 .go_xmote_th
= trans_go_xmote_th
,
472 .go_xmote_bh
= trans_go_xmote_bh
,
473 .go_drop_th
= trans_go_drop_th
,
474 .go_type
= LM_TYPE_NONDISK
,
477 const struct gfs2_glock_operations gfs2_iopen_glops
= {
478 .go_type
= LM_TYPE_IOPEN
,
481 const struct gfs2_glock_operations gfs2_flock_glops
= {
482 .go_type
= LM_TYPE_FLOCK
,
485 const struct gfs2_glock_operations gfs2_nondisk_glops
= {
486 .go_type
= LM_TYPE_NONDISK
,
489 const struct gfs2_glock_operations gfs2_quota_glops
= {
490 .go_demote_ok
= quota_go_demote_ok
,
491 .go_type
= LM_TYPE_QUOTA
,
494 const struct gfs2_glock_operations gfs2_journal_glops
= {
495 .go_type
= LM_TYPE_JOURNAL
,