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,
72 BUFFER_TRACE(bh, "enter");
74 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
76 bh, is_metadata, inode->i_mode,
77 test_opt(inode->i_sb, DATA_FLAGS));
79 /* Never use the revoke function if we are doing full data
80 * journaling: there is no need to, and a V1 superblock won't
81 * support it. Otherwise, only skip the revoke on un-journaled
84 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ||
85 (!is_metadata && !ext3_should_journal_data(inode))) {
87 BUFFER_TRACE(bh, "call journal_forget");
88 return ext3_journal_forget(handle, bh);
94 * data!=journal && (is_metadata || should_journal_data(inode))
96 BUFFER_TRACE(bh, "call ext3_journal_revoke");
97 err = ext3_journal_revoke(handle, blocknr, bh);
99 ext3_abort(inode->i_sb, __FUNCTION__,
100 "error %d when attempting revoke", err);
101 BUFFER_TRACE(bh, "exit");
106 * Work out how many blocks we need to progress with the next chunk of a
107 * truncate transaction.
110 static unsigned long blocks_for_truncate(struct inode *inode)
112 unsigned long needed;
114 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
116 /* Give ourselves just enough room to cope with inodes in which
117 * i_blocks is corrupt: we've seen disk corruptions in the past
118 * which resulted in random data in an inode which looked enough
119 * like a regular file for ext3 to try to delete it. Things
120 * will go a bit crazy if that happens, but at least we should
121 * try not to panic the whole kernel. */
125 /* But we need to bound the transaction so we don't overflow the
127 if (needed > EXT3_MAX_TRANS_DATA)
128 needed = EXT3_MAX_TRANS_DATA;
130 return EXT3_DATA_TRANS_BLOCKS + needed;
134 * Truncate transactions can be complex and absolutely huge. So we need to
135 * be able to restart the transaction at a conventient checkpoint to make
136 * sure we don't overflow the journal.
138 * start_transaction gets us a new handle for a truncate transaction,
139 * and extend_transaction tries to extend the existing one a bit. If
140 * extend fails, we need to propagate the failure up and restart the
141 * transaction in the top-level truncate loop. --sct
144 static handle_t *start_transaction(struct inode *inode)
148 result = ext3_journal_start(inode, blocks_for_truncate(inode));
152 ext3_std_error(inode->i_sb, PTR_ERR(result));
157 * Try to extend this transaction for the purposes of truncation.
159 * Returns 0 if we managed to create more room. If we can't create more
160 * room, and the transaction must be restarted we return 1.
162 static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
164 if (handle->h_buffer_credits > EXT3_RESERVE_TRANS_BLOCKS)
166 if (!ext3_journal_extend(handle, blocks_for_truncate(inode)))
172 * Restart the transaction associated with *handle. This does a commit,
173 * so before we call here everything must be consistently dirtied against
176 static int ext3_journal_test_restart(handle_t *handle, struct inode *inode)
178 jbd_debug(2, "restarting handle %p\n", handle);
179 return ext3_journal_restart(handle, blocks_for_truncate(inode));
182 static void ext3_truncate_nocheck (struct inode *inode);
185 * Called at the last iput() if i_nlink is zero.
187 void ext3_delete_inode (struct inode * inode)
191 if (is_bad_inode(inode))
194 handle = start_transaction(inode);
195 if (IS_ERR(handle)) {
196 /* If we're going to skip the normal cleanup, we still
197 * need to make sure that the in-core orphan linked list
198 * is properly cleaned up. */
199 ext3_orphan_del(NULL, inode);
207 ext3_truncate_nocheck(inode);
209 * Kill off the orphan record which ext3_truncate created.
210 * AKPM: I think this can be inside the above `if'.
211 * Note that ext3_orphan_del() has to be able to cope with the
212 * deletion of a non-existent orphan - this is because we don't
213 * know if ext3_truncate() actually created an orphan record.
214 * (Well, we could do this if we need to, but heck - it works)
216 ext3_orphan_del(handle, inode);
217 EXT3_I(inode)->i_dtime = get_seconds();
220 * One subtle ordering requirement: if anything has gone wrong
221 * (transaction abort, IO errors, whatever), then we can still
222 * do these next steps (the fs will already have been marked as
223 * having errors), but we can't free the inode if the mark_dirty
226 if (ext3_mark_inode_dirty(handle, inode))
227 /* If that failed, just do the required in-core inode clear. */
230 ext3_free_inode(handle, inode);
231 ext3_journal_stop(handle);
234 clear_inode(inode); /* We must guarantee clearing of inode... */
237 static int ext3_alloc_block (handle_t *handle,
238 struct inode * inode, unsigned long goal, int *err)
240 unsigned long result;
242 result = ext3_new_block(handle, inode, goal, err);
250 struct buffer_head *bh;
253 static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
255 p->key = *(p->p = v);
259 static inline int verify_chain(Indirect *from, Indirect *to)
261 while (from <= to && from->key == *from->p)
267 * ext3_block_to_path - parse the block number into array of offsets
268 * @inode: inode in question (we are only interested in its superblock)
269 * @i_block: block number to be parsed
270 * @offsets: array to store the offsets in
271 * @boundary: set this non-zero if the referred-to block is likely to be
272 * followed (on disk) by an indirect block.
274 * To store the locations of file's data ext3 uses a data structure common
275 * for UNIX filesystems - tree of pointers anchored in the inode, with
276 * data blocks at leaves and indirect blocks in intermediate nodes.
277 * This function translates the block number into path in that tree -
278 * return value is the path length and @offsets[n] is the offset of
279 * pointer to (n+1)th node in the nth one. If @block is out of range
280 * (negative or too large) warning is printed and zero returned.
282 * Note: function doesn't find node addresses, so no IO is needed. All
283 * we need to know is the capacity of indirect blocks (taken from the
288 * Portability note: the last comparison (check that we fit into triple
289 * indirect block) is spelled differently, because otherwise on an
290 * architecture with 32-bit longs and 8Kb pages we might get into trouble
291 * if our filesystem had 8Kb blocks. We might use long long, but that would
292 * kill us on x86. Oh, well, at least the sign propagation does not matter -
293 * i_block would have to be negative in the very beginning, so we would not
297 static int ext3_block_to_path(struct inode *inode,
298 long i_block, int offsets[4], int *boundary)
300 int ptrs = EXT3_ADDR_PER_BLOCK(inode->i_sb);
301 int ptrs_bits = EXT3_ADDR_PER_BLOCK_BITS(inode->i_sb);
302 const long direct_blocks = EXT3_NDIR_BLOCKS,
303 indirect_blocks = ptrs,
304 double_blocks = (1 << (ptrs_bits * 2));
309 ext3_warning (inode->i_sb, "ext3_block_to_path", "block < 0");
310 } else if (i_block < direct_blocks) {
311 offsets[n++] = i_block;
312 final = direct_blocks;
313 } else if ( (i_block -= direct_blocks) < indirect_blocks) {
314 offsets[n++] = EXT3_IND_BLOCK;
315 offsets[n++] = i_block;
317 } else if ((i_block -= indirect_blocks) < double_blocks) {
318 offsets[n++] = EXT3_DIND_BLOCK;
319 offsets[n++] = i_block >> ptrs_bits;
320 offsets[n++] = i_block & (ptrs - 1);
322 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
323 offsets[n++] = EXT3_TIND_BLOCK;
324 offsets[n++] = i_block >> (ptrs_bits * 2);
325 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
326 offsets[n++] = i_block & (ptrs - 1);
329 ext3_warning (inode->i_sb, "ext3_block_to_path", "block > big");
332 *boundary = (i_block & (ptrs - 1)) == (final - 1);
337 * ext3_get_branch - read the chain of indirect blocks leading to data
338 * @inode: inode in question
339 * @depth: depth of the chain (1 - direct pointer, etc.)
340 * @offsets: offsets of pointers in inode/indirect blocks
341 * @chain: place to store the result
342 * @err: here we store the error value
344 * Function fills the array of triples <key, p, bh> and returns %NULL
345 * if everything went OK or the pointer to the last filled triple
346 * (incomplete one) otherwise. Upon the return chain[i].key contains
347 * the number of (i+1)-th block in the chain (as it is stored in memory,
348 * i.e. little-endian 32-bit), chain[i].p contains the address of that
349 * number (it points into struct inode for i==0 and into the bh->b_data
350 * for i>0) and chain[i].bh points to the buffer_head of i-th indirect
351 * block for i>0 and NULL for i==0. In other words, it holds the block
352 * numbers of the chain, addresses they were taken from (and where we can
353 * verify that chain did not change) and buffer_heads hosting these
356 * Function stops when it stumbles upon zero pointer (absent block)
357 * (pointer to last triple returned, *@err == 0)
358 * or when it gets an IO error reading an indirect block
359 * (ditto, *@err == -EIO)
360 * or when it notices that chain had been changed while it was reading
361 * (ditto, *@err == -EAGAIN)
362 * or when it reads all @depth-1 indirect blocks successfully and finds
363 * the whole chain, all way to the data (returns %NULL, *err == 0).
365 static Indirect *ext3_get_branch(struct inode *inode, int depth, int *offsets,
366 Indirect chain[4], int *err)
368 struct super_block *sb = inode->i_sb;
370 struct buffer_head *bh;
373 /* i_data is not going away, no lock needed */
374 add_chain (chain, NULL, EXT3_I(inode)->i_data + *offsets);
378 bh = sb_bread(sb, le32_to_cpu(p->key));
381 /* Reader: pointers */
382 if (!verify_chain(chain, p))
384 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
402 * ext3_find_near - find a place for allocation with sufficient locality
404 * @ind: descriptor of indirect block.
406 * This function returns the prefered place for block allocation.
407 * It is used when heuristic for sequential allocation fails.
409 * + if there is a block to the left of our position - allocate near it.
410 * + if pointer will live in indirect block - allocate near that block.
411 * + if pointer will live in inode - allocate in the same
414 * In the latter case we colour the starting block by the callers PID to
415 * prevent it from clashing with concurrent allocations for a different inode
416 * in the same block group. The PID is used here so that functionally related
417 * files will be close-by on-disk.
419 * Caller must make sure that @ind is valid and will stay that way.
422 static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)
424 struct ext3_inode_info *ei = EXT3_I(inode);
425 __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
427 unsigned long bg_start;
428 unsigned long colour;
430 /* Try to find previous block */
431 for (p = ind->p - 1; p >= start; p--)
433 return le32_to_cpu(*p);
435 /* No such thing, so let's try location of indirect block */
437 return ind->bh->b_blocknr;
440 * It is going to be refered from inode itself? OK, just put it into
441 * the same cylinder group then.
443 bg_start = (ei->i_block_group * EXT3_BLOCKS_PER_GROUP(inode->i_sb)) +
444 le32_to_cpu(EXT3_SB(inode->i_sb)->s_es->s_first_data_block);
445 colour = (current->pid % 16) *
446 (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
447 return bg_start + colour;
451 * ext3_find_goal - find a prefered place for allocation.
453 * @block: block we want
454 * @chain: chain of indirect blocks
455 * @partial: pointer to the last triple within a chain
456 * @goal: place to store the result.
458 * Normally this function find the prefered place for block allocation,
459 * stores it in *@goal and returns zero. If the branch had been changed
460 * under us we return -EAGAIN.
463 static int ext3_find_goal(struct inode *inode, long block, Indirect chain[4],
464 Indirect *partial, unsigned long *goal)
466 struct ext3_inode_info *ei = EXT3_I(inode);
467 /* Writer: ->i_next_alloc* */
468 if (block == ei->i_next_alloc_block + 1) {
469 ei->i_next_alloc_block++;
470 ei->i_next_alloc_goal++;
473 /* Reader: pointers, ->i_next_alloc* */
474 if (verify_chain(chain, partial)) {
476 * try the heuristic for sequential allocation,
477 * failing that at least try to get decent locality.
479 if (block == ei->i_next_alloc_block)
480 *goal = ei->i_next_alloc_goal;
482 *goal = ext3_find_near(inode, partial);
490 * ext3_alloc_branch - allocate and set up a chain of blocks.
492 * @num: depth of the chain (number of blocks to allocate)
493 * @offsets: offsets (in the blocks) to store the pointers to next.
494 * @branch: place to store the chain in.
496 * This function allocates @num blocks, zeroes out all but the last one,
497 * links them into chain and (if we are synchronous) writes them to disk.
498 * In other words, it prepares a branch that can be spliced onto the
499 * inode. It stores the information about that chain in the branch[], in
500 * the same format as ext3_get_branch() would do. We are calling it after
501 * we had read the existing part of chain and partial points to the last
502 * triple of that (one with zero ->key). Upon the exit we have the same
503 * picture as after the successful ext3_get_block(), excpet that in one
504 * place chain is disconnected - *branch->p is still zero (we did not
505 * set the last link), but branch->key contains the number that should
506 * be placed into *branch->p to fill that gap.
508 * If allocation fails we free all blocks we've allocated (and forget
509 * their buffer_heads) and return the error value the from failed
510 * ext3_alloc_block() (normally -ENOSPC). Otherwise we set the chain
511 * as described above and return 0.
514 static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
520 int blocksize = inode->i_sb->s_blocksize;
524 int parent = ext3_alloc_block(handle, inode, goal, &err);
526 branch[0].key = cpu_to_le32(parent);
528 for (n = 1; n < num; n++) {
529 struct buffer_head *bh;
530 /* Allocate the next block */
531 int nr = ext3_alloc_block(handle, inode, parent, &err);
534 branch[n].key = cpu_to_le32(nr);
538 * Get buffer_head for parent block, zero it out
539 * and set the pointer to new one, then send
542 bh = sb_getblk(inode->i_sb, parent);
545 BUFFER_TRACE(bh, "call get_create_access");
546 err = ext3_journal_get_create_access(handle, bh);
553 memset(bh->b_data, 0, blocksize);
554 branch[n].p = (__le32*) bh->b_data + offsets[n];
555 *branch[n].p = branch[n].key;
556 BUFFER_TRACE(bh, "marking uptodate");
557 set_buffer_uptodate(bh);
560 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
561 err = ext3_journal_dirty_metadata(handle, bh);
571 /* Allocation failed, free what we already allocated */
572 for (i = 1; i < keys; i++) {
573 BUFFER_TRACE(branch[i].bh, "call journal_forget");
574 ext3_journal_forget(handle, branch[i].bh);
576 for (i = 0; i < keys; i++)
577 ext3_free_blocks(handle, inode, le32_to_cpu(branch[i].key), 1);
582 * ext3_splice_branch - splice the allocated branch onto inode.
584 * @block: (logical) number of block we are adding
585 * @chain: chain of indirect blocks (with a missing link - see
587 * @where: location of missing link
588 * @num: number of blocks we are adding
590 * This function verifies that chain (up to the missing link) had not
591 * changed, fills the missing link and does all housekeeping needed in
592 * inode (->i_blocks, etc.). In case of success we end up with the full
593 * chain to new block and return 0. Otherwise (== chain had been changed)
594 * we free the new blocks (forgetting their buffer_heads, indeed) and
598 static int ext3_splice_branch(handle_t *handle, struct inode *inode, long block,
599 Indirect chain[4], Indirect *where, int num)
603 struct ext3_inode_info *ei = EXT3_I(inode);
606 * If we're splicing into a [td]indirect block (as opposed to the
607 * inode) then we need to get write access to the [td]indirect block
611 BUFFER_TRACE(where->bh, "get_write_access");
612 err = ext3_journal_get_write_access(handle, where->bh);
616 /* Verify that place we are splicing to is still there and vacant */
618 /* Writer: pointers, ->i_next_alloc* */
619 if (!verify_chain(chain, where-1) || *where->p)
625 *where->p = where->key;
626 ei->i_next_alloc_block = block;
627 ei->i_next_alloc_goal = le32_to_cpu(where[num-1].key);
630 /* We are done with atomic stuff, now do the rest of housekeeping */
632 inode->i_ctime = CURRENT_TIME;
633 ext3_mark_inode_dirty(handle, inode);
635 /* had we spliced it onto indirect block? */
638 * akpm: If we spliced it onto an indirect block, we haven't
639 * altered the inode. Note however that if it is being spliced
640 * onto an indirect block at the very end of the file (the
641 * file is growing) then we *will* alter the inode to reflect
642 * the new i_size. But that is not done here - it is done in
643 * generic_commit_write->__mark_inode_dirty->ext3_dirty_inode.
645 jbd_debug(5, "splicing indirect only\n");
646 BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
647 err = ext3_journal_dirty_metadata(handle, where->bh);
652 * OK, we spliced it into the inode itself on a direct block.
653 * Inode was dirtied above.
655 jbd_debug(5, "splicing direct\n");
661 * AKPM: if where[i].bh isn't part of the current updating
662 * transaction then we explode nastily. Test this code path.
664 jbd_debug(1, "the chain changed: try again\n");
668 for (i = 1; i < num; i++) {
669 BUFFER_TRACE(where[i].bh, "call journal_forget");
670 ext3_journal_forget(handle, where[i].bh);
672 /* For the normal collision cleanup case, we free up the blocks.
673 * On genuine filesystem errors we don't even think about doing
676 for (i = 0; i < num; i++)
677 ext3_free_blocks(handle, inode,
678 le32_to_cpu(where[i].key), 1);
683 * Allocation strategy is simple: if we have to allocate something, we will
684 * have to go the whole way to leaf. So let's do it before attaching anything
685 * to tree, set linkage between the newborn blocks, write them if sync is
686 * required, recheck the path, free and repeat if check fails, otherwise
687 * set the last missing link (that will protect us from any truncate-generated
688 * removals - all blocks on the path are immune now) and possibly force the
689 * write on the parent block.
690 * That has a nice additional property: no special recovery from the failed
691 * allocations is needed - we simply release blocks and do not touch anything
692 * reachable from inode.
694 * akpm: `handle' can be NULL if create == 0.
696 * The BKL may not be held on entry here. Be sure to take it early.
700 ext3_get_block_handle(handle_t *handle, struct inode *inode, sector_t iblock,
701 struct buffer_head *bh_result, int create, int extend_disksize)
710 int depth = ext3_block_to_path(inode, iblock, offsets, &boundary);
711 struct ext3_inode_info *ei = EXT3_I(inode);
713 J_ASSERT(handle != NULL || create == 0);
719 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
721 /* Simplest case - block found, no allocation needed */
723 clear_buffer_new(bh_result);
725 map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
727 set_buffer_boundary(bh_result);
728 /* Clean up and exit */
729 partial = chain+depth-1; /* the whole chain */
733 /* Next simple case - plain lookup or failed read of indirect block */
734 if (!create || err == -EIO) {
736 while (partial > chain) {
737 BUFFER_TRACE(partial->bh, "call brelse");
741 BUFFER_TRACE(bh_result, "returned");
747 * Indirect block might be removed by truncate while we were
748 * reading it. Handling of that case (forget what we've got and
749 * reread) is taken out of the main path.
755 down(&ei->truncate_sem);
756 if (ext3_find_goal(inode, iblock, chain, partial, &goal) < 0) {
757 up(&ei->truncate_sem);
761 left = (chain + depth) - partial;
764 * Block out ext3_truncate while we alter the tree
766 err = ext3_alloc_branch(handle, inode, left, goal,
767 offsets+(partial-chain), partial);
769 /* The ext3_splice_branch call will free and forget any buffers
770 * on the new chain if there is a failure, but that risks using
771 * up transaction credits, especially for bitmaps where the
772 * credits cannot be returned. Can we handle this somehow? We
773 * may need to return -EAGAIN upwards in the worst case. --sct */
775 err = ext3_splice_branch(handle, inode, iblock, chain,
777 /* i_disksize growing is protected by truncate_sem
778 * don't forget to protect it if you're about to implement
779 * concurrent ext3_get_block() -bzzz */
780 if (!err && extend_disksize && inode->i_size > ei->i_disksize)
781 ei->i_disksize = inode->i_size;
782 up(&ei->truncate_sem);
788 set_buffer_new(bh_result);
792 while (partial > chain) {
793 jbd_debug(1, "buffer chain changed, retrying\n");
794 BUFFER_TRACE(partial->bh, "brelsing");
801 static int ext3_get_block(struct inode *inode, sector_t iblock,
802 struct buffer_head *bh_result, int create)
804 handle_t *handle = NULL;
808 handle = ext3_journal_current_handle();
809 J_ASSERT(handle != 0);
811 ret = ext3_get_block_handle(handle, inode, iblock,
812 bh_result, create, 1);
816 #define DIO_CREDITS (EXT3_RESERVE_TRANS_BLOCKS + 32)
819 ext3_direct_io_get_blocks(struct inode *inode, sector_t iblock,
820 unsigned long max_blocks, struct buffer_head *bh_result,
823 handle_t *handle = journal_current_handle();
827 goto get_block; /* A read */
829 if (handle->h_transaction->t_state == T_LOCKED) {
831 * Huge direct-io writes can hold off commits for long
832 * periods of time. Let this commit run.
834 ext3_journal_stop(handle);
835 handle = ext3_journal_start(inode, DIO_CREDITS);
837 ret = PTR_ERR(handle);
841 if (handle->h_buffer_credits <= EXT3_RESERVE_TRANS_BLOCKS) {
843 * Getting low on buffer credits...
845 ret = ext3_journal_extend(handle, DIO_CREDITS);
848 * Couldn't extend the transaction. Start a new one.
850 ret = ext3_journal_restart(handle, DIO_CREDITS);
856 ret = ext3_get_block_handle(handle, inode, iblock,
857 bh_result, create, 0);
858 bh_result->b_size = (1 << inode->i_blkbits);
863 * `handle' can be NULL if create is zero
865 struct buffer_head *ext3_getblk(handle_t *handle, struct inode * inode,
866 long block, int create, int * errp)
868 struct buffer_head dummy;
871 J_ASSERT(handle != NULL || create == 0);
874 dummy.b_blocknr = -1000;
875 buffer_trace_init(&dummy.b_history);
876 *errp = ext3_get_block_handle(handle, inode, block, &dummy, create, 1);
877 if (!*errp && buffer_mapped(&dummy)) {
878 struct buffer_head *bh;
879 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
880 if (buffer_new(&dummy)) {
881 J_ASSERT(create != 0);
882 J_ASSERT(handle != 0);
884 /* Now that we do not always journal data, we
885 should keep in mind whether this should
886 always journal the new buffer as metadata.
887 For now, regular file writes use
888 ext3_get_block instead, so it's not a
891 BUFFER_TRACE(bh, "call get_create_access");
892 fatal = ext3_journal_get_create_access(handle, bh);
893 if (!fatal && !buffer_uptodate(bh)) {
894 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
895 set_buffer_uptodate(bh);
898 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
899 err = ext3_journal_dirty_metadata(handle, bh);
903 BUFFER_TRACE(bh, "not a new buffer");
915 struct buffer_head *ext3_bread(handle_t *handle, struct inode * inode,
916 int block, int create, int *err)
918 struct buffer_head * bh;
920 bh = ext3_getblk(handle, inode, block, create, err);
923 if (buffer_uptodate(bh))
925 ll_rw_block(READ, 1, &bh);
927 if (buffer_uptodate(bh))
934 static int walk_page_buffers( handle_t *handle,
935 struct buffer_head *head,
939 int (*fn)( handle_t *handle,
940 struct buffer_head *bh))
942 struct buffer_head *bh;
943 unsigned block_start, block_end;
944 unsigned blocksize = head->b_size;
946 struct buffer_head *next;
948 for ( bh = head, block_start = 0;
949 ret == 0 && (bh != head || !block_start);
950 block_start = block_end, bh = next)
952 next = bh->b_this_page;
953 block_end = block_start + blocksize;
954 if (block_end <= from || block_start >= to) {
955 if (partial && !buffer_uptodate(bh))
959 err = (*fn)(handle, bh);
967 * To preserve ordering, it is essential that the hole instantiation and
968 * the data write be encapsulated in a single transaction. We cannot
969 * close off a transaction and start a new one between the ext3_get_block()
970 * and the commit_write(). So doing the journal_start at the start of
971 * prepare_write() is the right place.
973 * Also, this function can nest inside ext3_writepage() ->
974 * block_write_full_page(). In that case, we *know* that ext3_writepage()
975 * has generated enough buffer credits to do the whole page. So we won't
976 * block on the journal in that case, which is good, because the caller may
979 * By accident, ext3 can be reentered when a transaction is open via
980 * quota file writes. If we were to commit the transaction while thus
981 * reentered, there can be a deadlock - we would be holding a quota
982 * lock, and the commit would never complete if another thread had a
983 * transaction open and was blocking on the quota lock - a ranking
986 * So what we do is to rely on the fact that journal_stop/journal_start
987 * will _not_ run commit under these circumstances because handle->h_ref
988 * is elevated. We'll still have enough credits for the tiny quotafile
992 static int do_journal_get_write_access(handle_t *handle,
993 struct buffer_head *bh)
995 if (!buffer_mapped(bh) || buffer_freed(bh))
997 return ext3_journal_get_write_access(handle, bh);
1000 static int ext3_prepare_write(struct file *file, struct page *page,
1001 unsigned from, unsigned to)
1003 struct inode *inode = page->mapping->host;
1004 int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
1009 handle = ext3_journal_start(inode, needed_blocks);
1010 if (IS_ERR(handle)) {
1011 ret = PTR_ERR(handle);
1014 ret = block_prepare_write(page, from, to, ext3_get_block);
1016 goto prepare_write_failed;
1018 if (ext3_should_journal_data(inode)) {
1019 ret = walk_page_buffers(handle, page_buffers(page),
1020 from, to, NULL, do_journal_get_write_access);
1022 prepare_write_failed:
1024 ext3_journal_stop(handle);
1025 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1032 ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1034 int err = journal_dirty_data(handle, bh);
1036 ext3_journal_abort_handle(__FUNCTION__, __FUNCTION__,
1041 /* For commit_write() in data=journal mode */
1042 static int commit_write_fn(handle_t *handle, struct buffer_head *bh)
1044 if (!buffer_mapped(bh) || buffer_freed(bh))
1046 set_buffer_uptodate(bh);
1047 return ext3_journal_dirty_metadata(handle, bh);
1051 * We need to pick up the new inode size which generic_commit_write gave us
1052 * `file' can be NULL - eg, when called from page_symlink().
1054 * ext3 never places buffers on inode->i_mapping->private_list. metadata
1055 * buffers are managed internally.
1058 static int ext3_ordered_commit_write(struct file *file, struct page *page,
1059 unsigned from, unsigned to)
1061 handle_t *handle = ext3_journal_current_handle();
1062 struct inode *inode = page->mapping->host;
1065 ret = walk_page_buffers(handle, page_buffers(page),
1066 from, to, NULL, ext3_journal_dirty_data);
1070 * generic_commit_write() will run mark_inode_dirty() if i_size
1071 * changes. So let's piggyback the i_disksize mark_inode_dirty
1076 new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1077 if (new_i_size > EXT3_I(inode)->i_disksize)
1078 EXT3_I(inode)->i_disksize = new_i_size;
1079 ret = generic_commit_write(file, page, from, to);
1081 ret2 = ext3_journal_stop(handle);
1087 static int ext3_writeback_commit_write(struct file *file, struct page *page,
1088 unsigned from, unsigned to)
1090 handle_t *handle = ext3_journal_current_handle();
1091 struct inode *inode = page->mapping->host;
1095 new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1096 if (new_i_size > EXT3_I(inode)->i_disksize)
1097 EXT3_I(inode)->i_disksize = new_i_size;
1098 ret = generic_commit_write(file, page, from, to);
1099 ret2 = ext3_journal_stop(handle);
1105 static int ext3_journalled_commit_write(struct file *file,
1106 struct page *page, unsigned from, unsigned to)
1108 handle_t *handle = ext3_journal_current_handle();
1109 struct inode *inode = page->mapping->host;
1115 * Here we duplicate the generic_commit_write() functionality
1117 pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1119 ret = walk_page_buffers(handle, page_buffers(page), from,
1120 to, &partial, commit_write_fn);
1122 SetPageUptodate(page);
1123 if (pos > inode->i_size)
1124 i_size_write(inode, pos);
1125 EXT3_I(inode)->i_state |= EXT3_STATE_JDATA;
1126 if (inode->i_size > EXT3_I(inode)->i_disksize) {
1127 EXT3_I(inode)->i_disksize = inode->i_size;
1128 ret2 = ext3_mark_inode_dirty(handle, inode);
1132 ret2 = ext3_journal_stop(handle);
1139 * bmap() is special. It gets used by applications such as lilo and by
1140 * the swapper to find the on-disk block of a specific piece of data.
1142 * Naturally, this is dangerous if the block concerned is still in the
1143 * journal. If somebody makes a swapfile on an ext3 data-journaling
1144 * filesystem and enables swap, then they may get a nasty shock when the
1145 * data getting swapped to that swapfile suddenly gets overwritten by
1146 * the original zero's written out previously to the journal and
1147 * awaiting writeback in the kernel's buffer cache.
1149 * So, if we see any bmap calls here on a modified, data-journaled file,
1150 * take extra steps to flush any blocks which might be in the cache.
1152 static sector_t ext3_bmap(struct address_space *mapping, sector_t block)
1154 struct inode *inode = mapping->host;
1158 if (EXT3_I(inode)->i_state & EXT3_STATE_JDATA) {
1160 * This is a REALLY heavyweight approach, but the use of
1161 * bmap on dirty files is expected to be extremely rare:
1162 * only if we run lilo or swapon on a freshly made file
1163 * do we expect this to happen.
1165 * (bmap requires CAP_SYS_RAWIO so this does not
1166 * represent an unprivileged user DOS attack --- we'd be
1167 * in trouble if mortal users could trigger this path at
1170 * NB. EXT3_STATE_JDATA is not set on files other than
1171 * regular files. If somebody wants to bmap a directory
1172 * or symlink and gets confused because the buffer
1173 * hasn't yet been flushed to disk, they deserve
1174 * everything they get.
1177 EXT3_I(inode)->i_state &= ~EXT3_STATE_JDATA;
1178 journal = EXT3_JOURNAL(inode);
1179 journal_lock_updates(journal);
1180 err = journal_flush(journal);
1181 journal_unlock_updates(journal);
1187 return generic_block_bmap(mapping,block,ext3_get_block);
1190 static int bget_one(handle_t *handle, struct buffer_head *bh)
1196 static int bput_one(handle_t *handle, struct buffer_head *bh)
1202 static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
1204 if (buffer_mapped(bh))
1205 return ext3_journal_dirty_data(handle, bh);
1210 * Note that we always start a transaction even if we're not journalling
1211 * data. This is to preserve ordering: any hole instantiation within
1212 * __block_write_full_page -> ext3_get_block() should be journalled
1213 * along with the data so we don't crash and then get metadata which
1214 * refers to old data.
1216 * In all journalling modes block_write_full_page() will start the I/O.
1220 * ext3_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1225 * ext3_file_write() -> generic_file_write() -> __alloc_pages() -> ...
1227 * Same applies to ext3_get_block(). We will deadlock on various things like
1228 * lock_journal and i_truncate_sem.
1230 * Setting PF_MEMALLOC here doesn't work - too many internal memory
1233 * 16May01: If we're reentered then journal_current_handle() will be
1234 * non-zero. We simply *return*.
1236 * 1 July 2001: @@@ FIXME:
1237 * In journalled data mode, a data buffer may be metadata against the
1238 * current transaction. But the same file is part of a shared mapping
1239 * and someone does a writepage() on it.
1241 * We will move the buffer onto the async_data list, but *after* it has
1242 * been dirtied. So there's a small window where we have dirty data on
1245 * Note that this only applies to the last partial page in the file. The
1246 * bit which block_write_full_page() uses prepare/commit for. (That's
1247 * broken code anyway: it's wrong for msync()).
1249 * It's a rare case: affects the final partial page, for journalled data
1250 * where the file is subject to bith write() and writepage() in the same
1251 * transction. To fix it we'll need a custom block_write_full_page().
1252 * We'll probably need that anyway for journalling writepage() output.
1254 * We don't honour synchronous mounts for writepage(). That would be
1255 * disastrous. Any write() or metadata operation will sync the fs for
1258 * AKPM2: if all the page's buffers are mapped to disk and !data=journal,
1259 * we don't need to open a transaction here.
1261 static int ext3_ordered_writepage(struct page *page,
1262 struct writeback_control *wbc)
1264 struct inode *inode = page->mapping->host;
1265 struct buffer_head *page_bufs;
1266 handle_t *handle = NULL;
1270 J_ASSERT(PageLocked(page));
1273 * We give up here if we're reentered, because it might be for a
1274 * different filesystem.
1276 if (ext3_journal_current_handle())
1279 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1281 if (IS_ERR(handle)) {
1282 ret = PTR_ERR(handle);
1286 if (!page_has_buffers(page)) {
1287 create_empty_buffers(page, inode->i_sb->s_blocksize,
1288 (1 << BH_Dirty)|(1 << BH_Uptodate));
1290 page_bufs = page_buffers(page);
1291 walk_page_buffers(handle, page_bufs, 0,
1292 PAGE_CACHE_SIZE, NULL, bget_one);
1294 ret = block_write_full_page(page, ext3_get_block, wbc);
1297 * The page can become unlocked at any point now, and
1298 * truncate can then come in and change things. So we
1299 * can't touch *page from now on. But *page_bufs is
1300 * safe due to elevated refcount.
1304 * And attach them to the current transaction. But only if
1305 * block_write_full_page() succeeded. Otherwise they are unmapped,
1306 * and generally junk.
1309 err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
1310 NULL, journal_dirty_data_fn);
1314 walk_page_buffers(handle, page_bufs, 0,
1315 PAGE_CACHE_SIZE, NULL, bput_one);
1316 err = ext3_journal_stop(handle);
1322 redirty_page_for_writepage(wbc, page);
1327 static int ext3_writeback_writepage(struct page *page,
1328 struct writeback_control *wbc)
1330 struct inode *inode = page->mapping->host;
1331 handle_t *handle = NULL;
1335 if (ext3_journal_current_handle())
1338 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1339 if (IS_ERR(handle)) {
1340 ret = PTR_ERR(handle);
1344 ret = block_write_full_page(page, ext3_get_block, wbc);
1345 err = ext3_journal_stop(handle);
1351 redirty_page_for_writepage(wbc, page);
1356 static int ext3_journalled_writepage(struct page *page,
1357 struct writeback_control *wbc)
1359 struct inode *inode = page->mapping->host;
1360 handle_t *handle = NULL;
1364 if (ext3_journal_current_handle())
1367 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1368 if (IS_ERR(handle)) {
1369 ret = PTR_ERR(handle);
1373 if (!page_has_buffers(page) || PageChecked(page)) {
1375 * It's mmapped pagecache. Add buffers and journal it. There
1376 * doesn't seem much point in redirtying the page here.
1378 ClearPageChecked(page);
1379 ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
1383 ret = walk_page_buffers(handle, page_buffers(page), 0,
1384 PAGE_CACHE_SIZE, NULL, do_journal_get_write_access);
1386 err = walk_page_buffers(handle, page_buffers(page), 0,
1387 PAGE_CACHE_SIZE, NULL, commit_write_fn);
1390 EXT3_I(inode)->i_state |= EXT3_STATE_JDATA;
1394 * It may be a page full of checkpoint-mode buffers. We don't
1395 * really know unless we go poke around in the buffer_heads.
1396 * But block_write_full_page will do the right thing.
1398 ret = block_write_full_page(page, ext3_get_block, wbc);
1400 err = ext3_journal_stop(handle);
1407 redirty_page_for_writepage(wbc, page);
1413 static int ext3_readpage(struct file *file, struct page *page)
1415 return mpage_readpage(page, ext3_get_block);
1419 ext3_readpages(struct file *file, struct address_space *mapping,
1420 struct list_head *pages, unsigned nr_pages)
1422 return mpage_readpages(mapping, pages, nr_pages, ext3_get_block);
1425 static int ext3_invalidatepage(struct page *page, unsigned long offset)
1427 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1430 * If it's a full truncate we just forget about the pending dirtying
1433 ClearPageChecked(page);
1435 return journal_invalidatepage(journal, page, offset);
1438 static int ext3_releasepage(struct page *page, int wait)
1440 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1442 WARN_ON(PageChecked(page));
1443 return journal_try_to_free_buffers(journal, page, wait);
1447 * If the O_DIRECT write will extend the file then add this inode to the
1448 * orphan list. So recovery will truncate it back to the original size
1449 * if the machine crashes during the write.
1451 * If the O_DIRECT write is intantiating holes inside i_size and the machine
1452 * crashes then stale disk data _may_ be exposed inside the file.
1454 static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
1455 const struct iovec *iov, loff_t offset,
1456 unsigned long nr_segs)
1458 struct file *file = iocb->ki_filp;
1459 struct inode *inode = file->f_mapping->host;
1460 struct ext3_inode_info *ei = EXT3_I(inode);
1461 handle_t *handle = NULL;
1464 size_t count = iov_length(iov, nr_segs);
1467 loff_t final_size = offset + count;
1469 handle = ext3_journal_start(inode, DIO_CREDITS);
1470 if (IS_ERR(handle)) {
1471 ret = PTR_ERR(handle);
1474 if (final_size > inode->i_size) {
1475 ret = ext3_orphan_add(handle, inode);
1479 ei->i_disksize = inode->i_size;
1483 ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
1485 ext3_direct_io_get_blocks, NULL);
1488 * Reacquire the handle: ext3_direct_io_get_block() can restart the
1491 handle = journal_current_handle();
1497 if (orphan && inode->i_nlink)
1498 ext3_orphan_del(handle, inode);
1499 if (orphan && ret > 0) {
1500 loff_t end = offset + ret;
1501 if (end > inode->i_size) {
1502 ei->i_disksize = end;
1503 i_size_write(inode, end);
1505 * We're going to return a positive `ret'
1506 * here due to non-zero-length I/O, so there's
1507 * no way of reporting error returns from
1508 * ext3_mark_inode_dirty() to userspace. So
1511 ext3_mark_inode_dirty(handle, inode);
1514 err = ext3_journal_stop(handle);
1523 * Pages can be marked dirty completely asynchronously from ext3's journalling
1524 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
1525 * much here because ->set_page_dirty is called under VFS locks. The page is
1526 * not necessarily locked.
1528 * We cannot just dirty the page and leave attached buffers clean, because the
1529 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
1530 * or jbddirty because all the journalling code will explode.
1532 * So what we do is to mark the page "pending dirty" and next time writepage
1533 * is called, propagate that into the buffers appropriately.
1535 static int ext3_journalled_set_page_dirty(struct page *page)
1537 SetPageChecked(page);
1538 return __set_page_dirty_nobuffers(page);
1541 static struct address_space_operations ext3_ordered_aops = {
1542 .readpage = ext3_readpage,
1543 .readpages = ext3_readpages,
1544 .writepage = ext3_ordered_writepage,
1545 .sync_page = block_sync_page,
1546 .prepare_write = ext3_prepare_write,
1547 .commit_write = ext3_ordered_commit_write,
1549 .invalidatepage = ext3_invalidatepage,
1550 .releasepage = ext3_releasepage,
1551 .direct_IO = ext3_direct_IO,
1554 static struct address_space_operations ext3_writeback_aops = {
1555 .readpage = ext3_readpage,
1556 .readpages = ext3_readpages,
1557 .writepage = ext3_writeback_writepage,
1558 .sync_page = block_sync_page,
1559 .prepare_write = ext3_prepare_write,
1560 .commit_write = ext3_writeback_commit_write,
1562 .invalidatepage = ext3_invalidatepage,
1563 .releasepage = ext3_releasepage,
1564 .direct_IO = ext3_direct_IO,
1567 static struct address_space_operations ext3_journalled_aops = {
1568 .readpage = ext3_readpage,
1569 .readpages = ext3_readpages,
1570 .writepage = ext3_journalled_writepage,
1571 .sync_page = block_sync_page,
1572 .prepare_write = ext3_prepare_write,
1573 .commit_write = ext3_journalled_commit_write,
1574 .set_page_dirty = ext3_journalled_set_page_dirty,
1576 .invalidatepage = ext3_invalidatepage,
1577 .releasepage = ext3_releasepage,
1580 void ext3_set_aops(struct inode *inode)
1582 if (ext3_should_order_data(inode))
1583 inode->i_mapping->a_ops = &ext3_ordered_aops;
1584 else if (ext3_should_writeback_data(inode))
1585 inode->i_mapping->a_ops = &ext3_writeback_aops;
1587 inode->i_mapping->a_ops = &ext3_journalled_aops;
1591 * ext3_block_truncate_page() zeroes out a mapping from file offset `from'
1592 * up to the end of the block which corresponds to `from'.
1593 * This required during truncate. We need to physically zero the tail end
1594 * of that block so it doesn't yield old data if the file is later grown.
1596 static int ext3_block_truncate_page(handle_t *handle, struct page *page,
1597 struct address_space *mapping, loff_t from)
1599 unsigned long index = from >> PAGE_CACHE_SHIFT;
1600 unsigned offset = from & (PAGE_CACHE_SIZE-1);
1601 unsigned blocksize, iblock, length, pos;
1602 struct inode *inode = mapping->host;
1603 struct buffer_head *bh;
1607 blocksize = inode->i_sb->s_blocksize;
1608 length = blocksize - (offset & (blocksize - 1));
1609 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1611 if (!page_has_buffers(page))
1612 create_empty_buffers(page, blocksize, 0);
1614 /* Find the buffer that contains "offset" */
1615 bh = page_buffers(page);
1617 while (offset >= pos) {
1618 bh = bh->b_this_page;
1624 if (buffer_freed(bh)) {
1625 BUFFER_TRACE(bh, "freed: skip");
1629 if (!buffer_mapped(bh)) {
1630 BUFFER_TRACE(bh, "unmapped");
1631 ext3_get_block(inode, iblock, bh, 0);
1632 /* unmapped? It's a hole - nothing to do */
1633 if (!buffer_mapped(bh)) {
1634 BUFFER_TRACE(bh, "still unmapped");
1639 /* Ok, it's mapped. Make sure it's up-to-date */
1640 if (PageUptodate(page))
1641 set_buffer_uptodate(bh);
1643 if (!buffer_uptodate(bh)) {
1645 ll_rw_block(READ, 1, &bh);
1647 /* Uhhuh. Read error. Complain and punt. */
1648 if (!buffer_uptodate(bh))
1652 if (ext3_should_journal_data(inode)) {
1653 BUFFER_TRACE(bh, "get write access");
1654 err = ext3_journal_get_write_access(handle, bh);
1659 kaddr = kmap_atomic(page, KM_USER0);
1660 memset(kaddr + offset, 0, length);
1661 flush_dcache_page(page);
1662 kunmap_atomic(kaddr, KM_USER0);
1664 BUFFER_TRACE(bh, "zeroed end of block");
1667 if (ext3_should_journal_data(inode)) {
1668 err = ext3_journal_dirty_metadata(handle, bh);
1670 if (ext3_should_order_data(inode))
1671 err = ext3_journal_dirty_data(handle, bh);
1672 mark_buffer_dirty(bh);
1677 page_cache_release(page);
1682 * Probably it should be a library function... search for first non-zero word
1683 * or memcmp with zero_page, whatever is better for particular architecture.
1686 static inline int all_zeroes(__le32 *p, __le32 *q)
1695 * ext3_find_shared - find the indirect blocks for partial truncation.
1696 * @inode: inode in question
1697 * @depth: depth of the affected branch
1698 * @offsets: offsets of pointers in that branch (see ext3_block_to_path)
1699 * @chain: place to store the pointers to partial indirect blocks
1700 * @top: place to the (detached) top of branch
1702 * This is a helper function used by ext3_truncate().
1704 * When we do truncate() we may have to clean the ends of several
1705 * indirect blocks but leave the blocks themselves alive. Block is
1706 * partially truncated if some data below the new i_size is refered
1707 * from it (and it is on the path to the first completely truncated
1708 * data block, indeed). We have to free the top of that path along
1709 * with everything to the right of the path. Since no allocation
1710 * past the truncation point is possible until ext3_truncate()
1711 * finishes, we may safely do the latter, but top of branch may
1712 * require special attention - pageout below the truncation point
1713 * might try to populate it.
1715 * We atomically detach the top of branch from the tree, store the
1716 * block number of its root in *@top, pointers to buffer_heads of
1717 * partially truncated blocks - in @chain[].bh and pointers to
1718 * their last elements that should not be removed - in
1719 * @chain[].p. Return value is the pointer to last filled element
1722 * The work left to caller to do the actual freeing of subtrees:
1723 * a) free the subtree starting from *@top
1724 * b) free the subtrees whose roots are stored in
1725 * (@chain[i].p+1 .. end of @chain[i].bh->b_data)
1726 * c) free the subtrees growing from the inode past the @chain[0].
1727 * (no partially truncated stuff there). */
1729 static Indirect *ext3_find_shared(struct inode *inode,
1735 Indirect *partial, *p;
1739 /* Make k index the deepest non-null offest + 1 */
1740 for (k = depth; k > 1 && !offsets[k-1]; k--)
1742 partial = ext3_get_branch(inode, k, offsets, chain, &err);
1743 /* Writer: pointers */
1745 partial = chain + k-1;
1747 * If the branch acquired continuation since we've looked at it -
1748 * fine, it should all survive and (new) top doesn't belong to us.
1750 if (!partial->key && *partial->p)
1753 for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
1756 * OK, we've found the last block that must survive. The rest of our
1757 * branch should be detached before unlocking. However, if that rest
1758 * of branch is all ours and does not grow immediately from the inode
1759 * it's easier to cheat and just decrement partial->p.
1761 if (p == chain + k - 1 && p > chain) {
1765 /* Nope, don't do this in ext3. Must leave the tree intact */
1774 brelse(partial->bh);
1782 * Zero a number of block pointers in either an inode or an indirect block.
1783 * If we restart the transaction we must again get write access to the
1784 * indirect block for further modification.
1786 * We release `count' blocks on disk, but (last - first) may be greater
1787 * than `count' because there can be holes in there.
1790 ext3_clear_blocks(handle_t *handle, struct inode *inode, struct buffer_head *bh,
1791 unsigned long block_to_free, unsigned long count,
1792 __le32 *first, __le32 *last)
1795 if (try_to_extend_transaction(handle, inode)) {
1797 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
1798 ext3_journal_dirty_metadata(handle, bh);
1800 ext3_mark_inode_dirty(handle, inode);
1801 ext3_journal_test_restart(handle, inode);
1803 BUFFER_TRACE(bh, "retaking write access");
1804 ext3_journal_get_write_access(handle, bh);
1809 * Any buffers which are on the journal will be in memory. We find
1810 * them on the hash table so journal_revoke() will run journal_forget()
1811 * on them. We've already detached each block from the file, so
1812 * bforget() in journal_forget() should be safe.
1814 * AKPM: turn on bforget in journal_forget()!!!
1816 for (p = first; p < last; p++) {
1817 u32 nr = le32_to_cpu(*p);
1819 struct buffer_head *bh;
1822 bh = sb_find_get_block(inode->i_sb, nr);
1823 ext3_forget(handle, 0, inode, bh, nr);
1827 ext3_free_blocks(handle, inode, block_to_free, count);
1831 * ext3_free_data - free a list of data blocks
1832 * @handle: handle for this transaction
1833 * @inode: inode we are dealing with
1834 * @this_bh: indirect buffer_head which contains *@first and *@last
1835 * @first: array of block numbers
1836 * @last: points immediately past the end of array
1838 * We are freeing all blocks refered from that array (numbers are stored as
1839 * little-endian 32-bit) and updating @inode->i_blocks appropriately.
1841 * We accumulate contiguous runs of blocks to free. Conveniently, if these
1842 * blocks are contiguous then releasing them at one time will only affect one
1843 * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
1844 * actually use a lot of journal space.
1846 * @this_bh will be %NULL if @first and @last point into the inode's direct
1849 static void ext3_free_data(handle_t *handle, struct inode *inode,
1850 struct buffer_head *this_bh,
1851 __le32 *first, __le32 *last)
1853 unsigned long block_to_free = 0; /* Starting block # of a run */
1854 unsigned long count = 0; /* Number of blocks in the run */
1855 __le32 *block_to_free_p = NULL; /* Pointer into inode/ind
1858 unsigned long nr; /* Current block # */
1859 __le32 *p; /* Pointer into inode/ind
1860 for current block */
1863 if (this_bh) { /* For indirect block */
1864 BUFFER_TRACE(this_bh, "get_write_access");
1865 err = ext3_journal_get_write_access(handle, this_bh);
1866 /* Important: if we can't update the indirect pointers
1867 * to the blocks, we can't free them. */
1872 for (p = first; p < last; p++) {
1873 nr = le32_to_cpu(*p);
1875 /* accumulate blocks to free if they're contiguous */
1878 block_to_free_p = p;
1880 } else if (nr == block_to_free + count) {
1883 ext3_clear_blocks(handle, inode, this_bh,
1885 count, block_to_free_p, p);
1887 block_to_free_p = p;
1894 ext3_clear_blocks(handle, inode, this_bh, block_to_free,
1895 count, block_to_free_p, p);
1898 BUFFER_TRACE(this_bh, "call ext3_journal_dirty_metadata");
1899 ext3_journal_dirty_metadata(handle, this_bh);
1904 * ext3_free_branches - free an array of branches
1905 * @handle: JBD handle for this transaction
1906 * @inode: inode we are dealing with
1907 * @parent_bh: the buffer_head which contains *@first and *@last
1908 * @first: array of block numbers
1909 * @last: pointer immediately past the end of array
1910 * @depth: depth of the branches to free
1912 * We are freeing all blocks refered from these branches (numbers are
1913 * stored as little-endian 32-bit) and updating @inode->i_blocks
1916 static void ext3_free_branches(handle_t *handle, struct inode *inode,
1917 struct buffer_head *parent_bh,
1918 __le32 *first, __le32 *last, int depth)
1923 if (is_handle_aborted(handle))
1927 struct buffer_head *bh;
1928 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
1930 while (--p >= first) {
1931 nr = le32_to_cpu(*p);
1933 continue; /* A hole */
1935 /* Go read the buffer for the next level down */
1936 bh = sb_bread(inode->i_sb, nr);
1939 * A read failure? Report error and clear slot
1943 ext3_error(inode->i_sb, "ext3_free_branches",
1944 "Read failure, inode=%ld, block=%ld",
1949 /* This zaps the entire block. Bottom up. */
1950 BUFFER_TRACE(bh, "free child branches");
1951 ext3_free_branches(handle, inode, bh,
1952 (__le32*)bh->b_data,
1953 (__le32*)bh->b_data + addr_per_block,
1957 * We've probably journalled the indirect block several
1958 * times during the truncate. But it's no longer
1959 * needed and we now drop it from the transaction via
1962 * That's easy if it's exclusively part of this
1963 * transaction. But if it's part of the committing
1964 * transaction then journal_forget() will simply
1965 * brelse() it. That means that if the underlying
1966 * block is reallocated in ext3_get_block(),
1967 * unmap_underlying_metadata() will find this block
1968 * and will try to get rid of it. damn, damn.
1970 * If this block has already been committed to the
1971 * journal, a revoke record will be written. And
1972 * revoke records must be emitted *before* clearing
1973 * this block's bit in the bitmaps.
1975 ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
1978 * Everything below this this pointer has been
1979 * released. Now let this top-of-subtree go.
1981 * We want the freeing of this indirect block to be
1982 * atomic in the journal with the updating of the
1983 * bitmap block which owns it. So make some room in
1986 * We zero the parent pointer *after* freeing its
1987 * pointee in the bitmaps, so if extend_transaction()
1988 * for some reason fails to put the bitmap changes and
1989 * the release into the same transaction, recovery
1990 * will merely complain about releasing a free block,
1991 * rather than leaking blocks.
1993 if (is_handle_aborted(handle))
1995 if (try_to_extend_transaction(handle, inode)) {
1996 ext3_mark_inode_dirty(handle, inode);
1997 ext3_journal_test_restart(handle, inode);
2000 ext3_free_blocks(handle, inode, nr, 1);
2004 * The block which we have just freed is
2005 * pointed to by an indirect block: journal it
2007 BUFFER_TRACE(parent_bh, "get_write_access");
2008 if (!ext3_journal_get_write_access(handle,
2011 BUFFER_TRACE(parent_bh,
2012 "call ext3_journal_dirty_metadata");
2013 ext3_journal_dirty_metadata(handle,
2019 /* We have reached the bottom of the tree. */
2020 BUFFER_TRACE(parent_bh, "free data blocks");
2021 ext3_free_data(handle, inode, parent_bh, first, last);
2028 * We block out ext3_get_block() block instantiations across the entire
2029 * transaction, and VFS/VM ensures that ext3_truncate() cannot run
2030 * simultaneously on behalf of the same inode.
2032 * As we work through the truncate and commmit bits of it to the journal there
2033 * is one core, guiding principle: the file's tree must always be consistent on
2034 * disk. We must be able to restart the truncate after a crash.
2036 * The file's tree may be transiently inconsistent in memory (although it
2037 * probably isn't), but whenever we close off and commit a journal transaction,
2038 * the contents of (the filesystem + the journal) must be consistent and
2039 * restartable. It's pretty simple, really: bottom up, right to left (although
2040 * left-to-right works OK too).
2042 * Note that at recovery time, journal replay occurs *before* the restart of
2043 * truncate against the orphan inode list.
2045 * The committed inode has the new, desired i_size (which is the same as
2046 * i_disksize in this case). After a crash, ext3_orphan_cleanup() will see
2047 * that this inode's truncate did not complete and it will again call
2048 * ext3_truncate() to have another go. So there will be instantiated blocks
2049 * to the right of the truncation point in a crashed ext3 filesystem. But
2050 * that's fine - as long as they are linked from the inode, the post-crash
2051 * ext3_truncate() run will find them and release them.
2054 void ext3_truncate_nocheck(struct inode * inode)
2057 struct ext3_inode_info *ei = EXT3_I(inode);
2058 __le32 *i_data = ei->i_data;
2059 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2060 struct address_space *mapping = inode->i_mapping;
2067 unsigned blocksize = inode->i_sb->s_blocksize;
2070 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
2071 S_ISLNK(inode->i_mode)))
2073 if (ext3_inode_is_fast_symlink(inode))
2076 ext3_discard_reservation(inode);
2079 * We have to lock the EOF page here, because lock_page() nests
2080 * outside journal_start().
2082 if ((inode->i_size & (blocksize - 1)) == 0) {
2083 /* Block boundary? Nothing to do */
2086 page = grab_cache_page(mapping,
2087 inode->i_size >> PAGE_CACHE_SHIFT);
2092 handle = start_transaction(inode);
2093 if (IS_ERR(handle)) {
2095 clear_highpage(page);
2096 flush_dcache_page(page);
2098 page_cache_release(page);
2100 return; /* AKPM: return what? */
2103 last_block = (inode->i_size + blocksize-1)
2104 >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
2107 ext3_block_truncate_page(handle, page, mapping, inode->i_size);
2109 n = ext3_block_to_path(inode, last_block, offsets, NULL);
2111 goto out_stop; /* error */
2114 * OK. This truncate is going to happen. We add the inode to the
2115 * orphan list, so that if this truncate spans multiple transactions,
2116 * and we crash, we will resume the truncate when the filesystem
2117 * recovers. It also marks the inode dirty, to catch the new size.
2119 * Implication: the file must always be in a sane, consistent
2120 * truncatable state while each transaction commits.
2122 if (ext3_orphan_add(handle, inode))
2126 * The orphan list entry will now protect us from any crash which
2127 * occurs before the truncate completes, so it is now safe to propagate
2128 * the new, shorter inode size (held for now in i_size) into the
2129 * on-disk inode. We do this via i_disksize, which is the value which
2130 * ext3 *really* writes onto the disk inode.
2132 ei->i_disksize = inode->i_size;
2135 * From here we block out all ext3_get_block() callers who want to
2136 * modify the block allocation tree.
2138 down(&ei->truncate_sem);
2140 if (n == 1) { /* direct blocks */
2141 ext3_free_data(handle, inode, NULL, i_data+offsets[0],
2142 i_data + EXT3_NDIR_BLOCKS);
2146 partial = ext3_find_shared(inode, n, offsets, chain, &nr);
2147 /* Kill the top of shared branch (not detached) */
2149 if (partial == chain) {
2150 /* Shared branch grows from the inode */
2151 ext3_free_branches(handle, inode, NULL,
2152 &nr, &nr+1, (chain+n-1) - partial);
2155 * We mark the inode dirty prior to restart,
2156 * and prior to stop. No need for it here.
2159 /* Shared branch grows from an indirect block */
2160 BUFFER_TRACE(partial->bh, "get_write_access");
2161 ext3_free_branches(handle, inode, partial->bh,
2163 partial->p+1, (chain+n-1) - partial);
2166 /* Clear the ends of indirect blocks on the shared branch */
2167 while (partial > chain) {
2168 ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2169 (__le32*)partial->bh->b_data+addr_per_block,
2170 (chain+n-1) - partial);
2171 BUFFER_TRACE(partial->bh, "call brelse");
2172 brelse (partial->bh);
2176 /* Kill the remaining (whole) subtrees */
2177 switch (offsets[0]) {
2179 nr = i_data[EXT3_IND_BLOCK];
2181 ext3_free_branches(handle, inode, NULL,
2183 i_data[EXT3_IND_BLOCK] = 0;
2185 case EXT3_IND_BLOCK:
2186 nr = i_data[EXT3_DIND_BLOCK];
2188 ext3_free_branches(handle, inode, NULL,
2190 i_data[EXT3_DIND_BLOCK] = 0;
2192 case EXT3_DIND_BLOCK:
2193 nr = i_data[EXT3_TIND_BLOCK];
2195 ext3_free_branches(handle, inode, NULL,
2197 i_data[EXT3_TIND_BLOCK] = 0;
2199 case EXT3_TIND_BLOCK:
2202 up(&ei->truncate_sem);
2203 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2204 ext3_mark_inode_dirty(handle, inode);
2206 /* In a multi-transaction truncate, we only make the final
2207 * transaction synchronous */
2212 * If this was a simple ftruncate(), and the file will remain alive
2213 * then we need to clear up the orphan record which we created above.
2214 * However, if this was a real unlink then we were called by
2215 * ext3_delete_inode(), and we allow that function to clean up the
2216 * orphan info for us.
2219 ext3_orphan_del(handle, inode);
2221 ext3_journal_stop(handle);
2224 static unsigned long ext3_get_inode_block(struct super_block *sb,
2225 unsigned long ino, struct ext3_iloc *iloc)
2227 unsigned long desc, group_desc, block_group;
2228 unsigned long offset, block;
2229 struct buffer_head *bh;
2230 struct ext3_group_desc * gdp;
2233 if ((ino != EXT3_ROOT_INO &&
2234 ino != EXT3_JOURNAL_INO &&
2235 ino != EXT3_RESIZE_INO &&
2236 ino < EXT3_FIRST_INO(sb)) ||
2238 EXT3_SB(sb)->s_es->s_inodes_count)) {
2239 ext3_error (sb, "ext3_get_inode_block",
2240 "bad inode number: %lu", ino);
2243 block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
2244 if (block_group >= EXT3_SB(sb)->s_groups_count) {
2245 ext3_error (sb, "ext3_get_inode_block",
2246 "group >= groups count");
2250 group_desc = block_group >> EXT3_DESC_PER_BLOCK_BITS(sb);
2251 desc = block_group & (EXT3_DESC_PER_BLOCK(sb) - 1);
2252 bh = EXT3_SB(sb)->s_group_desc[group_desc];
2254 ext3_error (sb, "ext3_get_inode_block",
2255 "Descriptor not loaded");
2259 gdp = (struct ext3_group_desc *) bh->b_data;
2261 * Figure out the offset within the block group inode table
2263 offset = ((ino - 1) % EXT3_INODES_PER_GROUP(sb)) *
2264 EXT3_INODE_SIZE(sb);
2265 block = le32_to_cpu(gdp[desc].bg_inode_table) +
2266 (offset >> EXT3_BLOCK_SIZE_BITS(sb));
2268 iloc->block_group = block_group;
2269 iloc->offset = offset & (EXT3_BLOCK_SIZE(sb) - 1);
2274 * ext3_get_inode_loc returns with an extra refcount against the inode's
2275 * underlying buffer_head on success. If `in_mem' is false then we're purely
2276 * trying to determine the inode's location on-disk and no read need be
2279 static int ext3_get_inode_loc(struct inode *inode,
2280 struct ext3_iloc *iloc, int in_mem)
2282 unsigned long block;
2283 struct buffer_head *bh;
2285 block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
2289 bh = sb_getblk(inode->i_sb, block);
2291 ext3_error (inode->i_sb, "ext3_get_inode_loc",
2292 "unable to read inode block - "
2293 "inode=%lu, block=%lu", inode->i_ino, block);
2296 if (!buffer_uptodate(bh)) {
2298 if (buffer_uptodate(bh)) {
2299 /* someone brought it uptodate while we waited */
2304 /* we can't skip I/O if inode is on a disk only */
2306 struct buffer_head *bitmap_bh;
2307 struct ext3_group_desc *desc;
2308 int inodes_per_buffer;
2309 int inode_offset, i;
2314 * If this is the only valid inode in the block we
2315 * need not read the block.
2317 block_group = (inode->i_ino - 1) /
2318 EXT3_INODES_PER_GROUP(inode->i_sb);
2319 inodes_per_buffer = bh->b_size /
2320 EXT3_INODE_SIZE(inode->i_sb);
2321 inode_offset = ((inode->i_ino - 1) %
2322 EXT3_INODES_PER_GROUP(inode->i_sb));
2323 start = inode_offset & ~(inodes_per_buffer - 1);
2325 /* Is the inode bitmap in cache? */
2326 desc = ext3_get_group_desc(inode->i_sb,
2331 bitmap_bh = sb_getblk(inode->i_sb,
2332 le32_to_cpu(desc->bg_inode_bitmap));
2337 * If the inode bitmap isn't in cache then the
2338 * optimisation may end up performing two reads instead
2339 * of one, so skip it.
2341 if (!buffer_uptodate(bitmap_bh)) {
2345 for (i = start; i < start + inodes_per_buffer; i++) {
2346 if (i == inode_offset)
2348 if (ext3_test_bit(i, bitmap_bh->b_data))
2352 if (i == start + inodes_per_buffer) {
2353 /* all other inodes are free, so skip I/O */
2354 memset(bh->b_data, 0, bh->b_size);
2355 set_buffer_uptodate(bh);
2363 * There are another valid inodes in the buffer so we must
2364 * read the block from disk
2367 bh->b_end_io = end_buffer_read_sync;
2368 submit_bh(READ, bh);
2370 if (!buffer_uptodate(bh)) {
2371 ext3_error(inode->i_sb, "ext3_get_inode_loc",
2372 "unable to read inode block - "
2373 "inode=%lu, block=%lu",
2374 inode->i_ino, block);
2384 void ext3_truncate(struct inode * inode)
2386 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2388 ext3_truncate_nocheck(inode);
2391 void ext3_set_inode_flags(struct inode *inode)
2393 unsigned int flags = EXT3_I(inode)->i_flags;
2395 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_IUNLINK|S_BARRIER|S_NOATIME|S_DIRSYNC);
2396 if (flags & EXT3_SYNC_FL)
2397 inode->i_flags |= S_SYNC;
2398 if (flags & EXT3_APPEND_FL)
2399 inode->i_flags |= S_APPEND;
2400 if (flags & EXT3_IMMUTABLE_FL)
2401 inode->i_flags |= S_IMMUTABLE;
2402 if (flags & EXT3_IUNLINK_FL)
2403 inode->i_flags |= S_IUNLINK;
2404 if (flags & EXT3_BARRIER_FL)
2405 inode->i_flags |= S_BARRIER;
2406 if (flags & EXT3_NOATIME_FL)
2407 inode->i_flags |= S_NOATIME;
2408 if (flags & EXT3_DIRSYNC_FL)
2409 inode->i_flags |= S_DIRSYNC;
2412 void ext3_read_inode(struct inode * inode)
2414 struct ext3_iloc iloc;
2415 struct ext3_inode *raw_inode;
2416 struct ext3_inode_info *ei = EXT3_I(inode);
2417 struct buffer_head *bh;
2422 #ifdef CONFIG_EXT3_FS_POSIX_ACL
2423 ei->i_acl = EXT3_ACL_NOT_CACHED;
2424 ei->i_default_acl = EXT3_ACL_NOT_CACHED;
2426 ei->i_rsv_window.rsv_end = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
2428 if (ext3_get_inode_loc(inode, &iloc, 0))
2431 raw_inode = ext3_raw_inode(&iloc);
2432 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
2433 uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
2434 gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
2435 if(!(test_opt (inode->i_sb, NO_UID32))) {
2436 uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
2437 gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
2439 inode->i_uid = INOXID_UID(XID_TAG(inode), uid, gid);
2440 inode->i_gid = INOXID_GID(XID_TAG(inode), uid, gid);
2441 inode->i_xid = INOXID_XID(XID_TAG(inode), uid, gid,
2442 le16_to_cpu(raw_inode->i_raw_xid));
2444 inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
2445 inode->i_size = le32_to_cpu(raw_inode->i_size);
2446 inode->i_atime.tv_sec = le32_to_cpu(raw_inode->i_atime);
2447 inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->i_ctime);
2448 inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->i_mtime);
2449 inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
2452 ei->i_next_alloc_block = 0;
2453 ei->i_next_alloc_goal = 0;
2454 ei->i_dir_start_lookup = 0;
2455 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
2456 /* We now have enough fields to check if the inode was active or not.
2457 * This is needed because nfsd might try to access dead inodes
2458 * the test is that same one that e2fsck uses
2459 * NeilBrown 1999oct15
2461 if (inode->i_nlink == 0) {
2462 if (inode->i_mode == 0 ||
2463 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
2464 /* this inode is deleted */
2468 /* The only unlinked inodes we let through here have
2469 * valid i_mode and are being read by the orphan
2470 * recovery code: that's fine, we're about to complete
2471 * the process of deleting those. */
2473 inode->i_blksize = PAGE_SIZE; /* This is the optimal IO size
2474 * (for stat), not the fs block
2476 inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
2477 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
2478 #ifdef EXT3_FRAGMENTS
2479 ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
2480 ei->i_frag_no = raw_inode->i_frag;
2481 ei->i_frag_size = raw_inode->i_fsize;
2483 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
2484 if (!S_ISREG(inode->i_mode)) {
2485 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
2488 ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
2490 ei->i_disksize = inode->i_size;
2491 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
2492 ei->i_block_group = iloc.block_group;
2493 ei->i_rsv_window.rsv_start = 0;
2494 ei->i_rsv_window.rsv_end= 0;
2495 atomic_set(&ei->i_rsv_window.rsv_goal_size, EXT3_DEFAULT_RESERVE_BLOCKS);
2496 seqlock_init(&ei->i_rsv_window.rsv_seqlock);
2498 * NOTE! The in-memory inode i_data array is in little-endian order
2499 * even on big-endian machines: we do NOT byteswap the block numbers!
2501 for (block = 0; block < EXT3_N_BLOCKS; block++)
2502 ei->i_data[block] = raw_inode->i_block[block];
2503 INIT_LIST_HEAD(&ei->i_orphan);
2505 if (S_ISREG(inode->i_mode)) {
2506 inode->i_op = &ext3_file_inode_operations;
2507 inode->i_fop = &ext3_file_operations;
2508 ext3_set_aops(inode);
2509 } else if (S_ISDIR(inode->i_mode)) {
2510 inode->i_op = &ext3_dir_inode_operations;
2511 inode->i_fop = &ext3_dir_operations;
2512 } else if (S_ISLNK(inode->i_mode)) {
2513 if (ext3_inode_is_fast_symlink(inode))
2514 inode->i_op = &ext3_fast_symlink_inode_operations;
2516 inode->i_op = &ext3_symlink_inode_operations;
2517 ext3_set_aops(inode);
2520 inode->i_op = &ext3_special_inode_operations;
2521 if (raw_inode->i_block[0])
2522 init_special_inode(inode, inode->i_mode,
2523 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
2525 init_special_inode(inode, inode->i_mode,
2526 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
2529 ext3_set_inode_flags(inode);
2533 make_bad_inode(inode);
2538 * Post the struct inode info into an on-disk inode location in the
2539 * buffer-cache. This gobbles the caller's reference to the
2540 * buffer_head in the inode location struct.
2542 * The caller must have write access to iloc->bh.
2544 static int ext3_do_update_inode(handle_t *handle,
2545 struct inode *inode,
2546 struct ext3_iloc *iloc)
2548 struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
2549 struct ext3_inode_info *ei = EXT3_I(inode);
2550 struct buffer_head *bh = iloc->bh;
2551 uid_t uid = XIDINO_UID(XID_TAG(inode), inode->i_uid, inode->i_xid);
2552 gid_t gid = XIDINO_GID(XID_TAG(inode), inode->i_gid, inode->i_xid);
2553 int err = 0, rc, block;
2555 /* For fields not not tracking in the in-memory inode,
2556 * initialise them to zero for new inodes. */
2557 if (ei->i_state & EXT3_STATE_NEW)
2558 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
2560 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
2561 if(!(test_opt(inode->i_sb, NO_UID32))) {
2562 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(uid));
2563 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(gid));
2565 * Fix up interoperability with old kernels. Otherwise, old inodes get
2566 * re-used with the upper 16 bits of the uid/gid intact
2569 raw_inode->i_uid_high =
2570 cpu_to_le16(high_16_bits(uid));
2571 raw_inode->i_gid_high =
2572 cpu_to_le16(high_16_bits(gid));
2574 raw_inode->i_uid_high = 0;
2575 raw_inode->i_gid_high = 0;
2578 raw_inode->i_uid_low =
2579 cpu_to_le16(fs_high2lowuid(uid));
2580 raw_inode->i_gid_low =
2581 cpu_to_le16(fs_high2lowgid(gid));
2582 raw_inode->i_uid_high = 0;
2583 raw_inode->i_gid_high = 0;
2585 #ifdef CONFIG_INOXID_INTERN
2586 raw_inode->i_raw_xid = cpu_to_le16(inode->i_xid);
2588 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
2589 raw_inode->i_size = cpu_to_le32(ei->i_disksize);
2590 raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
2591 raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
2592 raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
2593 raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
2594 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
2595 raw_inode->i_flags = cpu_to_le32(ei->i_flags);
2596 #ifdef EXT3_FRAGMENTS
2597 raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
2598 raw_inode->i_frag = ei->i_frag_no;
2599 raw_inode->i_fsize = ei->i_frag_size;
2601 raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
2602 if (!S_ISREG(inode->i_mode)) {
2603 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
2605 raw_inode->i_size_high =
2606 cpu_to_le32(ei->i_disksize >> 32);
2607 if (ei->i_disksize > 0x7fffffffULL) {
2608 struct super_block *sb = inode->i_sb;
2609 if (!EXT3_HAS_RO_COMPAT_FEATURE(sb,
2610 EXT3_FEATURE_RO_COMPAT_LARGE_FILE) ||
2611 EXT3_SB(sb)->s_es->s_rev_level ==
2612 cpu_to_le32(EXT3_GOOD_OLD_REV)) {
2613 /* If this is the first large file
2614 * created, add a flag to the superblock.
2616 err = ext3_journal_get_write_access(handle,
2617 EXT3_SB(sb)->s_sbh);
2620 ext3_update_dynamic_rev(sb);
2621 EXT3_SET_RO_COMPAT_FEATURE(sb,
2622 EXT3_FEATURE_RO_COMPAT_LARGE_FILE);
2625 err = ext3_journal_dirty_metadata(handle,
2626 EXT3_SB(sb)->s_sbh);
2630 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
2631 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
2632 if (old_valid_dev(inode->i_rdev)) {
2633 raw_inode->i_block[0] =
2634 cpu_to_le32(old_encode_dev(inode->i_rdev));
2635 raw_inode->i_block[1] = 0;
2637 raw_inode->i_block[0] = 0;
2638 raw_inode->i_block[1] =
2639 cpu_to_le32(new_encode_dev(inode->i_rdev));
2640 raw_inode->i_block[2] = 0;
2642 } else for (block = 0; block < EXT3_N_BLOCKS; block++)
2643 raw_inode->i_block[block] = ei->i_data[block];
2645 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2646 rc = ext3_journal_dirty_metadata(handle, bh);
2649 ei->i_state &= ~EXT3_STATE_NEW;
2653 ext3_std_error(inode->i_sb, err);
2658 * ext3_write_inode()
2660 * We are called from a few places:
2662 * - Within generic_file_write() for O_SYNC files.
2663 * Here, there will be no transaction running. We wait for any running
2664 * trasnaction to commit.
2666 * - Within sys_sync(), kupdate and such.
2667 * We wait on commit, if tol to.
2669 * - Within prune_icache() (PF_MEMALLOC == true)
2670 * Here we simply return. We can't afford to block kswapd on the
2673 * In all cases it is actually safe for us to return without doing anything,
2674 * because the inode has been copied into a raw inode buffer in
2675 * ext3_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
2678 * Note that we are absolutely dependent upon all inode dirtiers doing the
2679 * right thing: they *must* call mark_inode_dirty() after dirtying info in
2680 * which we are interested.
2682 * It would be a bug for them to not do this. The code:
2684 * mark_inode_dirty(inode)
2686 * inode->i_size = expr;
2688 * is in error because a kswapd-driven write_inode() could occur while
2689 * `stuff()' is running, and the new i_size will be lost. Plus the inode
2690 * will no longer be on the superblock's dirty inode list.
2692 int ext3_write_inode(struct inode *inode, int wait)
2694 if (current->flags & PF_MEMALLOC)
2697 if (ext3_journal_current_handle()) {
2698 jbd_debug(0, "called recursively, non-PF_MEMALLOC!\n");
2706 return ext3_force_commit(inode->i_sb);
2709 int ext3_setattr_flags(struct inode *inode, unsigned int flags)
2711 unsigned int oldflags, newflags;
2714 oldflags = EXT3_I(inode)->i_flags;
2715 newflags = oldflags &
2716 ~(EXT3_IMMUTABLE_FL | EXT3_IUNLINK_FL | EXT3_BARRIER_FL);
2717 if (flags & ATTR_FLAG_IMMUTABLE)
2718 newflags |= EXT3_IMMUTABLE_FL;
2719 if (flags & ATTR_FLAG_IUNLINK)
2720 newflags |= EXT3_IUNLINK_FL;
2721 if (flags & ATTR_FLAG_BARRIER)
2722 newflags |= EXT3_BARRIER_FL;
2724 if (oldflags ^ newflags) {
2726 struct ext3_iloc iloc;
2728 handle = ext3_journal_start(inode, 1);
2730 return PTR_ERR(handle);
2733 err = ext3_reserve_inode_write(handle, inode, &iloc);
2737 EXT3_I(inode)->i_flags = newflags;
2738 inode->i_ctime = CURRENT_TIME;
2740 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
2742 ext3_journal_stop(handle);
2750 * Called from notify_change.
2752 * We want to trap VFS attempts to truncate the file as soon as
2753 * possible. In particular, we want to make sure that when the VFS
2754 * shrinks i_size, we put the inode on the orphan list and modify
2755 * i_disksize immediately, so that during the subsequent flushing of
2756 * dirty pages and freeing of disk blocks, we can guarantee that any
2757 * commit will leave the blocks being flushed in an unused state on
2758 * disk. (On recovery, the inode will get truncated and the blocks will
2759 * be freed, so we have a strong guarantee that no future commit will
2760 * leave these blocks visible to the user.)
2762 * Called with inode->sem down.
2764 int ext3_setattr(struct dentry *dentry, struct iattr *attr)
2766 struct inode *inode = dentry->d_inode;
2768 const unsigned int ia_valid = attr->ia_valid;
2770 error = inode_change_ok(inode, attr);
2774 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2775 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid) ||
2776 (ia_valid & ATTR_XID && attr->ia_xid != inode->i_xid)) {
2779 /* (user+group)*(old+new) structure, inode write (sb,
2780 * inode block, ? - but truncate inode update has it) */
2781 handle = ext3_journal_start(inode, 4*EXT3_QUOTA_INIT_BLOCKS+3);
2782 if (IS_ERR(handle)) {
2783 error = PTR_ERR(handle);
2786 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2788 ext3_journal_stop(handle);
2791 /* Update corresponding info in inode so that everything is in
2792 * one transaction */
2793 if (attr->ia_valid & ATTR_UID)
2794 inode->i_uid = attr->ia_uid;
2795 if (attr->ia_valid & ATTR_GID)
2796 inode->i_gid = attr->ia_gid;
2797 if ((attr->ia_valid & ATTR_XID)
2799 && (inode->i_sb->s_flags & MS_TAGXID))
2800 inode->i_xid = attr->ia_xid;
2801 error = ext3_mark_inode_dirty(handle, inode);
2802 ext3_journal_stop(handle);
2805 if (S_ISREG(inode->i_mode) &&
2806 attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
2809 handle = ext3_journal_start(inode, 3);
2810 if (IS_ERR(handle)) {
2811 error = PTR_ERR(handle);
2815 error = ext3_orphan_add(handle, inode);
2816 EXT3_I(inode)->i_disksize = attr->ia_size;
2817 rc = ext3_mark_inode_dirty(handle, inode);
2820 ext3_journal_stop(handle);
2823 if (ia_valid & ATTR_ATTR_FLAG) {
2824 rc = ext3_setattr_flags(inode, attr->ia_attr_flags);
2829 rc = inode_setattr(inode, attr);
2831 /* If inode_setattr's call to ext3_truncate failed to get a
2832 * transaction handle at all, we need to clean up the in-core
2833 * orphan list manually. */
2835 ext3_orphan_del(NULL, inode);
2837 if (!rc && (ia_valid & ATTR_MODE))
2838 rc = ext3_acl_chmod(inode);
2841 ext3_std_error(inode->i_sb, error);
2849 * akpm: how many blocks doth make a writepage()?
2851 * With N blocks per page, it may be:
2856 * N+5 bitmap blocks (from the above)
2857 * N+5 group descriptor summary blocks
2860 * 2 * EXT3_SINGLEDATA_TRANS_BLOCKS for the quote files
2862 * 3 * (N + 5) + 2 + 2 * EXT3_SINGLEDATA_TRANS_BLOCKS
2864 * With ordered or writeback data it's the same, less the N data blocks.
2866 * If the inode's direct blocks can hold an integral number of pages then a
2867 * page cannot straddle two indirect blocks, and we can only touch one indirect
2868 * and dindirect block, and the "5" above becomes "3".
2870 * This still overestimates under most circumstances. If we were to pass the
2871 * start and end offsets in here as well we could do block_to_path() on each
2872 * block and work out the exact number of indirects which are touched. Pah.
2875 int ext3_writepage_trans_blocks(struct inode *inode)
2877 int bpp = ext3_journal_blocks_per_page(inode);
2878 int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
2881 if (ext3_should_journal_data(inode))
2882 ret = 3 * (bpp + indirects) + 2;
2884 ret = 2 * (bpp + indirects) + 2;
2887 /* We know that structure was already allocated during DQUOT_INIT so
2888 * we will be updating only the data blocks + inodes */
2889 ret += 2*EXT3_QUOTA_TRANS_BLOCKS;
2896 * The caller must have previously called ext3_reserve_inode_write().
2897 * Give this, we know that the caller already has write access to iloc->bh.
2899 int ext3_mark_iloc_dirty(handle_t *handle,
2900 struct inode *inode, struct ext3_iloc *iloc)
2904 /* the do_update_inode consumes one bh->b_count */
2907 /* ext3_do_update_inode() does journal_dirty_metadata */
2908 err = ext3_do_update_inode(handle, inode, iloc);
2914 * On success, We end up with an outstanding reference count against
2915 * iloc->bh. This _must_ be cleaned up later.
2919 ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
2920 struct ext3_iloc *iloc)
2924 err = ext3_get_inode_loc(inode, iloc, 1);
2926 BUFFER_TRACE(iloc->bh, "get_write_access");
2927 err = ext3_journal_get_write_access(handle, iloc->bh);
2934 ext3_std_error(inode->i_sb, err);
2939 * akpm: What we do here is to mark the in-core inode as clean
2940 * with respect to inode dirtiness (it may still be data-dirty).
2941 * This means that the in-core inode may be reaped by prune_icache
2942 * without having to perform any I/O. This is a very good thing,
2943 * because *any* task may call prune_icache - even ones which
2944 * have a transaction open against a different journal.
2946 * Is this cheating? Not really. Sure, we haven't written the
2947 * inode out, but prune_icache isn't a user-visible syncing function.
2948 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
2949 * we start and wait on commits.
2951 * Is this efficient/effective? Well, we're being nice to the system
2952 * by cleaning up our inodes proactively so they can be reaped
2953 * without I/O. But we are potentially leaving up to five seconds'
2954 * worth of inodes floating about which prune_icache wants us to
2955 * write out. One way to fix that would be to get prune_icache()
2956 * to do a write_super() to free up some memory. It has the desired
2959 int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
2961 struct ext3_iloc iloc;
2965 err = ext3_reserve_inode_write(handle, inode, &iloc);
2967 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
2972 * akpm: ext3_dirty_inode() is called from __mark_inode_dirty()
2974 * We're really interested in the case where a file is being extended.
2975 * i_size has been changed by generic_commit_write() and we thus need
2976 * to include the updated inode in the current transaction.
2978 * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks
2979 * are allocated to the file.
2981 * If the inode is marked synchronous, we don't honour that here - doing
2982 * so would cause a commit on atime updates, which we don't bother doing.
2983 * We handle synchronous inodes at the highest possible level.
2985 void ext3_dirty_inode(struct inode *inode)
2987 handle_t *current_handle = ext3_journal_current_handle();
2990 handle = ext3_journal_start(inode, 2);
2993 if (current_handle &&
2994 current_handle->h_transaction != handle->h_transaction) {
2995 /* This task has a transaction open against a different fs */
2996 printk(KERN_EMERG "%s: transactions do not match!\n",
2999 jbd_debug(5, "marking dirty. outer handle=%p\n",
3001 ext3_mark_inode_dirty(handle, inode);
3003 ext3_journal_stop(handle);
3010 * Bind an inode's backing buffer_head into this transaction, to prevent
3011 * it from being flushed to disk early. Unlike
3012 * ext3_reserve_inode_write, this leaves behind no bh reference and
3013 * returns no iloc structure, so the caller needs to repeat the iloc
3014 * lookup to mark the inode dirty later.
3017 ext3_pin_inode(handle_t *handle, struct inode *inode)
3019 struct ext3_iloc iloc;
3023 err = ext3_get_inode_loc(inode, &iloc, 1);
3025 BUFFER_TRACE(iloc.bh, "get_write_access");
3026 err = journal_get_write_access(handle, iloc.bh);
3028 err = ext3_journal_dirty_metadata(handle,
3033 ext3_std_error(inode->i_sb, err);
3038 int ext3_change_inode_journal_flag(struct inode *inode, int val)
3045 * We have to be very careful here: changing a data block's
3046 * journaling status dynamically is dangerous. If we write a
3047 * data block to the journal, change the status and then delete
3048 * that block, we risk forgetting to revoke the old log record
3049 * from the journal and so a subsequent replay can corrupt data.
3050 * So, first we make sure that the journal is empty and that
3051 * nobody is changing anything.
3054 journal = EXT3_JOURNAL(inode);
3055 if (is_journal_aborted(journal) || IS_RDONLY(inode))
3058 journal_lock_updates(journal);
3059 journal_flush(journal);
3062 * OK, there are no updates running now, and all cached data is
3063 * synced to disk. We are now in a completely consistent state
3064 * which doesn't have anything in the journal, and we know that
3065 * no filesystem updates are running, so it is safe to modify
3066 * the inode's in-core data-journaling state flag now.
3070 EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
3072 EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
3073 ext3_set_aops(inode);
3075 journal_unlock_updates(journal);
3077 /* Finally we can mark the inode as dirty. */
3079 handle = ext3_journal_start(inode, 1);
3081 return PTR_ERR(handle);
3083 err = ext3_mark_inode_dirty(handle, inode);
3085 ext3_journal_stop(handle);
3086 ext3_std_error(inode->i_sb, err);