2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2008 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/spinlock.h>
11 #include <linux/completion.h>
12 #include <linux/buffer_head.h>
13 #include <linux/gfs2_ondisk.h>
14 #include <linux/bio.h>
15 #include <linux/posix_acl.h>
31 static void gfs2_ail_error(struct gfs2_glock
*gl
, const struct buffer_head
*bh
)
33 fs_err(gl
->gl_sbd
, "AIL buffer %p: blocknr %llu state 0x%08lx mapping %p page state 0x%lx\n",
34 bh
, (unsigned long long)bh
->b_blocknr
, bh
->b_state
,
35 bh
->b_page
->mapping
, bh
->b_page
->flags
);
36 fs_err(gl
->gl_sbd
, "AIL glock %u:%llu mapping %p\n",
37 gl
->gl_name
.ln_type
, gl
->gl_name
.ln_number
,
38 gfs2_glock2aspace(gl
));
39 gfs2_lm_withdraw(gl
->gl_sbd
, "AIL error\n");
43 * __gfs2_ail_flush - remove all buffers for a given lock from the AIL
46 * None of the buffers should be dirty, locked, or pinned.
49 static void __gfs2_ail_flush(struct gfs2_glock
*gl
, unsigned long b_state
)
51 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
52 struct list_head
*head
= &gl
->gl_ail_list
;
53 struct gfs2_bufdata
*bd
;
54 struct buffer_head
*bh
;
57 spin_lock(&sdp
->sd_ail_lock
);
58 while (!list_empty(head
)) {
59 bd
= list_entry(head
->next
, struct gfs2_bufdata
,
62 blocknr
= bh
->b_blocknr
;
63 if (bh
->b_state
& b_state
)
64 gfs2_ail_error(gl
, bh
);
66 gfs2_remove_from_ail(bd
); /* drops ref on bh */
67 spin_unlock(&sdp
->sd_ail_lock
);
70 bd
->bd_blkno
= blocknr
;
73 gfs2_trans_add_revoke(sdp
, bd
);
76 spin_lock(&sdp
->sd_ail_lock
);
78 gfs2_assert_withdraw(sdp
, !atomic_read(&gl
->gl_ail_count
));
79 spin_unlock(&sdp
->sd_ail_lock
);
83 static void gfs2_ail_empty_gl(struct gfs2_glock
*gl
)
85 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
88 memset(&tr
, 0, sizeof(tr
));
89 tr
.tr_revokes
= atomic_read(&gl
->gl_ail_count
);
94 /* A shortened, inline version of gfs2_trans_begin() */
95 tr
.tr_reserved
= 1 + gfs2_struct2blk(sdp
, tr
.tr_revokes
, sizeof(u64
));
96 tr
.tr_ip
= (unsigned long)__builtin_return_address(0);
97 INIT_LIST_HEAD(&tr
.tr_list_buf
);
98 gfs2_log_reserve(sdp
, tr
.tr_reserved
);
99 BUG_ON(current
->journal_info
);
100 current
->journal_info
= &tr
;
102 __gfs2_ail_flush(gl
, (1ul << BH_Dirty
)|(1ul << BH_Pinned
)|(1ul << BH_Lock
));
105 gfs2_log_flush(sdp
, NULL
);
108 void gfs2_ail_flush(struct gfs2_glock
*gl
)
110 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
111 unsigned int revokes
= atomic_read(&gl
->gl_ail_count
);
117 ret
= gfs2_trans_begin(sdp
, 0, revokes
);
120 __gfs2_ail_flush(gl
, (1ul << BH_Dirty
)|(1ul << BH_Pinned
));
122 gfs2_log_flush(sdp
, NULL
);
126 * rgrp_go_sync - sync out the metadata for this glock
129 * Called when demoting or unlocking an EX glock. We must flush
130 * to disk all dirty buffers/pages relating to this glock, and must not
131 * not return to caller to demote/unlock the glock until I/O is complete.
134 static void rgrp_go_sync(struct gfs2_glock
*gl
)
136 struct address_space
*metamapping
= gfs2_glock2aspace(gl
);
137 struct gfs2_rgrpd
*rgd
= gl
->gl_object
;
141 if (!test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
))
143 BUG_ON(gl
->gl_state
!= LM_ST_EXCLUSIVE
);
145 gfs2_log_flush(gl
->gl_sbd
, gl
);
146 filemap_fdatawrite(metamapping
);
147 error
= filemap_fdatawait(metamapping
);
148 mapping_set_error(metamapping
, error
);
149 gfs2_ail_empty_gl(gl
);
154 for (x
= 0; x
< rgd
->rd_length
; x
++) {
155 struct gfs2_bitmap
*bi
= rgd
->rd_bits
+ x
;
162 * rgrp_go_inval - invalidate the metadata for this glock
166 * We never used LM_ST_DEFERRED with resource groups, so that we
167 * should always see the metadata flag set here.
171 static void rgrp_go_inval(struct gfs2_glock
*gl
, int flags
)
173 struct address_space
*mapping
= gfs2_glock2aspace(gl
);
175 BUG_ON(!(flags
& DIO_METADATA
));
176 gfs2_assert_withdraw(gl
->gl_sbd
, !atomic_read(&gl
->gl_ail_count
));
177 truncate_inode_pages(mapping
, 0);
180 struct gfs2_rgrpd
*rgd
= (struct gfs2_rgrpd
*)gl
->gl_object
;
181 rgd
->rd_flags
&= ~GFS2_RDF_UPTODATE
;
186 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
187 * @gl: the glock protecting the inode
191 static void inode_go_sync(struct gfs2_glock
*gl
)
193 struct gfs2_inode
*ip
= gl
->gl_object
;
194 struct address_space
*metamapping
= gfs2_glock2aspace(gl
);
197 if (ip
&& !S_ISREG(ip
->i_inode
.i_mode
))
199 if (ip
&& test_and_clear_bit(GIF_SW_PAGED
, &ip
->i_flags
))
200 unmap_shared_mapping_range(ip
->i_inode
.i_mapping
, 0, 0);
201 if (!test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
))
204 BUG_ON(gl
->gl_state
!= LM_ST_EXCLUSIVE
);
206 gfs2_log_flush(gl
->gl_sbd
, gl
);
207 filemap_fdatawrite(metamapping
);
209 struct address_space
*mapping
= ip
->i_inode
.i_mapping
;
210 filemap_fdatawrite(mapping
);
211 error
= filemap_fdatawait(mapping
);
212 mapping_set_error(mapping
, error
);
214 error
= filemap_fdatawait(metamapping
);
215 mapping_set_error(metamapping
, error
);
216 gfs2_ail_empty_gl(gl
);
218 * Writeback of the data mapping may cause the dirty flag to be set
219 * so we have to clear it again here.
221 smp_mb__before_clear_bit();
222 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
226 * inode_go_inval - prepare a inode glock to be released
230 * Normally we invlidate everything, but if we are moving into
231 * LM_ST_DEFERRED from LM_ST_SHARED or LM_ST_EXCLUSIVE then we
232 * can keep hold of the metadata, since it won't have changed.
236 static void inode_go_inval(struct gfs2_glock
*gl
, int flags
)
238 struct gfs2_inode
*ip
= gl
->gl_object
;
240 gfs2_assert_withdraw(gl
->gl_sbd
, !atomic_read(&gl
->gl_ail_count
));
242 if (flags
& DIO_METADATA
) {
243 struct address_space
*mapping
= gfs2_glock2aspace(gl
);
244 truncate_inode_pages(mapping
, 0);
246 set_bit(GIF_INVALID
, &ip
->i_flags
);
247 forget_all_cached_acls(&ip
->i_inode
);
248 gfs2_dir_hash_inval(ip
);
252 if (ip
== GFS2_I(gl
->gl_sbd
->sd_rindex
)) {
253 gfs2_log_flush(gl
->gl_sbd
, NULL
);
254 gl
->gl_sbd
->sd_rindex_uptodate
= 0;
256 if (ip
&& S_ISREG(ip
->i_inode
.i_mode
))
257 truncate_inode_pages(ip
->i_inode
.i_mapping
, 0);
261 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
264 * Returns: 1 if it's ok
267 static int inode_go_demote_ok(const struct gfs2_glock
*gl
)
269 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
270 struct gfs2_holder
*gh
;
272 if (sdp
->sd_jindex
== gl
->gl_object
|| sdp
->sd_rindex
== gl
->gl_object
)
275 if (!list_empty(&gl
->gl_holders
)) {
276 gh
= list_entry(gl
->gl_holders
.next
, struct gfs2_holder
, gh_list
);
277 if (gh
->gh_list
.next
!= &gl
->gl_holders
)
285 * gfs2_set_nlink - Set the inode's link count based on on-disk info
286 * @inode: The inode in question
287 * @nlink: The link count
289 * If the link count has hit zero, it must never be raised, whatever the
290 * on-disk inode might say. When new struct inodes are created the link
291 * count is set to 1, so that we can safely use this test even when reading
292 * in on disk information for the first time.
295 static void gfs2_set_nlink(struct inode
*inode
, u32 nlink
)
298 * We will need to review setting the nlink count here in the
299 * light of the forthcoming ro bind mount work. This is a reminder
302 if ((inode
->i_nlink
!= nlink
) && (inode
->i_nlink
!= 0)) {
306 inode
->i_nlink
= nlink
;
310 static int gfs2_dinode_in(struct gfs2_inode
*ip
, const void *buf
)
312 const struct gfs2_dinode
*str
= buf
;
313 struct timespec atime
;
316 if (unlikely(ip
->i_no_addr
!= be64_to_cpu(str
->di_num
.no_addr
)))
318 ip
->i_no_formal_ino
= be64_to_cpu(str
->di_num
.no_formal_ino
);
319 ip
->i_inode
.i_mode
= be32_to_cpu(str
->di_mode
);
320 ip
->i_inode
.i_rdev
= 0;
321 switch (ip
->i_inode
.i_mode
& S_IFMT
) {
324 ip
->i_inode
.i_rdev
= MKDEV(be32_to_cpu(str
->di_major
),
325 be32_to_cpu(str
->di_minor
));
329 ip
->i_inode
.i_uid
= be32_to_cpu(str
->di_uid
);
330 ip
->i_inode
.i_gid
= be32_to_cpu(str
->di_gid
);
331 gfs2_set_nlink(&ip
->i_inode
, be32_to_cpu(str
->di_nlink
));
332 i_size_write(&ip
->i_inode
, be64_to_cpu(str
->di_size
));
333 gfs2_set_inode_blocks(&ip
->i_inode
, be64_to_cpu(str
->di_blocks
));
334 atime
.tv_sec
= be64_to_cpu(str
->di_atime
);
335 atime
.tv_nsec
= be32_to_cpu(str
->di_atime_nsec
);
336 if (timespec_compare(&ip
->i_inode
.i_atime
, &atime
) < 0)
337 ip
->i_inode
.i_atime
= atime
;
338 ip
->i_inode
.i_mtime
.tv_sec
= be64_to_cpu(str
->di_mtime
);
339 ip
->i_inode
.i_mtime
.tv_nsec
= be32_to_cpu(str
->di_mtime_nsec
);
340 ip
->i_inode
.i_ctime
.tv_sec
= be64_to_cpu(str
->di_ctime
);
341 ip
->i_inode
.i_ctime
.tv_nsec
= be32_to_cpu(str
->di_ctime_nsec
);
343 ip
->i_goal
= be64_to_cpu(str
->di_goal_meta
);
344 ip
->i_generation
= be64_to_cpu(str
->di_generation
);
346 ip
->i_diskflags
= be32_to_cpu(str
->di_flags
);
347 ip
->i_eattr
= be64_to_cpu(str
->di_eattr
);
348 /* i_diskflags and i_eattr must be set before gfs2_set_inode_flags() */
349 gfs2_set_inode_flags(&ip
->i_inode
);
350 height
= be16_to_cpu(str
->di_height
);
351 if (unlikely(height
> GFS2_MAX_META_HEIGHT
))
353 ip
->i_height
= (u8
)height
;
355 depth
= be16_to_cpu(str
->di_depth
);
356 if (unlikely(depth
> GFS2_DIR_MAX_DEPTH
))
358 ip
->i_depth
= (u8
)depth
;
359 ip
->i_entries
= be32_to_cpu(str
->di_entries
);
361 if (S_ISREG(ip
->i_inode
.i_mode
))
362 gfs2_set_aops(&ip
->i_inode
);
366 gfs2_consist_inode(ip
);
371 * gfs2_inode_refresh - Refresh the incore copy of the dinode
372 * @ip: The GFS2 inode
377 int gfs2_inode_refresh(struct gfs2_inode
*ip
)
379 struct buffer_head
*dibh
;
382 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
386 if (gfs2_metatype_check(GFS2_SB(&ip
->i_inode
), dibh
, GFS2_METATYPE_DI
)) {
391 error
= gfs2_dinode_in(ip
, dibh
->b_data
);
393 clear_bit(GIF_INVALID
, &ip
->i_flags
);
399 * inode_go_lock - operation done after an inode lock is locked by a process
406 static int inode_go_lock(struct gfs2_holder
*gh
)
408 struct gfs2_glock
*gl
= gh
->gh_gl
;
409 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
410 struct gfs2_inode
*ip
= gl
->gl_object
;
413 if (!ip
|| (gh
->gh_flags
& GL_SKIP
))
416 if (test_bit(GIF_INVALID
, &ip
->i_flags
)) {
417 error
= gfs2_inode_refresh(ip
);
422 if ((ip
->i_diskflags
& GFS2_DIF_TRUNC_IN_PROG
) &&
423 (gl
->gl_state
== LM_ST_EXCLUSIVE
) &&
424 (gh
->gh_state
== LM_ST_EXCLUSIVE
)) {
425 spin_lock(&sdp
->sd_trunc_lock
);
426 if (list_empty(&ip
->i_trunc_list
))
427 list_add(&sdp
->sd_trunc_list
, &ip
->i_trunc_list
);
428 spin_unlock(&sdp
->sd_trunc_lock
);
429 wake_up(&sdp
->sd_quota_wait
);
437 * inode_go_dump - print information about an inode
441 * Returns: 0 on success, -ENOBUFS when we run out of space
444 static int inode_go_dump(struct seq_file
*seq
, const struct gfs2_glock
*gl
)
446 const struct gfs2_inode
*ip
= gl
->gl_object
;
449 gfs2_print_dbg(seq
, " I: n:%llu/%llu t:%u f:0x%02lx d:0x%08x s:%llu\n",
450 (unsigned long long)ip
->i_no_formal_ino
,
451 (unsigned long long)ip
->i_no_addr
,
452 IF2DT(ip
->i_inode
.i_mode
), ip
->i_flags
,
453 (unsigned int)ip
->i_diskflags
,
454 (unsigned long long)i_size_read(&ip
->i_inode
));
459 * trans_go_sync - promote/demote the transaction glock
461 * @state: the requested state
466 static void trans_go_sync(struct gfs2_glock
*gl
)
468 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
470 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
471 test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
472 gfs2_meta_syncfs(sdp
);
473 gfs2_log_shutdown(sdp
);
478 * trans_go_xmote_bh - After promoting/demoting the transaction glock
483 static int trans_go_xmote_bh(struct gfs2_glock
*gl
, struct gfs2_holder
*gh
)
485 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
486 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
487 struct gfs2_glock
*j_gl
= ip
->i_gl
;
488 struct gfs2_log_header_host head
;
491 if (test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
492 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
494 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
);
497 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
))
500 /* Initialize some head of the log stuff */
501 if (!test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
)) {
502 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
503 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
516 static int trans_go_demote_ok(const struct gfs2_glock
*gl
)
522 * iopen_go_callback - schedule the dcache entry for the inode to be deleted
525 * gl_spin lock is held while calling this
527 static void iopen_go_callback(struct gfs2_glock
*gl
)
529 struct gfs2_inode
*ip
= (struct gfs2_inode
*)gl
->gl_object
;
530 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
532 if (sdp
->sd_vfs
->s_flags
& MS_RDONLY
)
535 if (gl
->gl_demote_state
== LM_ST_UNLOCKED
&&
536 gl
->gl_state
== LM_ST_SHARED
&& ip
) {
538 if (queue_work(gfs2_delete_workqueue
, &gl
->gl_delete
) == 0)
539 gfs2_glock_put_nolock(gl
);
543 const struct gfs2_glock_operations gfs2_meta_glops
= {
544 .go_type
= LM_TYPE_META
,
547 const struct gfs2_glock_operations gfs2_inode_glops
= {
548 .go_xmote_th
= inode_go_sync
,
549 .go_inval
= inode_go_inval
,
550 .go_demote_ok
= inode_go_demote_ok
,
551 .go_lock
= inode_go_lock
,
552 .go_dump
= inode_go_dump
,
553 .go_type
= LM_TYPE_INODE
,
554 .go_flags
= GLOF_ASPACE
,
557 const struct gfs2_glock_operations gfs2_rgrp_glops
= {
558 .go_xmote_th
= rgrp_go_sync
,
559 .go_inval
= rgrp_go_inval
,
560 .go_lock
= gfs2_rgrp_go_lock
,
561 .go_unlock
= gfs2_rgrp_go_unlock
,
562 .go_dump
= gfs2_rgrp_dump
,
563 .go_type
= LM_TYPE_RGRP
,
564 .go_flags
= GLOF_ASPACE
,
567 const struct gfs2_glock_operations gfs2_trans_glops
= {
568 .go_xmote_th
= trans_go_sync
,
569 .go_xmote_bh
= trans_go_xmote_bh
,
570 .go_demote_ok
= trans_go_demote_ok
,
571 .go_type
= LM_TYPE_NONDISK
,
574 const struct gfs2_glock_operations gfs2_iopen_glops
= {
575 .go_type
= LM_TYPE_IOPEN
,
576 .go_callback
= iopen_go_callback
,
579 const struct gfs2_glock_operations gfs2_flock_glops
= {
580 .go_type
= LM_TYPE_FLOCK
,
583 const struct gfs2_glock_operations gfs2_nondisk_glops
= {
584 .go_type
= LM_TYPE_NONDISK
,
587 const struct gfs2_glock_operations gfs2_quota_glops
= {
588 .go_type
= LM_TYPE_QUOTA
,
591 const struct gfs2_glock_operations gfs2_journal_glops
= {
592 .go_type
= LM_TYPE_JOURNAL
,
595 const struct gfs2_glock_operations
*gfs2_glops_list
[] = {
596 [LM_TYPE_META
] = &gfs2_meta_glops
,
597 [LM_TYPE_INODE
] = &gfs2_inode_glops
,
598 [LM_TYPE_RGRP
] = &gfs2_rgrp_glops
,
599 [LM_TYPE_IOPEN
] = &gfs2_iopen_glops
,
600 [LM_TYPE_FLOCK
] = &gfs2_flock_glops
,
601 [LM_TYPE_NONDISK
] = &gfs2_nondisk_glops
,
602 [LM_TYPE_QUOTA
] = &gfs2_quota_glops
,
603 [LM_TYPE_JOURNAL
] = &gfs2_journal_glops
,