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
45 * @fsync: set when called from fsync (not all buffers will be clean)
47 * None of the buffers should be dirty, locked, or pinned.
50 static void __gfs2_ail_flush(struct gfs2_glock
*gl
, bool fsync
)
52 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
53 struct list_head
*head
= &gl
->gl_ail_list
;
54 struct gfs2_bufdata
*bd
, *tmp
;
55 struct buffer_head
*bh
;
56 const unsigned long b_state
= (1UL << BH_Dirty
)|(1UL << BH_Pinned
)|(1UL << BH_Lock
);
59 spin_lock(&sdp
->sd_ail_lock
);
60 list_for_each_entry_safe(bd
, tmp
, head
, bd_ail_gl_list
) {
62 if (bh
->b_state
& b_state
) {
65 gfs2_ail_error(gl
, bh
);
67 gfs2_trans_add_revoke(sdp
, bd
);
69 GLOCK_BUG_ON(gl
, !fsync
&& atomic_read(&gl
->gl_ail_count
));
70 spin_unlock(&sdp
->sd_ail_lock
);
75 static void gfs2_ail_empty_gl(struct gfs2_glock
*gl
)
77 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
80 memset(&tr
, 0, sizeof(tr
));
81 tr
.tr_revokes
= atomic_read(&gl
->gl_ail_count
);
86 /* A shortened, inline version of gfs2_trans_begin() */
87 tr
.tr_reserved
= 1 + gfs2_struct2blk(sdp
, tr
.tr_revokes
, sizeof(u64
));
88 tr
.tr_ip
= (unsigned long)__builtin_return_address(0);
89 sb_start_intwrite(sdp
->sd_vfs
);
90 gfs2_log_reserve(sdp
, tr
.tr_reserved
);
91 WARN_ON_ONCE(current
->journal_info
);
92 current
->journal_info
= &tr
;
94 __gfs2_ail_flush(gl
, 0);
97 gfs2_log_flush(sdp
, NULL
);
100 void gfs2_ail_flush(struct gfs2_glock
*gl
, bool fsync
)
102 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
103 unsigned int revokes
= atomic_read(&gl
->gl_ail_count
);
109 ret
= gfs2_trans_begin(sdp
, 0, revokes
);
112 __gfs2_ail_flush(gl
, fsync
);
114 gfs2_log_flush(sdp
, NULL
);
118 * rgrp_go_sync - sync out the metadata for this glock
121 * Called when demoting or unlocking an EX glock. We must flush
122 * to disk all dirty buffers/pages relating to this glock, and must not
123 * not return to caller to demote/unlock the glock until I/O is complete.
126 static void rgrp_go_sync(struct gfs2_glock
*gl
)
128 struct address_space
*metamapping
= gfs2_glock2aspace(gl
);
129 struct gfs2_rgrpd
*rgd
;
132 if (!test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
))
134 GLOCK_BUG_ON(gl
, gl
->gl_state
!= LM_ST_EXCLUSIVE
);
136 gfs2_log_flush(gl
->gl_sbd
, gl
);
137 filemap_fdatawrite(metamapping
);
138 error
= filemap_fdatawait(metamapping
);
139 mapping_set_error(metamapping
, error
);
140 gfs2_ail_empty_gl(gl
);
142 spin_lock(&gl
->gl_spin
);
145 gfs2_free_clones(rgd
);
146 spin_unlock(&gl
->gl_spin
);
150 * rgrp_go_inval - invalidate the metadata for this glock
154 * We never used LM_ST_DEFERRED with resource groups, so that we
155 * should always see the metadata flag set here.
159 static void rgrp_go_inval(struct gfs2_glock
*gl
, int flags
)
161 struct address_space
*mapping
= gfs2_glock2aspace(gl
);
163 WARN_ON_ONCE(!(flags
& DIO_METADATA
));
164 gfs2_assert_withdraw(gl
->gl_sbd
, !atomic_read(&gl
->gl_ail_count
));
165 truncate_inode_pages(mapping
, 0);
168 struct gfs2_rgrpd
*rgd
= (struct gfs2_rgrpd
*)gl
->gl_object
;
169 rgd
->rd_flags
&= ~GFS2_RDF_UPTODATE
;
174 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
175 * @gl: the glock protecting the inode
179 static void inode_go_sync(struct gfs2_glock
*gl
)
181 struct gfs2_inode
*ip
= gl
->gl_object
;
182 struct address_space
*metamapping
= gfs2_glock2aspace(gl
);
185 if (ip
&& !S_ISREG(ip
->i_inode
.i_mode
))
187 if (ip
&& test_and_clear_bit(GIF_SW_PAGED
, &ip
->i_flags
))
188 unmap_shared_mapping_range(ip
->i_inode
.i_mapping
, 0, 0);
189 if (!test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
))
192 GLOCK_BUG_ON(gl
, gl
->gl_state
!= LM_ST_EXCLUSIVE
);
194 gfs2_log_flush(gl
->gl_sbd
, gl
);
195 filemap_fdatawrite(metamapping
);
197 struct address_space
*mapping
= ip
->i_inode
.i_mapping
;
198 filemap_fdatawrite(mapping
);
199 error
= filemap_fdatawait(mapping
);
200 mapping_set_error(mapping
, error
);
202 error
= filemap_fdatawait(metamapping
);
203 mapping_set_error(metamapping
, error
);
204 gfs2_ail_empty_gl(gl
);
206 * Writeback of the data mapping may cause the dirty flag to be set
207 * so we have to clear it again here.
209 smp_mb__before_clear_bit();
210 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
214 * inode_go_inval - prepare a inode glock to be released
218 * Normally we invlidate everything, but if we are moving into
219 * LM_ST_DEFERRED from LM_ST_SHARED or LM_ST_EXCLUSIVE then we
220 * can keep hold of the metadata, since it won't have changed.
224 static void inode_go_inval(struct gfs2_glock
*gl
, int flags
)
226 struct gfs2_inode
*ip
= gl
->gl_object
;
228 gfs2_assert_withdraw(gl
->gl_sbd
, !atomic_read(&gl
->gl_ail_count
));
230 if (flags
& DIO_METADATA
) {
231 struct address_space
*mapping
= gfs2_glock2aspace(gl
);
232 truncate_inode_pages(mapping
, 0);
234 set_bit(GIF_INVALID
, &ip
->i_flags
);
235 forget_all_cached_acls(&ip
->i_inode
);
236 gfs2_dir_hash_inval(ip
);
240 if (ip
== GFS2_I(gl
->gl_sbd
->sd_rindex
)) {
241 gfs2_log_flush(gl
->gl_sbd
, NULL
);
242 gl
->gl_sbd
->sd_rindex_uptodate
= 0;
244 if (ip
&& S_ISREG(ip
->i_inode
.i_mode
))
245 truncate_inode_pages(ip
->i_inode
.i_mapping
, 0);
249 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
252 * Returns: 1 if it's ok
255 static int inode_go_demote_ok(const struct gfs2_glock
*gl
)
257 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
258 struct gfs2_holder
*gh
;
260 if (sdp
->sd_jindex
== gl
->gl_object
|| sdp
->sd_rindex
== gl
->gl_object
)
263 if (!list_empty(&gl
->gl_holders
)) {
264 gh
= list_entry(gl
->gl_holders
.next
, struct gfs2_holder
, gh_list
);
265 if (gh
->gh_list
.next
!= &gl
->gl_holders
)
273 * gfs2_set_nlink - Set the inode's link count based on on-disk info
274 * @inode: The inode in question
275 * @nlink: The link count
277 * If the link count has hit zero, it must never be raised, whatever the
278 * on-disk inode might say. When new struct inodes are created the link
279 * count is set to 1, so that we can safely use this test even when reading
280 * in on disk information for the first time.
283 static void gfs2_set_nlink(struct inode
*inode
, u32 nlink
)
286 * We will need to review setting the nlink count here in the
287 * light of the forthcoming ro bind mount work. This is a reminder
290 if ((inode
->i_nlink
!= nlink
) && (inode
->i_nlink
!= 0)) {
294 set_nlink(inode
, nlink
);
298 static int gfs2_dinode_in(struct gfs2_inode
*ip
, const void *buf
)
300 const struct gfs2_dinode
*str
= buf
;
301 struct timespec atime
;
304 if (unlikely(ip
->i_no_addr
!= be64_to_cpu(str
->di_num
.no_addr
)))
306 ip
->i_no_formal_ino
= be64_to_cpu(str
->di_num
.no_formal_ino
);
307 ip
->i_inode
.i_mode
= be32_to_cpu(str
->di_mode
);
308 ip
->i_inode
.i_rdev
= 0;
309 switch (ip
->i_inode
.i_mode
& S_IFMT
) {
312 ip
->i_inode
.i_rdev
= MKDEV(be32_to_cpu(str
->di_major
),
313 be32_to_cpu(str
->di_minor
));
317 i_uid_write(&ip
->i_inode
, be32_to_cpu(str
->di_uid
));
318 i_gid_write(&ip
->i_inode
, be32_to_cpu(str
->di_gid
));
319 gfs2_set_nlink(&ip
->i_inode
, be32_to_cpu(str
->di_nlink
));
320 i_size_write(&ip
->i_inode
, be64_to_cpu(str
->di_size
));
321 gfs2_set_inode_blocks(&ip
->i_inode
, be64_to_cpu(str
->di_blocks
));
322 atime
.tv_sec
= be64_to_cpu(str
->di_atime
);
323 atime
.tv_nsec
= be32_to_cpu(str
->di_atime_nsec
);
324 if (timespec_compare(&ip
->i_inode
.i_atime
, &atime
) < 0)
325 ip
->i_inode
.i_atime
= atime
;
326 ip
->i_inode
.i_mtime
.tv_sec
= be64_to_cpu(str
->di_mtime
);
327 ip
->i_inode
.i_mtime
.tv_nsec
= be32_to_cpu(str
->di_mtime_nsec
);
328 ip
->i_inode
.i_ctime
.tv_sec
= be64_to_cpu(str
->di_ctime
);
329 ip
->i_inode
.i_ctime
.tv_nsec
= be32_to_cpu(str
->di_ctime_nsec
);
331 ip
->i_goal
= be64_to_cpu(str
->di_goal_meta
);
332 ip
->i_generation
= be64_to_cpu(str
->di_generation
);
334 ip
->i_diskflags
= be32_to_cpu(str
->di_flags
);
335 ip
->i_eattr
= be64_to_cpu(str
->di_eattr
);
336 /* i_diskflags and i_eattr must be set before gfs2_set_inode_flags() */
337 gfs2_set_inode_flags(&ip
->i_inode
);
338 height
= be16_to_cpu(str
->di_height
);
339 if (unlikely(height
> GFS2_MAX_META_HEIGHT
))
341 ip
->i_height
= (u8
)height
;
343 depth
= be16_to_cpu(str
->di_depth
);
344 if (unlikely(depth
> GFS2_DIR_MAX_DEPTH
))
346 ip
->i_depth
= (u8
)depth
;
347 ip
->i_entries
= be32_to_cpu(str
->di_entries
);
349 if (S_ISREG(ip
->i_inode
.i_mode
))
350 gfs2_set_aops(&ip
->i_inode
);
354 gfs2_consist_inode(ip
);
359 * gfs2_inode_refresh - Refresh the incore copy of the dinode
360 * @ip: The GFS2 inode
365 int gfs2_inode_refresh(struct gfs2_inode
*ip
)
367 struct buffer_head
*dibh
;
370 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
374 error
= gfs2_dinode_in(ip
, dibh
->b_data
);
376 clear_bit(GIF_INVALID
, &ip
->i_flags
);
382 * inode_go_lock - operation done after an inode lock is locked by a process
389 static int inode_go_lock(struct gfs2_holder
*gh
)
391 struct gfs2_glock
*gl
= gh
->gh_gl
;
392 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
393 struct gfs2_inode
*ip
= gl
->gl_object
;
396 if (!ip
|| (gh
->gh_flags
& GL_SKIP
))
399 if (test_bit(GIF_INVALID
, &ip
->i_flags
)) {
400 error
= gfs2_inode_refresh(ip
);
405 if ((ip
->i_diskflags
& GFS2_DIF_TRUNC_IN_PROG
) &&
406 (gl
->gl_state
== LM_ST_EXCLUSIVE
) &&
407 (gh
->gh_state
== LM_ST_EXCLUSIVE
)) {
408 spin_lock(&sdp
->sd_trunc_lock
);
409 if (list_empty(&ip
->i_trunc_list
))
410 list_add(&sdp
->sd_trunc_list
, &ip
->i_trunc_list
);
411 spin_unlock(&sdp
->sd_trunc_lock
);
412 wake_up(&sdp
->sd_quota_wait
);
420 * inode_go_dump - print information about an inode
424 * Returns: 0 on success, -ENOBUFS when we run out of space
427 static int inode_go_dump(struct seq_file
*seq
, const struct gfs2_glock
*gl
)
429 const struct gfs2_inode
*ip
= gl
->gl_object
;
432 gfs2_print_dbg(seq
, " I: n:%llu/%llu t:%u f:0x%02lx d:0x%08x s:%llu\n",
433 (unsigned long long)ip
->i_no_formal_ino
,
434 (unsigned long long)ip
->i_no_addr
,
435 IF2DT(ip
->i_inode
.i_mode
), ip
->i_flags
,
436 (unsigned int)ip
->i_diskflags
,
437 (unsigned long long)i_size_read(&ip
->i_inode
));
442 * trans_go_sync - promote/demote the transaction glock
444 * @state: the requested state
449 static void trans_go_sync(struct gfs2_glock
*gl
)
451 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
453 if (gl
->gl_state
!= LM_ST_UNLOCKED
&&
454 test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
455 gfs2_meta_syncfs(sdp
);
456 gfs2_log_shutdown(sdp
);
461 * trans_go_xmote_bh - After promoting/demoting the transaction glock
466 static int trans_go_xmote_bh(struct gfs2_glock
*gl
, struct gfs2_holder
*gh
)
468 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
469 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
470 struct gfs2_glock
*j_gl
= ip
->i_gl
;
471 struct gfs2_log_header_host head
;
474 if (test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
475 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
477 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
);
480 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
))
483 /* Initialize some head of the log stuff */
484 if (!test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
)) {
485 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
486 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
499 static int trans_go_demote_ok(const struct gfs2_glock
*gl
)
505 * iopen_go_callback - schedule the dcache entry for the inode to be deleted
508 * gl_spin lock is held while calling this
510 static void iopen_go_callback(struct gfs2_glock
*gl
, bool remote
)
512 struct gfs2_inode
*ip
= (struct gfs2_inode
*)gl
->gl_object
;
513 struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
515 if (!remote
|| (sdp
->sd_vfs
->s_flags
& MS_RDONLY
))
518 if (gl
->gl_demote_state
== LM_ST_UNLOCKED
&&
519 gl
->gl_state
== LM_ST_SHARED
&& ip
) {
521 if (queue_work(gfs2_delete_workqueue
, &gl
->gl_delete
) == 0)
522 gfs2_glock_put_nolock(gl
);
526 const struct gfs2_glock_operations gfs2_meta_glops
= {
527 .go_type
= LM_TYPE_META
,
530 const struct gfs2_glock_operations gfs2_inode_glops
= {
531 .go_sync
= inode_go_sync
,
532 .go_inval
= inode_go_inval
,
533 .go_demote_ok
= inode_go_demote_ok
,
534 .go_lock
= inode_go_lock
,
535 .go_dump
= inode_go_dump
,
536 .go_type
= LM_TYPE_INODE
,
537 .go_flags
= GLOF_ASPACE
,
540 const struct gfs2_glock_operations gfs2_rgrp_glops
= {
541 .go_sync
= rgrp_go_sync
,
542 .go_inval
= rgrp_go_inval
,
543 .go_lock
= gfs2_rgrp_go_lock
,
544 .go_unlock
= gfs2_rgrp_go_unlock
,
545 .go_dump
= gfs2_rgrp_dump
,
546 .go_type
= LM_TYPE_RGRP
,
547 .go_flags
= GLOF_ASPACE
| GLOF_LVB
,
550 const struct gfs2_glock_operations gfs2_trans_glops
= {
551 .go_sync
= trans_go_sync
,
552 .go_xmote_bh
= trans_go_xmote_bh
,
553 .go_demote_ok
= trans_go_demote_ok
,
554 .go_type
= LM_TYPE_NONDISK
,
557 const struct gfs2_glock_operations gfs2_iopen_glops
= {
558 .go_type
= LM_TYPE_IOPEN
,
559 .go_callback
= iopen_go_callback
,
562 const struct gfs2_glock_operations gfs2_flock_glops
= {
563 .go_type
= LM_TYPE_FLOCK
,
566 const struct gfs2_glock_operations gfs2_nondisk_glops
= {
567 .go_type
= LM_TYPE_NONDISK
,
570 const struct gfs2_glock_operations gfs2_quota_glops
= {
571 .go_type
= LM_TYPE_QUOTA
,
572 .go_flags
= GLOF_LVB
,
575 const struct gfs2_glock_operations gfs2_journal_glops
= {
576 .go_type
= LM_TYPE_JOURNAL
,
579 const struct gfs2_glock_operations
*gfs2_glops_list
[] = {
580 [LM_TYPE_META
] = &gfs2_meta_glops
,
581 [LM_TYPE_INODE
] = &gfs2_inode_glops
,
582 [LM_TYPE_RGRP
] = &gfs2_rgrp_glops
,
583 [LM_TYPE_IOPEN
] = &gfs2_iopen_glops
,
584 [LM_TYPE_FLOCK
] = &gfs2_flock_glops
,
585 [LM_TYPE_NONDISK
] = &gfs2_nondisk_glops
,
586 [LM_TYPE_QUOTA
] = &gfs2_quota_glops
,
587 [LM_TYPE_JOURNAL
] = &gfs2_journal_glops
,