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/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #include <linux/buffer_head.h>
14 #include <linux/gfs2_ondisk.h>
15 #include <linux/lm_interface.h>
31 * ail_empty_gl - remove all buffers for a given lock from the AIL
34 * None of the buffers should be dirty, locked, or pinned.
37 static void gfs2_ail_empty_gl(struct gfs2_glock
*gl
)
39 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
41 struct list_head
*head
= &gl
->gl_ail_list
;
42 struct gfs2_bufdata
*bd
;
43 struct buffer_head
*bh
;
47 blocks
= atomic_read(&gl
->gl_ail_count
);
51 error
= gfs2_trans_begin(sdp
, 0, blocks
);
52 if (gfs2_assert_withdraw(sdp
, !error
))
56 while (!list_empty(head
)) {
57 bd
= list_entry(head
->next
, struct gfs2_bufdata
,
60 blkno
= bh
->b_blocknr
;
61 gfs2_assert_withdraw(sdp
, !buffer_busy(bh
));
64 list_del(&bd
->bd_ail_st_list
);
65 list_del(&bd
->bd_ail_gl_list
);
66 atomic_dec(&gl
->gl_ail_count
);
70 gfs2_trans_add_revoke(sdp
, blkno
);
74 gfs2_assert_withdraw(sdp
, !atomic_read(&gl
->gl_ail_count
));
78 gfs2_log_flush(sdp
, NULL
);
82 * gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock
87 static void gfs2_pte_inval(struct gfs2_glock
*gl
)
89 struct gfs2_inode
*ip
;
94 if (!ip
|| !S_ISREG(inode
->i_mode
))
97 if (!test_bit(GIF_PAGED
, &ip
->i_flags
))
100 unmap_shared_mapping_range(inode
->i_mapping
, 0, 0);
102 if (test_bit(GIF_SW_PAGED
, &ip
->i_flags
))
103 set_bit(GLF_DIRTY
, &gl
->gl_flags
);
105 clear_bit(GIF_SW_PAGED
, &ip
->i_flags
);
109 * meta_go_sync - sync out the metadata for this glock
112 * Called when demoting or unlocking an EX glock. We must flush
113 * to disk all dirty buffers/pages relating to this glock, and must not
114 * not return to caller to demote/unlock the glock until I/O is complete.
117 static void meta_go_sync(struct gfs2_glock
*gl
)
119 if (gl
->gl_state
!= LM_ST_EXCLUSIVE
)
122 if (test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
)) {
123 gfs2_log_flush(gl
->gl_sbd
, gl
);
125 gfs2_ail_empty_gl(gl
);
130 * meta_go_inval - invalidate the metadata for this glock
136 static void meta_go_inval(struct gfs2_glock
*gl
, int flags
)
138 if (!(flags
& DIO_METADATA
))
146 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
147 * @gl: the glock protecting the inode
151 static void inode_go_sync(struct gfs2_glock
*gl
)
153 struct gfs2_inode
*ip
= gl
->gl_object
;
155 if (ip
&& !S_ISREG(ip
->i_inode
.i_mode
))
158 if (test_bit(GLF_DIRTY
, &gl
->gl_flags
)) {
159 if (ip
&& !gfs2_is_jdata(ip
))
160 filemap_fdatawrite(ip
->i_inode
.i_mapping
);
161 gfs2_log_flush(gl
->gl_sbd
, gl
);
162 if (ip
&& gfs2_is_jdata(ip
))
163 filemap_fdatawrite(ip
->i_inode
.i_mapping
);
166 struct address_space
*mapping
= ip
->i_inode
.i_mapping
;
167 int error
= filemap_fdatawait(mapping
);
168 mapping_set_error(mapping
, error
);
170 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
171 gfs2_ail_empty_gl(gl
);
176 * inode_go_xmote_th - promote/demote a glock
178 * @state: the requested state
183 static void inode_go_xmote_th(struct gfs2_glock
*gl
)
185 if (gl
->gl_state
!= LM_ST_UNLOCKED
)
187 if (gl
->gl_state
== LM_ST_EXCLUSIVE
)
192 * inode_go_xmote_bh - After promoting/demoting a glock
197 static void inode_go_xmote_bh(struct gfs2_glock
*gl
)
199 struct gfs2_holder
*gh
= gl
->gl_req_gh
;
200 struct buffer_head
*bh
;
203 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
204 (!gh
|| !(gh
->gh_flags
& GL_SKIP
))) {
205 error
= gfs2_meta_read(gl
, gl
->gl_name
.ln_number
, 0, &bh
);
212 * inode_go_drop_th - unlock a glock
215 * Invoked from rq_demote().
216 * Another node needs the lock in EXCLUSIVE mode, or lock (unused for too long)
217 * is being purged from our node's glock cache; we're dropping lock.
220 static void inode_go_drop_th(struct gfs2_glock
*gl
)
223 if (gl
->gl_state
== LM_ST_EXCLUSIVE
)
228 * inode_go_inval - prepare a inode glock to be released
234 static void inode_go_inval(struct gfs2_glock
*gl
, int flags
)
236 struct gfs2_inode
*ip
= gl
->gl_object
;
237 int meta
= (flags
& DIO_METADATA
);
242 set_bit(GIF_INVALID
, &ip
->i_flags
);
245 if (ip
&& S_ISREG(ip
->i_inode
.i_mode
)) {
246 truncate_inode_pages(ip
->i_inode
.i_mapping
, 0);
247 clear_bit(GIF_PAGED
, &ip
->i_flags
);
252 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
255 * Returns: 1 if it's ok
258 static int inode_go_demote_ok(struct gfs2_glock
*gl
)
260 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
263 if (!gl
->gl_object
&& !gl
->gl_aspace
->i_mapping
->nrpages
)
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
))
274 * inode_go_lock - operation done after an inode lock is locked by a process
281 static int inode_go_lock(struct gfs2_holder
*gh
)
283 struct gfs2_glock
*gl
= gh
->gh_gl
;
284 struct gfs2_inode
*ip
= gl
->gl_object
;
290 if (test_bit(GIF_INVALID
, &ip
->i_flags
)) {
291 error
= gfs2_inode_refresh(ip
);
296 if ((ip
->i_di
.di_flags
& GFS2_DIF_TRUNC_IN_PROG
) &&
297 (gl
->gl_state
== LM_ST_EXCLUSIVE
) &&
298 (gh
->gh_state
== LM_ST_EXCLUSIVE
))
299 error
= gfs2_truncatei_resume(ip
);
305 * inode_go_unlock - operation done before an inode lock is unlocked by a
312 static void inode_go_unlock(struct gfs2_holder
*gh
)
314 struct gfs2_glock
*gl
= gh
->gh_gl
;
315 struct gfs2_inode
*ip
= gl
->gl_object
;
318 gfs2_meta_cache_flush(ip
);
322 * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock
325 * Returns: 1 if it's ok
328 static int rgrp_go_demote_ok(struct gfs2_glock
*gl
)
330 return !gl
->gl_aspace
->i_mapping
->nrpages
;
334 * rgrp_go_lock - operation done after an rgrp lock is locked by
335 * a first holder on this node.
342 static int rgrp_go_lock(struct gfs2_holder
*gh
)
344 return gfs2_rgrp_bh_get(gh
->gh_gl
->gl_object
);
348 * rgrp_go_unlock - operation done before an rgrp lock is unlocked by
349 * a last holder on this node.
355 static void rgrp_go_unlock(struct gfs2_holder
*gh
)
357 gfs2_rgrp_bh_put(gh
->gh_gl
->gl_object
);
361 * trans_go_xmote_th - promote/demote the transaction glock
363 * @state: the requested state
368 static void trans_go_xmote_th(struct gfs2_glock
*gl
)
370 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
372 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
373 test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
374 gfs2_meta_syncfs(sdp
);
375 gfs2_log_shutdown(sdp
);
380 * trans_go_xmote_bh - After promoting/demoting the transaction glock
385 static void trans_go_xmote_bh(struct gfs2_glock
*gl
)
387 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
388 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
389 struct gfs2_glock
*j_gl
= ip
->i_gl
;
390 struct gfs2_log_header_host head
;
393 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
394 test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
395 gfs2_meta_cache_flush(GFS2_I(sdp
->sd_jdesc
->jd_inode
));
396 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
398 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
);
401 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
))
404 /* Initialize some head of the log stuff */
405 if (!test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
)) {
406 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
407 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
413 * trans_go_drop_th - unlock the transaction glock
416 * We want to sync the device even with localcaching. Remember
417 * that localcaching journal replay only marks buffers dirty.
420 static void trans_go_drop_th(struct gfs2_glock
*gl
)
422 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
424 if (test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
425 gfs2_meta_syncfs(sdp
);
426 gfs2_log_shutdown(sdp
);
431 * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
434 * Returns: 1 if it's ok
437 static int quota_go_demote_ok(struct gfs2_glock
*gl
)
439 return !atomic_read(&gl
->gl_lvb_count
);
442 const struct gfs2_glock_operations gfs2_meta_glops
= {
443 .go_xmote_th
= meta_go_sync
,
444 .go_drop_th
= meta_go_sync
,
445 .go_type
= LM_TYPE_META
,
448 const struct gfs2_glock_operations gfs2_inode_glops
= {
449 .go_xmote_th
= inode_go_xmote_th
,
450 .go_xmote_bh
= inode_go_xmote_bh
,
451 .go_drop_th
= inode_go_drop_th
,
452 .go_inval
= inode_go_inval
,
453 .go_demote_ok
= inode_go_demote_ok
,
454 .go_lock
= inode_go_lock
,
455 .go_unlock
= inode_go_unlock
,
456 .go_type
= LM_TYPE_INODE
,
457 .go_min_hold_time
= HZ
/ 10,
460 const struct gfs2_glock_operations gfs2_rgrp_glops
= {
461 .go_xmote_th
= meta_go_sync
,
462 .go_drop_th
= meta_go_sync
,
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
,
468 .go_min_hold_time
= HZ
/ 10,
471 const struct gfs2_glock_operations gfs2_trans_glops
= {
472 .go_xmote_th
= trans_go_xmote_th
,
473 .go_xmote_bh
= trans_go_xmote_bh
,
474 .go_drop_th
= trans_go_drop_th
,
475 .go_type
= LM_TYPE_NONDISK
,
478 const struct gfs2_glock_operations gfs2_iopen_glops
= {
479 .go_type
= LM_TYPE_IOPEN
,
482 const struct gfs2_glock_operations gfs2_flock_glops
= {
483 .go_type
= LM_TYPE_FLOCK
,
486 const struct gfs2_glock_operations gfs2_nondisk_glops
= {
487 .go_type
= LM_TYPE_NONDISK
,
490 const struct gfs2_glock_operations gfs2_quota_glops
= {
491 .go_demote_ok
= quota_go_demote_ok
,
492 .go_type
= LM_TYPE_QUOTA
,
495 const struct gfs2_glock_operations gfs2_journal_glops
= {
496 .go_type
= LM_TYPE_JOURNAL
,