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>
39 #include <linux/vserver/xid.h>
44 * Test whether an inode is a fast symlink.
46 static inline int ext3_inode_is_fast_symlink(struct inode *inode)
48 int ea_blocks = EXT3_I(inode)->i_file_acl ?
49 (inode->i_sb->s_blocksize >> 9) : 0;
51 return (S_ISLNK(inode->i_mode) &&
52 inode->i_blocks - ea_blocks == 0);
55 /* The ext3 forget function must perform a revoke if we are freeing data
56 * which has been journaled. Metadata (eg. indirect blocks) must be
57 * revoked in all cases.
59 * "bh" may be NULL: a metadata block may have been freed from memory
60 * but there may still be a record of it in the journal, and that record
61 * still needs to be revoked.
64 int ext3_forget(handle_t *handle, int is_metadata,
65 struct inode *inode, struct buffer_head *bh,
70 BUFFER_TRACE(bh, "enter");
72 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
74 bh, is_metadata, inode->i_mode,
75 test_opt(inode->i_sb, DATA_FLAGS));
77 /* Never use the revoke function if we are doing full data
78 * journaling: there is no need to, and a V1 superblock won't
79 * support it. Otherwise, only skip the revoke on un-journaled
82 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ||
83 (!is_metadata && !ext3_should_journal_data(inode))) {
85 BUFFER_TRACE(bh, "call journal_forget");
86 ext3_journal_forget(handle, bh);
92 * data!=journal && (is_metadata || should_journal_data(inode))
94 BUFFER_TRACE(bh, "call ext3_journal_revoke");
95 err = ext3_journal_revoke(handle, blocknr, bh);
97 ext3_abort(inode->i_sb, __FUNCTION__,
98 "error %d when attempting revoke", err);
99 BUFFER_TRACE(bh, "exit");
104 * Work out how many blocks we need to progress with the next chunk of a
105 * truncate transaction.
108 static unsigned long blocks_for_truncate(struct inode *inode)
110 unsigned long needed;
112 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
114 /* Give ourselves just enough room to cope with inodes in which
115 * i_blocks is corrupt: we've seen disk corruptions in the past
116 * which resulted in random data in an inode which looked enough
117 * like a regular file for ext3 to try to delete it. Things
118 * will go a bit crazy if that happens, but at least we should
119 * try not to panic the whole kernel. */
123 /* But we need to bound the transaction so we don't overflow the
125 if (needed > EXT3_MAX_TRANS_DATA)
126 needed = EXT3_MAX_TRANS_DATA;
128 return EXT3_DATA_TRANS_BLOCKS + needed;
132 * Truncate transactions can be complex and absolutely huge. So we need to
133 * be able to restart the transaction at a conventient checkpoint to make
134 * sure we don't overflow the journal.
136 * start_transaction gets us a new handle for a truncate transaction,
137 * and extend_transaction tries to extend the existing one a bit. If
138 * extend fails, we need to propagate the failure up and restart the
139 * transaction in the top-level truncate loop. --sct
142 static handle_t *start_transaction(struct inode *inode)
146 result = ext3_journal_start(inode, blocks_for_truncate(inode));
150 ext3_std_error(inode->i_sb, PTR_ERR(result));
155 * Try to extend this transaction for the purposes of truncation.
157 * Returns 0 if we managed to create more room. If we can't create more
158 * room, and the transaction must be restarted we return 1.
160 static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
162 if (handle->h_buffer_credits > EXT3_RESERVE_TRANS_BLOCKS)
164 if (!ext3_journal_extend(handle, blocks_for_truncate(inode)))
170 * Restart the transaction associated with *handle. This does a commit,
171 * so before we call here everything must be consistently dirtied against
174 static int ext3_journal_test_restart(handle_t *handle, struct inode *inode)
176 jbd_debug(2, "restarting handle %p\n", handle);
177 return ext3_journal_restart(handle, blocks_for_truncate(inode));
180 static void ext3_truncate_nocheck (struct inode *inode);
183 * Called at the last iput() if i_nlink is zero.
185 void ext3_delete_inode (struct inode * inode)
189 if (is_bad_inode(inode))
192 handle = start_transaction(inode);
193 if (IS_ERR(handle)) {
194 /* If we're going to skip the normal cleanup, we still
195 * need to make sure that the in-core orphan linked list
196 * is properly cleaned up. */
197 ext3_orphan_del(NULL, inode);
205 ext3_truncate_nocheck(inode);
207 * Kill off the orphan record which ext3_truncate created.
208 * AKPM: I think this can be inside the above `if'.
209 * Note that ext3_orphan_del() has to be able to cope with the
210 * deletion of a non-existent orphan - this is because we don't
211 * know if ext3_truncate() actually created an orphan record.
212 * (Well, we could do this if we need to, but heck - it works)
214 ext3_orphan_del(handle, inode);
215 EXT3_I(inode)->i_dtime = get_seconds();
218 * One subtle ordering requirement: if anything has gone wrong
219 * (transaction abort, IO errors, whatever), then we can still
220 * do these next steps (the fs will already have been marked as
221 * having errors), but we can't free the inode if the mark_dirty
224 if (ext3_mark_inode_dirty(handle, inode))
225 /* If that failed, just do the required in-core inode clear. */
228 ext3_free_inode(handle, inode);
229 ext3_journal_stop(handle);
232 clear_inode(inode); /* We must guarantee clearing of inode... */
235 static int ext3_alloc_block (handle_t *handle,
236 struct inode * inode, unsigned long goal, int *err)
238 unsigned long result;
240 result = ext3_new_block (handle, inode, goal, err);
248 struct buffer_head *bh;
251 static inline void add_chain(Indirect *p, struct buffer_head *bh, u32 *v)
253 p->key = *(p->p = v);
257 static inline int verify_chain(Indirect *from, Indirect *to)
259 while (from <= to && from->key == *from->p)
265 * ext3_block_to_path - parse the block number into array of offsets
266 * @inode: inode in question (we are only interested in its superblock)
267 * @i_block: block number to be parsed
268 * @offsets: array to store the offsets in
269 * @boundary: set this non-zero if the referred-to block is likely to be
270 * followed (on disk) by an indirect block.
272 * To store the locations of file's data ext3 uses a data structure common
273 * for UNIX filesystems - tree of pointers anchored in the inode, with
274 * data blocks at leaves and indirect blocks in intermediate nodes.
275 * This function translates the block number into path in that tree -
276 * return value is the path length and @offsets[n] is the offset of
277 * pointer to (n+1)th node in the nth one. If @block is out of range
278 * (negative or too large) warning is printed and zero returned.
280 * Note: function doesn't find node addresses, so no IO is needed. All
281 * we need to know is the capacity of indirect blocks (taken from the
286 * Portability note: the last comparison (check that we fit into triple
287 * indirect block) is spelled differently, because otherwise on an
288 * architecture with 32-bit longs and 8Kb pages we might get into trouble
289 * if our filesystem had 8Kb blocks. We might use long long, but that would
290 * kill us on x86. Oh, well, at least the sign propagation does not matter -
291 * i_block would have to be negative in the very beginning, so we would not
295 static int ext3_block_to_path(struct inode *inode,
296 long i_block, int offsets[4], int *boundary)
298 int ptrs = EXT3_ADDR_PER_BLOCK(inode->i_sb);
299 int ptrs_bits = EXT3_ADDR_PER_BLOCK_BITS(inode->i_sb);
300 const long direct_blocks = EXT3_NDIR_BLOCKS,
301 indirect_blocks = ptrs,
302 double_blocks = (1 << (ptrs_bits * 2));
307 ext3_warning (inode->i_sb, "ext3_block_to_path", "block < 0");
308 } else if (i_block < direct_blocks) {
309 offsets[n++] = i_block;
310 final = direct_blocks;
311 } else if ( (i_block -= direct_blocks) < indirect_blocks) {
312 offsets[n++] = EXT3_IND_BLOCK;
313 offsets[n++] = i_block;
315 } else if ((i_block -= indirect_blocks) < double_blocks) {
316 offsets[n++] = EXT3_DIND_BLOCK;
317 offsets[n++] = i_block >> ptrs_bits;
318 offsets[n++] = i_block & (ptrs - 1);
320 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
321 offsets[n++] = EXT3_TIND_BLOCK;
322 offsets[n++] = i_block >> (ptrs_bits * 2);
323 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
324 offsets[n++] = i_block & (ptrs - 1);
327 ext3_warning (inode->i_sb, "ext3_block_to_path", "block > big");
330 *boundary = (i_block & (ptrs - 1)) == (final - 1);
335 * ext3_get_branch - read the chain of indirect blocks leading to data
336 * @inode: inode in question
337 * @depth: depth of the chain (1 - direct pointer, etc.)
338 * @offsets: offsets of pointers in inode/indirect blocks
339 * @chain: place to store the result
340 * @err: here we store the error value
342 * Function fills the array of triples <key, p, bh> and returns %NULL
343 * if everything went OK or the pointer to the last filled triple
344 * (incomplete one) otherwise. Upon the return chain[i].key contains
345 * the number of (i+1)-th block in the chain (as it is stored in memory,
346 * i.e. little-endian 32-bit), chain[i].p contains the address of that
347 * number (it points into struct inode for i==0 and into the bh->b_data
348 * for i>0) and chain[i].bh points to the buffer_head of i-th indirect
349 * block for i>0 and NULL for i==0. In other words, it holds the block
350 * numbers of the chain, addresses they were taken from (and where we can
351 * verify that chain did not change) and buffer_heads hosting these
354 * Function stops when it stumbles upon zero pointer (absent block)
355 * (pointer to last triple returned, *@err == 0)
356 * or when it gets an IO error reading an indirect block
357 * (ditto, *@err == -EIO)
358 * or when it notices that chain had been changed while it was reading
359 * (ditto, *@err == -EAGAIN)
360 * or when it reads all @depth-1 indirect blocks successfully and finds
361 * the whole chain, all way to the data (returns %NULL, *err == 0).
363 static Indirect *ext3_get_branch(struct inode *inode, int depth, int *offsets,
364 Indirect chain[4], int *err)
366 struct super_block *sb = inode->i_sb;
368 struct buffer_head *bh;
371 /* i_data is not going away, no lock needed */
372 add_chain (chain, NULL, EXT3_I(inode)->i_data + *offsets);
376 bh = sb_bread(sb, le32_to_cpu(p->key));
379 /* Reader: pointers */
380 if (!verify_chain(chain, p))
382 add_chain(++p, bh, (u32*)bh->b_data + *++offsets);
400 * ext3_find_near - find a place for allocation with sufficient locality
402 * @ind: descriptor of indirect block.
404 * This function returns the prefered place for block allocation.
405 * It is used when heuristic for sequential allocation fails.
407 * + if there is a block to the left of our position - allocate near it.
408 * + if pointer will live in indirect block - allocate near that block.
409 * + if pointer will live in inode - allocate in the same
412 * In the latter case we colour the starting block by the callers PID to
413 * prevent it from clashing with concurrent allocations for a different inode
414 * in the same block group. The PID is used here so that functionally related
415 * files will be close-by on-disk.
417 * Caller must make sure that @ind is valid and will stay that way.
420 static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)
422 struct ext3_inode_info *ei = EXT3_I(inode);
423 u32 *start = ind->bh ? (u32*) ind->bh->b_data : ei->i_data;
425 unsigned long bg_start;
426 unsigned long colour;
428 /* Try to find previous block */
429 for (p = ind->p - 1; p >= start; p--)
431 return le32_to_cpu(*p);
433 /* No such thing, so let's try location of indirect block */
435 return ind->bh->b_blocknr;
438 * It is going to be refered from inode itself? OK, just put it into
439 * the same cylinder group then.
441 bg_start = (ei->i_block_group * EXT3_BLOCKS_PER_GROUP(inode->i_sb)) +
442 le32_to_cpu(EXT3_SB(inode->i_sb)->s_es->s_first_data_block);
443 colour = (current->pid % 16) *
444 (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
445 return bg_start + colour;
449 * ext3_find_goal - find a prefered place for allocation.
451 * @block: block we want
452 * @chain: chain of indirect blocks
453 * @partial: pointer to the last triple within a chain
454 * @goal: place to store the result.
456 * Normally this function find the prefered place for block allocation,
457 * stores it in *@goal and returns zero. If the branch had been changed
458 * under us we return -EAGAIN.
461 static int ext3_find_goal(struct inode *inode, long block, Indirect chain[4],
462 Indirect *partial, unsigned long *goal)
464 struct ext3_inode_info *ei = EXT3_I(inode);
465 /* Writer: ->i_next_alloc* */
466 if (block == ei->i_next_alloc_block + 1) {
467 ei->i_next_alloc_block++;
468 ei->i_next_alloc_goal++;
471 /* Reader: pointers, ->i_next_alloc* */
472 if (verify_chain(chain, partial)) {
474 * try the heuristic for sequential allocation,
475 * failing that at least try to get decent locality.
477 if (block == ei->i_next_alloc_block)
478 *goal = ei->i_next_alloc_goal;
480 *goal = ext3_find_near(inode, partial);
488 * ext3_alloc_branch - allocate and set up a chain of blocks.
490 * @num: depth of the chain (number of blocks to allocate)
491 * @offsets: offsets (in the blocks) to store the pointers to next.
492 * @branch: place to store the chain in.
494 * This function allocates @num blocks, zeroes out all but the last one,
495 * links them into chain and (if we are synchronous) writes them to disk.
496 * In other words, it prepares a branch that can be spliced onto the
497 * inode. It stores the information about that chain in the branch[], in
498 * the same format as ext3_get_branch() would do. We are calling it after
499 * we had read the existing part of chain and partial points to the last
500 * triple of that (one with zero ->key). Upon the exit we have the same
501 * picture as after the successful ext3_get_block(), excpet that in one
502 * place chain is disconnected - *branch->p is still zero (we did not
503 * set the last link), but branch->key contains the number that should
504 * be placed into *branch->p to fill that gap.
506 * If allocation fails we free all blocks we've allocated (and forget
507 * their buffer_heads) and return the error value the from failed
508 * ext3_alloc_block() (normally -ENOSPC). Otherwise we set the chain
509 * as described above and return 0.
512 static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
518 int blocksize = inode->i_sb->s_blocksize;
522 int parent = ext3_alloc_block(handle, inode, goal, &err);
524 branch[0].key = cpu_to_le32(parent);
526 for (n = 1; n < num; n++) {
527 struct buffer_head *bh;
528 /* Allocate the next block */
529 int nr = ext3_alloc_block(handle, inode, parent, &err);
532 branch[n].key = cpu_to_le32(nr);
536 * Get buffer_head for parent block, zero it out
537 * and set the pointer to new one, then send
540 bh = sb_getblk(inode->i_sb, parent);
543 BUFFER_TRACE(bh, "call get_create_access");
544 err = ext3_journal_get_create_access(handle, bh);
551 memset(bh->b_data, 0, blocksize);
552 branch[n].p = (u32*) bh->b_data + offsets[n];
553 *branch[n].p = branch[n].key;
554 BUFFER_TRACE(bh, "marking uptodate");
555 set_buffer_uptodate(bh);
558 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
559 err = ext3_journal_dirty_metadata(handle, bh);
569 /* Allocation failed, free what we already allocated */
570 for (i = 1; i < keys; i++) {
571 BUFFER_TRACE(branch[i].bh, "call journal_forget");
572 ext3_journal_forget(handle, branch[i].bh);
574 for (i = 0; i < keys; i++)
575 ext3_free_blocks(handle, inode, le32_to_cpu(branch[i].key), 1);
580 * ext3_splice_branch - splice the allocated branch onto inode.
582 * @block: (logical) number of block we are adding
583 * @chain: chain of indirect blocks (with a missing link - see
585 * @where: location of missing link
586 * @num: number of blocks we are adding
588 * This function verifies that chain (up to the missing link) had not
589 * changed, fills the missing link and does all housekeeping needed in
590 * inode (->i_blocks, etc.). In case of success we end up with the full
591 * chain to new block and return 0. Otherwise (== chain had been changed)
592 * we free the new blocks (forgetting their buffer_heads, indeed) and
596 static int ext3_splice_branch(handle_t *handle, struct inode *inode, long block,
597 Indirect chain[4], Indirect *where, int num)
601 struct ext3_inode_info *ei = EXT3_I(inode);
604 * If we're splicing into a [td]indirect block (as opposed to the
605 * inode) then we need to get write access to the [td]indirect block
609 BUFFER_TRACE(where->bh, "get_write_access");
610 err = ext3_journal_get_write_access(handle, where->bh);
614 /* Verify that place we are splicing to is still there and vacant */
616 /* Writer: pointers, ->i_next_alloc* */
617 if (!verify_chain(chain, where-1) || *where->p)
623 *where->p = where->key;
624 ei->i_next_alloc_block = block;
625 ei->i_next_alloc_goal = le32_to_cpu(where[num-1].key);
628 /* We are done with atomic stuff, now do the rest of housekeeping */
630 inode->i_ctime = CURRENT_TIME;
631 ext3_mark_inode_dirty(handle, inode);
633 /* had we spliced it onto indirect block? */
636 * akpm: If we spliced it onto an indirect block, we haven't
637 * altered the inode. Note however that if it is being spliced
638 * onto an indirect block at the very end of the file (the
639 * file is growing) then we *will* alter the inode to reflect
640 * the new i_size. But that is not done here - it is done in
641 * generic_commit_write->__mark_inode_dirty->ext3_dirty_inode.
643 jbd_debug(5, "splicing indirect only\n");
644 BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
645 err = ext3_journal_dirty_metadata(handle, where->bh);
650 * OK, we spliced it into the inode itself on a direct block.
651 * Inode was dirtied above.
653 jbd_debug(5, "splicing direct\n");
659 * AKPM: if where[i].bh isn't part of the current updating
660 * transaction then we explode nastily. Test this code path.
662 jbd_debug(1, "the chain changed: try again\n");
666 for (i = 1; i < num; i++) {
667 BUFFER_TRACE(where[i].bh, "call journal_forget");
668 ext3_journal_forget(handle, where[i].bh);
670 /* For the normal collision cleanup case, we free up the blocks.
671 * On genuine filesystem errors we don't even think about doing
674 for (i = 0; i < num; i++)
675 ext3_free_blocks(handle, inode,
676 le32_to_cpu(where[i].key), 1);
681 * Allocation strategy is simple: if we have to allocate something, we will
682 * have to go the whole way to leaf. So let's do it before attaching anything
683 * to tree, set linkage between the newborn blocks, write them if sync is
684 * required, recheck the path, free and repeat if check fails, otherwise
685 * set the last missing link (that will protect us from any truncate-generated
686 * removals - all blocks on the path are immune now) and possibly force the
687 * write on the parent block.
688 * That has a nice additional property: no special recovery from the failed
689 * allocations is needed - we simply release blocks and do not touch anything
690 * reachable from inode.
692 * akpm: `handle' can be NULL if create == 0.
694 * The BKL may not be held on entry here. Be sure to take it early.
698 ext3_get_block_handle(handle_t *handle, struct inode *inode, sector_t iblock,
699 struct buffer_head *bh_result, int create, int extend_disksize)
708 int depth = ext3_block_to_path(inode, iblock, offsets, &boundary);
709 struct ext3_inode_info *ei = EXT3_I(inode);
711 J_ASSERT(handle != NULL || create == 0);
717 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
719 /* Simplest case - block found, no allocation needed */
721 clear_buffer_new(bh_result);
723 map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
725 set_buffer_boundary(bh_result);
726 /* Clean up and exit */
727 partial = chain+depth-1; /* the whole chain */
731 /* Next simple case - plain lookup or failed read of indirect block */
732 if (!create || err == -EIO) {
734 while (partial > chain) {
735 BUFFER_TRACE(partial->bh, "call brelse");
739 BUFFER_TRACE(bh_result, "returned");
745 * Indirect block might be removed by truncate while we were
746 * reading it. Handling of that case (forget what we've got and
747 * reread) is taken out of the main path.
753 down(&ei->truncate_sem);
754 if (ext3_find_goal(inode, iblock, chain, partial, &goal) < 0) {
755 up(&ei->truncate_sem);
759 left = (chain + depth) - partial;
762 * Block out ext3_truncate while we alter the tree
764 err = ext3_alloc_branch(handle, inode, left, goal,
765 offsets+(partial-chain), partial);
767 /* The ext3_splice_branch call will free and forget any buffers
768 * on the new chain if there is a failure, but that risks using
769 * up transaction credits, especially for bitmaps where the
770 * credits cannot be returned. Can we handle this somehow? We
771 * may need to return -EAGAIN upwards in the worst case. --sct */
773 err = ext3_splice_branch(handle, inode, iblock, chain,
775 /* i_disksize growing is protected by truncate_sem
776 * don't forget to protect it if you're about to implement
777 * concurrent ext3_get_block() -bzzz */
778 if (!err && extend_disksize && inode->i_size > ei->i_disksize)
779 ei->i_disksize = inode->i_size;
780 up(&ei->truncate_sem);
786 set_buffer_new(bh_result);
790 while (partial > chain) {
791 jbd_debug(1, "buffer chain changed, retrying\n");
792 BUFFER_TRACE(partial->bh, "brelsing");
799 static int ext3_get_block(struct inode *inode, sector_t iblock,
800 struct buffer_head *bh_result, int create)
802 handle_t *handle = 0;
806 handle = ext3_journal_current_handle();
807 J_ASSERT(handle != 0);
809 ret = ext3_get_block_handle(handle, inode, iblock,
810 bh_result, create, 1);
814 #define DIO_CREDITS (EXT3_RESERVE_TRANS_BLOCKS + 32)
817 ext3_direct_io_get_blocks(struct inode *inode, sector_t iblock,
818 unsigned long max_blocks, struct buffer_head *bh_result,
821 handle_t *handle = journal_current_handle();
824 if (handle && handle->h_buffer_credits <= EXT3_RESERVE_TRANS_BLOCKS) {
826 * Getting low on buffer credits...
828 if (!ext3_journal_extend(handle, DIO_CREDITS)) {
830 * Couldn't extend the transaction. Start a new one
832 ret = ext3_journal_restart(handle, DIO_CREDITS);
836 ret = ext3_get_block_handle(handle, inode, iblock,
837 bh_result, create, 0);
839 bh_result->b_size = (1 << inode->i_blkbits);
845 * `handle' can be NULL if create is zero
847 struct buffer_head *ext3_getblk(handle_t *handle, struct inode * inode,
848 long block, int create, int * errp)
850 struct buffer_head dummy;
853 J_ASSERT(handle != NULL || create == 0);
856 dummy.b_blocknr = -1000;
857 buffer_trace_init(&dummy.b_history);
858 *errp = ext3_get_block_handle(handle, inode, block, &dummy, create, 1);
859 if (!*errp && buffer_mapped(&dummy)) {
860 struct buffer_head *bh;
861 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
862 if (buffer_new(&dummy)) {
863 J_ASSERT(create != 0);
864 J_ASSERT(handle != 0);
866 /* Now that we do not always journal data, we
867 should keep in mind whether this should
868 always journal the new buffer as metadata.
869 For now, regular file writes use
870 ext3_get_block instead, so it's not a
873 BUFFER_TRACE(bh, "call get_create_access");
874 fatal = ext3_journal_get_create_access(handle, bh);
875 if (!fatal && !buffer_uptodate(bh)) {
876 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
877 set_buffer_uptodate(bh);
880 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
881 err = ext3_journal_dirty_metadata(handle, bh);
885 BUFFER_TRACE(bh, "not a new buffer");
897 struct buffer_head *ext3_bread(handle_t *handle, struct inode * inode,
898 int block, int create, int *err)
900 struct buffer_head * bh;
903 prev_blocks = inode->i_blocks;
905 bh = ext3_getblk (handle, inode, block, create, err);
908 if (buffer_uptodate(bh))
910 ll_rw_block (READ, 1, &bh);
912 if (buffer_uptodate(bh))
919 static int walk_page_buffers( handle_t *handle,
920 struct buffer_head *head,
924 int (*fn)( handle_t *handle,
925 struct buffer_head *bh))
927 struct buffer_head *bh;
928 unsigned block_start, block_end;
929 unsigned blocksize = head->b_size;
931 struct buffer_head *next;
933 for ( bh = head, block_start = 0;
934 ret == 0 && (bh != head || !block_start);
935 block_start = block_end, bh = next)
937 next = bh->b_this_page;
938 block_end = block_start + blocksize;
939 if (block_end <= from || block_start >= to) {
940 if (partial && !buffer_uptodate(bh))
944 err = (*fn)(handle, bh);
952 * To preserve ordering, it is essential that the hole instantiation and
953 * the data write be encapsulated in a single transaction. We cannot
954 * close off a transaction and start a new one between the ext3_get_block()
955 * and the commit_write(). So doing the journal_start at the start of
956 * prepare_write() is the right place.
958 * Also, this function can nest inside ext3_writepage() ->
959 * block_write_full_page(). In that case, we *know* that ext3_writepage()
960 * has generated enough buffer credits to do the whole page. So we won't
961 * block on the journal in that case, which is good, because the caller may
964 * By accident, ext3 can be reentered when a transaction is open via
965 * quota file writes. If we were to commit the transaction while thus
966 * reentered, there can be a deadlock - we would be holding a quota
967 * lock, and the commit would never complete if another thread had a
968 * transaction open and was blocking on the quota lock - a ranking
971 * So what we do is to rely on the fact that journal_stop/journal_start
972 * will _not_ run commit under these circumstances because handle->h_ref
973 * is elevated. We'll still have enough credits for the tiny quotafile
977 static int do_journal_get_write_access(handle_t *handle,
978 struct buffer_head *bh)
980 if (!buffer_mapped(bh) || buffer_freed(bh))
982 return ext3_journal_get_write_access(handle, bh);
985 static int ext3_prepare_write(struct file *file, struct page *page,
986 unsigned from, unsigned to)
988 struct inode *inode = page->mapping->host;
989 int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
994 handle = ext3_journal_start(inode, needed_blocks);
995 if (IS_ERR(handle)) {
996 ret = PTR_ERR(handle);
999 ret = block_prepare_write(page, from, to, ext3_get_block);
1001 goto prepare_write_failed;
1003 if (ext3_should_journal_data(inode)) {
1004 ret = walk_page_buffers(handle, page_buffers(page),
1005 from, to, NULL, do_journal_get_write_access);
1007 prepare_write_failed:
1009 ext3_journal_stop(handle);
1010 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1017 ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1019 int err = journal_dirty_data(handle, bh);
1021 ext3_journal_abort_handle(__FUNCTION__, __FUNCTION__,
1026 /* For commit_write() in data=journal mode */
1027 static int commit_write_fn(handle_t *handle, struct buffer_head *bh)
1029 if (!buffer_mapped(bh) || buffer_freed(bh))
1031 set_buffer_uptodate(bh);
1032 return ext3_journal_dirty_metadata(handle, bh);
1036 * We need to pick up the new inode size which generic_commit_write gave us
1037 * `file' can be NULL - eg, when called from page_symlink().
1039 * ext3 never places buffers on inode->i_mapping->private_list. metadata
1040 * buffers are managed internally.
1043 static int ext3_ordered_commit_write(struct file *file, struct page *page,
1044 unsigned from, unsigned to)
1046 handle_t *handle = ext3_journal_current_handle();
1047 struct inode *inode = page->mapping->host;
1050 ret = walk_page_buffers(handle, page_buffers(page),
1051 from, to, NULL, ext3_journal_dirty_data);
1055 * generic_commit_write() will run mark_inode_dirty() if i_size
1056 * changes. So let's piggyback the i_disksize mark_inode_dirty
1061 new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1062 if (new_i_size > EXT3_I(inode)->i_disksize)
1063 EXT3_I(inode)->i_disksize = new_i_size;
1064 ret = generic_commit_write(file, page, from, to);
1066 ret2 = ext3_journal_stop(handle);
1072 static int ext3_writeback_commit_write(struct file *file, struct page *page,
1073 unsigned from, unsigned to)
1075 handle_t *handle = ext3_journal_current_handle();
1076 struct inode *inode = page->mapping->host;
1080 new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1081 if (new_i_size > EXT3_I(inode)->i_disksize)
1082 EXT3_I(inode)->i_disksize = new_i_size;
1083 ret = generic_commit_write(file, page, from, to);
1084 ret2 = ext3_journal_stop(handle);
1090 static int ext3_journalled_commit_write(struct file *file,
1091 struct page *page, unsigned from, unsigned to)
1093 handle_t *handle = ext3_journal_current_handle();
1094 struct inode *inode = page->mapping->host;
1100 * Here we duplicate the generic_commit_write() functionality
1102 pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1104 ret = walk_page_buffers(handle, page_buffers(page), from,
1105 to, &partial, commit_write_fn);
1107 SetPageUptodate(page);
1108 if (pos > inode->i_size)
1109 i_size_write(inode, pos);
1110 EXT3_I(inode)->i_state |= EXT3_STATE_JDATA;
1111 if (inode->i_size > EXT3_I(inode)->i_disksize) {
1112 EXT3_I(inode)->i_disksize = inode->i_size;
1113 ret2 = ext3_mark_inode_dirty(handle, inode);
1117 ret2 = ext3_journal_stop(handle);
1124 * bmap() is special. It gets used by applications such as lilo and by
1125 * the swapper to find the on-disk block of a specific piece of data.
1127 * Naturally, this is dangerous if the block concerned is still in the
1128 * journal. If somebody makes a swapfile on an ext3 data-journaling
1129 * filesystem and enables swap, then they may get a nasty shock when the
1130 * data getting swapped to that swapfile suddenly gets overwritten by
1131 * the original zero's written out previously to the journal and
1132 * awaiting writeback in the kernel's buffer cache.
1134 * So, if we see any bmap calls here on a modified, data-journaled file,
1135 * take extra steps to flush any blocks which might be in the cache.
1137 static sector_t ext3_bmap(struct address_space *mapping, sector_t block)
1139 struct inode *inode = mapping->host;
1143 if (EXT3_I(inode)->i_state & EXT3_STATE_JDATA) {
1145 * This is a REALLY heavyweight approach, but the use of
1146 * bmap on dirty files is expected to be extremely rare:
1147 * only if we run lilo or swapon on a freshly made file
1148 * do we expect this to happen.
1150 * (bmap requires CAP_SYS_RAWIO so this does not
1151 * represent an unprivileged user DOS attack --- we'd be
1152 * in trouble if mortal users could trigger this path at
1155 * NB. EXT3_STATE_JDATA is not set on files other than
1156 * regular files. If somebody wants to bmap a directory
1157 * or symlink and gets confused because the buffer
1158 * hasn't yet been flushed to disk, they deserve
1159 * everything they get.
1162 EXT3_I(inode)->i_state &= ~EXT3_STATE_JDATA;
1163 journal = EXT3_JOURNAL(inode);
1164 journal_lock_updates(journal);
1165 err = journal_flush(journal);
1166 journal_unlock_updates(journal);
1172 return generic_block_bmap(mapping,block,ext3_get_block);
1175 static int bget_one(handle_t *handle, struct buffer_head *bh)
1181 static int bput_one(handle_t *handle, struct buffer_head *bh)
1187 static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
1189 if (buffer_mapped(bh))
1190 return ext3_journal_dirty_data(handle, bh);
1195 * Note that we always start a transaction even if we're not journalling
1196 * data. This is to preserve ordering: any hole instantiation within
1197 * __block_write_full_page -> ext3_get_block() should be journalled
1198 * along with the data so we don't crash and then get metadata which
1199 * refers to old data.
1201 * In all journalling modes block_write_full_page() will start the I/O.
1205 * ext3_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1210 * ext3_file_write() -> generic_file_write() -> __alloc_pages() -> ...
1212 * Same applies to ext3_get_block(). We will deadlock on various things like
1213 * lock_journal and i_truncate_sem.
1215 * Setting PF_MEMALLOC here doesn't work - too many internal memory
1218 * 16May01: If we're reentered then journal_current_handle() will be
1219 * non-zero. We simply *return*.
1221 * 1 July 2001: @@@ FIXME:
1222 * In journalled data mode, a data buffer may be metadata against the
1223 * current transaction. But the same file is part of a shared mapping
1224 * and someone does a writepage() on it.
1226 * We will move the buffer onto the async_data list, but *after* it has
1227 * been dirtied. So there's a small window where we have dirty data on
1230 * Note that this only applies to the last partial page in the file. The
1231 * bit which block_write_full_page() uses prepare/commit for. (That's
1232 * broken code anyway: it's wrong for msync()).
1234 * It's a rare case: affects the final partial page, for journalled data
1235 * where the file is subject to bith write() and writepage() in the same
1236 * transction. To fix it we'll need a custom block_write_full_page().
1237 * We'll probably need that anyway for journalling writepage() output.
1239 * We don't honour synchronous mounts for writepage(). That would be
1240 * disastrous. Any write() or metadata operation will sync the fs for
1243 * AKPM2: if all the page's buffers are mapped to disk and !data=journal,
1244 * we don't need to open a transaction here.
1246 static int ext3_ordered_writepage(struct page *page,
1247 struct writeback_control *wbc)
1249 struct inode *inode = page->mapping->host;
1250 struct buffer_head *page_bufs;
1251 handle_t *handle = NULL;
1255 J_ASSERT(PageLocked(page));
1258 * We give up here if we're reentered, because it might be for a
1259 * different filesystem.
1261 if (ext3_journal_current_handle())
1264 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1266 if (IS_ERR(handle)) {
1267 ret = PTR_ERR(handle);
1271 if (!page_has_buffers(page)) {
1272 create_empty_buffers(page, inode->i_sb->s_blocksize,
1273 (1 << BH_Dirty)|(1 << BH_Uptodate));
1275 page_bufs = page_buffers(page);
1276 walk_page_buffers(handle, page_bufs, 0,
1277 PAGE_CACHE_SIZE, NULL, bget_one);
1279 ret = block_write_full_page(page, ext3_get_block, wbc);
1282 * The page can become unlocked at any point now, and
1283 * truncate can then come in and change things. So we
1284 * can't touch *page from now on. But *page_bufs is
1285 * safe due to elevated refcount.
1289 * And attach them to the current transaction. But only if
1290 * block_write_full_page() succeeded. Otherwise they are unmapped,
1291 * and generally junk.
1294 err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
1295 NULL, journal_dirty_data_fn);
1299 walk_page_buffers(handle, page_bufs, 0,
1300 PAGE_CACHE_SIZE, NULL, bput_one);
1301 err = ext3_journal_stop(handle);
1307 redirty_page_for_writepage(wbc, page);
1312 static int ext3_writeback_writepage(struct page *page,
1313 struct writeback_control *wbc)
1315 struct inode *inode = page->mapping->host;
1316 handle_t *handle = NULL;
1320 if (ext3_journal_current_handle())
1323 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1324 if (IS_ERR(handle)) {
1325 ret = PTR_ERR(handle);
1329 ret = block_write_full_page(page, ext3_get_block, wbc);
1330 err = ext3_journal_stop(handle);
1336 redirty_page_for_writepage(wbc, page);
1341 static int ext3_journalled_writepage(struct page *page,
1342 struct writeback_control *wbc)
1344 struct inode *inode = page->mapping->host;
1345 handle_t *handle = NULL;
1349 if (ext3_journal_current_handle())
1352 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1353 if (IS_ERR(handle)) {
1354 ret = PTR_ERR(handle);
1358 if (!page_has_buffers(page) || PageChecked(page)) {
1360 * It's mmapped pagecache. Add buffers and journal it. There
1361 * doesn't seem much point in redirtying the page here.
1363 ClearPageChecked(page);
1364 ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
1368 ret = walk_page_buffers(handle, page_buffers(page), 0,
1369 PAGE_CACHE_SIZE, NULL, do_journal_get_write_access);
1371 err = walk_page_buffers(handle, page_buffers(page), 0,
1372 PAGE_CACHE_SIZE, NULL, commit_write_fn);
1375 EXT3_I(inode)->i_state |= EXT3_STATE_JDATA;
1379 * It may be a page full of checkpoint-mode buffers. We don't
1380 * really know unless we go poke around in the buffer_heads.
1381 * But block_write_full_page will do the right thing.
1383 ret = block_write_full_page(page, ext3_get_block, wbc);
1385 err = ext3_journal_stop(handle);
1392 redirty_page_for_writepage(wbc, page);
1398 static int ext3_readpage(struct file *file, struct page *page)
1400 return mpage_readpage(page, ext3_get_block);
1404 ext3_readpages(struct file *file, struct address_space *mapping,
1405 struct list_head *pages, unsigned nr_pages)
1407 return mpage_readpages(mapping, pages, nr_pages, ext3_get_block);
1410 static int ext3_invalidatepage(struct page *page, unsigned long offset)
1412 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1415 * If it's a full truncate we just forget about the pending dirtying
1418 ClearPageChecked(page);
1420 return journal_invalidatepage(journal, page, offset);
1423 static int ext3_releasepage(struct page *page, int wait)
1425 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1427 WARN_ON(PageChecked(page));
1428 return journal_try_to_free_buffers(journal, page, wait);
1432 * If the O_DIRECT write will extend the file then add this inode to the
1433 * orphan list. So recovery will truncate it back to the original size
1434 * if the machine crashes during the write.
1436 * If the O_DIRECT write is intantiating holes inside i_size and the machine
1437 * crashes then stale disk data _may_ be exposed inside the file.
1439 static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
1440 const struct iovec *iov, loff_t offset,
1441 unsigned long nr_segs)
1443 struct file *file = iocb->ki_filp;
1444 struct inode *inode = file->f_mapping->host;
1445 struct ext3_inode_info *ei = EXT3_I(inode);
1446 handle_t *handle = NULL;
1449 size_t count = iov_length(iov, nr_segs);
1452 loff_t final_size = offset + count;
1454 handle = ext3_journal_start(inode, DIO_CREDITS);
1455 if (IS_ERR(handle)) {
1456 ret = PTR_ERR(handle);
1459 if (final_size > inode->i_size) {
1460 ret = ext3_orphan_add(handle, inode);
1464 ei->i_disksize = inode->i_size;
1468 ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
1470 ext3_direct_io_get_blocks, NULL);
1477 ext3_orphan_del(handle, inode);
1478 if (orphan && ret > 0) {
1479 loff_t end = offset + ret;
1480 if (end > inode->i_size) {
1481 ei->i_disksize = end;
1482 i_size_write(inode, end);
1483 err = ext3_mark_inode_dirty(handle, inode);
1488 err = ext3_journal_stop(handle);
1497 * Pages can be marked dirty completely asynchronously from ext3's journalling
1498 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
1499 * much here because ->set_page_dirty is called under VFS locks. The page is
1500 * not necessarily locked.
1502 * We cannot just dirty the page and leave attached buffers clean, because the
1503 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
1504 * or jbddirty because all the journalling code will explode.
1506 * So what we do is to mark the page "pending dirty" and next time writepage
1507 * is called, propagate that into the buffers appropriately.
1509 static int ext3_journalled_set_page_dirty(struct page *page)
1511 SetPageChecked(page);
1512 return __set_page_dirty_nobuffers(page);
1515 static struct address_space_operations ext3_ordered_aops = {
1516 .readpage = ext3_readpage,
1517 .readpages = ext3_readpages,
1518 .writepage = ext3_ordered_writepage,
1519 .sync_page = block_sync_page,
1520 .prepare_write = ext3_prepare_write,
1521 .commit_write = ext3_ordered_commit_write,
1523 .invalidatepage = ext3_invalidatepage,
1524 .releasepage = ext3_releasepage,
1525 .direct_IO = ext3_direct_IO,
1528 static struct address_space_operations ext3_writeback_aops = {
1529 .readpage = ext3_readpage,
1530 .readpages = ext3_readpages,
1531 .writepage = ext3_writeback_writepage,
1532 .sync_page = block_sync_page,
1533 .prepare_write = ext3_prepare_write,
1534 .commit_write = ext3_writeback_commit_write,
1536 .invalidatepage = ext3_invalidatepage,
1537 .releasepage = ext3_releasepage,
1538 .direct_IO = ext3_direct_IO,
1541 static struct address_space_operations ext3_journalled_aops = {
1542 .readpage = ext3_readpage,
1543 .readpages = ext3_readpages,
1544 .writepage = ext3_journalled_writepage,
1545 .sync_page = block_sync_page,
1546 .prepare_write = ext3_prepare_write,
1547 .commit_write = ext3_journalled_commit_write,
1548 .set_page_dirty = ext3_journalled_set_page_dirty,
1550 .invalidatepage = ext3_invalidatepage,
1551 .releasepage = ext3_releasepage,
1554 void ext3_set_aops(struct inode *inode)
1556 if (ext3_should_order_data(inode))
1557 inode->i_mapping->a_ops = &ext3_ordered_aops;
1558 else if (ext3_should_writeback_data(inode))
1559 inode->i_mapping->a_ops = &ext3_writeback_aops;
1561 inode->i_mapping->a_ops = &ext3_journalled_aops;
1565 * ext3_block_truncate_page() zeroes out a mapping from file offset `from'
1566 * up to the end of the block which corresponds to `from'.
1567 * This required during truncate. We need to physically zero the tail end
1568 * of that block so it doesn't yield old data if the file is later grown.
1570 static int ext3_block_truncate_page(handle_t *handle, struct page *page,
1571 struct address_space *mapping, loff_t from)
1573 unsigned long index = from >> PAGE_CACHE_SHIFT;
1574 unsigned offset = from & (PAGE_CACHE_SIZE-1);
1575 unsigned blocksize, iblock, length, pos;
1576 struct inode *inode = mapping->host;
1577 struct buffer_head *bh;
1581 blocksize = inode->i_sb->s_blocksize;
1582 length = blocksize - (offset & (blocksize - 1));
1583 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1585 if (!page_has_buffers(page))
1586 create_empty_buffers(page, blocksize, 0);
1588 /* Find the buffer that contains "offset" */
1589 bh = page_buffers(page);
1591 while (offset >= pos) {
1592 bh = bh->b_this_page;
1598 if (buffer_freed(bh)) {
1599 BUFFER_TRACE(bh, "freed: skip");
1603 if (!buffer_mapped(bh)) {
1604 BUFFER_TRACE(bh, "unmapped");
1605 ext3_get_block(inode, iblock, bh, 0);
1606 /* unmapped? It's a hole - nothing to do */
1607 if (!buffer_mapped(bh)) {
1608 BUFFER_TRACE(bh, "still unmapped");
1613 /* Ok, it's mapped. Make sure it's up-to-date */
1614 if (PageUptodate(page))
1615 set_buffer_uptodate(bh);
1617 if (!buffer_uptodate(bh)) {
1619 ll_rw_block(READ, 1, &bh);
1621 /* Uhhuh. Read error. Complain and punt. */
1622 if (!buffer_uptodate(bh))
1626 if (ext3_should_journal_data(inode)) {
1627 BUFFER_TRACE(bh, "get write access");
1628 err = ext3_journal_get_write_access(handle, bh);
1633 kaddr = kmap_atomic(page, KM_USER0);
1634 memset(kaddr + offset, 0, length);
1635 flush_dcache_page(page);
1636 kunmap_atomic(kaddr, KM_USER0);
1638 BUFFER_TRACE(bh, "zeroed end of block");
1641 if (ext3_should_journal_data(inode)) {
1642 err = ext3_journal_dirty_metadata(handle, bh);
1644 if (ext3_should_order_data(inode))
1645 err = ext3_journal_dirty_data(handle, bh);
1646 mark_buffer_dirty(bh);
1651 page_cache_release(page);
1656 * Probably it should be a library function... search for first non-zero word
1657 * or memcmp with zero_page, whatever is better for particular architecture.
1660 static inline int all_zeroes(u32 *p, u32 *q)
1669 * ext3_find_shared - find the indirect blocks for partial truncation.
1670 * @inode: inode in question
1671 * @depth: depth of the affected branch
1672 * @offsets: offsets of pointers in that branch (see ext3_block_to_path)
1673 * @chain: place to store the pointers to partial indirect blocks
1674 * @top: place to the (detached) top of branch
1676 * This is a helper function used by ext3_truncate().
1678 * When we do truncate() we may have to clean the ends of several
1679 * indirect blocks but leave the blocks themselves alive. Block is
1680 * partially truncated if some data below the new i_size is refered
1681 * from it (and it is on the path to the first completely truncated
1682 * data block, indeed). We have to free the top of that path along
1683 * with everything to the right of the path. Since no allocation
1684 * past the truncation point is possible until ext3_truncate()
1685 * finishes, we may safely do the latter, but top of branch may
1686 * require special attention - pageout below the truncation point
1687 * might try to populate it.
1689 * We atomically detach the top of branch from the tree, store the
1690 * block number of its root in *@top, pointers to buffer_heads of
1691 * partially truncated blocks - in @chain[].bh and pointers to
1692 * their last elements that should not be removed - in
1693 * @chain[].p. Return value is the pointer to last filled element
1696 * The work left to caller to do the actual freeing of subtrees:
1697 * a) free the subtree starting from *@top
1698 * b) free the subtrees whose roots are stored in
1699 * (@chain[i].p+1 .. end of @chain[i].bh->b_data)
1700 * c) free the subtrees growing from the inode past the @chain[0].
1701 * (no partially truncated stuff there). */
1703 static Indirect *ext3_find_shared(struct inode *inode,
1709 Indirect *partial, *p;
1713 /* Make k index the deepest non-null offest + 1 */
1714 for (k = depth; k > 1 && !offsets[k-1]; k--)
1716 partial = ext3_get_branch(inode, k, offsets, chain, &err);
1717 /* Writer: pointers */
1719 partial = chain + k-1;
1721 * If the branch acquired continuation since we've looked at it -
1722 * fine, it should all survive and (new) top doesn't belong to us.
1724 if (!partial->key && *partial->p)
1727 for (p=partial; p>chain && all_zeroes((u32*)p->bh->b_data,p->p); p--)
1730 * OK, we've found the last block that must survive. The rest of our
1731 * branch should be detached before unlocking. However, if that rest
1732 * of branch is all ours and does not grow immediately from the inode
1733 * it's easier to cheat and just decrement partial->p.
1735 if (p == chain + k - 1 && p > chain) {
1739 /* Nope, don't do this in ext3. Must leave the tree intact */
1748 brelse(partial->bh);
1756 * Zero a number of block pointers in either an inode or an indirect block.
1757 * If we restart the transaction we must again get write access to the
1758 * indirect block for further modification.
1760 * We release `count' blocks on disk, but (last - first) may be greater
1761 * than `count' because there can be holes in there.
1764 ext3_clear_blocks(handle_t *handle, struct inode *inode, struct buffer_head *bh,
1765 unsigned long block_to_free, unsigned long count,
1766 u32 *first, u32 *last)
1769 if (try_to_extend_transaction(handle, inode)) {
1771 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
1772 ext3_journal_dirty_metadata(handle, bh);
1774 ext3_mark_inode_dirty(handle, inode);
1775 ext3_journal_test_restart(handle, inode);
1777 BUFFER_TRACE(bh, "retaking write access");
1778 ext3_journal_get_write_access(handle, bh);
1783 * Any buffers which are on the journal will be in memory. We find
1784 * them on the hash table so journal_revoke() will run journal_forget()
1785 * on them. We've already detached each block from the file, so
1786 * bforget() in journal_forget() should be safe.
1788 * AKPM: turn on bforget in journal_forget()!!!
1790 for (p = first; p < last; p++) {
1791 u32 nr = le32_to_cpu(*p);
1793 struct buffer_head *bh;
1796 bh = sb_find_get_block(inode->i_sb, nr);
1797 ext3_forget(handle, 0, inode, bh, nr);
1801 ext3_free_blocks(handle, inode, block_to_free, count);
1805 * ext3_free_data - free a list of data blocks
1806 * @handle: handle for this transaction
1807 * @inode: inode we are dealing with
1808 * @this_bh: indirect buffer_head which contains *@first and *@last
1809 * @first: array of block numbers
1810 * @last: points immediately past the end of array
1812 * We are freeing all blocks refered from that array (numbers are stored as
1813 * little-endian 32-bit) and updating @inode->i_blocks appropriately.
1815 * We accumulate contiguous runs of blocks to free. Conveniently, if these
1816 * blocks are contiguous then releasing them at one time will only affect one
1817 * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
1818 * actually use a lot of journal space.
1820 * @this_bh will be %NULL if @first and @last point into the inode's direct
1823 static void ext3_free_data(handle_t *handle, struct inode *inode,
1824 struct buffer_head *this_bh, u32 *first, u32 *last)
1826 unsigned long block_to_free = 0; /* Starting block # of a run */
1827 unsigned long count = 0; /* Number of blocks in the run */
1828 u32 *block_to_free_p = NULL; /* Pointer into inode/ind
1831 unsigned long nr; /* Current block # */
1832 u32 *p; /* Pointer into inode/ind
1833 for current block */
1836 if (this_bh) { /* For indirect block */
1837 BUFFER_TRACE(this_bh, "get_write_access");
1838 err = ext3_journal_get_write_access(handle, this_bh);
1839 /* Important: if we can't update the indirect pointers
1840 * to the blocks, we can't free them. */
1845 for (p = first; p < last; p++) {
1846 nr = le32_to_cpu(*p);
1848 /* accumulate blocks to free if they're contiguous */
1851 block_to_free_p = p;
1853 } else if (nr == block_to_free + count) {
1856 ext3_clear_blocks(handle, inode, this_bh,
1858 count, block_to_free_p, p);
1860 block_to_free_p = p;
1867 ext3_clear_blocks(handle, inode, this_bh, block_to_free,
1868 count, block_to_free_p, p);
1871 BUFFER_TRACE(this_bh, "call ext3_journal_dirty_metadata");
1872 ext3_journal_dirty_metadata(handle, this_bh);
1877 * ext3_free_branches - free an array of branches
1878 * @handle: JBD handle for this transaction
1879 * @inode: inode we are dealing with
1880 * @parent_bh: the buffer_head which contains *@first and *@last
1881 * @first: array of block numbers
1882 * @last: pointer immediately past the end of array
1883 * @depth: depth of the branches to free
1885 * We are freeing all blocks refered from these branches (numbers are
1886 * stored as little-endian 32-bit) and updating @inode->i_blocks
1889 static void ext3_free_branches(handle_t *handle, struct inode *inode,
1890 struct buffer_head *parent_bh,
1891 u32 *first, u32 *last, int depth)
1896 if (is_handle_aborted(handle))
1900 struct buffer_head *bh;
1901 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
1903 while (--p >= first) {
1904 nr = le32_to_cpu(*p);
1906 continue; /* A hole */
1908 /* Go read the buffer for the next level down */
1909 bh = sb_bread(inode->i_sb, nr);
1912 * A read failure? Report error and clear slot
1916 ext3_error(inode->i_sb, "ext3_free_branches",
1917 "Read failure, inode=%ld, block=%ld",
1922 /* This zaps the entire block. Bottom up. */
1923 BUFFER_TRACE(bh, "free child branches");
1924 ext3_free_branches(handle, inode, bh, (u32*)bh->b_data,
1925 (u32*)bh->b_data + addr_per_block,
1929 * We've probably journalled the indirect block several
1930 * times during the truncate. But it's no longer
1931 * needed and we now drop it from the transaction via
1934 * That's easy if it's exclusively part of this
1935 * transaction. But if it's part of the committing
1936 * transaction then journal_forget() will simply
1937 * brelse() it. That means that if the underlying
1938 * block is reallocated in ext3_get_block(),
1939 * unmap_underlying_metadata() will find this block
1940 * and will try to get rid of it. damn, damn.
1942 * If this block has already been committed to the
1943 * journal, a revoke record will be written. And
1944 * revoke records must be emitted *before* clearing
1945 * this block's bit in the bitmaps.
1947 ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
1950 * Everything below this this pointer has been
1951 * released. Now let this top-of-subtree go.
1953 * We want the freeing of this indirect block to be
1954 * atomic in the journal with the updating of the
1955 * bitmap block which owns it. So make some room in
1958 * We zero the parent pointer *after* freeing its
1959 * pointee in the bitmaps, so if extend_transaction()
1960 * for some reason fails to put the bitmap changes and
1961 * the release into the same transaction, recovery
1962 * will merely complain about releasing a free block,
1963 * rather than leaking blocks.
1965 if (is_handle_aborted(handle))
1967 if (try_to_extend_transaction(handle, inode)) {
1968 ext3_mark_inode_dirty(handle, inode);
1969 ext3_journal_test_restart(handle, inode);
1972 ext3_free_blocks(handle, inode, nr, 1);
1976 * The block which we have just freed is
1977 * pointed to by an indirect block: journal it
1979 BUFFER_TRACE(parent_bh, "get_write_access");
1980 if (!ext3_journal_get_write_access(handle,
1983 BUFFER_TRACE(parent_bh,
1984 "call ext3_journal_dirty_metadata");
1985 ext3_journal_dirty_metadata(handle,
1991 /* We have reached the bottom of the tree. */
1992 BUFFER_TRACE(parent_bh, "free data blocks");
1993 ext3_free_data(handle, inode, parent_bh, first, last);
2000 * We block out ext3_get_block() block instantiations across the entire
2001 * transaction, and VFS/VM ensures that ext3_truncate() cannot run
2002 * simultaneously on behalf of the same inode.
2004 * As we work through the truncate and commmit bits of it to the journal there
2005 * is one core, guiding principle: the file's tree must always be consistent on
2006 * disk. We must be able to restart the truncate after a crash.
2008 * The file's tree may be transiently inconsistent in memory (although it
2009 * probably isn't), but whenever we close off and commit a journal transaction,
2010 * the contents of (the filesystem + the journal) must be consistent and
2011 * restartable. It's pretty simple, really: bottom up, right to left (although
2012 * left-to-right works OK too).
2014 * Note that at recovery time, journal replay occurs *before* the restart of
2015 * truncate against the orphan inode list.
2017 * The committed inode has the new, desired i_size (which is the same as
2018 * i_disksize in this case). After a crash, ext3_orphan_cleanup() will see
2019 * that this inode's truncate did not complete and it will again call
2020 * ext3_truncate() to have another go. So there will be instantiated blocks
2021 * to the right of the truncation point in a crashed ext3 filesystem. But
2022 * that's fine - as long as they are linked from the inode, the post-crash
2023 * ext3_truncate() run will find them and release them.
2026 void ext3_truncate_nocheck(struct inode * inode)
2029 struct ext3_inode_info *ei = EXT3_I(inode);
2030 u32 *i_data = ei->i_data;
2031 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2032 struct address_space *mapping = inode->i_mapping;
2039 unsigned blocksize = inode->i_sb->s_blocksize;
2042 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
2043 S_ISLNK(inode->i_mode)))
2045 if (ext3_inode_is_fast_symlink(inode))
2048 ext3_discard_reservation(inode);
2051 * We have to lock the EOF page here, because lock_page() nests
2052 * outside journal_start().
2054 if ((inode->i_size & (blocksize - 1)) == 0) {
2055 /* Block boundary? Nothing to do */
2058 page = grab_cache_page(mapping,
2059 inode->i_size >> PAGE_CACHE_SHIFT);
2064 handle = start_transaction(inode);
2065 if (IS_ERR(handle)) {
2067 clear_highpage(page);
2068 flush_dcache_page(page);
2070 page_cache_release(page);
2072 return; /* AKPM: return what? */
2075 last_block = (inode->i_size + blocksize-1)
2076 >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
2079 ext3_block_truncate_page(handle, page, mapping, inode->i_size);
2081 n = ext3_block_to_path(inode, last_block, offsets, NULL);
2083 goto out_stop; /* error */
2086 * OK. This truncate is going to happen. We add the inode to the
2087 * orphan list, so that if this truncate spans multiple transactions,
2088 * and we crash, we will resume the truncate when the filesystem
2089 * recovers. It also marks the inode dirty, to catch the new size.
2091 * Implication: the file must always be in a sane, consistent
2092 * truncatable state while each transaction commits.
2094 if (ext3_orphan_add(handle, inode))
2098 * The orphan list entry will now protect us from any crash which
2099 * occurs before the truncate completes, so it is now safe to propagate
2100 * the new, shorter inode size (held for now in i_size) into the
2101 * on-disk inode. We do this via i_disksize, which is the value which
2102 * ext3 *really* writes onto the disk inode.
2104 ei->i_disksize = inode->i_size;
2107 * From here we block out all ext3_get_block() callers who want to
2108 * modify the block allocation tree.
2110 down(&ei->truncate_sem);
2112 if (n == 1) { /* direct blocks */
2113 ext3_free_data(handle, inode, NULL, i_data+offsets[0],
2114 i_data + EXT3_NDIR_BLOCKS);
2118 partial = ext3_find_shared(inode, n, offsets, chain, &nr);
2119 /* Kill the top of shared branch (not detached) */
2121 if (partial == chain) {
2122 /* Shared branch grows from the inode */
2123 ext3_free_branches(handle, inode, NULL,
2124 &nr, &nr+1, (chain+n-1) - partial);
2127 * We mark the inode dirty prior to restart,
2128 * and prior to stop. No need for it here.
2131 /* Shared branch grows from an indirect block */
2132 BUFFER_TRACE(partial->bh, "get_write_access");
2133 ext3_free_branches(handle, inode, partial->bh,
2135 partial->p+1, (chain+n-1) - partial);
2138 /* Clear the ends of indirect blocks on the shared branch */
2139 while (partial > chain) {
2140 ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2141 (u32*)partial->bh->b_data + addr_per_block,
2142 (chain+n-1) - partial);
2143 BUFFER_TRACE(partial->bh, "call brelse");
2144 brelse (partial->bh);
2148 /* Kill the remaining (whole) subtrees */
2149 switch (offsets[0]) {
2151 nr = i_data[EXT3_IND_BLOCK];
2153 ext3_free_branches(handle, inode, NULL,
2155 i_data[EXT3_IND_BLOCK] = 0;
2157 case EXT3_IND_BLOCK:
2158 nr = i_data[EXT3_DIND_BLOCK];
2160 ext3_free_branches(handle, inode, NULL,
2162 i_data[EXT3_DIND_BLOCK] = 0;
2164 case EXT3_DIND_BLOCK:
2165 nr = i_data[EXT3_TIND_BLOCK];
2167 ext3_free_branches(handle, inode, NULL,
2169 i_data[EXT3_TIND_BLOCK] = 0;
2171 case EXT3_TIND_BLOCK:
2174 up(&ei->truncate_sem);
2175 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2176 ext3_mark_inode_dirty(handle, inode);
2178 /* In a multi-transaction truncate, we only make the final
2179 * transaction synchronous */
2184 * If this was a simple ftruncate(), and the file will remain alive
2185 * then we need to clear up the orphan record which we created above.
2186 * However, if this was a real unlink then we were called by
2187 * ext3_delete_inode(), and we allow that function to clean up the
2188 * orphan info for us.
2191 ext3_orphan_del(handle, inode);
2193 ext3_journal_stop(handle);
2196 static unsigned long ext3_get_inode_block(struct super_block *sb,
2197 unsigned long ino, struct ext3_iloc *iloc)
2199 unsigned long desc, group_desc, block_group;
2200 unsigned long offset, block;
2201 struct buffer_head *bh;
2202 struct ext3_group_desc * gdp;
2205 if ((ino != EXT3_ROOT_INO &&
2206 ino != EXT3_JOURNAL_INO &&
2207 ino != EXT3_RESIZE_INO &&
2208 ino < EXT3_FIRST_INO(sb)) ||
2210 EXT3_SB(sb)->s_es->s_inodes_count)) {
2211 ext3_error (sb, "ext3_get_inode_block",
2212 "bad inode number: %lu", ino);
2215 block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
2216 if (block_group >= EXT3_SB(sb)->s_groups_count) {
2217 ext3_error (sb, "ext3_get_inode_block",
2218 "group >= groups count");
2221 group_desc = block_group >> EXT3_DESC_PER_BLOCK_BITS(sb);
2222 desc = block_group & (EXT3_DESC_PER_BLOCK(sb) - 1);
2223 bh = EXT3_SB(sb)->s_group_desc[group_desc];
2225 ext3_error (sb, "ext3_get_inode_block",
2226 "Descriptor not loaded");
2230 gdp = (struct ext3_group_desc *) bh->b_data;
2232 * Figure out the offset within the block group inode table
2234 offset = ((ino - 1) % EXT3_INODES_PER_GROUP(sb)) *
2235 EXT3_INODE_SIZE(sb);
2236 block = le32_to_cpu(gdp[desc].bg_inode_table) +
2237 (offset >> EXT3_BLOCK_SIZE_BITS(sb));
2239 iloc->block_group = block_group;
2240 iloc->offset = offset & (EXT3_BLOCK_SIZE(sb) - 1);
2245 * ext3_get_inode_loc returns with an extra refcount against the inode's
2246 * underlying buffer_head on success. If `in_mem' is false then we're purely
2247 * trying to determine the inode's location on-disk and no read need be
2250 static int ext3_get_inode_loc(struct inode *inode,
2251 struct ext3_iloc *iloc, int in_mem)
2253 unsigned long block;
2254 struct buffer_head *bh;
2256 block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
2260 bh = sb_getblk(inode->i_sb, block);
2262 ext3_error (inode->i_sb, "ext3_get_inode_loc",
2263 "unable to read inode block - "
2264 "inode=%lu, block=%lu", inode->i_ino, block);
2267 if (!buffer_uptodate(bh)) {
2269 if (buffer_uptodate(bh)) {
2270 /* someone brought it uptodate while we waited */
2275 /* we can't skip I/O if inode is on a disk only */
2277 struct buffer_head *bitmap_bh;
2278 struct ext3_group_desc *desc;
2279 int inodes_per_buffer;
2280 int inode_offset, i;
2285 * If this is the only valid inode in the block we
2286 * need not read the block.
2288 block_group = (inode->i_ino - 1) /
2289 EXT3_INODES_PER_GROUP(inode->i_sb);
2290 inodes_per_buffer = bh->b_size /
2291 EXT3_INODE_SIZE(inode->i_sb);
2292 inode_offset = ((inode->i_ino - 1) %
2293 EXT3_INODES_PER_GROUP(inode->i_sb));
2294 start = inode_offset & ~(inodes_per_buffer - 1);
2296 /* Is the inode bitmap in cache? */
2297 desc = ext3_get_group_desc(inode->i_sb,
2302 bitmap_bh = sb_getblk(inode->i_sb,
2303 le32_to_cpu(desc->bg_inode_bitmap));
2308 * If the inode bitmap isn't in cache then the
2309 * optimisation may end up performing two reads instead
2310 * of one, so skip it.
2312 if (!buffer_uptodate(bitmap_bh)) {
2316 for (i = start; i < start + inodes_per_buffer; i++) {
2317 if (i == inode_offset)
2319 if (ext3_test_bit(i, bitmap_bh->b_data))
2323 if (i == start + inodes_per_buffer) {
2324 /* all other inodes are free, so skip I/O */
2325 memset(bh->b_data, 0, bh->b_size);
2326 set_buffer_uptodate(bh);
2334 * There are another valid inodes in the buffer so we must
2335 * read the block from disk
2338 bh->b_end_io = end_buffer_read_sync;
2339 submit_bh(READ, bh);
2341 if (!buffer_uptodate(bh)) {
2342 ext3_error(inode->i_sb, "ext3_get_inode_loc",
2343 "unable to read inode block - "
2344 "inode=%lu, block=%lu",
2345 inode->i_ino, block);
2355 void ext3_truncate(struct inode * inode)
2357 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2359 ext3_truncate_nocheck(inode);
2362 void ext3_set_inode_flags(struct inode *inode)
2364 unsigned int flags = EXT3_I(inode)->i_flags;
2366 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
2367 if (flags & EXT3_SYNC_FL)
2368 inode->i_flags |= S_SYNC;
2369 if (flags & EXT3_APPEND_FL)
2370 inode->i_flags |= S_APPEND;
2371 if (flags & EXT3_IMMUTABLE_FL)
2372 inode->i_flags |= S_IMMUTABLE;
2373 if (flags & EXT3_IUNLINK_FL)
2374 inode->i_flags |= S_IUNLINK;
2375 if (flags & EXT3_BARRIER_FL)
2376 inode->i_flags |= S_BARRIER;
2377 if (flags & EXT3_NOATIME_FL)
2378 inode->i_flags |= S_NOATIME;
2379 if (flags & EXT3_DIRSYNC_FL)
2380 inode->i_flags |= S_DIRSYNC;
2383 void ext3_read_inode(struct inode * inode)
2385 struct ext3_iloc iloc;
2386 struct ext3_inode *raw_inode;
2387 struct ext3_inode_info *ei = EXT3_I(inode);
2388 struct buffer_head *bh;
2393 #ifdef CONFIG_EXT3_FS_POSIX_ACL
2394 ei->i_acl = EXT3_ACL_NOT_CACHED;
2395 ei->i_default_acl = EXT3_ACL_NOT_CACHED;
2397 if (ext3_get_inode_loc(inode, &iloc, 0))
2400 raw_inode = ext3_raw_inode(&iloc);
2401 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
2402 uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
2403 gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
2404 if(!(test_opt (inode->i_sb, NO_UID32))) {
2405 uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
2406 gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
2408 inode->i_uid = INOXID_UID(uid, gid);
2409 inode->i_gid = INOXID_GID(uid, gid);
2410 if (inode->i_sb->s_flags & MS_TAGXID)
2411 inode->i_xid = INOXID_XID(uid, gid, le16_to_cpu(raw_inode->i_raw_xid));
2413 inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
2414 inode->i_size = le32_to_cpu(raw_inode->i_size);
2415 inode->i_atime.tv_sec = le32_to_cpu(raw_inode->i_atime);
2416 inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->i_ctime);
2417 inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->i_mtime);
2418 inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
2421 ei->i_next_alloc_block = 0;
2422 ei->i_next_alloc_goal = 0;
2423 ei->i_dir_start_lookup = 0;
2424 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
2425 /* We now have enough fields to check if the inode was active or not.
2426 * This is needed because nfsd might try to access dead inodes
2427 * the test is that same one that e2fsck uses
2428 * NeilBrown 1999oct15
2430 if (inode->i_nlink == 0) {
2431 if (inode->i_mode == 0 ||
2432 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
2433 /* this inode is deleted */
2437 /* The only unlinked inodes we let through here have
2438 * valid i_mode and are being read by the orphan
2439 * recovery code: that's fine, we're about to complete
2440 * the process of deleting those. */
2442 inode->i_blksize = PAGE_SIZE; /* This is the optimal IO size
2443 * (for stat), not the fs block
2445 inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
2446 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
2447 #ifdef EXT3_FRAGMENTS
2448 ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
2449 ei->i_frag_no = raw_inode->i_frag;
2450 ei->i_frag_size = raw_inode->i_fsize;
2452 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
2453 if (!S_ISREG(inode->i_mode)) {
2454 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
2457 ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
2459 ei->i_disksize = inode->i_size;
2460 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
2461 ei->i_block_group = iloc.block_group;
2462 ei->i_rsv_window.rsv_start = 0;
2463 ei->i_rsv_window.rsv_end= 0;
2464 atomic_set(&ei->i_rsv_window.rsv_goal_size, EXT3_DEFAULT_RESERVE_BLOCKS);
2465 INIT_LIST_HEAD(&ei->i_rsv_window.rsv_list);
2467 * NOTE! The in-memory inode i_data array is in little-endian order
2468 * even on big-endian machines: we do NOT byteswap the block numbers!
2470 for (block = 0; block < EXT3_N_BLOCKS; block++)
2471 ei->i_data[block] = raw_inode->i_block[block];
2472 INIT_LIST_HEAD(&ei->i_orphan);
2474 if (S_ISREG(inode->i_mode)) {
2475 inode->i_op = &ext3_file_inode_operations;
2476 inode->i_fop = &ext3_file_operations;
2477 ext3_set_aops(inode);
2478 } else if (S_ISDIR(inode->i_mode)) {
2479 inode->i_op = &ext3_dir_inode_operations;
2480 inode->i_fop = &ext3_dir_operations;
2481 } else if (S_ISLNK(inode->i_mode)) {
2482 if (ext3_inode_is_fast_symlink(inode))
2483 inode->i_op = &ext3_fast_symlink_inode_operations;
2485 inode->i_op = &ext3_symlink_inode_operations;
2486 ext3_set_aops(inode);
2489 inode->i_op = &ext3_special_inode_operations;
2490 if (raw_inode->i_block[0])
2491 init_special_inode(inode, inode->i_mode,
2492 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
2494 init_special_inode(inode, inode->i_mode,
2495 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
2498 ext3_set_inode_flags(inode);
2502 make_bad_inode(inode);
2507 * Post the struct inode info into an on-disk inode location in the
2508 * buffer-cache. This gobbles the caller's reference to the
2509 * buffer_head in the inode location struct.
2511 * The caller must have write access to iloc->bh.
2513 static int ext3_do_update_inode(handle_t *handle,
2514 struct inode *inode,
2515 struct ext3_iloc *iloc)
2517 struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
2518 struct ext3_inode_info *ei = EXT3_I(inode);
2519 struct buffer_head *bh = iloc->bh;
2520 uid_t uid = XIDINO_UID(inode->i_uid, inode->i_xid);
2521 gid_t gid = XIDINO_GID(inode->i_gid, inode->i_xid);
2522 int err = 0, rc, block;
2524 /* For fields not not tracking in the in-memory inode,
2525 * initialise them to zero for new inodes. */
2526 if (ei->i_state & EXT3_STATE_NEW)
2527 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
2529 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
2530 if(!(test_opt(inode->i_sb, NO_UID32))) {
2531 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(uid));
2532 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(gid));
2534 * Fix up interoperability with old kernels. Otherwise, old inodes get
2535 * re-used with the upper 16 bits of the uid/gid intact
2538 raw_inode->i_uid_high =
2539 cpu_to_le16(high_16_bits(uid));
2540 raw_inode->i_gid_high =
2541 cpu_to_le16(high_16_bits(gid));
2543 raw_inode->i_uid_high = 0;
2544 raw_inode->i_gid_high = 0;
2547 raw_inode->i_uid_low =
2548 cpu_to_le16(fs_high2lowuid(uid));
2549 raw_inode->i_gid_low =
2550 cpu_to_le16(fs_high2lowgid(gid));
2551 raw_inode->i_uid_high = 0;
2552 raw_inode->i_gid_high = 0;
2554 #ifdef CONFIG_INOXID_GID32
2555 raw_inode->i_raw_xid = cpu_to_le16(inode->i_xid);
2557 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
2558 raw_inode->i_size = cpu_to_le32(ei->i_disksize);
2559 raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
2560 raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
2561 raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
2562 raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
2563 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
2564 raw_inode->i_flags = cpu_to_le32(ei->i_flags);
2565 #ifdef EXT3_FRAGMENTS
2566 raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
2567 raw_inode->i_frag = ei->i_frag_no;
2568 raw_inode->i_fsize = ei->i_frag_size;
2570 raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
2571 if (!S_ISREG(inode->i_mode)) {
2572 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
2574 raw_inode->i_size_high =
2575 cpu_to_le32(ei->i_disksize >> 32);
2576 if (ei->i_disksize > 0x7fffffffULL) {
2577 struct super_block *sb = inode->i_sb;
2578 if (!EXT3_HAS_RO_COMPAT_FEATURE(sb,
2579 EXT3_FEATURE_RO_COMPAT_LARGE_FILE) ||
2580 EXT3_SB(sb)->s_es->s_rev_level ==
2581 cpu_to_le32(EXT3_GOOD_OLD_REV)) {
2582 /* If this is the first large file
2583 * created, add a flag to the superblock.
2585 err = ext3_journal_get_write_access(handle,
2586 EXT3_SB(sb)->s_sbh);
2589 ext3_update_dynamic_rev(sb);
2590 EXT3_SET_RO_COMPAT_FEATURE(sb,
2591 EXT3_FEATURE_RO_COMPAT_LARGE_FILE);
2594 err = ext3_journal_dirty_metadata(handle,
2595 EXT3_SB(sb)->s_sbh);
2599 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
2600 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
2601 if (old_valid_dev(inode->i_rdev)) {
2602 raw_inode->i_block[0] =
2603 cpu_to_le32(old_encode_dev(inode->i_rdev));
2604 raw_inode->i_block[1] = 0;
2606 raw_inode->i_block[0] = 0;
2607 raw_inode->i_block[1] =
2608 cpu_to_le32(new_encode_dev(inode->i_rdev));
2609 raw_inode->i_block[2] = 0;
2611 } else for (block = 0; block < EXT3_N_BLOCKS; block++)
2612 raw_inode->i_block[block] = ei->i_data[block];
2614 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2615 rc = ext3_journal_dirty_metadata(handle, bh);
2618 ei->i_state &= ~EXT3_STATE_NEW;
2622 ext3_std_error(inode->i_sb, err);
2627 * ext3_write_inode()
2629 * We are called from a few places:
2631 * - Within generic_file_write() for O_SYNC files.
2632 * Here, there will be no transaction running. We wait for any running
2633 * trasnaction to commit.
2635 * - Within sys_sync(), kupdate and such.
2636 * We wait on commit, if tol to.
2638 * - Within prune_icache() (PF_MEMALLOC == true)
2639 * Here we simply return. We can't afford to block kswapd on the
2642 * In all cases it is actually safe for us to return without doing anything,
2643 * because the inode has been copied into a raw inode buffer in
2644 * ext3_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
2647 * Note that we are absolutely dependent upon all inode dirtiers doing the
2648 * right thing: they *must* call mark_inode_dirty() after dirtying info in
2649 * which we are interested.
2651 * It would be a bug for them to not do this. The code:
2653 * mark_inode_dirty(inode)
2655 * inode->i_size = expr;
2657 * is in error because a kswapd-driven write_inode() could occur while
2658 * `stuff()' is running, and the new i_size will be lost. Plus the inode
2659 * will no longer be on the superblock's dirty inode list.
2661 void ext3_write_inode(struct inode *inode, int wait)
2663 if (current->flags & PF_MEMALLOC)
2666 if (ext3_journal_current_handle()) {
2667 jbd_debug(0, "called recursively, non-PF_MEMALLOC!\n");
2675 ext3_force_commit(inode->i_sb);
2678 int ext3_setattr_flags(struct inode *inode, unsigned int flags)
2680 unsigned int oldflags, newflags;
2683 oldflags = EXT3_I(inode)->i_flags;
2684 newflags = oldflags &
2685 ~(EXT3_IMMUTABLE_FL | EXT3_IUNLINK_FL | EXT3_BARRIER_FL);
2686 if (flags & ATTR_FLAG_IMMUTABLE)
2687 newflags |= EXT3_IMMUTABLE_FL;
2688 if (flags & ATTR_FLAG_IUNLINK)
2689 newflags |= EXT3_IUNLINK_FL;
2690 if (flags & ATTR_FLAG_BARRIER)
2691 newflags |= EXT3_BARRIER_FL;
2693 if (oldflags ^ newflags) {
2695 struct ext3_iloc iloc;
2697 handle = ext3_journal_start(inode, 1);
2699 return PTR_ERR(handle);
2702 err = ext3_reserve_inode_write(handle, inode, &iloc);
2706 EXT3_I(inode)->i_flags = newflags;
2707 inode->i_ctime = CURRENT_TIME;
2709 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
2711 ext3_journal_stop(handle);
2719 * Called from notify_change.
2721 * We want to trap VFS attempts to truncate the file as soon as
2722 * possible. In particular, we want to make sure that when the VFS
2723 * shrinks i_size, we put the inode on the orphan list and modify
2724 * i_disksize immediately, so that during the subsequent flushing of
2725 * dirty pages and freeing of disk blocks, we can guarantee that any
2726 * commit will leave the blocks being flushed in an unused state on
2727 * disk. (On recovery, the inode will get truncated and the blocks will
2728 * be freed, so we have a strong guarantee that no future commit will
2729 * leave these blocks visible to the user.)
2731 * Called with inode->sem down.
2733 int ext3_setattr(struct dentry *dentry, struct iattr *attr)
2735 struct inode *inode = dentry->d_inode;
2737 const unsigned int ia_valid = attr->ia_valid;
2739 error = inode_change_ok(inode, attr);
2743 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2744 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
2747 /* (user+group)*(old+new) structure, inode write (sb,
2748 * inode block, ? - but truncate inode update has it) */
2749 handle = ext3_journal_start(inode, 4*EXT3_QUOTA_INIT_BLOCKS+3);
2750 if (IS_ERR(handle)) {
2751 error = PTR_ERR(handle);
2754 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2756 ext3_journal_stop(handle);
2759 /* Update corresponding info in inode so that everything is in
2760 * one transaction */
2761 if (attr->ia_valid & ATTR_UID)
2762 inode->i_uid = attr->ia_uid;
2763 if (attr->ia_valid & ATTR_GID)
2764 inode->i_gid = attr->ia_gid;
2765 error = ext3_mark_inode_dirty(handle, inode);
2766 ext3_journal_stop(handle);
2769 if (S_ISREG(inode->i_mode) &&
2770 attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
2773 handle = ext3_journal_start(inode, 3);
2774 if (IS_ERR(handle)) {
2775 error = PTR_ERR(handle);
2779 error = ext3_orphan_add(handle, inode);
2780 EXT3_I(inode)->i_disksize = attr->ia_size;
2781 rc = ext3_mark_inode_dirty(handle, inode);
2784 ext3_journal_stop(handle);
2787 if (ia_valid & ATTR_ATTR_FLAG) {
2788 rc = ext3_setattr_flags(inode, attr->ia_attr_flags);
2793 rc = inode_setattr(inode, attr);
2795 /* If inode_setattr's call to ext3_truncate failed to get a
2796 * transaction handle at all, we need to clean up the in-core
2797 * orphan list manually. */
2799 ext3_orphan_del(NULL, inode);
2801 if (!rc && (ia_valid & ATTR_MODE))
2802 rc = ext3_acl_chmod(inode);
2805 ext3_std_error(inode->i_sb, error);
2813 * akpm: how many blocks doth make a writepage()?
2815 * With N blocks per page, it may be:
2820 * N+5 bitmap blocks (from the above)
2821 * N+5 group descriptor summary blocks
2824 * 2 * EXT3_SINGLEDATA_TRANS_BLOCKS for the quote files
2826 * 3 * (N + 5) + 2 + 2 * EXT3_SINGLEDATA_TRANS_BLOCKS
2828 * With ordered or writeback data it's the same, less the N data blocks.
2830 * If the inode's direct blocks can hold an integral number of pages then a
2831 * page cannot straddle two indirect blocks, and we can only touch one indirect
2832 * and dindirect block, and the "5" above becomes "3".
2834 * This still overestimates under most circumstances. If we were to pass the
2835 * start and end offsets in here as well we could do block_to_path() on each
2836 * block and work out the exact number of indirects which are touched. Pah.
2839 int ext3_writepage_trans_blocks(struct inode *inode)
2841 int bpp = ext3_journal_blocks_per_page(inode);
2842 int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
2845 if (ext3_should_journal_data(inode))
2846 ret = 3 * (bpp + indirects) + 2;
2848 ret = 2 * (bpp + indirects) + 2;
2851 /* We know that structure was already allocated during DQUOT_INIT so
2852 * we will be updating only the data blocks + inodes */
2853 ret += 2*EXT3_QUOTA_TRANS_BLOCKS;
2860 * The caller must have previously called ext3_reserve_inode_write().
2861 * Give this, we know that the caller already has write access to iloc->bh.
2863 int ext3_mark_iloc_dirty(handle_t *handle,
2864 struct inode *inode, struct ext3_iloc *iloc)
2868 /* the do_update_inode consumes one bh->b_count */
2871 /* ext3_do_update_inode() does journal_dirty_metadata */
2872 err = ext3_do_update_inode(handle, inode, iloc);
2878 * On success, We end up with an outstanding reference count against
2879 * iloc->bh. This _must_ be cleaned up later.
2883 ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
2884 struct ext3_iloc *iloc)
2888 err = ext3_get_inode_loc(inode, iloc, 1);
2890 BUFFER_TRACE(iloc->bh, "get_write_access");
2891 err = ext3_journal_get_write_access(handle, iloc->bh);
2898 ext3_std_error(inode->i_sb, err);
2903 * akpm: What we do here is to mark the in-core inode as clean
2904 * with respect to inode dirtiness (it may still be data-dirty).
2905 * This means that the in-core inode may be reaped by prune_icache
2906 * without having to perform any I/O. This is a very good thing,
2907 * because *any* task may call prune_icache - even ones which
2908 * have a transaction open against a different journal.
2910 * Is this cheating? Not really. Sure, we haven't written the
2911 * inode out, but prune_icache isn't a user-visible syncing function.
2912 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
2913 * we start and wait on commits.
2915 * Is this efficient/effective? Well, we're being nice to the system
2916 * by cleaning up our inodes proactively so they can be reaped
2917 * without I/O. But we are potentially leaving up to five seconds'
2918 * worth of inodes floating about which prune_icache wants us to
2919 * write out. One way to fix that would be to get prune_icache()
2920 * to do a write_super() to free up some memory. It has the desired
2923 int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
2925 struct ext3_iloc iloc;
2928 err = ext3_reserve_inode_write(handle, inode, &iloc);
2930 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
2935 * akpm: ext3_dirty_inode() is called from __mark_inode_dirty()
2937 * We're really interested in the case where a file is being extended.
2938 * i_size has been changed by generic_commit_write() and we thus need
2939 * to include the updated inode in the current transaction.
2941 * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks
2942 * are allocated to the file.
2944 * If the inode is marked synchronous, we don't honour that here - doing
2945 * so would cause a commit on atime updates, which we don't bother doing.
2946 * We handle synchronous inodes at the highest possible level.
2948 void ext3_dirty_inode(struct inode *inode)
2950 handle_t *current_handle = ext3_journal_current_handle();
2953 handle = ext3_journal_start(inode, 2);
2956 if (current_handle &&
2957 current_handle->h_transaction != handle->h_transaction) {
2958 /* This task has a transaction open against a different fs */
2959 printk(KERN_EMERG "%s: transactions do not match!\n",
2962 jbd_debug(5, "marking dirty. outer handle=%p\n",
2964 ext3_mark_inode_dirty(handle, inode);
2966 ext3_journal_stop(handle);
2973 * Bind an inode's backing buffer_head into this transaction, to prevent
2974 * it from being flushed to disk early. Unlike
2975 * ext3_reserve_inode_write, this leaves behind no bh reference and
2976 * returns no iloc structure, so the caller needs to repeat the iloc
2977 * lookup to mark the inode dirty later.
2980 ext3_pin_inode(handle_t *handle, struct inode *inode)
2982 struct ext3_iloc iloc;
2986 err = ext3_get_inode_loc(inode, &iloc, 1);
2988 BUFFER_TRACE(iloc.bh, "get_write_access");
2989 err = journal_get_write_access(handle, iloc.bh);
2991 err = ext3_journal_dirty_metadata(handle,
2996 ext3_std_error(inode->i_sb, err);
3001 int ext3_change_inode_journal_flag(struct inode *inode, int val)
3008 * We have to be very careful here: changing a data block's
3009 * journaling status dynamically is dangerous. If we write a
3010 * data block to the journal, change the status and then delete
3011 * that block, we risk forgetting to revoke the old log record
3012 * from the journal and so a subsequent replay can corrupt data.
3013 * So, first we make sure that the journal is empty and that
3014 * nobody is changing anything.
3017 journal = EXT3_JOURNAL(inode);
3018 if (is_journal_aborted(journal) || IS_RDONLY(inode))
3021 journal_lock_updates(journal);
3022 journal_flush(journal);
3025 * OK, there are no updates running now, and all cached data is
3026 * synced to disk. We are now in a completely consistent state
3027 * which doesn't have anything in the journal, and we know that
3028 * no filesystem updates are running, so it is safe to modify
3029 * the inode's in-core data-journaling state flag now.
3033 EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
3035 EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
3036 ext3_set_aops(inode);
3038 journal_unlock_updates(journal);
3040 /* Finally we can mark the inode as dirty. */
3042 handle = ext3_journal_start(inode, 1);
3044 return PTR_ERR(handle);
3046 err = ext3_mark_inode_dirty(handle, inode);
3048 ext3_journal_stop(handle);
3049 ext3_std_error(inode->i_sb, err);