2 * linux/fs/ext3/inode.c
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
11 * linux/fs/minix/inode.c
13 * Copyright (C) 1991, 1992 Linus Torvalds
15 * Goal-directed block allocation by Stephen Tweedie
16 * (sct@redhat.com), 1993, 1998
17 * Big-endian to little-endian byte-swapping/bitmaps by
18 * David S. Miller (davem@caip.rutgers.edu), 1995
19 * 64-bit file support on 64-bit platforms by Jakub Jelinek
20 * (jj@sunsite.ms.mff.cuni.cz)
22 * Assorted race fixes, rewrite of ext3_get_block() by Al Viro, 2000
25 #include <linux/module.h>
27 #include <linux/time.h>
28 #include <linux/ext3_jbd.h>
29 #include <linux/jbd.h>
30 #include <linux/smp_lock.h>
31 #include <linux/highuid.h>
32 #include <linux/pagemap.h>
33 #include <linux/quotaops.h>
34 #include <linux/string.h>
35 #include <linux/buffer_head.h>
36 #include <linux/writeback.h>
37 #include <linux/mpage.h>
38 #include <linux/uio.h>
42 static int ext3_writepage_trans_blocks(struct inode *inode);
45 * Test whether an inode is a fast symlink.
47 static inline int ext3_inode_is_fast_symlink(struct inode *inode)
49 int ea_blocks = EXT3_I(inode)->i_file_acl ?
50 (inode->i_sb->s_blocksize >> 9) : 0;
52 return (S_ISLNK(inode->i_mode) &&
53 inode->i_blocks - ea_blocks == 0);
56 /* The ext3 forget function must perform a revoke if we are freeing data
57 * which has been journaled. Metadata (eg. indirect blocks) must be
58 * revoked in all cases.
60 * "bh" may be NULL: a metadata block may have been freed from memory
61 * but there may still be a record of it in the journal, and that record
62 * still needs to be revoked.
65 int ext3_forget(handle_t *handle, int is_metadata,
66 struct inode *inode, struct buffer_head *bh,
73 BUFFER_TRACE(bh, "enter");
75 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
77 bh, is_metadata, inode->i_mode,
78 test_opt(inode->i_sb, DATA_FLAGS));
80 /* Never use the revoke function if we are doing full data
81 * journaling: there is no need to, and a V1 superblock won't
82 * support it. Otherwise, only skip the revoke on un-journaled
85 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ||
86 (!is_metadata && !ext3_should_journal_data(inode))) {
88 BUFFER_TRACE(bh, "call journal_forget");
89 return ext3_journal_forget(handle, bh);
95 * data!=journal && (is_metadata || should_journal_data(inode))
97 BUFFER_TRACE(bh, "call ext3_journal_revoke");
98 err = ext3_journal_revoke(handle, blocknr, bh);
100 ext3_abort(inode->i_sb, __FUNCTION__,
101 "error %d when attempting revoke", err);
102 BUFFER_TRACE(bh, "exit");
107 * Work out how many blocks we need to progress with the next chunk of a
108 * truncate transaction.
111 static unsigned long blocks_for_truncate(struct inode *inode)
113 unsigned long needed;
115 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
117 /* Give ourselves just enough room to cope with inodes in which
118 * i_blocks is corrupt: we've seen disk corruptions in the past
119 * which resulted in random data in an inode which looked enough
120 * like a regular file for ext3 to try to delete it. Things
121 * will go a bit crazy if that happens, but at least we should
122 * try not to panic the whole kernel. */
126 /* But we need to bound the transaction so we don't overflow the
128 if (needed > EXT3_MAX_TRANS_DATA)
129 needed = EXT3_MAX_TRANS_DATA;
131 return EXT3_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
135 * Truncate transactions can be complex and absolutely huge. So we need to
136 * be able to restart the transaction at a conventient checkpoint to make
137 * sure we don't overflow the journal.
139 * start_transaction gets us a new handle for a truncate transaction,
140 * and extend_transaction tries to extend the existing one a bit. If
141 * extend fails, we need to propagate the failure up and restart the
142 * transaction in the top-level truncate loop. --sct
145 static handle_t *start_transaction(struct inode *inode)
149 result = ext3_journal_start(inode, blocks_for_truncate(inode));
153 ext3_std_error(inode->i_sb, PTR_ERR(result));
158 * Try to extend this transaction for the purposes of truncation.
160 * Returns 0 if we managed to create more room. If we can't create more
161 * room, and the transaction must be restarted we return 1.
163 static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
165 if (handle->h_buffer_credits > EXT3_RESERVE_TRANS_BLOCKS)
167 if (!ext3_journal_extend(handle, blocks_for_truncate(inode)))
173 * Restart the transaction associated with *handle. This does a commit,
174 * so before we call here everything must be consistently dirtied against
177 static int ext3_journal_test_restart(handle_t *handle, struct inode *inode)
179 jbd_debug(2, "restarting handle %p\n", handle);
180 return ext3_journal_restart(handle, blocks_for_truncate(inode));
184 * Called at the last iput() if i_nlink is zero.
186 void ext3_delete_inode (struct inode * inode)
190 truncate_inode_pages(&inode->i_data, 0);
192 if (is_bad_inode(inode))
195 handle = start_transaction(inode);
196 if (IS_ERR(handle)) {
197 /* If we're going to skip the normal cleanup, we still
198 * need to make sure that the in-core orphan linked list
199 * is properly cleaned up. */
200 ext3_orphan_del(NULL, inode);
208 ext3_truncate(inode);
210 * Kill off the orphan record which ext3_truncate created.
211 * AKPM: I think this can be inside the above `if'.
212 * Note that ext3_orphan_del() has to be able to cope with the
213 * deletion of a non-existent orphan - this is because we don't
214 * know if ext3_truncate() actually created an orphan record.
215 * (Well, we could do this if we need to, but heck - it works)
217 ext3_orphan_del(handle, inode);
218 EXT3_I(inode)->i_dtime = get_seconds();
221 * One subtle ordering requirement: if anything has gone wrong
222 * (transaction abort, IO errors, whatever), then we can still
223 * do these next steps (the fs will already have been marked as
224 * having errors), but we can't free the inode if the mark_dirty
227 if (ext3_mark_inode_dirty(handle, inode))
228 /* If that failed, just do the required in-core inode clear. */
231 ext3_free_inode(handle, inode);
232 ext3_journal_stop(handle);
235 clear_inode(inode); /* We must guarantee clearing of inode... */
238 static int ext3_alloc_block (handle_t *handle,
239 struct inode * inode, unsigned long goal, int *err)
241 unsigned long result;
243 result = ext3_new_block(handle, inode, goal, err);
251 struct buffer_head *bh;
254 static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
256 p->key = *(p->p = v);
260 static inline int verify_chain(Indirect *from, Indirect *to)
262 while (from <= to && from->key == *from->p)
268 * ext3_block_to_path - parse the block number into array of offsets
269 * @inode: inode in question (we are only interested in its superblock)
270 * @i_block: block number to be parsed
271 * @offsets: array to store the offsets in
272 * @boundary: set this non-zero if the referred-to block is likely to be
273 * followed (on disk) by an indirect block.
275 * To store the locations of file's data ext3 uses a data structure common
276 * for UNIX filesystems - tree of pointers anchored in the inode, with
277 * data blocks at leaves and indirect blocks in intermediate nodes.
278 * This function translates the block number into path in that tree -
279 * return value is the path length and @offsets[n] is the offset of
280 * pointer to (n+1)th node in the nth one. If @block is out of range
281 * (negative or too large) warning is printed and zero returned.
283 * Note: function doesn't find node addresses, so no IO is needed. All
284 * we need to know is the capacity of indirect blocks (taken from the
289 * Portability note: the last comparison (check that we fit into triple
290 * indirect block) is spelled differently, because otherwise on an
291 * architecture with 32-bit longs and 8Kb pages we might get into trouble
292 * if our filesystem had 8Kb blocks. We might use long long, but that would
293 * kill us on x86. Oh, well, at least the sign propagation does not matter -
294 * i_block would have to be negative in the very beginning, so we would not
298 static int ext3_block_to_path(struct inode *inode,
299 long i_block, int offsets[4], int *boundary)
301 int ptrs = EXT3_ADDR_PER_BLOCK(inode->i_sb);
302 int ptrs_bits = EXT3_ADDR_PER_BLOCK_BITS(inode->i_sb);
303 const long direct_blocks = EXT3_NDIR_BLOCKS,
304 indirect_blocks = ptrs,
305 double_blocks = (1 << (ptrs_bits * 2));
310 ext3_warning (inode->i_sb, "ext3_block_to_path", "block < 0");
311 } else if (i_block < direct_blocks) {
312 offsets[n++] = i_block;
313 final = direct_blocks;
314 } else if ( (i_block -= direct_blocks) < indirect_blocks) {
315 offsets[n++] = EXT3_IND_BLOCK;
316 offsets[n++] = i_block;
318 } else if ((i_block -= indirect_blocks) < double_blocks) {
319 offsets[n++] = EXT3_DIND_BLOCK;
320 offsets[n++] = i_block >> ptrs_bits;
321 offsets[n++] = i_block & (ptrs - 1);
323 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
324 offsets[n++] = EXT3_TIND_BLOCK;
325 offsets[n++] = i_block >> (ptrs_bits * 2);
326 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
327 offsets[n++] = i_block & (ptrs - 1);
330 ext3_warning (inode->i_sb, "ext3_block_to_path", "block > big");
333 *boundary = final - 1 - (i_block & (ptrs - 1));
338 * ext3_get_branch - read the chain of indirect blocks leading to data
339 * @inode: inode in question
340 * @depth: depth of the chain (1 - direct pointer, etc.)
341 * @offsets: offsets of pointers in inode/indirect blocks
342 * @chain: place to store the result
343 * @err: here we store the error value
345 * Function fills the array of triples <key, p, bh> and returns %NULL
346 * if everything went OK or the pointer to the last filled triple
347 * (incomplete one) otherwise. Upon the return chain[i].key contains
348 * the number of (i+1)-th block in the chain (as it is stored in memory,
349 * i.e. little-endian 32-bit), chain[i].p contains the address of that
350 * number (it points into struct inode for i==0 and into the bh->b_data
351 * for i>0) and chain[i].bh points to the buffer_head of i-th indirect
352 * block for i>0 and NULL for i==0. In other words, it holds the block
353 * numbers of the chain, addresses they were taken from (and where we can
354 * verify that chain did not change) and buffer_heads hosting these
357 * Function stops when it stumbles upon zero pointer (absent block)
358 * (pointer to last triple returned, *@err == 0)
359 * or when it gets an IO error reading an indirect block
360 * (ditto, *@err == -EIO)
361 * or when it notices that chain had been changed while it was reading
362 * (ditto, *@err == -EAGAIN)
363 * or when it reads all @depth-1 indirect blocks successfully and finds
364 * the whole chain, all way to the data (returns %NULL, *err == 0).
366 static Indirect *ext3_get_branch(struct inode *inode, int depth, int *offsets,
367 Indirect chain[4], int *err)
369 struct super_block *sb = inode->i_sb;
371 struct buffer_head *bh;
374 /* i_data is not going away, no lock needed */
375 add_chain (chain, NULL, EXT3_I(inode)->i_data + *offsets);
379 bh = sb_bread(sb, le32_to_cpu(p->key));
382 /* Reader: pointers */
383 if (!verify_chain(chain, p))
385 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
403 * ext3_find_near - find a place for allocation with sufficient locality
405 * @ind: descriptor of indirect block.
407 * This function returns the prefered place for block allocation.
408 * It is used when heuristic for sequential allocation fails.
410 * + if there is a block to the left of our position - allocate near it.
411 * + if pointer will live in indirect block - allocate near that block.
412 * + if pointer will live in inode - allocate in the same
415 * In the latter case we colour the starting block by the callers PID to
416 * prevent it from clashing with concurrent allocations for a different inode
417 * in the same block group. The PID is used here so that functionally related
418 * files will be close-by on-disk.
420 * Caller must make sure that @ind is valid and will stay that way.
423 static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)
425 struct ext3_inode_info *ei = EXT3_I(inode);
426 __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
428 unsigned long bg_start;
429 unsigned long colour;
431 /* Try to find previous block */
432 for (p = ind->p - 1; p >= start; p--)
434 return le32_to_cpu(*p);
436 /* No such thing, so let's try location of indirect block */
438 return ind->bh->b_blocknr;
441 * It is going to be refered from inode itself? OK, just put it into
442 * the same cylinder group then.
444 bg_start = (ei->i_block_group * EXT3_BLOCKS_PER_GROUP(inode->i_sb)) +
445 le32_to_cpu(EXT3_SB(inode->i_sb)->s_es->s_first_data_block);
446 colour = (current->pid % 16) *
447 (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
448 return bg_start + colour;
452 * ext3_find_goal - find a prefered place for allocation.
454 * @block: block we want
455 * @chain: chain of indirect blocks
456 * @partial: pointer to the last triple within a chain
457 * @goal: place to store the result.
459 * Normally this function find the prefered place for block allocation,
460 * stores it in *@goal and returns zero.
463 static unsigned long ext3_find_goal(struct inode *inode, long block,
464 Indirect chain[4], Indirect *partial)
466 struct ext3_block_alloc_info *block_i = EXT3_I(inode)->i_block_alloc_info;
469 * try the heuristic for sequential allocation,
470 * failing that at least try to get decent locality.
472 if (block_i && (block == block_i->last_alloc_logical_block + 1)
473 && (block_i->last_alloc_physical_block != 0)) {
474 return block_i->last_alloc_physical_block + 1;
477 return ext3_find_near(inode, partial);
481 * ext3_alloc_branch - allocate and set up a chain of blocks.
483 * @num: depth of the chain (number of blocks to allocate)
484 * @offsets: offsets (in the blocks) to store the pointers to next.
485 * @branch: place to store the chain in.
487 * This function allocates @num blocks, zeroes out all but the last one,
488 * links them into chain and (if we are synchronous) writes them to disk.
489 * In other words, it prepares a branch that can be spliced onto the
490 * inode. It stores the information about that chain in the branch[], in
491 * the same format as ext3_get_branch() would do. We are calling it after
492 * we had read the existing part of chain and partial points to the last
493 * triple of that (one with zero ->key). Upon the exit we have the same
494 * picture as after the successful ext3_get_block(), except that in one
495 * place chain is disconnected - *branch->p is still zero (we did not
496 * set the last link), but branch->key contains the number that should
497 * be placed into *branch->p to fill that gap.
499 * If allocation fails we free all blocks we've allocated (and forget
500 * their buffer_heads) and return the error value the from failed
501 * ext3_alloc_block() (normally -ENOSPC). Otherwise we set the chain
502 * as described above and return 0.
505 static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
511 int blocksize = inode->i_sb->s_blocksize;
515 int parent = ext3_alloc_block(handle, inode, goal, &err);
517 branch[0].key = cpu_to_le32(parent);
519 for (n = 1; n < num; n++) {
520 struct buffer_head *bh;
521 /* Allocate the next block */
522 int nr = ext3_alloc_block(handle, inode, parent, &err);
525 branch[n].key = cpu_to_le32(nr);
528 * Get buffer_head for parent block, zero it out
529 * and set the pointer to new one, then send
532 bh = sb_getblk(inode->i_sb, parent);
538 BUFFER_TRACE(bh, "call get_create_access");
539 err = ext3_journal_get_create_access(handle, bh);
546 memset(bh->b_data, 0, blocksize);
547 branch[n].p = (__le32*) bh->b_data + offsets[n];
548 *branch[n].p = branch[n].key;
549 BUFFER_TRACE(bh, "marking uptodate");
550 set_buffer_uptodate(bh);
553 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
554 err = ext3_journal_dirty_metadata(handle, bh);
564 /* Allocation failed, free what we already allocated */
565 for (i = 1; i < keys; i++) {
566 BUFFER_TRACE(branch[i].bh, "call journal_forget");
567 ext3_journal_forget(handle, branch[i].bh);
569 for (i = 0; i < keys; i++)
570 ext3_free_blocks(handle, inode, le32_to_cpu(branch[i].key), 1);
575 * ext3_splice_branch - splice the allocated branch onto inode.
577 * @block: (logical) number of block we are adding
578 * @chain: chain of indirect blocks (with a missing link - see
580 * @where: location of missing link
581 * @num: number of blocks we are adding
583 * This function fills the missing link and does all housekeeping needed in
584 * inode (->i_blocks, etc.). In case of success we end up with the full
585 * chain to new block and return 0.
588 static int ext3_splice_branch(handle_t *handle, struct inode *inode, long block,
589 Indirect chain[4], Indirect *where, int num)
593 struct ext3_block_alloc_info *block_i = EXT3_I(inode)->i_block_alloc_info;
596 * If we're splicing into a [td]indirect block (as opposed to the
597 * inode) then we need to get write access to the [td]indirect block
601 BUFFER_TRACE(where->bh, "get_write_access");
602 err = ext3_journal_get_write_access(handle, where->bh);
608 *where->p = where->key;
611 * update the most recently allocated logical & physical block
612 * in i_block_alloc_info, to assist find the proper goal block for next
616 block_i->last_alloc_logical_block = block;
617 block_i->last_alloc_physical_block = le32_to_cpu(where[num-1].key);
620 /* We are done with atomic stuff, now do the rest of housekeeping */
622 inode->i_ctime = CURRENT_TIME_SEC;
623 ext3_mark_inode_dirty(handle, inode);
625 /* had we spliced it onto indirect block? */
628 * akpm: If we spliced it onto an indirect block, we haven't
629 * altered the inode. Note however that if it is being spliced
630 * onto an indirect block at the very end of the file (the
631 * file is growing) then we *will* alter the inode to reflect
632 * the new i_size. But that is not done here - it is done in
633 * generic_commit_write->__mark_inode_dirty->ext3_dirty_inode.
635 jbd_debug(5, "splicing indirect only\n");
636 BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
637 err = ext3_journal_dirty_metadata(handle, where->bh);
642 * OK, we spliced it into the inode itself on a direct block.
643 * Inode was dirtied above.
645 jbd_debug(5, "splicing direct\n");
650 for (i = 1; i < num; i++) {
651 BUFFER_TRACE(where[i].bh, "call journal_forget");
652 ext3_journal_forget(handle, where[i].bh);
658 * Allocation strategy is simple: if we have to allocate something, we will
659 * have to go the whole way to leaf. So let's do it before attaching anything
660 * to tree, set linkage between the newborn blocks, write them if sync is
661 * required, recheck the path, free and repeat if check fails, otherwise
662 * set the last missing link (that will protect us from any truncate-generated
663 * removals - all blocks on the path are immune now) and possibly force the
664 * write on the parent block.
665 * That has a nice additional property: no special recovery from the failed
666 * allocations is needed - we simply release blocks and do not touch anything
667 * reachable from inode.
669 * akpm: `handle' can be NULL if create == 0.
671 * The BKL may not be held on entry here. Be sure to take it early.
672 * return > 0, # of blocks mapped or allocated.
673 * return = 0, if plain lookup failed.
674 * return < 0, error case.
678 ext3_get_blocks_handle(handle_t *handle, struct inode *inode, sector_t iblock,
679 unsigned long maxblocks, struct buffer_head *bh_result,
680 int create, int extend_disksize)
688 int blocks_to_boundary = 0;
690 struct ext3_inode_info *ei = EXT3_I(inode);
692 unsigned long first_block = 0;
695 J_ASSERT(handle != NULL || create == 0);
696 depth = ext3_block_to_path(inode, iblock, offsets, &blocks_to_boundary);
701 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
703 /* Simplest case - block found, no allocation needed */
705 first_block = chain[depth - 1].key;
706 clear_buffer_new(bh_result);
709 while (count < maxblocks && count <= blocks_to_boundary) {
710 if (!verify_chain(chain, partial)) {
712 * Indirect block might be removed by
713 * truncate while we were reading it.
714 * Handling of that case: forget what we've
715 * got now. Flag the err as EAGAIN, so it
722 if (le32_to_cpu(*(chain[depth-1].p+count) ==
723 (first_block + count)))
732 /* Next simple case - plain lookup or failed read of indirect block */
733 if (!create || err == -EIO)
736 mutex_lock(&ei->truncate_mutex);
739 * If the indirect block is missing while we are reading
740 * the chain(ext3_get_branch() returns -EAGAIN err), or
741 * if the chain has been changed after we grab the semaphore,
742 * (either because another process truncated this branch, or
743 * another get_block allocated this branch) re-grab the chain to see if
744 * the request block has been allocated or not.
746 * Since we already block the truncate/other get_block
747 * at this point, we will have the current copy of the chain when we
748 * splice the branch into the tree.
750 if (err == -EAGAIN || !verify_chain(chain, partial)) {
751 while (partial > chain) {
755 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
758 mutex_unlock(&ei->truncate_mutex);
761 clear_buffer_new(bh_result);
767 * Okay, we need to do block allocation. Lazily initialize the block
768 * allocation info here if necessary
770 if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
771 ext3_init_block_alloc_info(inode);
773 goal = ext3_find_goal(inode, iblock, chain, partial);
775 left = (chain + depth) - partial;
778 * Block out ext3_truncate while we alter the tree
780 err = ext3_alloc_branch(handle, inode, left, goal,
781 offsets + (partial - chain), partial);
784 * The ext3_splice_branch call will free and forget any buffers
785 * on the new chain if there is a failure, but that risks using
786 * up transaction credits, especially for bitmaps where the
787 * credits cannot be returned. Can we handle this somehow? We
788 * may need to return -EAGAIN upwards in the worst case. --sct
791 err = ext3_splice_branch(handle, inode, iblock, chain,
794 * i_disksize growing is protected by truncate_mutex. Don't forget to
795 * protect it if you're about to implement concurrent
796 * ext3_get_block() -bzzz
798 if (!err && extend_disksize && inode->i_size > ei->i_disksize)
799 ei->i_disksize = inode->i_size;
800 mutex_unlock(&ei->truncate_mutex);
804 set_buffer_new(bh_result);
806 map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
807 if (blocks_to_boundary == 0)
808 set_buffer_boundary(bh_result);
810 /* Clean up and exit */
811 partial = chain + depth - 1; /* the whole chain */
813 while (partial > chain) {
814 BUFFER_TRACE(partial->bh, "call brelse");
818 BUFFER_TRACE(bh_result, "returned");
823 #define DIO_CREDITS (EXT3_RESERVE_TRANS_BLOCKS + 32)
826 ext3_direct_io_get_blocks(struct inode *inode, sector_t iblock,
827 unsigned long max_blocks, struct buffer_head *bh_result,
830 handle_t *handle = journal_current_handle();
834 goto get_block; /* A read */
837 goto get_block; /* A single block get */
839 if (handle->h_transaction->t_state == T_LOCKED) {
841 * Huge direct-io writes can hold off commits for long
842 * periods of time. Let this commit run.
844 ext3_journal_stop(handle);
845 handle = ext3_journal_start(inode, DIO_CREDITS);
847 ret = PTR_ERR(handle);
851 if (handle->h_buffer_credits <= EXT3_RESERVE_TRANS_BLOCKS) {
853 * Getting low on buffer credits...
855 ret = ext3_journal_extend(handle, DIO_CREDITS);
858 * Couldn't extend the transaction. Start a new one.
860 ret = ext3_journal_restart(handle, DIO_CREDITS);
866 ret = ext3_get_blocks_handle(handle, inode, iblock,
867 max_blocks, bh_result, create, 0);
869 bh_result->b_size = (ret << inode->i_blkbits);
876 static int ext3_get_blocks(struct inode *inode, sector_t iblock,
877 unsigned long maxblocks, struct buffer_head *bh_result,
880 return ext3_direct_io_get_blocks(inode, iblock, maxblocks,
884 static int ext3_get_block(struct inode *inode, sector_t iblock,
885 struct buffer_head *bh_result, int create)
887 return ext3_get_blocks(inode, iblock, 1, bh_result, create);
891 * `handle' can be NULL if create is zero
893 struct buffer_head *ext3_getblk(handle_t *handle, struct inode * inode,
894 long block, int create, int * errp)
896 struct buffer_head dummy;
899 J_ASSERT(handle != NULL || create == 0);
902 dummy.b_blocknr = -1000;
903 buffer_trace_init(&dummy.b_history);
904 err = ext3_get_blocks_handle(handle, inode, block, 1,
908 } else if (err >= 0) {
913 if (!err && buffer_mapped(&dummy)) {
914 struct buffer_head *bh;
915 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
920 if (buffer_new(&dummy)) {
921 J_ASSERT(create != 0);
922 J_ASSERT(handle != 0);
924 /* Now that we do not always journal data, we
925 should keep in mind whether this should
926 always journal the new buffer as metadata.
927 For now, regular file writes use
928 ext3_get_block instead, so it's not a
931 BUFFER_TRACE(bh, "call get_create_access");
932 fatal = ext3_journal_get_create_access(handle, bh);
933 if (!fatal && !buffer_uptodate(bh)) {
934 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
935 set_buffer_uptodate(bh);
938 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
939 err = ext3_journal_dirty_metadata(handle, bh);
943 BUFFER_TRACE(bh, "not a new buffer");
956 struct buffer_head *ext3_bread(handle_t *handle, struct inode * inode,
957 int block, int create, int *err)
959 struct buffer_head * bh;
961 bh = ext3_getblk(handle, inode, block, create, err);
964 if (buffer_uptodate(bh))
966 ll_rw_block(READ, 1, &bh);
968 if (buffer_uptodate(bh))
975 static int walk_page_buffers( handle_t *handle,
976 struct buffer_head *head,
980 int (*fn)( handle_t *handle,
981 struct buffer_head *bh))
983 struct buffer_head *bh;
984 unsigned block_start, block_end;
985 unsigned blocksize = head->b_size;
987 struct buffer_head *next;
989 for ( bh = head, block_start = 0;
990 ret == 0 && (bh != head || !block_start);
991 block_start = block_end, bh = next)
993 next = bh->b_this_page;
994 block_end = block_start + blocksize;
995 if (block_end <= from || block_start >= to) {
996 if (partial && !buffer_uptodate(bh))
1000 err = (*fn)(handle, bh);
1008 * To preserve ordering, it is essential that the hole instantiation and
1009 * the data write be encapsulated in a single transaction. We cannot
1010 * close off a transaction and start a new one between the ext3_get_block()
1011 * and the commit_write(). So doing the journal_start at the start of
1012 * prepare_write() is the right place.
1014 * Also, this function can nest inside ext3_writepage() ->
1015 * block_write_full_page(). In that case, we *know* that ext3_writepage()
1016 * has generated enough buffer credits to do the whole page. So we won't
1017 * block on the journal in that case, which is good, because the caller may
1020 * By accident, ext3 can be reentered when a transaction is open via
1021 * quota file writes. If we were to commit the transaction while thus
1022 * reentered, there can be a deadlock - we would be holding a quota
1023 * lock, and the commit would never complete if another thread had a
1024 * transaction open and was blocking on the quota lock - a ranking
1027 * So what we do is to rely on the fact that journal_stop/journal_start
1028 * will _not_ run commit under these circumstances because handle->h_ref
1029 * is elevated. We'll still have enough credits for the tiny quotafile
1033 static int do_journal_get_write_access(handle_t *handle,
1034 struct buffer_head *bh)
1036 if (!buffer_mapped(bh) || buffer_freed(bh))
1038 return ext3_journal_get_write_access(handle, bh);
1041 static int ext3_prepare_write(struct file *file, struct page *page,
1042 unsigned from, unsigned to)
1044 struct inode *inode = page->mapping->host;
1045 int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
1050 handle = ext3_journal_start(inode, needed_blocks);
1051 if (IS_ERR(handle)) {
1052 ret = PTR_ERR(handle);
1055 if (test_opt(inode->i_sb, NOBH))
1056 ret = nobh_prepare_write(page, from, to, ext3_get_block);
1058 ret = block_prepare_write(page, from, to, ext3_get_block);
1060 goto prepare_write_failed;
1062 if (ext3_should_journal_data(inode)) {
1063 ret = walk_page_buffers(handle, page_buffers(page),
1064 from, to, NULL, do_journal_get_write_access);
1066 prepare_write_failed:
1068 ext3_journal_stop(handle);
1069 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1076 ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1078 int err = journal_dirty_data(handle, bh);
1080 ext3_journal_abort_handle(__FUNCTION__, __FUNCTION__,
1085 /* For commit_write() in data=journal mode */
1086 static int commit_write_fn(handle_t *handle, struct buffer_head *bh)
1088 if (!buffer_mapped(bh) || buffer_freed(bh))
1090 set_buffer_uptodate(bh);
1091 return ext3_journal_dirty_metadata(handle, bh);
1095 * We need to pick up the new inode size which generic_commit_write gave us
1096 * `file' can be NULL - eg, when called from page_symlink().
1098 * ext3 never places buffers on inode->i_mapping->private_list. metadata
1099 * buffers are managed internally.
1102 static int ext3_ordered_commit_write(struct file *file, struct page *page,
1103 unsigned from, unsigned to)
1105 handle_t *handle = ext3_journal_current_handle();
1106 struct inode *inode = page->mapping->host;
1109 ret = walk_page_buffers(handle, page_buffers(page),
1110 from, to, NULL, ext3_journal_dirty_data);
1114 * generic_commit_write() will run mark_inode_dirty() if i_size
1115 * changes. So let's piggyback the i_disksize mark_inode_dirty
1120 new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1121 if (new_i_size > EXT3_I(inode)->i_disksize)
1122 EXT3_I(inode)->i_disksize = new_i_size;
1123 ret = generic_commit_write(file, page, from, to);
1125 ret2 = ext3_journal_stop(handle);
1131 static int ext3_writeback_commit_write(struct file *file, struct page *page,
1132 unsigned from, unsigned to)
1134 handle_t *handle = ext3_journal_current_handle();
1135 struct inode *inode = page->mapping->host;
1139 new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1140 if (new_i_size > EXT3_I(inode)->i_disksize)
1141 EXT3_I(inode)->i_disksize = new_i_size;
1143 if (test_opt(inode->i_sb, NOBH))
1144 ret = nobh_commit_write(file, page, from, to);
1146 ret = generic_commit_write(file, page, from, to);
1148 ret2 = ext3_journal_stop(handle);
1154 static int ext3_journalled_commit_write(struct file *file,
1155 struct page *page, unsigned from, unsigned to)
1157 handle_t *handle = ext3_journal_current_handle();
1158 struct inode *inode = page->mapping->host;
1164 * Here we duplicate the generic_commit_write() functionality
1166 pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1168 ret = walk_page_buffers(handle, page_buffers(page), from,
1169 to, &partial, commit_write_fn);
1171 SetPageUptodate(page);
1172 if (pos > inode->i_size)
1173 i_size_write(inode, pos);
1174 EXT3_I(inode)->i_state |= EXT3_STATE_JDATA;
1175 if (inode->i_size > EXT3_I(inode)->i_disksize) {
1176 EXT3_I(inode)->i_disksize = inode->i_size;
1177 ret2 = ext3_mark_inode_dirty(handle, inode);
1181 ret2 = ext3_journal_stop(handle);
1188 * bmap() is special. It gets used by applications such as lilo and by
1189 * the swapper to find the on-disk block of a specific piece of data.
1191 * Naturally, this is dangerous if the block concerned is still in the
1192 * journal. If somebody makes a swapfile on an ext3 data-journaling
1193 * filesystem and enables swap, then they may get a nasty shock when the
1194 * data getting swapped to that swapfile suddenly gets overwritten by
1195 * the original zero's written out previously to the journal and
1196 * awaiting writeback in the kernel's buffer cache.
1198 * So, if we see any bmap calls here on a modified, data-journaled file,
1199 * take extra steps to flush any blocks which might be in the cache.
1201 static sector_t ext3_bmap(struct address_space *mapping, sector_t block)
1203 struct inode *inode = mapping->host;
1207 if (EXT3_I(inode)->i_state & EXT3_STATE_JDATA) {
1209 * This is a REALLY heavyweight approach, but the use of
1210 * bmap on dirty files is expected to be extremely rare:
1211 * only if we run lilo or swapon on a freshly made file
1212 * do we expect this to happen.
1214 * (bmap requires CAP_SYS_RAWIO so this does not
1215 * represent an unprivileged user DOS attack --- we'd be
1216 * in trouble if mortal users could trigger this path at
1219 * NB. EXT3_STATE_JDATA is not set on files other than
1220 * regular files. If somebody wants to bmap a directory
1221 * or symlink and gets confused because the buffer
1222 * hasn't yet been flushed to disk, they deserve
1223 * everything they get.
1226 EXT3_I(inode)->i_state &= ~EXT3_STATE_JDATA;
1227 journal = EXT3_JOURNAL(inode);
1228 journal_lock_updates(journal);
1229 err = journal_flush(journal);
1230 journal_unlock_updates(journal);
1236 return generic_block_bmap(mapping,block,ext3_get_block);
1239 static int bget_one(handle_t *handle, struct buffer_head *bh)
1245 static int bput_one(handle_t *handle, struct buffer_head *bh)
1251 static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
1253 if (buffer_mapped(bh))
1254 return ext3_journal_dirty_data(handle, bh);
1259 * Note that we always start a transaction even if we're not journalling
1260 * data. This is to preserve ordering: any hole instantiation within
1261 * __block_write_full_page -> ext3_get_block() should be journalled
1262 * along with the data so we don't crash and then get metadata which
1263 * refers to old data.
1265 * In all journalling modes block_write_full_page() will start the I/O.
1269 * ext3_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1274 * ext3_file_write() -> generic_file_write() -> __alloc_pages() -> ...
1276 * Same applies to ext3_get_block(). We will deadlock on various things like
1277 * lock_journal and i_truncate_mutex.
1279 * Setting PF_MEMALLOC here doesn't work - too many internal memory
1282 * 16May01: If we're reentered then journal_current_handle() will be
1283 * non-zero. We simply *return*.
1285 * 1 July 2001: @@@ FIXME:
1286 * In journalled data mode, a data buffer may be metadata against the
1287 * current transaction. But the same file is part of a shared mapping
1288 * and someone does a writepage() on it.
1290 * We will move the buffer onto the async_data list, but *after* it has
1291 * been dirtied. So there's a small window where we have dirty data on
1294 * Note that this only applies to the last partial page in the file. The
1295 * bit which block_write_full_page() uses prepare/commit for. (That's
1296 * broken code anyway: it's wrong for msync()).
1298 * It's a rare case: affects the final partial page, for journalled data
1299 * where the file is subject to bith write() and writepage() in the same
1300 * transction. To fix it we'll need a custom block_write_full_page().
1301 * We'll probably need that anyway for journalling writepage() output.
1303 * We don't honour synchronous mounts for writepage(). That would be
1304 * disastrous. Any write() or metadata operation will sync the fs for
1307 * AKPM2: if all the page's buffers are mapped to disk and !data=journal,
1308 * we don't need to open a transaction here.
1310 static int ext3_ordered_writepage(struct page *page,
1311 struct writeback_control *wbc)
1313 struct inode *inode = page->mapping->host;
1314 struct buffer_head *page_bufs;
1315 handle_t *handle = NULL;
1319 J_ASSERT(PageLocked(page));
1322 * We give up here if we're reentered, because it might be for a
1323 * different filesystem.
1325 if (ext3_journal_current_handle())
1328 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1330 if (IS_ERR(handle)) {
1331 ret = PTR_ERR(handle);
1335 if (!page_has_buffers(page)) {
1336 create_empty_buffers(page, inode->i_sb->s_blocksize,
1337 (1 << BH_Dirty)|(1 << BH_Uptodate));
1339 page_bufs = page_buffers(page);
1340 walk_page_buffers(handle, page_bufs, 0,
1341 PAGE_CACHE_SIZE, NULL, bget_one);
1343 ret = block_write_full_page(page, ext3_get_block, wbc);
1346 * The page can become unlocked at any point now, and
1347 * truncate can then come in and change things. So we
1348 * can't touch *page from now on. But *page_bufs is
1349 * safe due to elevated refcount.
1353 * And attach them to the current transaction. But only if
1354 * block_write_full_page() succeeded. Otherwise they are unmapped,
1355 * and generally junk.
1358 err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
1359 NULL, journal_dirty_data_fn);
1363 walk_page_buffers(handle, page_bufs, 0,
1364 PAGE_CACHE_SIZE, NULL, bput_one);
1365 err = ext3_journal_stop(handle);
1371 redirty_page_for_writepage(wbc, page);
1376 static int ext3_writeback_writepage(struct page *page,
1377 struct writeback_control *wbc)
1379 struct inode *inode = page->mapping->host;
1380 handle_t *handle = NULL;
1384 if (ext3_journal_current_handle())
1387 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1388 if (IS_ERR(handle)) {
1389 ret = PTR_ERR(handle);
1393 if (test_opt(inode->i_sb, NOBH))
1394 ret = nobh_writepage(page, ext3_get_block, wbc);
1396 ret = block_write_full_page(page, ext3_get_block, wbc);
1398 err = ext3_journal_stop(handle);
1404 redirty_page_for_writepage(wbc, page);
1409 static int ext3_journalled_writepage(struct page *page,
1410 struct writeback_control *wbc)
1412 struct inode *inode = page->mapping->host;
1413 handle_t *handle = NULL;
1417 if (ext3_journal_current_handle())
1420 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1421 if (IS_ERR(handle)) {
1422 ret = PTR_ERR(handle);
1426 if (!page_has_buffers(page) || PageChecked(page)) {
1428 * It's mmapped pagecache. Add buffers and journal it. There
1429 * doesn't seem much point in redirtying the page here.
1431 ClearPageChecked(page);
1432 ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
1435 ext3_journal_stop(handle);
1438 ret = walk_page_buffers(handle, page_buffers(page), 0,
1439 PAGE_CACHE_SIZE, NULL, do_journal_get_write_access);
1441 err = walk_page_buffers(handle, page_buffers(page), 0,
1442 PAGE_CACHE_SIZE, NULL, commit_write_fn);
1445 EXT3_I(inode)->i_state |= EXT3_STATE_JDATA;
1449 * It may be a page full of checkpoint-mode buffers. We don't
1450 * really know unless we go poke around in the buffer_heads.
1451 * But block_write_full_page will do the right thing.
1453 ret = block_write_full_page(page, ext3_get_block, wbc);
1455 err = ext3_journal_stop(handle);
1462 redirty_page_for_writepage(wbc, page);
1468 static int ext3_readpage(struct file *file, struct page *page)
1470 return mpage_readpage(page, ext3_get_block);
1474 ext3_readpages(struct file *file, struct address_space *mapping,
1475 struct list_head *pages, unsigned nr_pages)
1477 return mpage_readpages(mapping, pages, nr_pages, ext3_get_block);
1480 static void ext3_invalidatepage(struct page *page, unsigned long offset)
1482 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1485 * If it's a full truncate we just forget about the pending dirtying
1488 ClearPageChecked(page);
1490 journal_invalidatepage(journal, page, offset);
1493 static int ext3_releasepage(struct page *page, gfp_t wait)
1495 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1497 WARN_ON(PageChecked(page));
1498 if (!page_has_buffers(page))
1500 return journal_try_to_free_buffers(journal, page, wait);
1504 * If the O_DIRECT write will extend the file then add this inode to the
1505 * orphan list. So recovery will truncate it back to the original size
1506 * if the machine crashes during the write.
1508 * If the O_DIRECT write is intantiating holes inside i_size and the machine
1509 * crashes then stale disk data _may_ be exposed inside the file.
1511 static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
1512 const struct iovec *iov, loff_t offset,
1513 unsigned long nr_segs)
1515 struct file *file = iocb->ki_filp;
1516 struct inode *inode = file->f_mapping->host;
1517 struct ext3_inode_info *ei = EXT3_I(inode);
1518 handle_t *handle = NULL;
1521 size_t count = iov_length(iov, nr_segs);
1524 loff_t final_size = offset + count;
1526 handle = ext3_journal_start(inode, DIO_CREDITS);
1527 if (IS_ERR(handle)) {
1528 ret = PTR_ERR(handle);
1531 if (final_size > inode->i_size) {
1532 ret = ext3_orphan_add(handle, inode);
1536 ei->i_disksize = inode->i_size;
1540 ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
1542 ext3_direct_io_get_blocks, NULL);
1545 * Reacquire the handle: ext3_direct_io_get_block() can restart the
1548 handle = journal_current_handle();
1554 if (orphan && inode->i_nlink)
1555 ext3_orphan_del(handle, inode);
1556 if (orphan && ret > 0) {
1557 loff_t end = offset + ret;
1558 if (end > inode->i_size) {
1559 ei->i_disksize = end;
1560 i_size_write(inode, end);
1562 * We're going to return a positive `ret'
1563 * here due to non-zero-length I/O, so there's
1564 * no way of reporting error returns from
1565 * ext3_mark_inode_dirty() to userspace. So
1568 ext3_mark_inode_dirty(handle, inode);
1571 err = ext3_journal_stop(handle);
1580 * Pages can be marked dirty completely asynchronously from ext3's journalling
1581 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
1582 * much here because ->set_page_dirty is called under VFS locks. The page is
1583 * not necessarily locked.
1585 * We cannot just dirty the page and leave attached buffers clean, because the
1586 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
1587 * or jbddirty because all the journalling code will explode.
1589 * So what we do is to mark the page "pending dirty" and next time writepage
1590 * is called, propagate that into the buffers appropriately.
1592 static int ext3_journalled_set_page_dirty(struct page *page)
1594 SetPageChecked(page);
1595 return __set_page_dirty_nobuffers(page);
1598 static struct address_space_operations ext3_ordered_aops = {
1599 .readpage = ext3_readpage,
1600 .readpages = ext3_readpages,
1601 .writepage = ext3_ordered_writepage,
1602 .sync_page = block_sync_page,
1603 .prepare_write = ext3_prepare_write,
1604 .commit_write = ext3_ordered_commit_write,
1606 .invalidatepage = ext3_invalidatepage,
1607 .releasepage = ext3_releasepage,
1608 .direct_IO = ext3_direct_IO,
1609 .migratepage = buffer_migrate_page,
1612 static struct address_space_operations ext3_writeback_aops = {
1613 .readpage = ext3_readpage,
1614 .readpages = ext3_readpages,
1615 .writepage = ext3_writeback_writepage,
1616 .sync_page = block_sync_page,
1617 .prepare_write = ext3_prepare_write,
1618 .commit_write = ext3_writeback_commit_write,
1620 .invalidatepage = ext3_invalidatepage,
1621 .releasepage = ext3_releasepage,
1622 .direct_IO = ext3_direct_IO,
1623 .migratepage = buffer_migrate_page,
1626 static struct address_space_operations ext3_journalled_aops = {
1627 .readpage = ext3_readpage,
1628 .readpages = ext3_readpages,
1629 .writepage = ext3_journalled_writepage,
1630 .sync_page = block_sync_page,
1631 .prepare_write = ext3_prepare_write,
1632 .commit_write = ext3_journalled_commit_write,
1633 .set_page_dirty = ext3_journalled_set_page_dirty,
1635 .invalidatepage = ext3_invalidatepage,
1636 .releasepage = ext3_releasepage,
1639 void ext3_set_aops(struct inode *inode)
1641 if (ext3_should_order_data(inode))
1642 inode->i_mapping->a_ops = &ext3_ordered_aops;
1643 else if (ext3_should_writeback_data(inode))
1644 inode->i_mapping->a_ops = &ext3_writeback_aops;
1646 inode->i_mapping->a_ops = &ext3_journalled_aops;
1650 * ext3_block_truncate_page() zeroes out a mapping from file offset `from'
1651 * up to the end of the block which corresponds to `from'.
1652 * This required during truncate. We need to physically zero the tail end
1653 * of that block so it doesn't yield old data if the file is later grown.
1655 static int ext3_block_truncate_page(handle_t *handle, struct page *page,
1656 struct address_space *mapping, loff_t from)
1658 unsigned long index = from >> PAGE_CACHE_SHIFT;
1659 unsigned offset = from & (PAGE_CACHE_SIZE-1);
1660 unsigned blocksize, iblock, length, pos;
1661 struct inode *inode = mapping->host;
1662 struct buffer_head *bh;
1666 blocksize = inode->i_sb->s_blocksize;
1667 length = blocksize - (offset & (blocksize - 1));
1668 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1671 * For "nobh" option, we can only work if we don't need to
1672 * read-in the page - otherwise we create buffers to do the IO.
1674 if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
1675 ext3_should_writeback_data(inode) && PageUptodate(page)) {
1676 kaddr = kmap_atomic(page, KM_USER0);
1677 memset(kaddr + offset, 0, length);
1678 flush_dcache_page(page);
1679 kunmap_atomic(kaddr, KM_USER0);
1680 set_page_dirty(page);
1684 if (!page_has_buffers(page))
1685 create_empty_buffers(page, blocksize, 0);
1687 /* Find the buffer that contains "offset" */
1688 bh = page_buffers(page);
1690 while (offset >= pos) {
1691 bh = bh->b_this_page;
1697 if (buffer_freed(bh)) {
1698 BUFFER_TRACE(bh, "freed: skip");
1702 if (!buffer_mapped(bh)) {
1703 BUFFER_TRACE(bh, "unmapped");
1704 ext3_get_block(inode, iblock, bh, 0);
1705 /* unmapped? It's a hole - nothing to do */
1706 if (!buffer_mapped(bh)) {
1707 BUFFER_TRACE(bh, "still unmapped");
1712 /* Ok, it's mapped. Make sure it's up-to-date */
1713 if (PageUptodate(page))
1714 set_buffer_uptodate(bh);
1716 if (!buffer_uptodate(bh)) {
1718 ll_rw_block(READ, 1, &bh);
1720 /* Uhhuh. Read error. Complain and punt. */
1721 if (!buffer_uptodate(bh))
1725 if (ext3_should_journal_data(inode)) {
1726 BUFFER_TRACE(bh, "get write access");
1727 err = ext3_journal_get_write_access(handle, bh);
1732 kaddr = kmap_atomic(page, KM_USER0);
1733 memset(kaddr + offset, 0, length);
1734 flush_dcache_page(page);
1735 kunmap_atomic(kaddr, KM_USER0);
1737 BUFFER_TRACE(bh, "zeroed end of block");
1740 if (ext3_should_journal_data(inode)) {
1741 err = ext3_journal_dirty_metadata(handle, bh);
1743 if (ext3_should_order_data(inode))
1744 err = ext3_journal_dirty_data(handle, bh);
1745 mark_buffer_dirty(bh);
1750 page_cache_release(page);
1755 * Probably it should be a library function... search for first non-zero word
1756 * or memcmp with zero_page, whatever is better for particular architecture.
1759 static inline int all_zeroes(__le32 *p, __le32 *q)
1768 * ext3_find_shared - find the indirect blocks for partial truncation.
1769 * @inode: inode in question
1770 * @depth: depth of the affected branch
1771 * @offsets: offsets of pointers in that branch (see ext3_block_to_path)
1772 * @chain: place to store the pointers to partial indirect blocks
1773 * @top: place to the (detached) top of branch
1775 * This is a helper function used by ext3_truncate().
1777 * When we do truncate() we may have to clean the ends of several
1778 * indirect blocks but leave the blocks themselves alive. Block is
1779 * partially truncated if some data below the new i_size is refered
1780 * from it (and it is on the path to the first completely truncated
1781 * data block, indeed). We have to free the top of that path along
1782 * with everything to the right of the path. Since no allocation
1783 * past the truncation point is possible until ext3_truncate()
1784 * finishes, we may safely do the latter, but top of branch may
1785 * require special attention - pageout below the truncation point
1786 * might try to populate it.
1788 * We atomically detach the top of branch from the tree, store the
1789 * block number of its root in *@top, pointers to buffer_heads of
1790 * partially truncated blocks - in @chain[].bh and pointers to
1791 * their last elements that should not be removed - in
1792 * @chain[].p. Return value is the pointer to last filled element
1795 * The work left to caller to do the actual freeing of subtrees:
1796 * a) free the subtree starting from *@top
1797 * b) free the subtrees whose roots are stored in
1798 * (@chain[i].p+1 .. end of @chain[i].bh->b_data)
1799 * c) free the subtrees growing from the inode past the @chain[0].
1800 * (no partially truncated stuff there). */
1802 static Indirect *ext3_find_shared(struct inode *inode,
1808 Indirect *partial, *p;
1812 /* Make k index the deepest non-null offest + 1 */
1813 for (k = depth; k > 1 && !offsets[k-1]; k--)
1815 partial = ext3_get_branch(inode, k, offsets, chain, &err);
1816 /* Writer: pointers */
1818 partial = chain + k-1;
1820 * If the branch acquired continuation since we've looked at it -
1821 * fine, it should all survive and (new) top doesn't belong to us.
1823 if (!partial->key && *partial->p)
1826 for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
1829 * OK, we've found the last block that must survive. The rest of our
1830 * branch should be detached before unlocking. However, if that rest
1831 * of branch is all ours and does not grow immediately from the inode
1832 * it's easier to cheat and just decrement partial->p.
1834 if (p == chain + k - 1 && p > chain) {
1838 /* Nope, don't do this in ext3. Must leave the tree intact */
1847 brelse(partial->bh);
1855 * Zero a number of block pointers in either an inode or an indirect block.
1856 * If we restart the transaction we must again get write access to the
1857 * indirect block for further modification.
1859 * We release `count' blocks on disk, but (last - first) may be greater
1860 * than `count' because there can be holes in there.
1863 ext3_clear_blocks(handle_t *handle, struct inode *inode, struct buffer_head *bh,
1864 unsigned long block_to_free, unsigned long count,
1865 __le32 *first, __le32 *last)
1868 if (try_to_extend_transaction(handle, inode)) {
1870 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
1871 ext3_journal_dirty_metadata(handle, bh);
1873 ext3_mark_inode_dirty(handle, inode);
1874 ext3_journal_test_restart(handle, inode);
1876 BUFFER_TRACE(bh, "retaking write access");
1877 ext3_journal_get_write_access(handle, bh);
1882 * Any buffers which are on the journal will be in memory. We find
1883 * them on the hash table so journal_revoke() will run journal_forget()
1884 * on them. We've already detached each block from the file, so
1885 * bforget() in journal_forget() should be safe.
1887 * AKPM: turn on bforget in journal_forget()!!!
1889 for (p = first; p < last; p++) {
1890 u32 nr = le32_to_cpu(*p);
1892 struct buffer_head *bh;
1895 bh = sb_find_get_block(inode->i_sb, nr);
1896 ext3_forget(handle, 0, inode, bh, nr);
1900 ext3_free_blocks(handle, inode, block_to_free, count);
1904 * ext3_free_data - free a list of data blocks
1905 * @handle: handle for this transaction
1906 * @inode: inode we are dealing with
1907 * @this_bh: indirect buffer_head which contains *@first and *@last
1908 * @first: array of block numbers
1909 * @last: points immediately past the end of array
1911 * We are freeing all blocks refered from that array (numbers are stored as
1912 * little-endian 32-bit) and updating @inode->i_blocks appropriately.
1914 * We accumulate contiguous runs of blocks to free. Conveniently, if these
1915 * blocks are contiguous then releasing them at one time will only affect one
1916 * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
1917 * actually use a lot of journal space.
1919 * @this_bh will be %NULL if @first and @last point into the inode's direct
1922 static void ext3_free_data(handle_t *handle, struct inode *inode,
1923 struct buffer_head *this_bh,
1924 __le32 *first, __le32 *last)
1926 unsigned long block_to_free = 0; /* Starting block # of a run */
1927 unsigned long count = 0; /* Number of blocks in the run */
1928 __le32 *block_to_free_p = NULL; /* Pointer into inode/ind
1931 unsigned long nr; /* Current block # */
1932 __le32 *p; /* Pointer into inode/ind
1933 for current block */
1936 if (this_bh) { /* For indirect block */
1937 BUFFER_TRACE(this_bh, "get_write_access");
1938 err = ext3_journal_get_write_access(handle, this_bh);
1939 /* Important: if we can't update the indirect pointers
1940 * to the blocks, we can't free them. */
1945 for (p = first; p < last; p++) {
1946 nr = le32_to_cpu(*p);
1948 /* accumulate blocks to free if they're contiguous */
1951 block_to_free_p = p;
1953 } else if (nr == block_to_free + count) {
1956 ext3_clear_blocks(handle, inode, this_bh,
1958 count, block_to_free_p, p);
1960 block_to_free_p = p;
1967 ext3_clear_blocks(handle, inode, this_bh, block_to_free,
1968 count, block_to_free_p, p);
1971 BUFFER_TRACE(this_bh, "call ext3_journal_dirty_metadata");
1972 ext3_journal_dirty_metadata(handle, this_bh);
1977 * ext3_free_branches - free an array of branches
1978 * @handle: JBD handle for this transaction
1979 * @inode: inode we are dealing with
1980 * @parent_bh: the buffer_head which contains *@first and *@last
1981 * @first: array of block numbers
1982 * @last: pointer immediately past the end of array
1983 * @depth: depth of the branches to free
1985 * We are freeing all blocks refered from these branches (numbers are
1986 * stored as little-endian 32-bit) and updating @inode->i_blocks
1989 static void ext3_free_branches(handle_t *handle, struct inode *inode,
1990 struct buffer_head *parent_bh,
1991 __le32 *first, __le32 *last, int depth)
1996 if (is_handle_aborted(handle))
2000 struct buffer_head *bh;
2001 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2003 while (--p >= first) {
2004 nr = le32_to_cpu(*p);
2006 continue; /* A hole */
2008 /* Go read the buffer for the next level down */
2009 bh = sb_bread(inode->i_sb, nr);
2012 * A read failure? Report error and clear slot
2016 ext3_error(inode->i_sb, "ext3_free_branches",
2017 "Read failure, inode=%ld, block=%ld",
2022 /* This zaps the entire block. Bottom up. */
2023 BUFFER_TRACE(bh, "free child branches");
2024 ext3_free_branches(handle, inode, bh,
2025 (__le32*)bh->b_data,
2026 (__le32*)bh->b_data + addr_per_block,
2030 * We've probably journalled the indirect block several
2031 * times during the truncate. But it's no longer
2032 * needed and we now drop it from the transaction via
2035 * That's easy if it's exclusively part of this
2036 * transaction. But if it's part of the committing
2037 * transaction then journal_forget() will simply
2038 * brelse() it. That means that if the underlying
2039 * block is reallocated in ext3_get_block(),
2040 * unmap_underlying_metadata() will find this block
2041 * and will try to get rid of it. damn, damn.
2043 * If this block has already been committed to the
2044 * journal, a revoke record will be written. And
2045 * revoke records must be emitted *before* clearing
2046 * this block's bit in the bitmaps.
2048 ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
2051 * Everything below this this pointer has been
2052 * released. Now let this top-of-subtree go.
2054 * We want the freeing of this indirect block to be
2055 * atomic in the journal with the updating of the
2056 * bitmap block which owns it. So make some room in
2059 * We zero the parent pointer *after* freeing its
2060 * pointee in the bitmaps, so if extend_transaction()
2061 * for some reason fails to put the bitmap changes and
2062 * the release into the same transaction, recovery
2063 * will merely complain about releasing a free block,
2064 * rather than leaking blocks.
2066 if (is_handle_aborted(handle))
2068 if (try_to_extend_transaction(handle, inode)) {
2069 ext3_mark_inode_dirty(handle, inode);
2070 ext3_journal_test_restart(handle, inode);
2073 ext3_free_blocks(handle, inode, nr, 1);
2077 * The block which we have just freed is
2078 * pointed to by an indirect block: journal it
2080 BUFFER_TRACE(parent_bh, "get_write_access");
2081 if (!ext3_journal_get_write_access(handle,
2084 BUFFER_TRACE(parent_bh,
2085 "call ext3_journal_dirty_metadata");
2086 ext3_journal_dirty_metadata(handle,
2092 /* We have reached the bottom of the tree. */
2093 BUFFER_TRACE(parent_bh, "free data blocks");
2094 ext3_free_data(handle, inode, parent_bh, first, last);
2101 * We block out ext3_get_block() block instantiations across the entire
2102 * transaction, and VFS/VM ensures that ext3_truncate() cannot run
2103 * simultaneously on behalf of the same inode.
2105 * As we work through the truncate and commmit bits of it to the journal there
2106 * is one core, guiding principle: the file's tree must always be consistent on
2107 * disk. We must be able to restart the truncate after a crash.
2109 * The file's tree may be transiently inconsistent in memory (although it
2110 * probably isn't), but whenever we close off and commit a journal transaction,
2111 * the contents of (the filesystem + the journal) must be consistent and
2112 * restartable. It's pretty simple, really: bottom up, right to left (although
2113 * left-to-right works OK too).
2115 * Note that at recovery time, journal replay occurs *before* the restart of
2116 * truncate against the orphan inode list.
2118 * The committed inode has the new, desired i_size (which is the same as
2119 * i_disksize in this case). After a crash, ext3_orphan_cleanup() will see
2120 * that this inode's truncate did not complete and it will again call
2121 * ext3_truncate() to have another go. So there will be instantiated blocks
2122 * to the right of the truncation point in a crashed ext3 filesystem. But
2123 * that's fine - as long as they are linked from the inode, the post-crash
2124 * ext3_truncate() run will find them and release them.
2127 void ext3_truncate(struct inode * inode)
2130 struct ext3_inode_info *ei = EXT3_I(inode);
2131 __le32 *i_data = ei->i_data;
2132 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2133 struct address_space *mapping = inode->i_mapping;
2140 unsigned blocksize = inode->i_sb->s_blocksize;
2143 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
2144 S_ISLNK(inode->i_mode)))
2146 if (ext3_inode_is_fast_symlink(inode))
2148 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2152 * We have to lock the EOF page here, because lock_page() nests
2153 * outside journal_start().
2155 if ((inode->i_size & (blocksize - 1)) == 0) {
2156 /* Block boundary? Nothing to do */
2159 page = grab_cache_page(mapping,
2160 inode->i_size >> PAGE_CACHE_SHIFT);
2165 handle = start_transaction(inode);
2166 if (IS_ERR(handle)) {
2168 clear_highpage(page);
2169 flush_dcache_page(page);
2171 page_cache_release(page);
2173 return; /* AKPM: return what? */
2176 last_block = (inode->i_size + blocksize-1)
2177 >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
2180 ext3_block_truncate_page(handle, page, mapping, inode->i_size);
2182 n = ext3_block_to_path(inode, last_block, offsets, NULL);
2184 goto out_stop; /* error */
2187 * OK. This truncate is going to happen. We add the inode to the
2188 * orphan list, so that if this truncate spans multiple transactions,
2189 * and we crash, we will resume the truncate when the filesystem
2190 * recovers. It also marks the inode dirty, to catch the new size.
2192 * Implication: the file must always be in a sane, consistent
2193 * truncatable state while each transaction commits.
2195 if (ext3_orphan_add(handle, inode))
2199 * The orphan list entry will now protect us from any crash which
2200 * occurs before the truncate completes, so it is now safe to propagate
2201 * the new, shorter inode size (held for now in i_size) into the
2202 * on-disk inode. We do this via i_disksize, which is the value which
2203 * ext3 *really* writes onto the disk inode.
2205 ei->i_disksize = inode->i_size;
2208 * From here we block out all ext3_get_block() callers who want to
2209 * modify the block allocation tree.
2211 mutex_lock(&ei->truncate_mutex);
2213 if (n == 1) { /* direct blocks */
2214 ext3_free_data(handle, inode, NULL, i_data+offsets[0],
2215 i_data + EXT3_NDIR_BLOCKS);
2219 partial = ext3_find_shared(inode, n, offsets, chain, &nr);
2220 /* Kill the top of shared branch (not detached) */
2222 if (partial == chain) {
2223 /* Shared branch grows from the inode */
2224 ext3_free_branches(handle, inode, NULL,
2225 &nr, &nr+1, (chain+n-1) - partial);
2228 * We mark the inode dirty prior to restart,
2229 * and prior to stop. No need for it here.
2232 /* Shared branch grows from an indirect block */
2233 BUFFER_TRACE(partial->bh, "get_write_access");
2234 ext3_free_branches(handle, inode, partial->bh,
2236 partial->p+1, (chain+n-1) - partial);
2239 /* Clear the ends of indirect blocks on the shared branch */
2240 while (partial > chain) {
2241 ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2242 (__le32*)partial->bh->b_data+addr_per_block,
2243 (chain+n-1) - partial);
2244 BUFFER_TRACE(partial->bh, "call brelse");
2245 brelse (partial->bh);
2249 /* Kill the remaining (whole) subtrees */
2250 switch (offsets[0]) {
2252 nr = i_data[EXT3_IND_BLOCK];
2254 ext3_free_branches(handle, inode, NULL,
2256 i_data[EXT3_IND_BLOCK] = 0;
2258 case EXT3_IND_BLOCK:
2259 nr = i_data[EXT3_DIND_BLOCK];
2261 ext3_free_branches(handle, inode, NULL,
2263 i_data[EXT3_DIND_BLOCK] = 0;
2265 case EXT3_DIND_BLOCK:
2266 nr = i_data[EXT3_TIND_BLOCK];
2268 ext3_free_branches(handle, inode, NULL,
2270 i_data[EXT3_TIND_BLOCK] = 0;
2272 case EXT3_TIND_BLOCK:
2276 ext3_discard_reservation(inode);
2278 mutex_unlock(&ei->truncate_mutex);
2279 inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
2280 ext3_mark_inode_dirty(handle, inode);
2282 /* In a multi-transaction truncate, we only make the final
2283 * transaction synchronous */
2288 * If this was a simple ftruncate(), and the file will remain alive
2289 * then we need to clear up the orphan record which we created above.
2290 * However, if this was a real unlink then we were called by
2291 * ext3_delete_inode(), and we allow that function to clean up the
2292 * orphan info for us.
2295 ext3_orphan_del(handle, inode);
2297 ext3_journal_stop(handle);
2300 static unsigned long ext3_get_inode_block(struct super_block *sb,
2301 unsigned long ino, struct ext3_iloc *iloc)
2303 unsigned long desc, group_desc, block_group;
2304 unsigned long offset, block;
2305 struct buffer_head *bh;
2306 struct ext3_group_desc * gdp;
2309 if ((ino != EXT3_ROOT_INO &&
2310 ino != EXT3_JOURNAL_INO &&
2311 ino != EXT3_RESIZE_INO &&
2312 ino < EXT3_FIRST_INO(sb)) ||
2314 EXT3_SB(sb)->s_es->s_inodes_count)) {
2315 ext3_error (sb, "ext3_get_inode_block",
2316 "bad inode number: %lu", ino);
2319 block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
2320 if (block_group >= EXT3_SB(sb)->s_groups_count) {
2321 ext3_error (sb, "ext3_get_inode_block",
2322 "group >= groups count");
2326 group_desc = block_group >> EXT3_DESC_PER_BLOCK_BITS(sb);
2327 desc = block_group & (EXT3_DESC_PER_BLOCK(sb) - 1);
2328 bh = EXT3_SB(sb)->s_group_desc[group_desc];
2330 ext3_error (sb, "ext3_get_inode_block",
2331 "Descriptor not loaded");
2335 gdp = (struct ext3_group_desc *) bh->b_data;
2337 * Figure out the offset within the block group inode table
2339 offset = ((ino - 1) % EXT3_INODES_PER_GROUP(sb)) *
2340 EXT3_INODE_SIZE(sb);
2341 block = le32_to_cpu(gdp[desc].bg_inode_table) +
2342 (offset >> EXT3_BLOCK_SIZE_BITS(sb));
2344 iloc->block_group = block_group;
2345 iloc->offset = offset & (EXT3_BLOCK_SIZE(sb) - 1);
2350 * ext3_get_inode_loc returns with an extra refcount against the inode's
2351 * underlying buffer_head on success. If 'in_mem' is true, we have all
2352 * data in memory that is needed to recreate the on-disk version of this
2355 static int __ext3_get_inode_loc(struct inode *inode,
2356 struct ext3_iloc *iloc, int in_mem)
2358 unsigned long block;
2359 struct buffer_head *bh;
2361 block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
2365 bh = sb_getblk(inode->i_sb, block);
2367 ext3_error (inode->i_sb, "ext3_get_inode_loc",
2368 "unable to read inode block - "
2369 "inode=%lu, block=%lu", inode->i_ino, block);
2372 if (!buffer_uptodate(bh)) {
2374 if (buffer_uptodate(bh)) {
2375 /* someone brought it uptodate while we waited */
2381 * If we have all information of the inode in memory and this
2382 * is the only valid inode in the block, we need not read the
2386 struct buffer_head *bitmap_bh;
2387 struct ext3_group_desc *desc;
2388 int inodes_per_buffer;
2389 int inode_offset, i;
2393 block_group = (inode->i_ino - 1) /
2394 EXT3_INODES_PER_GROUP(inode->i_sb);
2395 inodes_per_buffer = bh->b_size /
2396 EXT3_INODE_SIZE(inode->i_sb);
2397 inode_offset = ((inode->i_ino - 1) %
2398 EXT3_INODES_PER_GROUP(inode->i_sb));
2399 start = inode_offset & ~(inodes_per_buffer - 1);
2401 /* Is the inode bitmap in cache? */
2402 desc = ext3_get_group_desc(inode->i_sb,
2407 bitmap_bh = sb_getblk(inode->i_sb,
2408 le32_to_cpu(desc->bg_inode_bitmap));
2413 * If the inode bitmap isn't in cache then the
2414 * optimisation may end up performing two reads instead
2415 * of one, so skip it.
2417 if (!buffer_uptodate(bitmap_bh)) {
2421 for (i = start; i < start + inodes_per_buffer; i++) {
2422 if (i == inode_offset)
2424 if (ext3_test_bit(i, bitmap_bh->b_data))
2428 if (i == start + inodes_per_buffer) {
2429 /* all other inodes are free, so skip I/O */
2430 memset(bh->b_data, 0, bh->b_size);
2431 set_buffer_uptodate(bh);
2439 * There are other valid inodes in the buffer, this inode
2440 * has in-inode xattrs, or we don't have this inode in memory.
2441 * Read the block from disk.
2444 bh->b_end_io = end_buffer_read_sync;
2445 submit_bh(READ, bh);
2447 if (!buffer_uptodate(bh)) {
2448 ext3_error(inode->i_sb, "ext3_get_inode_loc",
2449 "unable to read inode block - "
2450 "inode=%lu, block=%lu",
2451 inode->i_ino, block);
2461 int ext3_get_inode_loc(struct inode *inode, struct ext3_iloc *iloc)
2463 /* We have all inode data except xattrs in memory here. */
2464 return __ext3_get_inode_loc(inode, iloc,
2465 !(EXT3_I(inode)->i_state & EXT3_STATE_XATTR));
2468 void ext3_set_inode_flags(struct inode *inode)
2470 unsigned int flags = EXT3_I(inode)->i_flags;
2472 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
2473 if (flags & EXT3_SYNC_FL)
2474 inode->i_flags |= S_SYNC;
2475 if (flags & EXT3_APPEND_FL)
2476 inode->i_flags |= S_APPEND;
2477 if (flags & EXT3_IMMUTABLE_FL)
2478 inode->i_flags |= S_IMMUTABLE;
2479 if (flags & EXT3_NOATIME_FL)
2480 inode->i_flags |= S_NOATIME;
2481 if (flags & EXT3_DIRSYNC_FL)
2482 inode->i_flags |= S_DIRSYNC;
2485 void ext3_read_inode(struct inode * inode)
2487 struct ext3_iloc iloc;
2488 struct ext3_inode *raw_inode;
2489 struct ext3_inode_info *ei = EXT3_I(inode);
2490 struct buffer_head *bh;
2493 #ifdef CONFIG_EXT3_FS_POSIX_ACL
2494 ei->i_acl = EXT3_ACL_NOT_CACHED;
2495 ei->i_default_acl = EXT3_ACL_NOT_CACHED;
2497 ei->i_block_alloc_info = NULL;
2499 if (__ext3_get_inode_loc(inode, &iloc, 0))
2502 raw_inode = ext3_raw_inode(&iloc);
2503 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
2504 inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
2505 inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
2506 if(!(test_opt (inode->i_sb, NO_UID32))) {
2507 inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
2508 inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
2510 inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
2511 inode->i_size = le32_to_cpu(raw_inode->i_size);
2512 inode->i_atime.tv_sec = le32_to_cpu(raw_inode->i_atime);
2513 inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->i_ctime);
2514 inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->i_mtime);
2515 inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
2518 ei->i_dir_start_lookup = 0;
2519 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
2520 /* We now have enough fields to check if the inode was active or not.
2521 * This is needed because nfsd might try to access dead inodes
2522 * the test is that same one that e2fsck uses
2523 * NeilBrown 1999oct15
2525 if (inode->i_nlink == 0) {
2526 if (inode->i_mode == 0 ||
2527 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
2528 /* this inode is deleted */
2532 /* The only unlinked inodes we let through here have
2533 * valid i_mode and are being read by the orphan
2534 * recovery code: that's fine, we're about to complete
2535 * the process of deleting those. */
2537 inode->i_blksize = PAGE_SIZE; /* This is the optimal IO size
2538 * (for stat), not the fs block
2540 inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
2541 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
2542 #ifdef EXT3_FRAGMENTS
2543 ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
2544 ei->i_frag_no = raw_inode->i_frag;
2545 ei->i_frag_size = raw_inode->i_fsize;
2547 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
2548 if (!S_ISREG(inode->i_mode)) {
2549 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
2552 ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
2554 ei->i_disksize = inode->i_size;
2555 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
2556 ei->i_block_group = iloc.block_group;
2558 * NOTE! The in-memory inode i_data array is in little-endian order
2559 * even on big-endian machines: we do NOT byteswap the block numbers!
2561 for (block = 0; block < EXT3_N_BLOCKS; block++)
2562 ei->i_data[block] = raw_inode->i_block[block];
2563 INIT_LIST_HEAD(&ei->i_orphan);
2565 if (inode->i_ino >= EXT3_FIRST_INO(inode->i_sb) + 1 &&
2566 EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) {
2568 * When mke2fs creates big inodes it does not zero out
2569 * the unused bytes above EXT3_GOOD_OLD_INODE_SIZE,
2570 * so ignore those first few inodes.
2572 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
2573 if (EXT3_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
2574 EXT3_INODE_SIZE(inode->i_sb))
2576 if (ei->i_extra_isize == 0) {
2577 /* The extra space is currently unused. Use it. */
2578 ei->i_extra_isize = sizeof(struct ext3_inode) -
2579 EXT3_GOOD_OLD_INODE_SIZE;
2581 __le32 *magic = (void *)raw_inode +
2582 EXT3_GOOD_OLD_INODE_SIZE +
2584 if (*magic == cpu_to_le32(EXT3_XATTR_MAGIC))
2585 ei->i_state |= EXT3_STATE_XATTR;
2588 ei->i_extra_isize = 0;
2590 if (S_ISREG(inode->i_mode)) {
2591 inode->i_op = &ext3_file_inode_operations;
2592 inode->i_fop = &ext3_file_operations;
2593 ext3_set_aops(inode);
2594 } else if (S_ISDIR(inode->i_mode)) {
2595 inode->i_op = &ext3_dir_inode_operations;
2596 inode->i_fop = &ext3_dir_operations;
2597 } else if (S_ISLNK(inode->i_mode)) {
2598 if (ext3_inode_is_fast_symlink(inode))
2599 inode->i_op = &ext3_fast_symlink_inode_operations;
2601 inode->i_op = &ext3_symlink_inode_operations;
2602 ext3_set_aops(inode);
2605 inode->i_op = &ext3_special_inode_operations;
2606 if (raw_inode->i_block[0])
2607 init_special_inode(inode, inode->i_mode,
2608 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
2610 init_special_inode(inode, inode->i_mode,
2611 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
2614 ext3_set_inode_flags(inode);
2618 make_bad_inode(inode);
2623 * Post the struct inode info into an on-disk inode location in the
2624 * buffer-cache. This gobbles the caller's reference to the
2625 * buffer_head in the inode location struct.
2627 * The caller must have write access to iloc->bh.
2629 static int ext3_do_update_inode(handle_t *handle,
2630 struct inode *inode,
2631 struct ext3_iloc *iloc)
2633 struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
2634 struct ext3_inode_info *ei = EXT3_I(inode);
2635 struct buffer_head *bh = iloc->bh;
2636 int err = 0, rc, block;
2638 /* For fields not not tracking in the in-memory inode,
2639 * initialise them to zero for new inodes. */
2640 if (ei->i_state & EXT3_STATE_NEW)
2641 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
2643 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
2644 if(!(test_opt(inode->i_sb, NO_UID32))) {
2645 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
2646 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
2648 * Fix up interoperability with old kernels. Otherwise, old inodes get
2649 * re-used with the upper 16 bits of the uid/gid intact
2652 raw_inode->i_uid_high =
2653 cpu_to_le16(high_16_bits(inode->i_uid));
2654 raw_inode->i_gid_high =
2655 cpu_to_le16(high_16_bits(inode->i_gid));
2657 raw_inode->i_uid_high = 0;
2658 raw_inode->i_gid_high = 0;
2661 raw_inode->i_uid_low =
2662 cpu_to_le16(fs_high2lowuid(inode->i_uid));
2663 raw_inode->i_gid_low =
2664 cpu_to_le16(fs_high2lowgid(inode->i_gid));
2665 raw_inode->i_uid_high = 0;
2666 raw_inode->i_gid_high = 0;
2668 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
2669 raw_inode->i_size = cpu_to_le32(ei->i_disksize);
2670 raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
2671 raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
2672 raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
2673 raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
2674 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
2675 raw_inode->i_flags = cpu_to_le32(ei->i_flags);
2676 #ifdef EXT3_FRAGMENTS
2677 raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
2678 raw_inode->i_frag = ei->i_frag_no;
2679 raw_inode->i_fsize = ei->i_frag_size;
2681 raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
2682 if (!S_ISREG(inode->i_mode)) {
2683 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
2685 raw_inode->i_size_high =
2686 cpu_to_le32(ei->i_disksize >> 32);
2687 if (ei->i_disksize > 0x7fffffffULL) {
2688 struct super_block *sb = inode->i_sb;
2689 if (!EXT3_HAS_RO_COMPAT_FEATURE(sb,
2690 EXT3_FEATURE_RO_COMPAT_LARGE_FILE) ||
2691 EXT3_SB(sb)->s_es->s_rev_level ==
2692 cpu_to_le32(EXT3_GOOD_OLD_REV)) {
2693 /* If this is the first large file
2694 * created, add a flag to the superblock.
2696 err = ext3_journal_get_write_access(handle,
2697 EXT3_SB(sb)->s_sbh);
2700 ext3_update_dynamic_rev(sb);
2701 EXT3_SET_RO_COMPAT_FEATURE(sb,
2702 EXT3_FEATURE_RO_COMPAT_LARGE_FILE);
2705 err = ext3_journal_dirty_metadata(handle,
2706 EXT3_SB(sb)->s_sbh);
2710 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
2711 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
2712 if (old_valid_dev(inode->i_rdev)) {
2713 raw_inode->i_block[0] =
2714 cpu_to_le32(old_encode_dev(inode->i_rdev));
2715 raw_inode->i_block[1] = 0;
2717 raw_inode->i_block[0] = 0;
2718 raw_inode->i_block[1] =
2719 cpu_to_le32(new_encode_dev(inode->i_rdev));
2720 raw_inode->i_block[2] = 0;
2722 } else for (block = 0; block < EXT3_N_BLOCKS; block++)
2723 raw_inode->i_block[block] = ei->i_data[block];
2725 if (ei->i_extra_isize)
2726 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
2728 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2729 rc = ext3_journal_dirty_metadata(handle, bh);
2732 ei->i_state &= ~EXT3_STATE_NEW;
2736 ext3_std_error(inode->i_sb, err);
2741 * ext3_write_inode()
2743 * We are called from a few places:
2745 * - Within generic_file_write() for O_SYNC files.
2746 * Here, there will be no transaction running. We wait for any running
2747 * trasnaction to commit.
2749 * - Within sys_sync(), kupdate and such.
2750 * We wait on commit, if tol to.
2752 * - Within prune_icache() (PF_MEMALLOC == true)
2753 * Here we simply return. We can't afford to block kswapd on the
2756 * In all cases it is actually safe for us to return without doing anything,
2757 * because the inode has been copied into a raw inode buffer in
2758 * ext3_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
2761 * Note that we are absolutely dependent upon all inode dirtiers doing the
2762 * right thing: they *must* call mark_inode_dirty() after dirtying info in
2763 * which we are interested.
2765 * It would be a bug for them to not do this. The code:
2767 * mark_inode_dirty(inode)
2769 * inode->i_size = expr;
2771 * is in error because a kswapd-driven write_inode() could occur while
2772 * `stuff()' is running, and the new i_size will be lost. Plus the inode
2773 * will no longer be on the superblock's dirty inode list.
2775 int ext3_write_inode(struct inode *inode, int wait)
2777 if (current->flags & PF_MEMALLOC)
2780 if (ext3_journal_current_handle()) {
2781 jbd_debug(0, "called recursively, non-PF_MEMALLOC!\n");
2789 return ext3_force_commit(inode->i_sb);
2795 * Called from notify_change.
2797 * We want to trap VFS attempts to truncate the file as soon as
2798 * possible. In particular, we want to make sure that when the VFS
2799 * shrinks i_size, we put the inode on the orphan list and modify
2800 * i_disksize immediately, so that during the subsequent flushing of
2801 * dirty pages and freeing of disk blocks, we can guarantee that any
2802 * commit will leave the blocks being flushed in an unused state on
2803 * disk. (On recovery, the inode will get truncated and the blocks will
2804 * be freed, so we have a strong guarantee that no future commit will
2805 * leave these blocks visible to the user.)
2807 * Called with inode->sem down.
2809 int ext3_setattr(struct dentry *dentry, struct iattr *attr)
2811 struct inode *inode = dentry->d_inode;
2813 const unsigned int ia_valid = attr->ia_valid;
2815 error = inode_change_ok(inode, attr);
2819 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2820 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
2823 /* (user+group)*(old+new) structure, inode write (sb,
2824 * inode block, ? - but truncate inode update has it) */
2825 handle = ext3_journal_start(inode, 2*(EXT3_QUOTA_INIT_BLOCKS(inode->i_sb)+
2826 EXT3_QUOTA_DEL_BLOCKS(inode->i_sb))+3);
2827 if (IS_ERR(handle)) {
2828 error = PTR_ERR(handle);
2831 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2833 ext3_journal_stop(handle);
2836 /* Update corresponding info in inode so that everything is in
2837 * one transaction */
2838 if (attr->ia_valid & ATTR_UID)
2839 inode->i_uid = attr->ia_uid;
2840 if (attr->ia_valid & ATTR_GID)
2841 inode->i_gid = attr->ia_gid;
2842 error = ext3_mark_inode_dirty(handle, inode);
2843 ext3_journal_stop(handle);
2846 if (S_ISREG(inode->i_mode) &&
2847 attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
2850 handle = ext3_journal_start(inode, 3);
2851 if (IS_ERR(handle)) {
2852 error = PTR_ERR(handle);
2856 error = ext3_orphan_add(handle, inode);
2857 EXT3_I(inode)->i_disksize = attr->ia_size;
2858 rc = ext3_mark_inode_dirty(handle, inode);
2861 ext3_journal_stop(handle);
2864 rc = inode_setattr(inode, attr);
2866 /* If inode_setattr's call to ext3_truncate failed to get a
2867 * transaction handle at all, we need to clean up the in-core
2868 * orphan list manually. */
2870 ext3_orphan_del(NULL, inode);
2872 if (!rc && (ia_valid & ATTR_MODE))
2873 rc = ext3_acl_chmod(inode);
2876 ext3_std_error(inode->i_sb, error);
2884 * akpm: how many blocks doth make a writepage()?
2886 * With N blocks per page, it may be:
2891 * N+5 bitmap blocks (from the above)
2892 * N+5 group descriptor summary blocks
2895 * 2 * EXT3_SINGLEDATA_TRANS_BLOCKS for the quote files
2897 * 3 * (N + 5) + 2 + 2 * EXT3_SINGLEDATA_TRANS_BLOCKS
2899 * With ordered or writeback data it's the same, less the N data blocks.
2901 * If the inode's direct blocks can hold an integral number of pages then a
2902 * page cannot straddle two indirect blocks, and we can only touch one indirect
2903 * and dindirect block, and the "5" above becomes "3".
2905 * This still overestimates under most circumstances. If we were to pass the
2906 * start and end offsets in here as well we could do block_to_path() on each
2907 * block and work out the exact number of indirects which are touched. Pah.
2910 static int ext3_writepage_trans_blocks(struct inode *inode)
2912 int bpp = ext3_journal_blocks_per_page(inode);
2913 int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
2916 if (ext3_should_journal_data(inode))
2917 ret = 3 * (bpp + indirects) + 2;
2919 ret = 2 * (bpp + indirects) + 2;
2922 /* We know that structure was already allocated during DQUOT_INIT so
2923 * we will be updating only the data blocks + inodes */
2924 ret += 2*EXT3_QUOTA_TRANS_BLOCKS(inode->i_sb);
2931 * The caller must have previously called ext3_reserve_inode_write().
2932 * Give this, we know that the caller already has write access to iloc->bh.
2934 int ext3_mark_iloc_dirty(handle_t *handle,
2935 struct inode *inode, struct ext3_iloc *iloc)
2939 /* the do_update_inode consumes one bh->b_count */
2942 /* ext3_do_update_inode() does journal_dirty_metadata */
2943 err = ext3_do_update_inode(handle, inode, iloc);
2949 * On success, We end up with an outstanding reference count against
2950 * iloc->bh. This _must_ be cleaned up later.
2954 ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
2955 struct ext3_iloc *iloc)
2959 err = ext3_get_inode_loc(inode, iloc);
2961 BUFFER_TRACE(iloc->bh, "get_write_access");
2962 err = ext3_journal_get_write_access(handle, iloc->bh);
2969 ext3_std_error(inode->i_sb, err);
2974 * akpm: What we do here is to mark the in-core inode as clean
2975 * with respect to inode dirtiness (it may still be data-dirty).
2976 * This means that the in-core inode may be reaped by prune_icache
2977 * without having to perform any I/O. This is a very good thing,
2978 * because *any* task may call prune_icache - even ones which
2979 * have a transaction open against a different journal.
2981 * Is this cheating? Not really. Sure, we haven't written the
2982 * inode out, but prune_icache isn't a user-visible syncing function.
2983 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
2984 * we start and wait on commits.
2986 * Is this efficient/effective? Well, we're being nice to the system
2987 * by cleaning up our inodes proactively so they can be reaped
2988 * without I/O. But we are potentially leaving up to five seconds'
2989 * worth of inodes floating about which prune_icache wants us to
2990 * write out. One way to fix that would be to get prune_icache()
2991 * to do a write_super() to free up some memory. It has the desired
2994 int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
2996 struct ext3_iloc iloc;
3000 err = ext3_reserve_inode_write(handle, inode, &iloc);
3002 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
3007 * akpm: ext3_dirty_inode() is called from __mark_inode_dirty()
3009 * We're really interested in the case where a file is being extended.
3010 * i_size has been changed by generic_commit_write() and we thus need
3011 * to include the updated inode in the current transaction.
3013 * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks
3014 * are allocated to the file.
3016 * If the inode is marked synchronous, we don't honour that here - doing
3017 * so would cause a commit on atime updates, which we don't bother doing.
3018 * We handle synchronous inodes at the highest possible level.
3020 void ext3_dirty_inode(struct inode *inode)
3022 handle_t *current_handle = ext3_journal_current_handle();
3025 handle = ext3_journal_start(inode, 2);
3028 if (current_handle &&
3029 current_handle->h_transaction != handle->h_transaction) {
3030 /* This task has a transaction open against a different fs */
3031 printk(KERN_EMERG "%s: transactions do not match!\n",
3034 jbd_debug(5, "marking dirty. outer handle=%p\n",
3036 ext3_mark_inode_dirty(handle, inode);
3038 ext3_journal_stop(handle);
3045 * Bind an inode's backing buffer_head into this transaction, to prevent
3046 * it from being flushed to disk early. Unlike
3047 * ext3_reserve_inode_write, this leaves behind no bh reference and
3048 * returns no iloc structure, so the caller needs to repeat the iloc
3049 * lookup to mark the inode dirty later.
3052 ext3_pin_inode(handle_t *handle, struct inode *inode)
3054 struct ext3_iloc iloc;
3058 err = ext3_get_inode_loc(inode, &iloc);
3060 BUFFER_TRACE(iloc.bh, "get_write_access");
3061 err = journal_get_write_access(handle, iloc.bh);
3063 err = ext3_journal_dirty_metadata(handle,
3068 ext3_std_error(inode->i_sb, err);
3073 int ext3_change_inode_journal_flag(struct inode *inode, int val)
3080 * We have to be very careful here: changing a data block's
3081 * journaling status dynamically is dangerous. If we write a
3082 * data block to the journal, change the status and then delete
3083 * that block, we risk forgetting to revoke the old log record
3084 * from the journal and so a subsequent replay can corrupt data.
3085 * So, first we make sure that the journal is empty and that
3086 * nobody is changing anything.
3089 journal = EXT3_JOURNAL(inode);
3090 if (is_journal_aborted(journal) || IS_RDONLY(inode))
3093 journal_lock_updates(journal);
3094 journal_flush(journal);
3097 * OK, there are no updates running now, and all cached data is
3098 * synced to disk. We are now in a completely consistent state
3099 * which doesn't have anything in the journal, and we know that
3100 * no filesystem updates are running, so it is safe to modify
3101 * the inode's in-core data-journaling state flag now.
3105 EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
3107 EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
3108 ext3_set_aops(inode);
3110 journal_unlock_updates(journal);
3112 /* Finally we can mark the inode as dirty. */
3114 handle = ext3_journal_start(inode, 1);
3116 return PTR_ERR(handle);
3118 err = ext3_mark_inode_dirty(handle, inode);
3120 ext3_journal_stop(handle);
3121 ext3_std_error(inode->i_sb, err);