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 * gfs2_page_inval - Invalidate all pages associated with a glock
115 static void gfs2_page_inval(struct gfs2_glock
*gl
)
117 struct gfs2_inode
*ip
;
121 inode
= &ip
->i_inode
;
122 if (!ip
|| !S_ISREG(inode
->i_mode
))
125 truncate_inode_pages(inode
->i_mapping
, 0);
126 gfs2_assert_withdraw(GFS2_SB(&ip
->i_inode
), !inode
->i_mapping
->nrpages
);
127 clear_bit(GIF_PAGED
, &ip
->i_flags
);
131 * gfs2_page_wait - Wait for writeback of data
134 * Syncs data (not metadata) for a regular file.
135 * No-op for all other types.
138 static void gfs2_page_wait(struct gfs2_glock
*gl
)
140 struct gfs2_inode
*ip
= gl
->gl_object
;
141 struct inode
*inode
= &ip
->i_inode
;
142 struct address_space
*mapping
= inode
->i_mapping
;
145 if (!S_ISREG(inode
->i_mode
))
148 error
= filemap_fdatawait(mapping
);
150 /* Put back any errors cleared by filemap_fdatawait()
151 so they can be caught by someone who can pass them
154 if (error
== -ENOSPC
)
155 set_bit(AS_ENOSPC
, &mapping
->flags
);
157 set_bit(AS_EIO
, &mapping
->flags
);
161 static void gfs2_page_writeback(struct gfs2_glock
*gl
)
163 struct gfs2_inode
*ip
= gl
->gl_object
;
164 struct inode
*inode
= &ip
->i_inode
;
165 struct address_space
*mapping
= inode
->i_mapping
;
167 if (!S_ISREG(inode
->i_mode
))
170 filemap_fdatawrite(mapping
);
174 * meta_go_sync - sync out the metadata for this glock
178 * Called when demoting or unlocking an EX glock. We must flush
179 * to disk all dirty buffers/pages relating to this glock, and must not
180 * not return to caller to demote/unlock the glock until I/O is complete.
183 static void meta_go_sync(struct gfs2_glock
*gl
, int flags
)
185 if (!(flags
& DIO_METADATA
))
188 if (test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
)) {
189 gfs2_log_flush(gl
->gl_sbd
, gl
);
191 if (flags
& DIO_RELEASE
)
192 gfs2_ail_empty_gl(gl
);
198 * meta_go_inval - invalidate the metadata for this glock
204 static void meta_go_inval(struct gfs2_glock
*gl
, int flags
)
206 if (!(flags
& DIO_METADATA
))
214 * inode_go_xmote_th - promote/demote a glock
216 * @state: the requested state
221 static void inode_go_xmote_th(struct gfs2_glock
*gl
, unsigned int state
,
224 if (gl
->gl_state
!= LM_ST_UNLOCKED
)
226 gfs2_glock_xmote_th(gl
, state
, flags
);
230 * inode_go_xmote_bh - After promoting/demoting a glock
235 static void inode_go_xmote_bh(struct gfs2_glock
*gl
)
237 struct gfs2_holder
*gh
= gl
->gl_req_gh
;
238 struct buffer_head
*bh
;
241 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
242 (!gh
|| !(gh
->gh_flags
& GL_SKIP
))) {
243 error
= gfs2_meta_read(gl
, gl
->gl_name
.ln_number
, 0, &bh
);
250 * inode_go_drop_th - unlock a glock
253 * Invoked from rq_demote().
254 * Another node needs the lock in EXCLUSIVE mode, or lock (unused for too long)
255 * is being purged from our node's glock cache; we're dropping lock.
258 static void inode_go_drop_th(struct gfs2_glock
*gl
)
261 gfs2_glock_drop_th(gl
);
265 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
266 * @gl: the glock protecting the inode
271 static void inode_go_sync(struct gfs2_glock
*gl
, int flags
)
273 int meta
= (flags
& DIO_METADATA
);
274 int data
= (flags
& DIO_DATA
);
276 if (test_bit(GLF_DIRTY
, &gl
->gl_flags
)) {
278 gfs2_page_writeback(gl
);
279 gfs2_log_flush(gl
->gl_sbd
, gl
);
282 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
284 gfs2_log_flush(gl
->gl_sbd
, gl
);
287 gfs2_page_writeback(gl
);
290 if (flags
& DIO_RELEASE
)
291 gfs2_ail_empty_gl(gl
);
296 * inode_go_inval - prepare a inode glock to be released
302 static void inode_go_inval(struct gfs2_glock
*gl
, int flags
)
304 int meta
= (flags
& DIO_METADATA
);
305 int data
= (flags
& DIO_DATA
);
308 struct gfs2_inode
*ip
= gl
->gl_object
;
310 set_bit(GIF_INVALID
, &ip
->i_flags
);
317 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
320 * Returns: 1 if it's ok
323 static int inode_go_demote_ok(struct gfs2_glock
*gl
)
325 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
328 if (!gl
->gl_object
&& !gl
->gl_aspace
->i_mapping
->nrpages
)
330 else if (!sdp
->sd_args
.ar_localcaching
&&
331 time_after_eq(jiffies
, gl
->gl_stamp
+
332 gfs2_tune_get(sdp
, gt_demote_secs
) * HZ
))
339 * inode_go_lock - operation done after an inode lock is locked by a process
346 static int inode_go_lock(struct gfs2_holder
*gh
)
348 struct gfs2_glock
*gl
= gh
->gh_gl
;
349 struct gfs2_inode
*ip
= gl
->gl_object
;
355 if (test_bit(GIF_INVALID
, &ip
->i_flags
)) {
356 error
= gfs2_inode_refresh(ip
);
359 gfs2_inode_attr_in(ip
);
362 if ((ip
->i_di
.di_flags
& GFS2_DIF_TRUNC_IN_PROG
) &&
363 (gl
->gl_state
== LM_ST_EXCLUSIVE
) &&
364 (gh
->gh_flags
& GL_LOCAL_EXCL
))
365 error
= gfs2_truncatei_resume(ip
);
371 * inode_go_unlock - operation done before an inode lock is unlocked by a
378 static void inode_go_unlock(struct gfs2_holder
*gh
)
380 struct gfs2_glock
*gl
= gh
->gh_gl
;
381 struct gfs2_inode
*ip
= gl
->gl_object
;
385 if (test_bit(GLF_DIRTY
, &gl
->gl_flags
))
386 gfs2_inode_attr_in(ip
);
387 gfs2_meta_cache_flush(ip
);
396 static void inode_greedy(struct gfs2_glock
*gl
)
398 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
399 struct gfs2_inode
*ip
= gl
->gl_object
;
400 unsigned int quantum
= gfs2_tune_get(sdp
, gt_greedy_quantum
);
401 unsigned int max
= gfs2_tune_get(sdp
, gt_greedy_max
);
402 unsigned int new_time
;
404 spin_lock(&ip
->i_spin
);
406 if (time_after(ip
->i_last_pfault
+ quantum
, jiffies
)) {
407 new_time
= ip
->i_greedy
+ quantum
;
411 new_time
= ip
->i_greedy
- quantum
;
412 if (!new_time
|| new_time
> max
)
416 ip
->i_greedy
= new_time
;
418 spin_unlock(&ip
->i_spin
);
424 * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock
427 * Returns: 1 if it's ok
430 static int rgrp_go_demote_ok(struct gfs2_glock
*gl
)
432 return !gl
->gl_aspace
->i_mapping
->nrpages
;
436 * rgrp_go_lock - operation done after an rgrp lock is locked by
437 * a first holder on this node.
444 static int rgrp_go_lock(struct gfs2_holder
*gh
)
446 return gfs2_rgrp_bh_get(gh
->gh_gl
->gl_object
);
450 * rgrp_go_unlock - operation done before an rgrp lock is unlocked by
451 * a last holder on this node.
457 static void rgrp_go_unlock(struct gfs2_holder
*gh
)
459 gfs2_rgrp_bh_put(gh
->gh_gl
->gl_object
);
463 * trans_go_xmote_th - promote/demote the transaction glock
465 * @state: the requested state
470 static void trans_go_xmote_th(struct gfs2_glock
*gl
, unsigned int state
,
473 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
475 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
476 test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
477 gfs2_meta_syncfs(sdp
);
478 gfs2_log_shutdown(sdp
);
481 gfs2_glock_xmote_th(gl
, state
, flags
);
485 * trans_go_xmote_bh - After promoting/demoting the transaction glock
490 static void trans_go_xmote_bh(struct gfs2_glock
*gl
)
492 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
493 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
494 struct gfs2_glock
*j_gl
= ip
->i_gl
;
495 struct gfs2_log_header_host head
;
498 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
499 test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
500 gfs2_meta_cache_flush(GFS2_I(sdp
->sd_jdesc
->jd_inode
));
501 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
| DIO_DATA
);
503 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
);
506 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
))
509 /* Initialize some head of the log stuff */
510 if (!test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
)) {
511 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
512 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
518 * trans_go_drop_th - unlock the transaction glock
521 * We want to sync the device even with localcaching. Remember
522 * that localcaching journal replay only marks buffers dirty.
525 static void trans_go_drop_th(struct gfs2_glock
*gl
)
527 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
529 if (test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
530 gfs2_meta_syncfs(sdp
);
531 gfs2_log_shutdown(sdp
);
534 gfs2_glock_drop_th(gl
);
538 * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
541 * Returns: 1 if it's ok
544 static int quota_go_demote_ok(struct gfs2_glock
*gl
)
546 return !atomic_read(&gl
->gl_lvb_count
);
549 const struct gfs2_glock_operations gfs2_meta_glops
= {
550 .go_xmote_th
= gfs2_glock_xmote_th
,
551 .go_drop_th
= gfs2_glock_drop_th
,
552 .go_type
= LM_TYPE_META
,
555 const struct gfs2_glock_operations gfs2_inode_glops
= {
556 .go_xmote_th
= inode_go_xmote_th
,
557 .go_xmote_bh
= inode_go_xmote_bh
,
558 .go_drop_th
= inode_go_drop_th
,
559 .go_sync
= inode_go_sync
,
560 .go_inval
= inode_go_inval
,
561 .go_demote_ok
= inode_go_demote_ok
,
562 .go_lock
= inode_go_lock
,
563 .go_unlock
= inode_go_unlock
,
564 .go_greedy
= inode_greedy
,
565 .go_type
= LM_TYPE_INODE
,
568 const struct gfs2_glock_operations gfs2_rgrp_glops
= {
569 .go_xmote_th
= gfs2_glock_xmote_th
,
570 .go_drop_th
= gfs2_glock_drop_th
,
571 .go_sync
= meta_go_sync
,
572 .go_inval
= meta_go_inval
,
573 .go_demote_ok
= rgrp_go_demote_ok
,
574 .go_lock
= rgrp_go_lock
,
575 .go_unlock
= rgrp_go_unlock
,
576 .go_type
= LM_TYPE_RGRP
,
579 const struct gfs2_glock_operations gfs2_trans_glops
= {
580 .go_xmote_th
= trans_go_xmote_th
,
581 .go_xmote_bh
= trans_go_xmote_bh
,
582 .go_drop_th
= trans_go_drop_th
,
583 .go_type
= LM_TYPE_NONDISK
,
586 const struct gfs2_glock_operations gfs2_iopen_glops
= {
587 .go_xmote_th
= gfs2_glock_xmote_th
,
588 .go_drop_th
= gfs2_glock_drop_th
,
589 .go_type
= LM_TYPE_IOPEN
,
592 const struct gfs2_glock_operations gfs2_flock_glops
= {
593 .go_xmote_th
= gfs2_glock_xmote_th
,
594 .go_drop_th
= gfs2_glock_drop_th
,
595 .go_type
= LM_TYPE_FLOCK
,
598 const struct gfs2_glock_operations gfs2_nondisk_glops
= {
599 .go_xmote_th
= gfs2_glock_xmote_th
,
600 .go_drop_th
= gfs2_glock_drop_th
,
601 .go_type
= LM_TYPE_NONDISK
,
604 const struct gfs2_glock_operations gfs2_quota_glops
= {
605 .go_xmote_th
= gfs2_glock_xmote_th
,
606 .go_drop_th
= gfs2_glock_drop_th
,
607 .go_demote_ok
= quota_go_demote_ok
,
608 .go_type
= LM_TYPE_QUOTA
,
611 const struct gfs2_glock_operations gfs2_journal_glops
= {
612 .go_xmote_th
= gfs2_glock_xmote_th
,
613 .go_drop_th
= gfs2_glock_drop_th
,
614 .go_type
= LM_TYPE_JOURNAL
,