2 * linux/fs/ext3/inode.c
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
11 * linux/fs/minix/inode.c
13 * Copyright (C) 1991, 1992 Linus Torvalds
15 * Goal-directed block allocation by Stephen Tweedie
16 * (sct@redhat.com), 1993, 1998
17 * Big-endian to little-endian byte-swapping/bitmaps by
18 * David S. Miller (davem@caip.rutgers.edu), 1995
19 * 64-bit file support on 64-bit platforms by Jakub Jelinek
20 * (jj@sunsite.ms.mff.cuni.cz)
22 * Assorted race fixes, rewrite of ext3_get_block() by Al Viro, 2000
25 #include <linux/module.h>
27 #include <linux/time.h>
28 #include <linux/ext3_jbd.h>
29 #include <linux/jbd.h>
30 #include <linux/smp_lock.h>
31 #include <linux/highuid.h>
32 #include <linux/pagemap.h>
33 #include <linux/quotaops.h>
34 #include <linux/string.h>
35 #include <linux/buffer_head.h>
36 #include <linux/writeback.h>
37 #include <linux/mpage.h>
38 #include <linux/uio.h>
42 static int ext3_writepage_trans_blocks(struct inode
*inode
);
45 * Test whether an inode is a fast symlink.
47 static inline int ext3_inode_is_fast_symlink(struct inode
*inode
)
49 int ea_blocks
= EXT3_I(inode
)->i_file_acl
?
50 (inode
->i_sb
->s_blocksize
>> 9) : 0;
52 return (S_ISLNK(inode
->i_mode
) &&
53 inode
->i_blocks
- ea_blocks
== 0);
56 /* The ext3 forget function must perform a revoke if we are freeing data
57 * which has been journaled. Metadata (eg. indirect blocks) must be
58 * revoked in all cases.
60 * "bh" may be NULL: a metadata block may have been freed from memory
61 * but there may still be a record of it in the journal, and that record
62 * still needs to be revoked.
65 int ext3_forget(handle_t
*handle
, int is_metadata
,
66 struct inode
*inode
, struct buffer_head
*bh
,
73 BUFFER_TRACE(bh
, "enter");
75 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
77 bh
, is_metadata
, inode
->i_mode
,
78 test_opt(inode
->i_sb
, DATA_FLAGS
));
80 /* Never use the revoke function if we are doing full data
81 * journaling: there is no need to, and a V1 superblock won't
82 * support it. Otherwise, only skip the revoke on un-journaled
85 if (test_opt(inode
->i_sb
, DATA_FLAGS
) == EXT3_MOUNT_JOURNAL_DATA
||
86 (!is_metadata
&& !ext3_should_journal_data(inode
))) {
88 BUFFER_TRACE(bh
, "call journal_forget");
89 return ext3_journal_forget(handle
, bh
);
95 * data!=journal && (is_metadata || should_journal_data(inode))
97 BUFFER_TRACE(bh
, "call ext3_journal_revoke");
98 err
= ext3_journal_revoke(handle
, blocknr
, bh
);
100 ext3_abort(inode
->i_sb
, __FUNCTION__
,
101 "error %d when attempting revoke", err
);
102 BUFFER_TRACE(bh
, "exit");
107 * Work out how many blocks we need to progress with the next chunk of a
108 * truncate transaction.
111 static unsigned long blocks_for_truncate(struct inode
*inode
)
113 unsigned long needed
;
115 needed
= inode
->i_blocks
>> (inode
->i_sb
->s_blocksize_bits
- 9);
117 /* Give ourselves just enough room to cope with inodes in which
118 * i_blocks is corrupt: we've seen disk corruptions in the past
119 * which resulted in random data in an inode which looked enough
120 * like a regular file for ext3 to try to delete it. Things
121 * will go a bit crazy if that happens, but at least we should
122 * try not to panic the whole kernel. */
126 /* But we need to bound the transaction so we don't overflow the
128 if (needed
> EXT3_MAX_TRANS_DATA
)
129 needed
= EXT3_MAX_TRANS_DATA
;
131 return EXT3_DATA_TRANS_BLOCKS
+ needed
;
135 * Truncate transactions can be complex and absolutely huge. So we need to
136 * be able to restart the transaction at a conventient checkpoint to make
137 * sure we don't overflow the journal.
139 * start_transaction gets us a new handle for a truncate transaction,
140 * and extend_transaction tries to extend the existing one a bit. If
141 * extend fails, we need to propagate the failure up and restart the
142 * transaction in the top-level truncate loop. --sct
145 static handle_t
*start_transaction(struct inode
*inode
)
149 result
= ext3_journal_start(inode
, blocks_for_truncate(inode
));
153 ext3_std_error(inode
->i_sb
, PTR_ERR(result
));
158 * Try to extend this transaction for the purposes of truncation.
160 * Returns 0 if we managed to create more room. If we can't create more
161 * room, and the transaction must be restarted we return 1.
163 static int try_to_extend_transaction(handle_t
*handle
, struct inode
*inode
)
165 if (handle
->h_buffer_credits
> EXT3_RESERVE_TRANS_BLOCKS
)
167 if (!ext3_journal_extend(handle
, blocks_for_truncate(inode
)))
173 * Restart the transaction associated with *handle. This does a commit,
174 * so before we call here everything must be consistently dirtied against
177 static int ext3_journal_test_restart(handle_t
*handle
, struct inode
*inode
)
179 jbd_debug(2, "restarting handle %p\n", handle
);
180 return ext3_journal_restart(handle
, blocks_for_truncate(inode
));
184 * Called at the last iput() if i_nlink is zero.
186 void ext3_delete_inode (struct inode
* inode
)
190 if (is_bad_inode(inode
))
193 handle
= start_transaction(inode
);
194 if (IS_ERR(handle
)) {
195 /* If we're going to skip the normal cleanup, we still
196 * need to make sure that the in-core orphan linked list
197 * is properly cleaned up. */
198 ext3_orphan_del(NULL
, inode
);
206 ext3_truncate(inode
);
208 * Kill off the orphan record which ext3_truncate created.
209 * AKPM: I think this can be inside the above `if'.
210 * Note that ext3_orphan_del() has to be able to cope with the
211 * deletion of a non-existent orphan - this is because we don't
212 * know if ext3_truncate() actually created an orphan record.
213 * (Well, we could do this if we need to, but heck - it works)
215 ext3_orphan_del(handle
, inode
);
216 EXT3_I(inode
)->i_dtime
= get_seconds();
219 * One subtle ordering requirement: if anything has gone wrong
220 * (transaction abort, IO errors, whatever), then we can still
221 * do these next steps (the fs will already have been marked as
222 * having errors), but we can't free the inode if the mark_dirty
225 if (ext3_mark_inode_dirty(handle
, inode
))
226 /* If that failed, just do the required in-core inode clear. */
229 ext3_free_inode(handle
, inode
);
230 ext3_journal_stop(handle
);
233 clear_inode(inode
); /* We must guarantee clearing of inode... */
236 static int ext3_alloc_block (handle_t
*handle
,
237 struct inode
* inode
, unsigned long goal
, int *err
)
239 unsigned long result
;
241 result
= ext3_new_block(handle
, inode
, goal
, err
);
249 struct buffer_head
*bh
;
252 static inline void add_chain(Indirect
*p
, struct buffer_head
*bh
, __le32
*v
)
254 p
->key
= *(p
->p
= v
);
258 static inline int verify_chain(Indirect
*from
, Indirect
*to
)
260 while (from
<= to
&& from
->key
== *from
->p
)
266 * ext3_block_to_path - parse the block number into array of offsets
267 * @inode: inode in question (we are only interested in its superblock)
268 * @i_block: block number to be parsed
269 * @offsets: array to store the offsets in
270 * @boundary: set this non-zero if the referred-to block is likely to be
271 * followed (on disk) by an indirect block.
273 * To store the locations of file's data ext3 uses a data structure common
274 * for UNIX filesystems - tree of pointers anchored in the inode, with
275 * data blocks at leaves and indirect blocks in intermediate nodes.
276 * This function translates the block number into path in that tree -
277 * return value is the path length and @offsets[n] is the offset of
278 * pointer to (n+1)th node in the nth one. If @block is out of range
279 * (negative or too large) warning is printed and zero returned.
281 * Note: function doesn't find node addresses, so no IO is needed. All
282 * we need to know is the capacity of indirect blocks (taken from the
287 * Portability note: the last comparison (check that we fit into triple
288 * indirect block) is spelled differently, because otherwise on an
289 * architecture with 32-bit longs and 8Kb pages we might get into trouble
290 * if our filesystem had 8Kb blocks. We might use long long, but that would
291 * kill us on x86. Oh, well, at least the sign propagation does not matter -
292 * i_block would have to be negative in the very beginning, so we would not
296 static int ext3_block_to_path(struct inode
*inode
,
297 long i_block
, int offsets
[4], int *boundary
)
299 int ptrs
= EXT3_ADDR_PER_BLOCK(inode
->i_sb
);
300 int ptrs_bits
= EXT3_ADDR_PER_BLOCK_BITS(inode
->i_sb
);
301 const long direct_blocks
= EXT3_NDIR_BLOCKS
,
302 indirect_blocks
= ptrs
,
303 double_blocks
= (1 << (ptrs_bits
* 2));
308 ext3_warning (inode
->i_sb
, "ext3_block_to_path", "block < 0");
309 } else if (i_block
< direct_blocks
) {
310 offsets
[n
++] = i_block
;
311 final
= direct_blocks
;
312 } else if ( (i_block
-= direct_blocks
) < indirect_blocks
) {
313 offsets
[n
++] = EXT3_IND_BLOCK
;
314 offsets
[n
++] = i_block
;
316 } else if ((i_block
-= indirect_blocks
) < double_blocks
) {
317 offsets
[n
++] = EXT3_DIND_BLOCK
;
318 offsets
[n
++] = i_block
>> ptrs_bits
;
319 offsets
[n
++] = i_block
& (ptrs
- 1);
321 } else if (((i_block
-= double_blocks
) >> (ptrs_bits
* 2)) < ptrs
) {
322 offsets
[n
++] = EXT3_TIND_BLOCK
;
323 offsets
[n
++] = i_block
>> (ptrs_bits
* 2);
324 offsets
[n
++] = (i_block
>> ptrs_bits
) & (ptrs
- 1);
325 offsets
[n
++] = i_block
& (ptrs
- 1);
328 ext3_warning (inode
->i_sb
, "ext3_block_to_path", "block > big");
331 *boundary
= (i_block
& (ptrs
- 1)) == (final
- 1);
336 * ext3_get_branch - read the chain of indirect blocks leading to data
337 * @inode: inode in question
338 * @depth: depth of the chain (1 - direct pointer, etc.)
339 * @offsets: offsets of pointers in inode/indirect blocks
340 * @chain: place to store the result
341 * @err: here we store the error value
343 * Function fills the array of triples <key, p, bh> and returns %NULL
344 * if everything went OK or the pointer to the last filled triple
345 * (incomplete one) otherwise. Upon the return chain[i].key contains
346 * the number of (i+1)-th block in the chain (as it is stored in memory,
347 * i.e. little-endian 32-bit), chain[i].p contains the address of that
348 * number (it points into struct inode for i==0 and into the bh->b_data
349 * for i>0) and chain[i].bh points to the buffer_head of i-th indirect
350 * block for i>0 and NULL for i==0. In other words, it holds the block
351 * numbers of the chain, addresses they were taken from (and where we can
352 * verify that chain did not change) and buffer_heads hosting these
355 * Function stops when it stumbles upon zero pointer (absent block)
356 * (pointer to last triple returned, *@err == 0)
357 * or when it gets an IO error reading an indirect block
358 * (ditto, *@err == -EIO)
359 * or when it notices that chain had been changed while it was reading
360 * (ditto, *@err == -EAGAIN)
361 * or when it reads all @depth-1 indirect blocks successfully and finds
362 * the whole chain, all way to the data (returns %NULL, *err == 0).
364 static Indirect
*ext3_get_branch(struct inode
*inode
, int depth
, int *offsets
,
365 Indirect chain
[4], int *err
)
367 struct super_block
*sb
= inode
->i_sb
;
369 struct buffer_head
*bh
;
372 /* i_data is not going away, no lock needed */
373 add_chain (chain
, NULL
, EXT3_I(inode
)->i_data
+ *offsets
);
377 bh
= sb_bread(sb
, le32_to_cpu(p
->key
));
380 /* Reader: pointers */
381 if (!verify_chain(chain
, p
))
383 add_chain(++p
, bh
, (__le32
*)bh
->b_data
+ *++offsets
);
401 * ext3_find_near - find a place for allocation with sufficient locality
403 * @ind: descriptor of indirect block.
405 * This function returns the prefered place for block allocation.
406 * It is used when heuristic for sequential allocation fails.
408 * + if there is a block to the left of our position - allocate near it.
409 * + if pointer will live in indirect block - allocate near that block.
410 * + if pointer will live in inode - allocate in the same
413 * In the latter case we colour the starting block by the callers PID to
414 * prevent it from clashing with concurrent allocations for a different inode
415 * in the same block group. The PID is used here so that functionally related
416 * files will be close-by on-disk.
418 * Caller must make sure that @ind is valid and will stay that way.
421 static unsigned long ext3_find_near(struct inode
*inode
, Indirect
*ind
)
423 struct ext3_inode_info
*ei
= EXT3_I(inode
);
424 __le32
*start
= ind
->bh
? (__le32
*) ind
->bh
->b_data
: ei
->i_data
;
426 unsigned long bg_start
;
427 unsigned long colour
;
429 /* Try to find previous block */
430 for (p
= ind
->p
- 1; p
>= start
; p
--)
432 return le32_to_cpu(*p
);
434 /* No such thing, so let's try location of indirect block */
436 return ind
->bh
->b_blocknr
;
439 * It is going to be refered from inode itself? OK, just put it into
440 * the same cylinder group then.
442 bg_start
= (ei
->i_block_group
* EXT3_BLOCKS_PER_GROUP(inode
->i_sb
)) +
443 le32_to_cpu(EXT3_SB(inode
->i_sb
)->s_es
->s_first_data_block
);
444 colour
= (current
->pid
% 16) *
445 (EXT3_BLOCKS_PER_GROUP(inode
->i_sb
) / 16);
446 return bg_start
+ colour
;
450 * ext3_find_goal - find a prefered place for allocation.
452 * @block: block we want
453 * @chain: chain of indirect blocks
454 * @partial: pointer to the last triple within a chain
455 * @goal: place to store the result.
457 * Normally this function find the prefered place for block allocation,
458 * stores it in *@goal and returns zero. If the branch had been changed
459 * under us we return -EAGAIN.
462 static int ext3_find_goal(struct inode
*inode
, long block
, Indirect chain
[4],
463 Indirect
*partial
, unsigned long *goal
)
465 struct ext3_block_alloc_info
*block_i
= EXT3_I(inode
)->i_block_alloc_info
;
468 * try the heuristic for sequential allocation,
469 * failing that at least try to get decent locality.
471 if (block_i
&& (block
== block_i
->last_alloc_logical_block
+ 1)
472 && (block_i
->last_alloc_physical_block
!= 0)) {
473 *goal
= block_i
->last_alloc_physical_block
+ 1;
477 if (verify_chain(chain
, partial
)) {
478 *goal
= ext3_find_near(inode
, partial
);
485 * ext3_alloc_branch - allocate and set up a chain of blocks.
487 * @num: depth of the chain (number of blocks to allocate)
488 * @offsets: offsets (in the blocks) to store the pointers to next.
489 * @branch: place to store the chain in.
491 * This function allocates @num blocks, zeroes out all but the last one,
492 * links them into chain and (if we are synchronous) writes them to disk.
493 * In other words, it prepares a branch that can be spliced onto the
494 * inode. It stores the information about that chain in the branch[], in
495 * the same format as ext3_get_branch() would do. We are calling it after
496 * we had read the existing part of chain and partial points to the last
497 * triple of that (one with zero ->key). Upon the exit we have the same
498 * picture as after the successful ext3_get_block(), excpet that in one
499 * place chain is disconnected - *branch->p is still zero (we did not
500 * set the last link), but branch->key contains the number that should
501 * be placed into *branch->p to fill that gap.
503 * If allocation fails we free all blocks we've allocated (and forget
504 * their buffer_heads) and return the error value the from failed
505 * ext3_alloc_block() (normally -ENOSPC). Otherwise we set the chain
506 * as described above and return 0.
509 static int ext3_alloc_branch(handle_t
*handle
, struct inode
*inode
,
515 int blocksize
= inode
->i_sb
->s_blocksize
;
519 int parent
= ext3_alloc_block(handle
, inode
, goal
, &err
);
521 branch
[0].key
= cpu_to_le32(parent
);
523 for (n
= 1; n
< num
; n
++) {
524 struct buffer_head
*bh
;
525 /* Allocate the next block */
526 int nr
= ext3_alloc_block(handle
, inode
, parent
, &err
);
529 branch
[n
].key
= cpu_to_le32(nr
);
533 * Get buffer_head for parent block, zero it out
534 * and set the pointer to new one, then send
537 bh
= sb_getblk(inode
->i_sb
, parent
);
540 BUFFER_TRACE(bh
, "call get_create_access");
541 err
= ext3_journal_get_create_access(handle
, bh
);
548 memset(bh
->b_data
, 0, blocksize
);
549 branch
[n
].p
= (__le32
*) bh
->b_data
+ offsets
[n
];
550 *branch
[n
].p
= branch
[n
].key
;
551 BUFFER_TRACE(bh
, "marking uptodate");
552 set_buffer_uptodate(bh
);
555 BUFFER_TRACE(bh
, "call ext3_journal_dirty_metadata");
556 err
= ext3_journal_dirty_metadata(handle
, bh
);
566 /* Allocation failed, free what we already allocated */
567 for (i
= 1; i
< keys
; i
++) {
568 BUFFER_TRACE(branch
[i
].bh
, "call journal_forget");
569 ext3_journal_forget(handle
, branch
[i
].bh
);
571 for (i
= 0; i
< keys
; i
++)
572 ext3_free_blocks(handle
, inode
, le32_to_cpu(branch
[i
].key
), 1);
577 * ext3_splice_branch - splice the allocated branch onto inode.
579 * @block: (logical) number of block we are adding
580 * @chain: chain of indirect blocks (with a missing link - see
582 * @where: location of missing link
583 * @num: number of blocks we are adding
585 * This function verifies that chain (up to the missing link) had not
586 * changed, fills the missing link and does all housekeeping needed in
587 * inode (->i_blocks, etc.). In case of success we end up with the full
588 * chain to new block and return 0. Otherwise (== chain had been changed)
589 * we free the new blocks (forgetting their buffer_heads, indeed) and
593 static int ext3_splice_branch(handle_t
*handle
, struct inode
*inode
, long block
,
594 Indirect chain
[4], Indirect
*where
, int num
)
598 struct ext3_block_alloc_info
*block_i
= EXT3_I(inode
)->i_block_alloc_info
;
601 * If we're splicing into a [td]indirect block (as opposed to the
602 * inode) then we need to get write access to the [td]indirect block
606 BUFFER_TRACE(where
->bh
, "get_write_access");
607 err
= ext3_journal_get_write_access(handle
, where
->bh
);
611 /* Verify that place we are splicing to is still there and vacant */
613 if (!verify_chain(chain
, where
-1) || *where
->p
)
619 *where
->p
= where
->key
;
622 * update the most recently allocated logical & physical block
623 * in i_block_alloc_info, to assist find the proper goal block for next
627 block_i
->last_alloc_logical_block
= block
;
628 block_i
->last_alloc_physical_block
= le32_to_cpu(where
[num
-1].key
);
631 /* We are done with atomic stuff, now do the rest of housekeeping */
633 inode
->i_ctime
= CURRENT_TIME_SEC
;
634 ext3_mark_inode_dirty(handle
, inode
);
636 /* had we spliced it onto indirect block? */
639 * akpm: If we spliced it onto an indirect block, we haven't
640 * altered the inode. Note however that if it is being spliced
641 * onto an indirect block at the very end of the file (the
642 * file is growing) then we *will* alter the inode to reflect
643 * the new i_size. But that is not done here - it is done in
644 * generic_commit_write->__mark_inode_dirty->ext3_dirty_inode.
646 jbd_debug(5, "splicing indirect only\n");
647 BUFFER_TRACE(where
->bh
, "call ext3_journal_dirty_metadata");
648 err
= ext3_journal_dirty_metadata(handle
, where
->bh
);
653 * OK, we spliced it into the inode itself on a direct block.
654 * Inode was dirtied above.
656 jbd_debug(5, "splicing direct\n");
662 * AKPM: if where[i].bh isn't part of the current updating
663 * transaction then we explode nastily. Test this code path.
665 jbd_debug(1, "the chain changed: try again\n");
669 for (i
= 1; i
< num
; i
++) {
670 BUFFER_TRACE(where
[i
].bh
, "call journal_forget");
671 ext3_journal_forget(handle
, where
[i
].bh
);
673 /* For the normal collision cleanup case, we free up the blocks.
674 * On genuine filesystem errors we don't even think about doing
677 for (i
= 0; i
< num
; i
++)
678 ext3_free_blocks(handle
, inode
,
679 le32_to_cpu(where
[i
].key
), 1);
684 * Allocation strategy is simple: if we have to allocate something, we will
685 * have to go the whole way to leaf. So let's do it before attaching anything
686 * to tree, set linkage between the newborn blocks, write them if sync is
687 * required, recheck the path, free and repeat if check fails, otherwise
688 * set the last missing link (that will protect us from any truncate-generated
689 * removals - all blocks on the path are immune now) and possibly force the
690 * write on the parent block.
691 * That has a nice additional property: no special recovery from the failed
692 * allocations is needed - we simply release blocks and do not touch anything
693 * reachable from inode.
695 * akpm: `handle' can be NULL if create == 0.
697 * The BKL may not be held on entry here. Be sure to take it early.
701 ext3_get_block_handle(handle_t
*handle
, struct inode
*inode
, sector_t iblock
,
702 struct buffer_head
*bh_result
, int create
, int extend_disksize
)
711 int depth
= ext3_block_to_path(inode
, iblock
, offsets
, &boundary
);
712 struct ext3_inode_info
*ei
= EXT3_I(inode
);
714 J_ASSERT(handle
!= NULL
|| create
== 0);
720 partial
= ext3_get_branch(inode
, depth
, offsets
, chain
, &err
);
722 /* Simplest case - block found, no allocation needed */
724 clear_buffer_new(bh_result
);
726 map_bh(bh_result
, inode
->i_sb
, le32_to_cpu(chain
[depth
-1].key
));
728 set_buffer_boundary(bh_result
);
729 /* Clean up and exit */
730 partial
= chain
+depth
-1; /* the whole chain */
734 /* Next simple case - plain lookup or failed read of indirect block */
735 if (!create
|| err
== -EIO
) {
737 while (partial
> chain
) {
738 BUFFER_TRACE(partial
->bh
, "call brelse");
742 BUFFER_TRACE(bh_result
, "returned");
748 * Indirect block might be removed by truncate while we were
749 * reading it. Handling of that case (forget what we've got and
750 * reread) is taken out of the main path.
756 down(&ei
->truncate_sem
);
758 /* lazy initialize the block allocation info here if necessary */
759 if (S_ISREG(inode
->i_mode
) && (!ei
->i_block_alloc_info
)) {
760 ext3_init_block_alloc_info(inode
);
763 if (ext3_find_goal(inode
, iblock
, chain
, partial
, &goal
) < 0) {
764 up(&ei
->truncate_sem
);
768 left
= (chain
+ depth
) - partial
;
771 * Block out ext3_truncate while we alter the tree
773 err
= ext3_alloc_branch(handle
, inode
, left
, goal
,
774 offsets
+(partial
-chain
), partial
);
776 /* The ext3_splice_branch call will free and forget any buffers
777 * on the new chain if there is a failure, but that risks using
778 * up transaction credits, especially for bitmaps where the
779 * credits cannot be returned. Can we handle this somehow? We
780 * may need to return -EAGAIN upwards in the worst case. --sct */
782 err
= ext3_splice_branch(handle
, inode
, iblock
, chain
,
784 /* i_disksize growing is protected by truncate_sem
785 * don't forget to protect it if you're about to implement
786 * concurrent ext3_get_block() -bzzz */
787 if (!err
&& extend_disksize
&& inode
->i_size
> ei
->i_disksize
)
788 ei
->i_disksize
= inode
->i_size
;
789 up(&ei
->truncate_sem
);
795 set_buffer_new(bh_result
);
799 while (partial
> chain
) {
800 jbd_debug(1, "buffer chain changed, retrying\n");
801 BUFFER_TRACE(partial
->bh
, "brelsing");
808 static int ext3_get_block(struct inode
*inode
, sector_t iblock
,
809 struct buffer_head
*bh_result
, int create
)
811 handle_t
*handle
= NULL
;
815 handle
= ext3_journal_current_handle();
816 J_ASSERT(handle
!= 0);
818 ret
= ext3_get_block_handle(handle
, inode
, iblock
,
819 bh_result
, create
, 1);
823 #define DIO_CREDITS (EXT3_RESERVE_TRANS_BLOCKS + 32)
826 ext3_direct_io_get_blocks(struct inode
*inode
, sector_t iblock
,
827 unsigned long max_blocks
, struct buffer_head
*bh_result
,
830 handle_t
*handle
= journal_current_handle();
834 goto get_block
; /* A read */
836 if (handle
->h_transaction
->t_state
== T_LOCKED
) {
838 * Huge direct-io writes can hold off commits for long
839 * periods of time. Let this commit run.
841 ext3_journal_stop(handle
);
842 handle
= ext3_journal_start(inode
, DIO_CREDITS
);
844 ret
= PTR_ERR(handle
);
848 if (handle
->h_buffer_credits
<= EXT3_RESERVE_TRANS_BLOCKS
) {
850 * Getting low on buffer credits...
852 ret
= ext3_journal_extend(handle
, DIO_CREDITS
);
855 * Couldn't extend the transaction. Start a new one.
857 ret
= ext3_journal_restart(handle
, DIO_CREDITS
);
863 ret
= ext3_get_block_handle(handle
, inode
, iblock
,
864 bh_result
, create
, 0);
865 bh_result
->b_size
= (1 << inode
->i_blkbits
);
869 static int ext3_writepages_get_block(struct inode
*inode
, sector_t iblock
,
870 struct buffer_head
*bh
, int create
)
872 return ext3_direct_io_get_blocks(inode
, iblock
, 1, bh
, create
);
876 * `handle' can be NULL if create is zero
878 struct buffer_head
*ext3_getblk(handle_t
*handle
, struct inode
* inode
,
879 long block
, int create
, int * errp
)
881 struct buffer_head dummy
;
884 J_ASSERT(handle
!= NULL
|| create
== 0);
887 dummy
.b_blocknr
= -1000;
888 buffer_trace_init(&dummy
.b_history
);
889 *errp
= ext3_get_block_handle(handle
, inode
, block
, &dummy
, create
, 1);
890 if (!*errp
&& buffer_mapped(&dummy
)) {
891 struct buffer_head
*bh
;
892 bh
= sb_getblk(inode
->i_sb
, dummy
.b_blocknr
);
893 if (buffer_new(&dummy
)) {
894 J_ASSERT(create
!= 0);
895 J_ASSERT(handle
!= 0);
897 /* Now that we do not always journal data, we
898 should keep in mind whether this should
899 always journal the new buffer as metadata.
900 For now, regular file writes use
901 ext3_get_block instead, so it's not a
904 BUFFER_TRACE(bh
, "call get_create_access");
905 fatal
= ext3_journal_get_create_access(handle
, bh
);
906 if (!fatal
&& !buffer_uptodate(bh
)) {
907 memset(bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
908 set_buffer_uptodate(bh
);
911 BUFFER_TRACE(bh
, "call ext3_journal_dirty_metadata");
912 err
= ext3_journal_dirty_metadata(handle
, bh
);
916 BUFFER_TRACE(bh
, "not a new buffer");
928 struct buffer_head
*ext3_bread(handle_t
*handle
, struct inode
* inode
,
929 int block
, int create
, int *err
)
931 struct buffer_head
* bh
;
933 bh
= ext3_getblk(handle
, inode
, block
, create
, err
);
936 if (buffer_uptodate(bh
))
938 ll_rw_block(READ
, 1, &bh
);
940 if (buffer_uptodate(bh
))
947 static int walk_page_buffers( handle_t
*handle
,
948 struct buffer_head
*head
,
952 int (*fn
)( handle_t
*handle
,
953 struct buffer_head
*bh
))
955 struct buffer_head
*bh
;
956 unsigned block_start
, block_end
;
957 unsigned blocksize
= head
->b_size
;
959 struct buffer_head
*next
;
961 for ( bh
= head
, block_start
= 0;
962 ret
== 0 && (bh
!= head
|| !block_start
);
963 block_start
= block_end
, bh
= next
)
965 next
= bh
->b_this_page
;
966 block_end
= block_start
+ blocksize
;
967 if (block_end
<= from
|| block_start
>= to
) {
968 if (partial
&& !buffer_uptodate(bh
))
972 err
= (*fn
)(handle
, bh
);
980 * To preserve ordering, it is essential that the hole instantiation and
981 * the data write be encapsulated in a single transaction. We cannot
982 * close off a transaction and start a new one between the ext3_get_block()
983 * and the commit_write(). So doing the journal_start at the start of
984 * prepare_write() is the right place.
986 * Also, this function can nest inside ext3_writepage() ->
987 * block_write_full_page(). In that case, we *know* that ext3_writepage()
988 * has generated enough buffer credits to do the whole page. So we won't
989 * block on the journal in that case, which is good, because the caller may
992 * By accident, ext3 can be reentered when a transaction is open via
993 * quota file writes. If we were to commit the transaction while thus
994 * reentered, there can be a deadlock - we would be holding a quota
995 * lock, and the commit would never complete if another thread had a
996 * transaction open and was blocking on the quota lock - a ranking
999 * So what we do is to rely on the fact that journal_stop/journal_start
1000 * will _not_ run commit under these circumstances because handle->h_ref
1001 * is elevated. We'll still have enough credits for the tiny quotafile
1005 static int do_journal_get_write_access(handle_t
*handle
,
1006 struct buffer_head
*bh
)
1008 if (!buffer_mapped(bh
) || buffer_freed(bh
))
1010 return ext3_journal_get_write_access(handle
, bh
);
1013 static int ext3_prepare_write(struct file
*file
, struct page
*page
,
1014 unsigned from
, unsigned to
)
1016 struct inode
*inode
= page
->mapping
->host
;
1017 int ret
, needed_blocks
= ext3_writepage_trans_blocks(inode
);
1022 handle
= ext3_journal_start(inode
, needed_blocks
);
1023 if (IS_ERR(handle
)) {
1024 ret
= PTR_ERR(handle
);
1027 if (test_opt(inode
->i_sb
, NOBH
))
1028 ret
= nobh_prepare_write(page
, from
, to
, ext3_get_block
);
1030 ret
= block_prepare_write(page
, from
, to
, ext3_get_block
);
1032 goto prepare_write_failed
;
1034 if (ext3_should_journal_data(inode
)) {
1035 ret
= walk_page_buffers(handle
, page_buffers(page
),
1036 from
, to
, NULL
, do_journal_get_write_access
);
1038 prepare_write_failed
:
1040 ext3_journal_stop(handle
);
1041 if (ret
== -ENOSPC
&& ext3_should_retry_alloc(inode
->i_sb
, &retries
))
1048 ext3_journal_dirty_data(handle_t
*handle
, struct buffer_head
*bh
)
1050 int err
= journal_dirty_data(handle
, bh
);
1052 ext3_journal_abort_handle(__FUNCTION__
, __FUNCTION__
,
1057 /* For commit_write() in data=journal mode */
1058 static int commit_write_fn(handle_t
*handle
, struct buffer_head
*bh
)
1060 if (!buffer_mapped(bh
) || buffer_freed(bh
))
1062 set_buffer_uptodate(bh
);
1063 return ext3_journal_dirty_metadata(handle
, bh
);
1067 * We need to pick up the new inode size which generic_commit_write gave us
1068 * `file' can be NULL - eg, when called from page_symlink().
1070 * ext3 never places buffers on inode->i_mapping->private_list. metadata
1071 * buffers are managed internally.
1074 static int ext3_ordered_commit_write(struct file
*file
, struct page
*page
,
1075 unsigned from
, unsigned to
)
1077 handle_t
*handle
= ext3_journal_current_handle();
1078 struct inode
*inode
= page
->mapping
->host
;
1081 ret
= walk_page_buffers(handle
, page_buffers(page
),
1082 from
, to
, NULL
, ext3_journal_dirty_data
);
1086 * generic_commit_write() will run mark_inode_dirty() if i_size
1087 * changes. So let's piggyback the i_disksize mark_inode_dirty
1092 new_i_size
= ((loff_t
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
1093 if (new_i_size
> EXT3_I(inode
)->i_disksize
)
1094 EXT3_I(inode
)->i_disksize
= new_i_size
;
1095 ret
= generic_commit_write(file
, page
, from
, to
);
1097 ret2
= ext3_journal_stop(handle
);
1103 static int ext3_writeback_commit_write(struct file
*file
, struct page
*page
,
1104 unsigned from
, unsigned to
)
1106 handle_t
*handle
= ext3_journal_current_handle();
1107 struct inode
*inode
= page
->mapping
->host
;
1111 new_i_size
= ((loff_t
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
1112 if (new_i_size
> EXT3_I(inode
)->i_disksize
)
1113 EXT3_I(inode
)->i_disksize
= new_i_size
;
1115 if (test_opt(inode
->i_sb
, NOBH
))
1116 ret
= nobh_commit_write(file
, page
, from
, to
);
1118 ret
= generic_commit_write(file
, page
, from
, to
);
1120 ret2
= ext3_journal_stop(handle
);
1126 static int ext3_journalled_commit_write(struct file
*file
,
1127 struct page
*page
, unsigned from
, unsigned to
)
1129 handle_t
*handle
= ext3_journal_current_handle();
1130 struct inode
*inode
= page
->mapping
->host
;
1136 * Here we duplicate the generic_commit_write() functionality
1138 pos
= ((loff_t
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
1140 ret
= walk_page_buffers(handle
, page_buffers(page
), from
,
1141 to
, &partial
, commit_write_fn
);
1143 SetPageUptodate(page
);
1144 if (pos
> inode
->i_size
)
1145 i_size_write(inode
, pos
);
1146 EXT3_I(inode
)->i_state
|= EXT3_STATE_JDATA
;
1147 if (inode
->i_size
> EXT3_I(inode
)->i_disksize
) {
1148 EXT3_I(inode
)->i_disksize
= inode
->i_size
;
1149 ret2
= ext3_mark_inode_dirty(handle
, inode
);
1153 ret2
= ext3_journal_stop(handle
);
1160 * bmap() is special. It gets used by applications such as lilo and by
1161 * the swapper to find the on-disk block of a specific piece of data.
1163 * Naturally, this is dangerous if the block concerned is still in the
1164 * journal. If somebody makes a swapfile on an ext3 data-journaling
1165 * filesystem and enables swap, then they may get a nasty shock when the
1166 * data getting swapped to that swapfile suddenly gets overwritten by
1167 * the original zero's written out previously to the journal and
1168 * awaiting writeback in the kernel's buffer cache.
1170 * So, if we see any bmap calls here on a modified, data-journaled file,
1171 * take extra steps to flush any blocks which might be in the cache.
1173 static sector_t
ext3_bmap(struct address_space
*mapping
, sector_t block
)
1175 struct inode
*inode
= mapping
->host
;
1179 if (EXT3_I(inode
)->i_state
& EXT3_STATE_JDATA
) {
1181 * This is a REALLY heavyweight approach, but the use of
1182 * bmap on dirty files is expected to be extremely rare:
1183 * only if we run lilo or swapon on a freshly made file
1184 * do we expect this to happen.
1186 * (bmap requires CAP_SYS_RAWIO so this does not
1187 * represent an unprivileged user DOS attack --- we'd be
1188 * in trouble if mortal users could trigger this path at
1191 * NB. EXT3_STATE_JDATA is not set on files other than
1192 * regular files. If somebody wants to bmap a directory
1193 * or symlink and gets confused because the buffer
1194 * hasn't yet been flushed to disk, they deserve
1195 * everything they get.
1198 EXT3_I(inode
)->i_state
&= ~EXT3_STATE_JDATA
;
1199 journal
= EXT3_JOURNAL(inode
);
1200 journal_lock_updates(journal
);
1201 err
= journal_flush(journal
);
1202 journal_unlock_updates(journal
);
1208 return generic_block_bmap(mapping
,block
,ext3_get_block
);
1211 static int bget_one(handle_t
*handle
, struct buffer_head
*bh
)
1217 static int bput_one(handle_t
*handle
, struct buffer_head
*bh
)
1223 static int journal_dirty_data_fn(handle_t
*handle
, struct buffer_head
*bh
)
1225 if (buffer_mapped(bh
))
1226 return ext3_journal_dirty_data(handle
, bh
);
1231 * Note that we always start a transaction even if we're not journalling
1232 * data. This is to preserve ordering: any hole instantiation within
1233 * __block_write_full_page -> ext3_get_block() should be journalled
1234 * along with the data so we don't crash and then get metadata which
1235 * refers to old data.
1237 * In all journalling modes block_write_full_page() will start the I/O.
1241 * ext3_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1246 * ext3_file_write() -> generic_file_write() -> __alloc_pages() -> ...
1248 * Same applies to ext3_get_block(). We will deadlock on various things like
1249 * lock_journal and i_truncate_sem.
1251 * Setting PF_MEMALLOC here doesn't work - too many internal memory
1254 * 16May01: If we're reentered then journal_current_handle() will be
1255 * non-zero. We simply *return*.
1257 * 1 July 2001: @@@ FIXME:
1258 * In journalled data mode, a data buffer may be metadata against the
1259 * current transaction. But the same file is part of a shared mapping
1260 * and someone does a writepage() on it.
1262 * We will move the buffer onto the async_data list, but *after* it has
1263 * been dirtied. So there's a small window where we have dirty data on
1266 * Note that this only applies to the last partial page in the file. The
1267 * bit which block_write_full_page() uses prepare/commit for. (That's
1268 * broken code anyway: it's wrong for msync()).
1270 * It's a rare case: affects the final partial page, for journalled data
1271 * where the file is subject to bith write() and writepage() in the same
1272 * transction. To fix it we'll need a custom block_write_full_page().
1273 * We'll probably need that anyway for journalling writepage() output.
1275 * We don't honour synchronous mounts for writepage(). That would be
1276 * disastrous. Any write() or metadata operation will sync the fs for
1279 * AKPM2: if all the page's buffers are mapped to disk and !data=journal,
1280 * we don't need to open a transaction here.
1282 static int ext3_ordered_writepage(struct page
*page
,
1283 struct writeback_control
*wbc
)
1285 struct inode
*inode
= page
->mapping
->host
;
1286 struct buffer_head
*page_bufs
;
1287 handle_t
*handle
= NULL
;
1291 J_ASSERT(PageLocked(page
));
1294 * We give up here if we're reentered, because it might be for a
1295 * different filesystem.
1297 if (ext3_journal_current_handle())
1300 handle
= ext3_journal_start(inode
, ext3_writepage_trans_blocks(inode
));
1302 if (IS_ERR(handle
)) {
1303 ret
= PTR_ERR(handle
);
1307 if (!page_has_buffers(page
)) {
1308 create_empty_buffers(page
, inode
->i_sb
->s_blocksize
,
1309 (1 << BH_Dirty
)|(1 << BH_Uptodate
));
1311 page_bufs
= page_buffers(page
);
1312 walk_page_buffers(handle
, page_bufs
, 0,
1313 PAGE_CACHE_SIZE
, NULL
, bget_one
);
1315 ret
= block_write_full_page(page
, ext3_get_block
, wbc
);
1318 * The page can become unlocked at any point now, and
1319 * truncate can then come in and change things. So we
1320 * can't touch *page from now on. But *page_bufs is
1321 * safe due to elevated refcount.
1325 * And attach them to the current transaction. But only if
1326 * block_write_full_page() succeeded. Otherwise they are unmapped,
1327 * and generally junk.
1330 err
= walk_page_buffers(handle
, page_bufs
, 0, PAGE_CACHE_SIZE
,
1331 NULL
, journal_dirty_data_fn
);
1335 walk_page_buffers(handle
, page_bufs
, 0,
1336 PAGE_CACHE_SIZE
, NULL
, bput_one
);
1337 err
= ext3_journal_stop(handle
);
1343 redirty_page_for_writepage(wbc
, page
);
1349 ext3_writeback_writepage_helper(struct page
*page
,
1350 struct writeback_control
*wbc
)
1352 return block_write_full_page(page
, ext3_get_block
, wbc
);
1356 ext3_writeback_writepages(struct address_space
*mapping
,
1357 struct writeback_control
*wbc
)
1359 struct inode
*inode
= mapping
->host
;
1360 handle_t
*handle
= NULL
;
1363 if (!mapping_tagged(mapping
, PAGECACHE_TAG_DIRTY
))
1366 handle
= ext3_journal_start(inode
, ext3_writepage_trans_blocks(inode
));
1367 if (IS_ERR(handle
)) {
1368 ret
= PTR_ERR(handle
);
1372 ret
= __mpage_writepages(mapping
, wbc
, ext3_writepages_get_block
,
1373 ext3_writeback_writepage_helper
);
1376 * Need to reaquire the handle since ext3_writepages_get_block()
1377 * can restart the handle
1379 handle
= journal_current_handle();
1381 err
= ext3_journal_stop(handle
);
1387 static int ext3_writeback_writepage(struct page
*page
,
1388 struct writeback_control
*wbc
)
1390 struct inode
*inode
= page
->mapping
->host
;
1391 handle_t
*handle
= NULL
;
1395 if (ext3_journal_current_handle())
1398 handle
= ext3_journal_start(inode
, ext3_writepage_trans_blocks(inode
));
1399 if (IS_ERR(handle
)) {
1400 ret
= PTR_ERR(handle
);
1404 if (test_opt(inode
->i_sb
, NOBH
))
1405 ret
= nobh_writepage(page
, ext3_get_block
, wbc
);
1407 ret
= block_write_full_page(page
, ext3_get_block
, wbc
);
1409 err
= ext3_journal_stop(handle
);
1415 redirty_page_for_writepage(wbc
, page
);
1420 static int ext3_journalled_writepage(struct page
*page
,
1421 struct writeback_control
*wbc
)
1423 struct inode
*inode
= page
->mapping
->host
;
1424 handle_t
*handle
= NULL
;
1428 if (ext3_journal_current_handle())
1431 handle
= ext3_journal_start(inode
, ext3_writepage_trans_blocks(inode
));
1432 if (IS_ERR(handle
)) {
1433 ret
= PTR_ERR(handle
);
1437 if (!page_has_buffers(page
) || PageChecked(page
)) {
1439 * It's mmapped pagecache. Add buffers and journal it. There
1440 * doesn't seem much point in redirtying the page here.
1442 ClearPageChecked(page
);
1443 ret
= block_prepare_write(page
, 0, PAGE_CACHE_SIZE
,
1447 ret
= walk_page_buffers(handle
, page_buffers(page
), 0,
1448 PAGE_CACHE_SIZE
, NULL
, do_journal_get_write_access
);
1450 err
= walk_page_buffers(handle
, page_buffers(page
), 0,
1451 PAGE_CACHE_SIZE
, NULL
, commit_write_fn
);
1454 EXT3_I(inode
)->i_state
|= EXT3_STATE_JDATA
;
1458 * It may be a page full of checkpoint-mode buffers. We don't
1459 * really know unless we go poke around in the buffer_heads.
1460 * But block_write_full_page will do the right thing.
1462 ret
= block_write_full_page(page
, ext3_get_block
, wbc
);
1464 err
= ext3_journal_stop(handle
);
1471 redirty_page_for_writepage(wbc
, page
);
1477 static int ext3_readpage(struct file
*file
, struct page
*page
)
1479 return mpage_readpage(page
, ext3_get_block
);
1483 ext3_readpages(struct file
*file
, struct address_space
*mapping
,
1484 struct list_head
*pages
, unsigned nr_pages
)
1486 return mpage_readpages(mapping
, pages
, nr_pages
, ext3_get_block
);
1489 static int ext3_invalidatepage(struct page
*page
, unsigned long offset
)
1491 journal_t
*journal
= EXT3_JOURNAL(page
->mapping
->host
);
1494 * If it's a full truncate we just forget about the pending dirtying
1497 ClearPageChecked(page
);
1499 return journal_invalidatepage(journal
, page
, offset
);
1502 static int ext3_releasepage(struct page
*page
, int wait
)
1504 journal_t
*journal
= EXT3_JOURNAL(page
->mapping
->host
);
1506 WARN_ON(PageChecked(page
));
1507 if (!page_has_buffers(page
))
1509 return journal_try_to_free_buffers(journal
, page
, wait
);
1513 * If the O_DIRECT write will extend the file then add this inode to the
1514 * orphan list. So recovery will truncate it back to the original size
1515 * if the machine crashes during the write.
1517 * If the O_DIRECT write is intantiating holes inside i_size and the machine
1518 * crashes then stale disk data _may_ be exposed inside the file.
1520 static ssize_t
ext3_direct_IO(int rw
, struct kiocb
*iocb
,
1521 const struct iovec
*iov
, loff_t offset
,
1522 unsigned long nr_segs
)
1524 struct file
*file
= iocb
->ki_filp
;
1525 struct inode
*inode
= file
->f_mapping
->host
;
1526 struct ext3_inode_info
*ei
= EXT3_I(inode
);
1527 handle_t
*handle
= NULL
;
1530 size_t count
= iov_length(iov
, nr_segs
);
1533 loff_t final_size
= offset
+ count
;
1535 handle
= ext3_journal_start(inode
, DIO_CREDITS
);
1536 if (IS_ERR(handle
)) {
1537 ret
= PTR_ERR(handle
);
1540 if (final_size
> inode
->i_size
) {
1541 ret
= ext3_orphan_add(handle
, inode
);
1545 ei
->i_disksize
= inode
->i_size
;
1549 ret
= blockdev_direct_IO(rw
, iocb
, inode
, inode
->i_sb
->s_bdev
, iov
,
1551 ext3_direct_io_get_blocks
, NULL
);
1554 * Reacquire the handle: ext3_direct_io_get_block() can restart the
1557 handle
= journal_current_handle();
1563 if (orphan
&& inode
->i_nlink
)
1564 ext3_orphan_del(handle
, inode
);
1565 if (orphan
&& ret
> 0) {
1566 loff_t end
= offset
+ ret
;
1567 if (end
> inode
->i_size
) {
1568 ei
->i_disksize
= end
;
1569 i_size_write(inode
, end
);
1571 * We're going to return a positive `ret'
1572 * here due to non-zero-length I/O, so there's
1573 * no way of reporting error returns from
1574 * ext3_mark_inode_dirty() to userspace. So
1577 ext3_mark_inode_dirty(handle
, inode
);
1580 err
= ext3_journal_stop(handle
);
1589 * Pages can be marked dirty completely asynchronously from ext3's journalling
1590 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
1591 * much here because ->set_page_dirty is called under VFS locks. The page is
1592 * not necessarily locked.
1594 * We cannot just dirty the page and leave attached buffers clean, because the
1595 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
1596 * or jbddirty because all the journalling code will explode.
1598 * So what we do is to mark the page "pending dirty" and next time writepage
1599 * is called, propagate that into the buffers appropriately.
1601 static int ext3_journalled_set_page_dirty(struct page
*page
)
1603 SetPageChecked(page
);
1604 return __set_page_dirty_nobuffers(page
);
1607 static struct address_space_operations ext3_ordered_aops
= {
1608 .readpage
= ext3_readpage
,
1609 .readpages
= ext3_readpages
,
1610 .writepage
= ext3_ordered_writepage
,
1611 .sync_page
= block_sync_page
,
1612 .prepare_write
= ext3_prepare_write
,
1613 .commit_write
= ext3_ordered_commit_write
,
1615 .invalidatepage
= ext3_invalidatepage
,
1616 .releasepage
= ext3_releasepage
,
1617 .direct_IO
= ext3_direct_IO
,
1620 static struct address_space_operations ext3_writeback_aops
= {
1621 .readpage
= ext3_readpage
,
1622 .readpages
= ext3_readpages
,
1623 .writepage
= ext3_writeback_writepage
,
1624 .writepages
= ext3_writeback_writepages
,
1625 .sync_page
= block_sync_page
,
1626 .prepare_write
= ext3_prepare_write
,
1627 .commit_write
= ext3_writeback_commit_write
,
1629 .invalidatepage
= ext3_invalidatepage
,
1630 .releasepage
= ext3_releasepage
,
1631 .direct_IO
= ext3_direct_IO
,
1634 static struct address_space_operations ext3_journalled_aops
= {
1635 .readpage
= ext3_readpage
,
1636 .readpages
= ext3_readpages
,
1637 .writepage
= ext3_journalled_writepage
,
1638 .sync_page
= block_sync_page
,
1639 .prepare_write
= ext3_prepare_write
,
1640 .commit_write
= ext3_journalled_commit_write
,
1641 .set_page_dirty
= ext3_journalled_set_page_dirty
,
1643 .invalidatepage
= ext3_invalidatepage
,
1644 .releasepage
= ext3_releasepage
,
1647 void ext3_set_aops(struct inode
*inode
)
1649 if (ext3_should_order_data(inode
))
1650 inode
->i_mapping
->a_ops
= &ext3_ordered_aops
;
1651 else if (ext3_should_writeback_data(inode
))
1652 inode
->i_mapping
->a_ops
= &ext3_writeback_aops
;
1654 inode
->i_mapping
->a_ops
= &ext3_journalled_aops
;
1658 * ext3_block_truncate_page() zeroes out a mapping from file offset `from'
1659 * up to the end of the block which corresponds to `from'.
1660 * This required during truncate. We need to physically zero the tail end
1661 * of that block so it doesn't yield old data if the file is later grown.
1663 static int ext3_block_truncate_page(handle_t
*handle
, struct page
*page
,
1664 struct address_space
*mapping
, loff_t from
)
1666 unsigned long index
= from
>> PAGE_CACHE_SHIFT
;
1667 unsigned offset
= from
& (PAGE_CACHE_SIZE
-1);
1668 unsigned blocksize
, iblock
, length
, pos
;
1669 struct inode
*inode
= mapping
->host
;
1670 struct buffer_head
*bh
;
1674 blocksize
= inode
->i_sb
->s_blocksize
;
1675 length
= blocksize
- (offset
& (blocksize
- 1));
1676 iblock
= index
<< (PAGE_CACHE_SHIFT
- inode
->i_sb
->s_blocksize_bits
);
1679 * For "nobh" option, we can only work if we don't need to
1680 * read-in the page - otherwise we create buffers to do the IO.
1682 if (!page_has_buffers(page
) && test_opt(inode
->i_sb
, NOBH
)) {
1683 if (PageUptodate(page
)) {
1684 kaddr
= kmap_atomic(page
, KM_USER0
);
1685 memset(kaddr
+ offset
, 0, length
);
1686 flush_dcache_page(page
);
1687 kunmap_atomic(kaddr
, KM_USER0
);
1688 set_page_dirty(page
);
1693 if (!page_has_buffers(page
))
1694 create_empty_buffers(page
, blocksize
, 0);
1696 /* Find the buffer that contains "offset" */
1697 bh
= page_buffers(page
);
1699 while (offset
>= pos
) {
1700 bh
= bh
->b_this_page
;
1706 if (buffer_freed(bh
)) {
1707 BUFFER_TRACE(bh
, "freed: skip");
1711 if (!buffer_mapped(bh
)) {
1712 BUFFER_TRACE(bh
, "unmapped");
1713 ext3_get_block(inode
, iblock
, bh
, 0);
1714 /* unmapped? It's a hole - nothing to do */
1715 if (!buffer_mapped(bh
)) {
1716 BUFFER_TRACE(bh
, "still unmapped");
1721 /* Ok, it's mapped. Make sure it's up-to-date */
1722 if (PageUptodate(page
))
1723 set_buffer_uptodate(bh
);
1725 if (!buffer_uptodate(bh
)) {
1727 ll_rw_block(READ
, 1, &bh
);
1729 /* Uhhuh. Read error. Complain and punt. */
1730 if (!buffer_uptodate(bh
))
1734 if (ext3_should_journal_data(inode
)) {
1735 BUFFER_TRACE(bh
, "get write access");
1736 err
= ext3_journal_get_write_access(handle
, bh
);
1741 kaddr
= kmap_atomic(page
, KM_USER0
);
1742 memset(kaddr
+ offset
, 0, length
);
1743 flush_dcache_page(page
);
1744 kunmap_atomic(kaddr
, KM_USER0
);
1746 BUFFER_TRACE(bh
, "zeroed end of block");
1749 if (ext3_should_journal_data(inode
)) {
1750 err
= ext3_journal_dirty_metadata(handle
, bh
);
1752 if (ext3_should_order_data(inode
))
1753 err
= ext3_journal_dirty_data(handle
, bh
);
1754 mark_buffer_dirty(bh
);
1759 page_cache_release(page
);
1764 * Probably it should be a library function... search for first non-zero word
1765 * or memcmp with zero_page, whatever is better for particular architecture.
1768 static inline int all_zeroes(__le32
*p
, __le32
*q
)
1777 * ext3_find_shared - find the indirect blocks for partial truncation.
1778 * @inode: inode in question
1779 * @depth: depth of the affected branch
1780 * @offsets: offsets of pointers in that branch (see ext3_block_to_path)
1781 * @chain: place to store the pointers to partial indirect blocks
1782 * @top: place to the (detached) top of branch
1784 * This is a helper function used by ext3_truncate().
1786 * When we do truncate() we may have to clean the ends of several
1787 * indirect blocks but leave the blocks themselves alive. Block is
1788 * partially truncated if some data below the new i_size is refered
1789 * from it (and it is on the path to the first completely truncated
1790 * data block, indeed). We have to free the top of that path along
1791 * with everything to the right of the path. Since no allocation
1792 * past the truncation point is possible until ext3_truncate()
1793 * finishes, we may safely do the latter, but top of branch may
1794 * require special attention - pageout below the truncation point
1795 * might try to populate it.
1797 * We atomically detach the top of branch from the tree, store the
1798 * block number of its root in *@top, pointers to buffer_heads of
1799 * partially truncated blocks - in @chain[].bh and pointers to
1800 * their last elements that should not be removed - in
1801 * @chain[].p. Return value is the pointer to last filled element
1804 * The work left to caller to do the actual freeing of subtrees:
1805 * a) free the subtree starting from *@top
1806 * b) free the subtrees whose roots are stored in
1807 * (@chain[i].p+1 .. end of @chain[i].bh->b_data)
1808 * c) free the subtrees growing from the inode past the @chain[0].
1809 * (no partially truncated stuff there). */
1811 static Indirect
*ext3_find_shared(struct inode
*inode
,
1817 Indirect
*partial
, *p
;
1821 /* Make k index the deepest non-null offest + 1 */
1822 for (k
= depth
; k
> 1 && !offsets
[k
-1]; k
--)
1824 partial
= ext3_get_branch(inode
, k
, offsets
, chain
, &err
);
1825 /* Writer: pointers */
1827 partial
= chain
+ k
-1;
1829 * If the branch acquired continuation since we've looked at it -
1830 * fine, it should all survive and (new) top doesn't belong to us.
1832 if (!partial
->key
&& *partial
->p
)
1835 for (p
=partial
; p
>chain
&& all_zeroes((__le32
*)p
->bh
->b_data
,p
->p
); p
--)
1838 * OK, we've found the last block that must survive. The rest of our
1839 * branch should be detached before unlocking. However, if that rest
1840 * of branch is all ours and does not grow immediately from the inode
1841 * it's easier to cheat and just decrement partial->p.
1843 if (p
== chain
+ k
- 1 && p
> chain
) {
1847 /* Nope, don't do this in ext3. Must leave the tree intact */
1856 brelse(partial
->bh
);
1864 * Zero a number of block pointers in either an inode or an indirect block.
1865 * If we restart the transaction we must again get write access to the
1866 * indirect block for further modification.
1868 * We release `count' blocks on disk, but (last - first) may be greater
1869 * than `count' because there can be holes in there.
1872 ext3_clear_blocks(handle_t
*handle
, struct inode
*inode
, struct buffer_head
*bh
,
1873 unsigned long block_to_free
, unsigned long count
,
1874 __le32
*first
, __le32
*last
)
1877 if (try_to_extend_transaction(handle
, inode
)) {
1879 BUFFER_TRACE(bh
, "call ext3_journal_dirty_metadata");
1880 ext3_journal_dirty_metadata(handle
, bh
);
1882 ext3_mark_inode_dirty(handle
, inode
);
1883 ext3_journal_test_restart(handle
, inode
);
1885 BUFFER_TRACE(bh
, "retaking write access");
1886 ext3_journal_get_write_access(handle
, bh
);
1891 * Any buffers which are on the journal will be in memory. We find
1892 * them on the hash table so journal_revoke() will run journal_forget()
1893 * on them. We've already detached each block from the file, so
1894 * bforget() in journal_forget() should be safe.
1896 * AKPM: turn on bforget in journal_forget()!!!
1898 for (p
= first
; p
< last
; p
++) {
1899 u32 nr
= le32_to_cpu(*p
);
1901 struct buffer_head
*bh
;
1904 bh
= sb_find_get_block(inode
->i_sb
, nr
);
1905 ext3_forget(handle
, 0, inode
, bh
, nr
);
1909 ext3_free_blocks(handle
, inode
, block_to_free
, count
);
1913 * ext3_free_data - free a list of data blocks
1914 * @handle: handle for this transaction
1915 * @inode: inode we are dealing with
1916 * @this_bh: indirect buffer_head which contains *@first and *@last
1917 * @first: array of block numbers
1918 * @last: points immediately past the end of array
1920 * We are freeing all blocks refered from that array (numbers are stored as
1921 * little-endian 32-bit) and updating @inode->i_blocks appropriately.
1923 * We accumulate contiguous runs of blocks to free. Conveniently, if these
1924 * blocks are contiguous then releasing them at one time will only affect one
1925 * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
1926 * actually use a lot of journal space.
1928 * @this_bh will be %NULL if @first and @last point into the inode's direct
1931 static void ext3_free_data(handle_t
*handle
, struct inode
*inode
,
1932 struct buffer_head
*this_bh
,
1933 __le32
*first
, __le32
*last
)
1935 unsigned long block_to_free
= 0; /* Starting block # of a run */
1936 unsigned long count
= 0; /* Number of blocks in the run */
1937 __le32
*block_to_free_p
= NULL
; /* Pointer into inode/ind
1940 unsigned long nr
; /* Current block # */
1941 __le32
*p
; /* Pointer into inode/ind
1942 for current block */
1945 if (this_bh
) { /* For indirect block */
1946 BUFFER_TRACE(this_bh
, "get_write_access");
1947 err
= ext3_journal_get_write_access(handle
, this_bh
);
1948 /* Important: if we can't update the indirect pointers
1949 * to the blocks, we can't free them. */
1954 for (p
= first
; p
< last
; p
++) {
1955 nr
= le32_to_cpu(*p
);
1957 /* accumulate blocks to free if they're contiguous */
1960 block_to_free_p
= p
;
1962 } else if (nr
== block_to_free
+ count
) {
1965 ext3_clear_blocks(handle
, inode
, this_bh
,
1967 count
, block_to_free_p
, p
);
1969 block_to_free_p
= p
;
1976 ext3_clear_blocks(handle
, inode
, this_bh
, block_to_free
,
1977 count
, block_to_free_p
, p
);
1980 BUFFER_TRACE(this_bh
, "call ext3_journal_dirty_metadata");
1981 ext3_journal_dirty_metadata(handle
, this_bh
);
1986 * ext3_free_branches - free an array of branches
1987 * @handle: JBD handle for this transaction
1988 * @inode: inode we are dealing with
1989 * @parent_bh: the buffer_head which contains *@first and *@last
1990 * @first: array of block numbers
1991 * @last: pointer immediately past the end of array
1992 * @depth: depth of the branches to free
1994 * We are freeing all blocks refered from these branches (numbers are
1995 * stored as little-endian 32-bit) and updating @inode->i_blocks
1998 static void ext3_free_branches(handle_t
*handle
, struct inode
*inode
,
1999 struct buffer_head
*parent_bh
,
2000 __le32
*first
, __le32
*last
, int depth
)
2005 if (is_handle_aborted(handle
))
2009 struct buffer_head
*bh
;
2010 int addr_per_block
= EXT3_ADDR_PER_BLOCK(inode
->i_sb
);
2012 while (--p
>= first
) {
2013 nr
= le32_to_cpu(*p
);
2015 continue; /* A hole */
2017 /* Go read the buffer for the next level down */
2018 bh
= sb_bread(inode
->i_sb
, nr
);
2021 * A read failure? Report error and clear slot
2025 ext3_error(inode
->i_sb
, "ext3_free_branches",
2026 "Read failure, inode=%ld, block=%ld",
2031 /* This zaps the entire block. Bottom up. */
2032 BUFFER_TRACE(bh
, "free child branches");
2033 ext3_free_branches(handle
, inode
, bh
,
2034 (__le32
*)bh
->b_data
,
2035 (__le32
*)bh
->b_data
+ addr_per_block
,
2039 * We've probably journalled the indirect block several
2040 * times during the truncate. But it's no longer
2041 * needed and we now drop it from the transaction via
2044 * That's easy if it's exclusively part of this
2045 * transaction. But if it's part of the committing
2046 * transaction then journal_forget() will simply
2047 * brelse() it. That means that if the underlying
2048 * block is reallocated in ext3_get_block(),
2049 * unmap_underlying_metadata() will find this block
2050 * and will try to get rid of it. damn, damn.
2052 * If this block has already been committed to the
2053 * journal, a revoke record will be written. And
2054 * revoke records must be emitted *before* clearing
2055 * this block's bit in the bitmaps.
2057 ext3_forget(handle
, 1, inode
, bh
, bh
->b_blocknr
);
2060 * Everything below this this pointer has been
2061 * released. Now let this top-of-subtree go.
2063 * We want the freeing of this indirect block to be
2064 * atomic in the journal with the updating of the
2065 * bitmap block which owns it. So make some room in
2068 * We zero the parent pointer *after* freeing its
2069 * pointee in the bitmaps, so if extend_transaction()
2070 * for some reason fails to put the bitmap changes and
2071 * the release into the same transaction, recovery
2072 * will merely complain about releasing a free block,
2073 * rather than leaking blocks.
2075 if (is_handle_aborted(handle
))
2077 if (try_to_extend_transaction(handle
, inode
)) {
2078 ext3_mark_inode_dirty(handle
, inode
);
2079 ext3_journal_test_restart(handle
, inode
);
2082 ext3_free_blocks(handle
, inode
, nr
, 1);
2086 * The block which we have just freed is
2087 * pointed to by an indirect block: journal it
2089 BUFFER_TRACE(parent_bh
, "get_write_access");
2090 if (!ext3_journal_get_write_access(handle
,
2093 BUFFER_TRACE(parent_bh
,
2094 "call ext3_journal_dirty_metadata");
2095 ext3_journal_dirty_metadata(handle
,
2101 /* We have reached the bottom of the tree. */
2102 BUFFER_TRACE(parent_bh
, "free data blocks");
2103 ext3_free_data(handle
, inode
, parent_bh
, first
, last
);
2110 * We block out ext3_get_block() block instantiations across the entire
2111 * transaction, and VFS/VM ensures that ext3_truncate() cannot run
2112 * simultaneously on behalf of the same inode.
2114 * As we work through the truncate and commmit bits of it to the journal there
2115 * is one core, guiding principle: the file's tree must always be consistent on
2116 * disk. We must be able to restart the truncate after a crash.
2118 * The file's tree may be transiently inconsistent in memory (although it
2119 * probably isn't), but whenever we close off and commit a journal transaction,
2120 * the contents of (the filesystem + the journal) must be consistent and
2121 * restartable. It's pretty simple, really: bottom up, right to left (although
2122 * left-to-right works OK too).
2124 * Note that at recovery time, journal replay occurs *before* the restart of
2125 * truncate against the orphan inode list.
2127 * The committed inode has the new, desired i_size (which is the same as
2128 * i_disksize in this case). After a crash, ext3_orphan_cleanup() will see
2129 * that this inode's truncate did not complete and it will again call
2130 * ext3_truncate() to have another go. So there will be instantiated blocks
2131 * to the right of the truncation point in a crashed ext3 filesystem. But
2132 * that's fine - as long as they are linked from the inode, the post-crash
2133 * ext3_truncate() run will find them and release them.
2136 void ext3_truncate(struct inode
* inode
)
2139 struct ext3_inode_info
*ei
= EXT3_I(inode
);
2140 __le32
*i_data
= ei
->i_data
;
2141 int addr_per_block
= EXT3_ADDR_PER_BLOCK(inode
->i_sb
);
2142 struct address_space
*mapping
= inode
->i_mapping
;
2149 unsigned blocksize
= inode
->i_sb
->s_blocksize
;
2152 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
2153 S_ISLNK(inode
->i_mode
)))
2155 if (ext3_inode_is_fast_symlink(inode
))
2157 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
2161 * We have to lock the EOF page here, because lock_page() nests
2162 * outside journal_start().
2164 if ((inode
->i_size
& (blocksize
- 1)) == 0) {
2165 /* Block boundary? Nothing to do */
2168 page
= grab_cache_page(mapping
,
2169 inode
->i_size
>> PAGE_CACHE_SHIFT
);
2174 handle
= start_transaction(inode
);
2175 if (IS_ERR(handle
)) {
2177 clear_highpage(page
);
2178 flush_dcache_page(page
);
2180 page_cache_release(page
);
2182 return; /* AKPM: return what? */
2185 last_block
= (inode
->i_size
+ blocksize
-1)
2186 >> EXT3_BLOCK_SIZE_BITS(inode
->i_sb
);
2189 ext3_block_truncate_page(handle
, page
, mapping
, inode
->i_size
);
2191 n
= ext3_block_to_path(inode
, last_block
, offsets
, NULL
);
2193 goto out_stop
; /* error */
2196 * OK. This truncate is going to happen. We add the inode to the
2197 * orphan list, so that if this truncate spans multiple transactions,
2198 * and we crash, we will resume the truncate when the filesystem
2199 * recovers. It also marks the inode dirty, to catch the new size.
2201 * Implication: the file must always be in a sane, consistent
2202 * truncatable state while each transaction commits.
2204 if (ext3_orphan_add(handle
, inode
))
2208 * The orphan list entry will now protect us from any crash which
2209 * occurs before the truncate completes, so it is now safe to propagate
2210 * the new, shorter inode size (held for now in i_size) into the
2211 * on-disk inode. We do this via i_disksize, which is the value which
2212 * ext3 *really* writes onto the disk inode.
2214 ei
->i_disksize
= inode
->i_size
;
2217 * From here we block out all ext3_get_block() callers who want to
2218 * modify the block allocation tree.
2220 down(&ei
->truncate_sem
);
2222 if (n
== 1) { /* direct blocks */
2223 ext3_free_data(handle
, inode
, NULL
, i_data
+offsets
[0],
2224 i_data
+ EXT3_NDIR_BLOCKS
);
2228 partial
= ext3_find_shared(inode
, n
, offsets
, chain
, &nr
);
2229 /* Kill the top of shared branch (not detached) */
2231 if (partial
== chain
) {
2232 /* Shared branch grows from the inode */
2233 ext3_free_branches(handle
, inode
, NULL
,
2234 &nr
, &nr
+1, (chain
+n
-1) - partial
);
2237 * We mark the inode dirty prior to restart,
2238 * and prior to stop. No need for it here.
2241 /* Shared branch grows from an indirect block */
2242 BUFFER_TRACE(partial
->bh
, "get_write_access");
2243 ext3_free_branches(handle
, inode
, partial
->bh
,
2245 partial
->p
+1, (chain
+n
-1) - partial
);
2248 /* Clear the ends of indirect blocks on the shared branch */
2249 while (partial
> chain
) {
2250 ext3_free_branches(handle
, inode
, partial
->bh
, partial
->p
+ 1,
2251 (__le32
*)partial
->bh
->b_data
+addr_per_block
,
2252 (chain
+n
-1) - partial
);
2253 BUFFER_TRACE(partial
->bh
, "call brelse");
2254 brelse (partial
->bh
);
2258 /* Kill the remaining (whole) subtrees */
2259 switch (offsets
[0]) {
2261 nr
= i_data
[EXT3_IND_BLOCK
];
2263 ext3_free_branches(handle
, inode
, NULL
,
2265 i_data
[EXT3_IND_BLOCK
] = 0;
2267 case EXT3_IND_BLOCK
:
2268 nr
= i_data
[EXT3_DIND_BLOCK
];
2270 ext3_free_branches(handle
, inode
, NULL
,
2272 i_data
[EXT3_DIND_BLOCK
] = 0;
2274 case EXT3_DIND_BLOCK
:
2275 nr
= i_data
[EXT3_TIND_BLOCK
];
2277 ext3_free_branches(handle
, inode
, NULL
,
2279 i_data
[EXT3_TIND_BLOCK
] = 0;
2281 case EXT3_TIND_BLOCK
:
2285 ext3_discard_reservation(inode
);
2287 up(&ei
->truncate_sem
);
2288 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
2289 ext3_mark_inode_dirty(handle
, inode
);
2291 /* In a multi-transaction truncate, we only make the final
2292 * transaction synchronous */
2297 * If this was a simple ftruncate(), and the file will remain alive
2298 * then we need to clear up the orphan record which we created above.
2299 * However, if this was a real unlink then we were called by
2300 * ext3_delete_inode(), and we allow that function to clean up the
2301 * orphan info for us.
2304 ext3_orphan_del(handle
, inode
);
2306 ext3_journal_stop(handle
);
2309 static unsigned long ext3_get_inode_block(struct super_block
*sb
,
2310 unsigned long ino
, struct ext3_iloc
*iloc
)
2312 unsigned long desc
, group_desc
, block_group
;
2313 unsigned long offset
, block
;
2314 struct buffer_head
*bh
;
2315 struct ext3_group_desc
* gdp
;
2318 if ((ino
!= EXT3_ROOT_INO
&&
2319 ino
!= EXT3_JOURNAL_INO
&&
2320 ino
!= EXT3_RESIZE_INO
&&
2321 ino
< EXT3_FIRST_INO(sb
)) ||
2323 EXT3_SB(sb
)->s_es
->s_inodes_count
)) {
2324 ext3_error (sb
, "ext3_get_inode_block",
2325 "bad inode number: %lu", ino
);
2328 block_group
= (ino
- 1) / EXT3_INODES_PER_GROUP(sb
);
2329 if (block_group
>= EXT3_SB(sb
)->s_groups_count
) {
2330 ext3_error (sb
, "ext3_get_inode_block",
2331 "group >= groups count");
2335 group_desc
= block_group
>> EXT3_DESC_PER_BLOCK_BITS(sb
);
2336 desc
= block_group
& (EXT3_DESC_PER_BLOCK(sb
) - 1);
2337 bh
= EXT3_SB(sb
)->s_group_desc
[group_desc
];
2339 ext3_error (sb
, "ext3_get_inode_block",
2340 "Descriptor not loaded");
2344 gdp
= (struct ext3_group_desc
*) bh
->b_data
;
2346 * Figure out the offset within the block group inode table
2348 offset
= ((ino
- 1) % EXT3_INODES_PER_GROUP(sb
)) *
2349 EXT3_INODE_SIZE(sb
);
2350 block
= le32_to_cpu(gdp
[desc
].bg_inode_table
) +
2351 (offset
>> EXT3_BLOCK_SIZE_BITS(sb
));
2353 iloc
->block_group
= block_group
;
2354 iloc
->offset
= offset
& (EXT3_BLOCK_SIZE(sb
) - 1);
2359 * ext3_get_inode_loc returns with an extra refcount against the inode's
2360 * underlying buffer_head on success. If 'in_mem' is true, we have all
2361 * data in memory that is needed to recreate the on-disk version of this
2364 static int __ext3_get_inode_loc(struct inode
*inode
,
2365 struct ext3_iloc
*iloc
, int in_mem
)
2367 unsigned long block
;
2368 struct buffer_head
*bh
;
2370 block
= ext3_get_inode_block(inode
->i_sb
, inode
->i_ino
, iloc
);
2374 bh
= sb_getblk(inode
->i_sb
, block
);
2376 ext3_error (inode
->i_sb
, "ext3_get_inode_loc",
2377 "unable to read inode block - "
2378 "inode=%lu, block=%lu", inode
->i_ino
, block
);
2381 if (!buffer_uptodate(bh
)) {
2383 if (buffer_uptodate(bh
)) {
2384 /* someone brought it uptodate while we waited */
2390 * If we have all information of the inode in memory and this
2391 * is the only valid inode in the block, we need not read the
2395 struct buffer_head
*bitmap_bh
;
2396 struct ext3_group_desc
*desc
;
2397 int inodes_per_buffer
;
2398 int inode_offset
, i
;
2402 block_group
= (inode
->i_ino
- 1) /
2403 EXT3_INODES_PER_GROUP(inode
->i_sb
);
2404 inodes_per_buffer
= bh
->b_size
/
2405 EXT3_INODE_SIZE(inode
->i_sb
);
2406 inode_offset
= ((inode
->i_ino
- 1) %
2407 EXT3_INODES_PER_GROUP(inode
->i_sb
));
2408 start
= inode_offset
& ~(inodes_per_buffer
- 1);
2410 /* Is the inode bitmap in cache? */
2411 desc
= ext3_get_group_desc(inode
->i_sb
,
2416 bitmap_bh
= sb_getblk(inode
->i_sb
,
2417 le32_to_cpu(desc
->bg_inode_bitmap
));
2422 * If the inode bitmap isn't in cache then the
2423 * optimisation may end up performing two reads instead
2424 * of one, so skip it.
2426 if (!buffer_uptodate(bitmap_bh
)) {
2430 for (i
= start
; i
< start
+ inodes_per_buffer
; i
++) {
2431 if (i
== inode_offset
)
2433 if (ext3_test_bit(i
, bitmap_bh
->b_data
))
2437 if (i
== start
+ inodes_per_buffer
) {
2438 /* all other inodes are free, so skip I/O */
2439 memset(bh
->b_data
, 0, bh
->b_size
);
2440 set_buffer_uptodate(bh
);
2448 * There are other valid inodes in the buffer, this inode
2449 * has in-inode xattrs, or we don't have this inode in memory.
2450 * Read the block from disk.
2453 bh
->b_end_io
= end_buffer_read_sync
;
2454 submit_bh(READ
, bh
);
2456 if (!buffer_uptodate(bh
)) {
2457 ext3_error(inode
->i_sb
, "ext3_get_inode_loc",
2458 "unable to read inode block - "
2459 "inode=%lu, block=%lu",
2460 inode
->i_ino
, block
);
2470 int ext3_get_inode_loc(struct inode
*inode
, struct ext3_iloc
*iloc
)
2472 /* We have all inode data except xattrs in memory here. */
2473 return __ext3_get_inode_loc(inode
, iloc
,
2474 !(EXT3_I(inode
)->i_state
& EXT3_STATE_XATTR
));
2477 void ext3_set_inode_flags(struct inode
*inode
)
2479 unsigned int flags
= EXT3_I(inode
)->i_flags
;
2481 inode
->i_flags
&= ~(S_SYNC
|S_APPEND
|S_IMMUTABLE
|S_NOATIME
|S_DIRSYNC
);
2482 if (flags
& EXT3_SYNC_FL
)
2483 inode
->i_flags
|= S_SYNC
;
2484 if (flags
& EXT3_APPEND_FL
)
2485 inode
->i_flags
|= S_APPEND
;
2486 if (flags
& EXT3_IMMUTABLE_FL
)
2487 inode
->i_flags
|= S_IMMUTABLE
;
2488 if (flags
& EXT3_NOATIME_FL
)
2489 inode
->i_flags
|= S_NOATIME
;
2490 if (flags
& EXT3_DIRSYNC_FL
)
2491 inode
->i_flags
|= S_DIRSYNC
;
2494 void ext3_read_inode(struct inode
* inode
)
2496 struct ext3_iloc iloc
;
2497 struct ext3_inode
*raw_inode
;
2498 struct ext3_inode_info
*ei
= EXT3_I(inode
);
2499 struct buffer_head
*bh
;
2502 #ifdef CONFIG_EXT3_FS_POSIX_ACL
2503 ei
->i_acl
= EXT3_ACL_NOT_CACHED
;
2504 ei
->i_default_acl
= EXT3_ACL_NOT_CACHED
;
2506 ei
->i_block_alloc_info
= NULL
;
2508 if (__ext3_get_inode_loc(inode
, &iloc
, 0))
2511 raw_inode
= ext3_raw_inode(&iloc
);
2512 inode
->i_mode
= le16_to_cpu(raw_inode
->i_mode
);
2513 inode
->i_uid
= (uid_t
)le16_to_cpu(raw_inode
->i_uid_low
);
2514 inode
->i_gid
= (gid_t
)le16_to_cpu(raw_inode
->i_gid_low
);
2515 if(!(test_opt (inode
->i_sb
, NO_UID32
))) {
2516 inode
->i_uid
|= le16_to_cpu(raw_inode
->i_uid_high
) << 16;
2517 inode
->i_gid
|= le16_to_cpu(raw_inode
->i_gid_high
) << 16;
2519 inode
->i_nlink
= le16_to_cpu(raw_inode
->i_links_count
);
2520 inode
->i_size
= le32_to_cpu(raw_inode
->i_size
);
2521 inode
->i_atime
.tv_sec
= le32_to_cpu(raw_inode
->i_atime
);
2522 inode
->i_ctime
.tv_sec
= le32_to_cpu(raw_inode
->i_ctime
);
2523 inode
->i_mtime
.tv_sec
= le32_to_cpu(raw_inode
->i_mtime
);
2524 inode
->i_atime
.tv_nsec
= inode
->i_ctime
.tv_nsec
= inode
->i_mtime
.tv_nsec
= 0;
2527 ei
->i_dir_start_lookup
= 0;
2528 ei
->i_dtime
= le32_to_cpu(raw_inode
->i_dtime
);
2529 /* We now have enough fields to check if the inode was active or not.
2530 * This is needed because nfsd might try to access dead inodes
2531 * the test is that same one that e2fsck uses
2532 * NeilBrown 1999oct15
2534 if (inode
->i_nlink
== 0) {
2535 if (inode
->i_mode
== 0 ||
2536 !(EXT3_SB(inode
->i_sb
)->s_mount_state
& EXT3_ORPHAN_FS
)) {
2537 /* this inode is deleted */
2541 /* The only unlinked inodes we let through here have
2542 * valid i_mode and are being read by the orphan
2543 * recovery code: that's fine, we're about to complete
2544 * the process of deleting those. */
2546 inode
->i_blksize
= PAGE_SIZE
; /* This is the optimal IO size
2547 * (for stat), not the fs block
2549 inode
->i_blocks
= le32_to_cpu(raw_inode
->i_blocks
);
2550 ei
->i_flags
= le32_to_cpu(raw_inode
->i_flags
);
2551 #ifdef EXT3_FRAGMENTS
2552 ei
->i_faddr
= le32_to_cpu(raw_inode
->i_faddr
);
2553 ei
->i_frag_no
= raw_inode
->i_frag
;
2554 ei
->i_frag_size
= raw_inode
->i_fsize
;
2556 ei
->i_file_acl
= le32_to_cpu(raw_inode
->i_file_acl
);
2557 if (!S_ISREG(inode
->i_mode
)) {
2558 ei
->i_dir_acl
= le32_to_cpu(raw_inode
->i_dir_acl
);
2561 ((__u64
)le32_to_cpu(raw_inode
->i_size_high
)) << 32;
2563 ei
->i_disksize
= inode
->i_size
;
2564 inode
->i_generation
= le32_to_cpu(raw_inode
->i_generation
);
2565 ei
->i_block_group
= iloc
.block_group
;
2567 * NOTE! The in-memory inode i_data array is in little-endian order
2568 * even on big-endian machines: we do NOT byteswap the block numbers!
2570 for (block
= 0; block
< EXT3_N_BLOCKS
; block
++)
2571 ei
->i_data
[block
] = raw_inode
->i_block
[block
];
2572 INIT_LIST_HEAD(&ei
->i_orphan
);
2574 if (inode
->i_ino
>= EXT3_FIRST_INO(inode
->i_sb
) + 1 &&
2575 EXT3_INODE_SIZE(inode
->i_sb
) > EXT3_GOOD_OLD_INODE_SIZE
) {
2577 * When mke2fs creates big inodes it does not zero out
2578 * the unused bytes above EXT3_GOOD_OLD_INODE_SIZE,
2579 * so ignore those first few inodes.
2581 ei
->i_extra_isize
= le16_to_cpu(raw_inode
->i_extra_isize
);
2582 if (EXT3_GOOD_OLD_INODE_SIZE
+ ei
->i_extra_isize
>
2583 EXT3_INODE_SIZE(inode
->i_sb
))
2585 if (ei
->i_extra_isize
== 0) {
2586 /* The extra space is currently unused. Use it. */
2587 ei
->i_extra_isize
= sizeof(struct ext3_inode
) -
2588 EXT3_GOOD_OLD_INODE_SIZE
;
2590 __le32
*magic
= (void *)raw_inode
+
2591 EXT3_GOOD_OLD_INODE_SIZE
+
2593 if (*magic
== cpu_to_le32(EXT3_XATTR_MAGIC
))
2594 ei
->i_state
|= EXT3_STATE_XATTR
;
2597 ei
->i_extra_isize
= 0;
2599 if (S_ISREG(inode
->i_mode
)) {
2600 inode
->i_op
= &ext3_file_inode_operations
;
2601 inode
->i_fop
= &ext3_file_operations
;
2602 ext3_set_aops(inode
);
2603 } else if (S_ISDIR(inode
->i_mode
)) {
2604 inode
->i_op
= &ext3_dir_inode_operations
;
2605 inode
->i_fop
= &ext3_dir_operations
;
2606 } else if (S_ISLNK(inode
->i_mode
)) {
2607 if (ext3_inode_is_fast_symlink(inode
))
2608 inode
->i_op
= &ext3_fast_symlink_inode_operations
;
2610 inode
->i_op
= &ext3_symlink_inode_operations
;
2611 ext3_set_aops(inode
);
2614 inode
->i_op
= &ext3_special_inode_operations
;
2615 if (raw_inode
->i_block
[0])
2616 init_special_inode(inode
, inode
->i_mode
,
2617 old_decode_dev(le32_to_cpu(raw_inode
->i_block
[0])));
2619 init_special_inode(inode
, inode
->i_mode
,
2620 new_decode_dev(le32_to_cpu(raw_inode
->i_block
[1])));
2623 ext3_set_inode_flags(inode
);
2627 make_bad_inode(inode
);
2632 * Post the struct inode info into an on-disk inode location in the
2633 * buffer-cache. This gobbles the caller's reference to the
2634 * buffer_head in the inode location struct.
2636 * The caller must have write access to iloc->bh.
2638 static int ext3_do_update_inode(handle_t
*handle
,
2639 struct inode
*inode
,
2640 struct ext3_iloc
*iloc
)
2642 struct ext3_inode
*raw_inode
= ext3_raw_inode(iloc
);
2643 struct ext3_inode_info
*ei
= EXT3_I(inode
);
2644 struct buffer_head
*bh
= iloc
->bh
;
2645 int err
= 0, rc
, block
;
2647 /* For fields not not tracking in the in-memory inode,
2648 * initialise them to zero for new inodes. */
2649 if (ei
->i_state
& EXT3_STATE_NEW
)
2650 memset(raw_inode
, 0, EXT3_SB(inode
->i_sb
)->s_inode_size
);
2652 raw_inode
->i_mode
= cpu_to_le16(inode
->i_mode
);
2653 if(!(test_opt(inode
->i_sb
, NO_UID32
))) {
2654 raw_inode
->i_uid_low
= cpu_to_le16(low_16_bits(inode
->i_uid
));
2655 raw_inode
->i_gid_low
= cpu_to_le16(low_16_bits(inode
->i_gid
));
2657 * Fix up interoperability with old kernels. Otherwise, old inodes get
2658 * re-used with the upper 16 bits of the uid/gid intact
2661 raw_inode
->i_uid_high
=
2662 cpu_to_le16(high_16_bits(inode
->i_uid
));
2663 raw_inode
->i_gid_high
=
2664 cpu_to_le16(high_16_bits(inode
->i_gid
));
2666 raw_inode
->i_uid_high
= 0;
2667 raw_inode
->i_gid_high
= 0;
2670 raw_inode
->i_uid_low
=
2671 cpu_to_le16(fs_high2lowuid(inode
->i_uid
));
2672 raw_inode
->i_gid_low
=
2673 cpu_to_le16(fs_high2lowgid(inode
->i_gid
));
2674 raw_inode
->i_uid_high
= 0;
2675 raw_inode
->i_gid_high
= 0;
2677 raw_inode
->i_links_count
= cpu_to_le16(inode
->i_nlink
);
2678 raw_inode
->i_size
= cpu_to_le32(ei
->i_disksize
);
2679 raw_inode
->i_atime
= cpu_to_le32(inode
->i_atime
.tv_sec
);
2680 raw_inode
->i_ctime
= cpu_to_le32(inode
->i_ctime
.tv_sec
);
2681 raw_inode
->i_mtime
= cpu_to_le32(inode
->i_mtime
.tv_sec
);
2682 raw_inode
->i_blocks
= cpu_to_le32(inode
->i_blocks
);
2683 raw_inode
->i_dtime
= cpu_to_le32(ei
->i_dtime
);
2684 raw_inode
->i_flags
= cpu_to_le32(ei
->i_flags
);
2685 #ifdef EXT3_FRAGMENTS
2686 raw_inode
->i_faddr
= cpu_to_le32(ei
->i_faddr
);
2687 raw_inode
->i_frag
= ei
->i_frag_no
;
2688 raw_inode
->i_fsize
= ei
->i_frag_size
;
2690 raw_inode
->i_file_acl
= cpu_to_le32(ei
->i_file_acl
);
2691 if (!S_ISREG(inode
->i_mode
)) {
2692 raw_inode
->i_dir_acl
= cpu_to_le32(ei
->i_dir_acl
);
2694 raw_inode
->i_size_high
=
2695 cpu_to_le32(ei
->i_disksize
>> 32);
2696 if (ei
->i_disksize
> 0x7fffffffULL
) {
2697 struct super_block
*sb
= inode
->i_sb
;
2698 if (!EXT3_HAS_RO_COMPAT_FEATURE(sb
,
2699 EXT3_FEATURE_RO_COMPAT_LARGE_FILE
) ||
2700 EXT3_SB(sb
)->s_es
->s_rev_level
==
2701 cpu_to_le32(EXT3_GOOD_OLD_REV
)) {
2702 /* If this is the first large file
2703 * created, add a flag to the superblock.
2705 err
= ext3_journal_get_write_access(handle
,
2706 EXT3_SB(sb
)->s_sbh
);
2709 ext3_update_dynamic_rev(sb
);
2710 EXT3_SET_RO_COMPAT_FEATURE(sb
,
2711 EXT3_FEATURE_RO_COMPAT_LARGE_FILE
);
2714 err
= ext3_journal_dirty_metadata(handle
,
2715 EXT3_SB(sb
)->s_sbh
);
2719 raw_inode
->i_generation
= cpu_to_le32(inode
->i_generation
);
2720 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
2721 if (old_valid_dev(inode
->i_rdev
)) {
2722 raw_inode
->i_block
[0] =
2723 cpu_to_le32(old_encode_dev(inode
->i_rdev
));
2724 raw_inode
->i_block
[1] = 0;
2726 raw_inode
->i_block
[0] = 0;
2727 raw_inode
->i_block
[1] =
2728 cpu_to_le32(new_encode_dev(inode
->i_rdev
));
2729 raw_inode
->i_block
[2] = 0;
2731 } else for (block
= 0; block
< EXT3_N_BLOCKS
; block
++)
2732 raw_inode
->i_block
[block
] = ei
->i_data
[block
];
2734 if (EXT3_INODE_SIZE(inode
->i_sb
) > EXT3_GOOD_OLD_INODE_SIZE
)
2735 raw_inode
->i_extra_isize
= cpu_to_le16(ei
->i_extra_isize
);
2737 BUFFER_TRACE(bh
, "call ext3_journal_dirty_metadata");
2738 rc
= ext3_journal_dirty_metadata(handle
, bh
);
2741 ei
->i_state
&= ~EXT3_STATE_NEW
;
2745 ext3_std_error(inode
->i_sb
, err
);
2750 * ext3_write_inode()
2752 * We are called from a few places:
2754 * - Within generic_file_write() for O_SYNC files.
2755 * Here, there will be no transaction running. We wait for any running
2756 * trasnaction to commit.
2758 * - Within sys_sync(), kupdate and such.
2759 * We wait on commit, if tol to.
2761 * - Within prune_icache() (PF_MEMALLOC == true)
2762 * Here we simply return. We can't afford to block kswapd on the
2765 * In all cases it is actually safe for us to return without doing anything,
2766 * because the inode has been copied into a raw inode buffer in
2767 * ext3_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
2770 * Note that we are absolutely dependent upon all inode dirtiers doing the
2771 * right thing: they *must* call mark_inode_dirty() after dirtying info in
2772 * which we are interested.
2774 * It would be a bug for them to not do this. The code:
2776 * mark_inode_dirty(inode)
2778 * inode->i_size = expr;
2780 * is in error because a kswapd-driven write_inode() could occur while
2781 * `stuff()' is running, and the new i_size will be lost. Plus the inode
2782 * will no longer be on the superblock's dirty inode list.
2784 int ext3_write_inode(struct inode
*inode
, int wait
)
2786 if (current
->flags
& PF_MEMALLOC
)
2789 if (ext3_journal_current_handle()) {
2790 jbd_debug(0, "called recursively, non-PF_MEMALLOC!\n");
2798 return ext3_force_commit(inode
->i_sb
);
2804 * Called from notify_change.
2806 * We want to trap VFS attempts to truncate the file as soon as
2807 * possible. In particular, we want to make sure that when the VFS
2808 * shrinks i_size, we put the inode on the orphan list and modify
2809 * i_disksize immediately, so that during the subsequent flushing of
2810 * dirty pages and freeing of disk blocks, we can guarantee that any
2811 * commit will leave the blocks being flushed in an unused state on
2812 * disk. (On recovery, the inode will get truncated and the blocks will
2813 * be freed, so we have a strong guarantee that no future commit will
2814 * leave these blocks visible to the user.)
2816 * Called with inode->sem down.
2818 int ext3_setattr(struct dentry
*dentry
, struct iattr
*attr
)
2820 struct inode
*inode
= dentry
->d_inode
;
2822 const unsigned int ia_valid
= attr
->ia_valid
;
2824 error
= inode_change_ok(inode
, attr
);
2828 if ((ia_valid
& ATTR_UID
&& attr
->ia_uid
!= inode
->i_uid
) ||
2829 (ia_valid
& ATTR_GID
&& attr
->ia_gid
!= inode
->i_gid
)) {
2832 /* (user+group)*(old+new) structure, inode write (sb,
2833 * inode block, ? - but truncate inode update has it) */
2834 handle
= ext3_journal_start(inode
, 4*EXT3_QUOTA_INIT_BLOCKS
+3);
2835 if (IS_ERR(handle
)) {
2836 error
= PTR_ERR(handle
);
2839 error
= DQUOT_TRANSFER(inode
, attr
) ? -EDQUOT
: 0;
2841 ext3_journal_stop(handle
);
2844 /* Update corresponding info in inode so that everything is in
2845 * one transaction */
2846 if (attr
->ia_valid
& ATTR_UID
)
2847 inode
->i_uid
= attr
->ia_uid
;
2848 if (attr
->ia_valid
& ATTR_GID
)
2849 inode
->i_gid
= attr
->ia_gid
;
2850 error
= ext3_mark_inode_dirty(handle
, inode
);
2851 ext3_journal_stop(handle
);
2854 if (S_ISREG(inode
->i_mode
) &&
2855 attr
->ia_valid
& ATTR_SIZE
&& attr
->ia_size
< inode
->i_size
) {
2858 handle
= ext3_journal_start(inode
, 3);
2859 if (IS_ERR(handle
)) {
2860 error
= PTR_ERR(handle
);
2864 error
= ext3_orphan_add(handle
, inode
);
2865 EXT3_I(inode
)->i_disksize
= attr
->ia_size
;
2866 rc
= ext3_mark_inode_dirty(handle
, inode
);
2869 ext3_journal_stop(handle
);
2872 rc
= inode_setattr(inode
, attr
);
2874 /* If inode_setattr's call to ext3_truncate failed to get a
2875 * transaction handle at all, we need to clean up the in-core
2876 * orphan list manually. */
2878 ext3_orphan_del(NULL
, inode
);
2880 if (!rc
&& (ia_valid
& ATTR_MODE
))
2881 rc
= ext3_acl_chmod(inode
);
2884 ext3_std_error(inode
->i_sb
, error
);
2892 * akpm: how many blocks doth make a writepage()?
2894 * With N blocks per page, it may be:
2899 * N+5 bitmap blocks (from the above)
2900 * N+5 group descriptor summary blocks
2903 * 2 * EXT3_SINGLEDATA_TRANS_BLOCKS for the quote files
2905 * 3 * (N + 5) + 2 + 2 * EXT3_SINGLEDATA_TRANS_BLOCKS
2907 * With ordered or writeback data it's the same, less the N data blocks.
2909 * If the inode's direct blocks can hold an integral number of pages then a
2910 * page cannot straddle two indirect blocks, and we can only touch one indirect
2911 * and dindirect block, and the "5" above becomes "3".
2913 * This still overestimates under most circumstances. If we were to pass the
2914 * start and end offsets in here as well we could do block_to_path() on each
2915 * block and work out the exact number of indirects which are touched. Pah.
2918 static int ext3_writepage_trans_blocks(struct inode
*inode
)
2920 int bpp
= ext3_journal_blocks_per_page(inode
);
2921 int indirects
= (EXT3_NDIR_BLOCKS
% bpp
) ? 5 : 3;
2924 if (ext3_should_journal_data(inode
))
2925 ret
= 3 * (bpp
+ indirects
) + 2;
2927 ret
= 2 * (bpp
+ indirects
) + 2;
2930 /* We know that structure was already allocated during DQUOT_INIT so
2931 * we will be updating only the data blocks + inodes */
2932 ret
+= 2*EXT3_QUOTA_TRANS_BLOCKS
;
2939 * The caller must have previously called ext3_reserve_inode_write().
2940 * Give this, we know that the caller already has write access to iloc->bh.
2942 int ext3_mark_iloc_dirty(handle_t
*handle
,
2943 struct inode
*inode
, struct ext3_iloc
*iloc
)
2947 /* the do_update_inode consumes one bh->b_count */
2950 /* ext3_do_update_inode() does journal_dirty_metadata */
2951 err
= ext3_do_update_inode(handle
, inode
, iloc
);
2957 * On success, We end up with an outstanding reference count against
2958 * iloc->bh. This _must_ be cleaned up later.
2962 ext3_reserve_inode_write(handle_t
*handle
, struct inode
*inode
,
2963 struct ext3_iloc
*iloc
)
2967 err
= ext3_get_inode_loc(inode
, iloc
);
2969 BUFFER_TRACE(iloc
->bh
, "get_write_access");
2970 err
= ext3_journal_get_write_access(handle
, iloc
->bh
);
2977 ext3_std_error(inode
->i_sb
, err
);
2982 * akpm: What we do here is to mark the in-core inode as clean
2983 * with respect to inode dirtiness (it may still be data-dirty).
2984 * This means that the in-core inode may be reaped by prune_icache
2985 * without having to perform any I/O. This is a very good thing,
2986 * because *any* task may call prune_icache - even ones which
2987 * have a transaction open against a different journal.
2989 * Is this cheating? Not really. Sure, we haven't written the
2990 * inode out, but prune_icache isn't a user-visible syncing function.
2991 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
2992 * we start and wait on commits.
2994 * Is this efficient/effective? Well, we're being nice to the system
2995 * by cleaning up our inodes proactively so they can be reaped
2996 * without I/O. But we are potentially leaving up to five seconds'
2997 * worth of inodes floating about which prune_icache wants us to
2998 * write out. One way to fix that would be to get prune_icache()
2999 * to do a write_super() to free up some memory. It has the desired
3002 int ext3_mark_inode_dirty(handle_t
*handle
, struct inode
*inode
)
3004 struct ext3_iloc iloc
;
3008 err
= ext3_reserve_inode_write(handle
, inode
, &iloc
);
3010 err
= ext3_mark_iloc_dirty(handle
, inode
, &iloc
);
3015 * akpm: ext3_dirty_inode() is called from __mark_inode_dirty()
3017 * We're really interested in the case where a file is being extended.
3018 * i_size has been changed by generic_commit_write() and we thus need
3019 * to include the updated inode in the current transaction.
3021 * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks
3022 * are allocated to the file.
3024 * If the inode is marked synchronous, we don't honour that here - doing
3025 * so would cause a commit on atime updates, which we don't bother doing.
3026 * We handle synchronous inodes at the highest possible level.
3028 void ext3_dirty_inode(struct inode
*inode
)
3030 handle_t
*current_handle
= ext3_journal_current_handle();
3033 handle
= ext3_journal_start(inode
, 2);
3036 if (current_handle
&&
3037 current_handle
->h_transaction
!= handle
->h_transaction
) {
3038 /* This task has a transaction open against a different fs */
3039 printk(KERN_EMERG
"%s: transactions do not match!\n",
3042 jbd_debug(5, "marking dirty. outer handle=%p\n",
3044 ext3_mark_inode_dirty(handle
, inode
);
3046 ext3_journal_stop(handle
);
3053 * Bind an inode's backing buffer_head into this transaction, to prevent
3054 * it from being flushed to disk early. Unlike
3055 * ext3_reserve_inode_write, this leaves behind no bh reference and
3056 * returns no iloc structure, so the caller needs to repeat the iloc
3057 * lookup to mark the inode dirty later.
3060 ext3_pin_inode(handle_t
*handle
, struct inode
*inode
)
3062 struct ext3_iloc iloc
;
3066 err
= ext3_get_inode_loc(inode
, &iloc
);
3068 BUFFER_TRACE(iloc
.bh
, "get_write_access");
3069 err
= journal_get_write_access(handle
, iloc
.bh
);
3071 err
= ext3_journal_dirty_metadata(handle
,
3076 ext3_std_error(inode
->i_sb
, err
);
3081 int ext3_change_inode_journal_flag(struct inode
*inode
, int val
)
3088 * We have to be very careful here: changing a data block's
3089 * journaling status dynamically is dangerous. If we write a
3090 * data block to the journal, change the status and then delete
3091 * that block, we risk forgetting to revoke the old log record
3092 * from the journal and so a subsequent replay can corrupt data.
3093 * So, first we make sure that the journal is empty and that
3094 * nobody is changing anything.
3097 journal
= EXT3_JOURNAL(inode
);
3098 if (is_journal_aborted(journal
) || IS_RDONLY(inode
))
3101 journal_lock_updates(journal
);
3102 journal_flush(journal
);
3105 * OK, there are no updates running now, and all cached data is
3106 * synced to disk. We are now in a completely consistent state
3107 * which doesn't have anything in the journal, and we know that
3108 * no filesystem updates are running, so it is safe to modify
3109 * the inode's in-core data-journaling state flag now.
3113 EXT3_I(inode
)->i_flags
|= EXT3_JOURNAL_DATA_FL
;
3115 EXT3_I(inode
)->i_flags
&= ~EXT3_JOURNAL_DATA_FL
;
3116 ext3_set_aops(inode
);
3118 journal_unlock_updates(journal
);
3120 /* Finally we can mark the inode as dirty. */
3122 handle
= ext3_journal_start(inode
, 1);
3124 return PTR_ERR(handle
);
3126 err
= ext3_mark_inode_dirty(handle
, inode
);
3128 ext3_journal_stop(handle
);
3129 ext3_std_error(inode
->i_sb
, err
);