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 (test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
)) {
121 gfs2_log_flush(gl
->gl_sbd
, gl
);
123 gfs2_ail_empty_gl(gl
);
129 * meta_go_inval - invalidate the metadata for this glock
135 static void meta_go_inval(struct gfs2_glock
*gl
, int flags
)
137 if (!(flags
& DIO_METADATA
))
145 * inode_go_xmote_th - promote/demote a glock
147 * @state: the requested state
152 static void inode_go_xmote_th(struct gfs2_glock
*gl
, unsigned int state
,
155 if (gl
->gl_state
!= LM_ST_UNLOCKED
)
157 gfs2_glock_xmote_th(gl
, state
, flags
);
161 * inode_go_xmote_bh - After promoting/demoting a glock
166 static void inode_go_xmote_bh(struct gfs2_glock
*gl
)
168 struct gfs2_holder
*gh
= gl
->gl_req_gh
;
169 struct buffer_head
*bh
;
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
);
181 * inode_go_drop_th - unlock a glock
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.
189 static void inode_go_drop_th(struct gfs2_glock
*gl
)
192 gfs2_glock_drop_th(gl
);
196 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
197 * @gl: the glock protecting the inode
201 static void inode_go_sync(struct gfs2_glock
*gl
)
203 struct gfs2_inode
*ip
= gl
->gl_object
;
205 if (ip
&& !S_ISREG(ip
->i_inode
.i_mode
))
208 if (test_bit(GLF_DIRTY
, &gl
->gl_flags
)) {
209 gfs2_log_flush(gl
->gl_sbd
, gl
);
211 filemap_fdatawrite(ip
->i_inode
.i_mapping
);
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
);
219 set_bit(AS_EIO
, &mapping
->flags
);
221 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
222 gfs2_ail_empty_gl(gl
);
227 * inode_go_inval - prepare a inode glock to be released
233 static void inode_go_inval(struct gfs2_glock
*gl
, int flags
)
235 struct gfs2_inode
*ip
= gl
->gl_object
;
236 int meta
= (flags
& DIO_METADATA
);
241 set_bit(GIF_INVALID
, &ip
->i_flags
);
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
);
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_flags
& GL_LOCAL_EXCL
))
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
, unsigned int state
,
371 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
373 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
374 test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
375 gfs2_meta_syncfs(sdp
);
376 gfs2_log_shutdown(sdp
);
379 gfs2_glock_xmote_th(gl
, state
, flags
);
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
);
432 gfs2_glock_drop_th(gl
);
436 * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
439 * Returns: 1 if it's ok
442 static int quota_go_demote_ok(struct gfs2_glock
*gl
)
444 return !atomic_read(&gl
->gl_lvb_count
);
447 const struct gfs2_glock_operations gfs2_meta_glops
= {
448 .go_xmote_th
= gfs2_glock_xmote_th
,
449 .go_drop_th
= gfs2_glock_drop_th
,
450 .go_type
= LM_TYPE_META
,
453 const struct gfs2_glock_operations gfs2_inode_glops
= {
454 .go_xmote_th
= inode_go_xmote_th
,
455 .go_xmote_bh
= inode_go_xmote_bh
,
456 .go_drop_th
= inode_go_drop_th
,
457 .go_sync
= inode_go_sync
,
458 .go_inval
= inode_go_inval
,
459 .go_demote_ok
= inode_go_demote_ok
,
460 .go_lock
= inode_go_lock
,
461 .go_unlock
= inode_go_unlock
,
462 .go_type
= LM_TYPE_INODE
,
465 const struct gfs2_glock_operations gfs2_rgrp_glops
= {
466 .go_xmote_th
= gfs2_glock_xmote_th
,
467 .go_drop_th
= gfs2_glock_drop_th
,
468 .go_sync
= meta_go_sync
,
469 .go_inval
= meta_go_inval
,
470 .go_demote_ok
= rgrp_go_demote_ok
,
471 .go_lock
= rgrp_go_lock
,
472 .go_unlock
= rgrp_go_unlock
,
473 .go_type
= LM_TYPE_RGRP
,
476 const struct gfs2_glock_operations gfs2_trans_glops
= {
477 .go_xmote_th
= trans_go_xmote_th
,
478 .go_xmote_bh
= trans_go_xmote_bh
,
479 .go_drop_th
= trans_go_drop_th
,
480 .go_type
= LM_TYPE_NONDISK
,
483 const struct gfs2_glock_operations gfs2_iopen_glops
= {
484 .go_xmote_th
= gfs2_glock_xmote_th
,
485 .go_drop_th
= gfs2_glock_drop_th
,
486 .go_type
= LM_TYPE_IOPEN
,
489 const struct gfs2_glock_operations gfs2_flock_glops
= {
490 .go_xmote_th
= gfs2_glock_xmote_th
,
491 .go_drop_th
= gfs2_glock_drop_th
,
492 .go_type
= LM_TYPE_FLOCK
,
495 const struct gfs2_glock_operations gfs2_nondisk_glops
= {
496 .go_xmote_th
= gfs2_glock_xmote_th
,
497 .go_drop_th
= gfs2_glock_drop_th
,
498 .go_type
= LM_TYPE_NONDISK
,
501 const struct gfs2_glock_operations gfs2_quota_glops
= {
502 .go_xmote_th
= gfs2_glock_xmote_th
,
503 .go_drop_th
= gfs2_glock_drop_th
,
504 .go_demote_ok
= quota_go_demote_ok
,
505 .go_type
= LM_TYPE_QUOTA
,
508 const struct gfs2_glock_operations gfs2_journal_glops
= {
509 .go_xmote_th
= gfs2_glock_xmote_th
,
510 .go_drop_th
= gfs2_glock_drop_th
,
511 .go_type
= LM_TYPE_JOURNAL
,