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>
43 static int ext3_writepage_trans_blocks(struct inode *inode);
46 * Test whether an inode is a fast symlink.
48 static inline int ext3_inode_is_fast_symlink(struct inode *inode)
50 int ea_blocks = EXT3_I(inode)->i_file_acl ?
51 (inode->i_sb->s_blocksize >> 9) : 0;
53 return (S_ISLNK(inode->i_mode) &&
54 inode->i_blocks - ea_blocks == 0);
57 /* The ext3 forget function must perform a revoke if we are freeing data
58 * which has been journaled. Metadata (eg. indirect blocks) must be
59 * revoked in all cases.
61 * "bh" may be NULL: a metadata block may have been freed from memory
62 * but there may still be a record of it in the journal, and that record
63 * still needs to be revoked.
66 int ext3_forget(handle_t *handle, int is_metadata,
67 struct inode *inode, struct buffer_head *bh,
74 BUFFER_TRACE(bh, "enter");
76 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
78 bh, is_metadata, inode->i_mode,
79 test_opt(inode->i_sb, DATA_FLAGS));
81 /* Never use the revoke function if we are doing full data
82 * journaling: there is no need to, and a V1 superblock won't
83 * support it. Otherwise, only skip the revoke on un-journaled
86 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ||
87 (!is_metadata && !ext3_should_journal_data(inode))) {
89 BUFFER_TRACE(bh, "call journal_forget");
90 return ext3_journal_forget(handle, bh);
96 * data!=journal && (is_metadata || should_journal_data(inode))
98 BUFFER_TRACE(bh, "call ext3_journal_revoke");
99 err = ext3_journal_revoke(handle, blocknr, bh);
101 ext3_abort(inode->i_sb, __FUNCTION__,
102 "error %d when attempting revoke", err);
103 BUFFER_TRACE(bh, "exit");
108 * Work out how many blocks we need to progress with the next chunk of a
109 * truncate transaction.
112 static unsigned long blocks_for_truncate(struct inode *inode)
114 unsigned long needed;
116 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
118 /* Give ourselves just enough room to cope with inodes in which
119 * i_blocks is corrupt: we've seen disk corruptions in the past
120 * which resulted in random data in an inode which looked enough
121 * like a regular file for ext3 to try to delete it. Things
122 * will go a bit crazy if that happens, but at least we should
123 * try not to panic the whole kernel. */
127 /* But we need to bound the transaction so we don't overflow the
129 if (needed > EXT3_MAX_TRANS_DATA)
130 needed = EXT3_MAX_TRANS_DATA;
132 return EXT3_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
136 * Truncate transactions can be complex and absolutely huge. So we need to
137 * be able to restart the transaction at a conventient checkpoint to make
138 * sure we don't overflow the journal.
140 * start_transaction gets us a new handle for a truncate transaction,
141 * and extend_transaction tries to extend the existing one a bit. If
142 * extend fails, we need to propagate the failure up and restart the
143 * transaction in the top-level truncate loop. --sct
146 static handle_t *start_transaction(struct inode *inode)
150 result = ext3_journal_start(inode, blocks_for_truncate(inode));
154 ext3_std_error(inode->i_sb, PTR_ERR(result));
159 * Try to extend this transaction for the purposes of truncation.
161 * Returns 0 if we managed to create more room. If we can't create more
162 * room, and the transaction must be restarted we return 1.
164 static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
166 if (handle->h_buffer_credits > EXT3_RESERVE_TRANS_BLOCKS)
168 if (!ext3_journal_extend(handle, blocks_for_truncate(inode)))
174 * Restart the transaction associated with *handle. This does a commit,
175 * so before we call here everything must be consistently dirtied against
178 static int ext3_journal_test_restart(handle_t *handle, struct inode *inode)
180 jbd_debug(2, "restarting handle %p\n", handle);
181 return ext3_journal_restart(handle, blocks_for_truncate(inode));
185 * Called at the last iput() if i_nlink is zero.
187 void ext3_delete_inode (struct inode * inode)
191 truncate_inode_pages(&inode->i_data, 0);
193 if (is_bad_inode(inode))
196 handle = start_transaction(inode);
197 if (IS_ERR(handle)) {
198 /* If we're going to skip the normal cleanup, we still
199 * need to make sure that the in-core orphan linked list
200 * is properly cleaned up. */
201 ext3_orphan_del(NULL, inode);
209 ext3_truncate(inode);
211 * Kill off the orphan record which ext3_truncate created.
212 * AKPM: I think this can be inside the above `if'.
213 * Note that ext3_orphan_del() has to be able to cope with the
214 * deletion of a non-existent orphan - this is because we don't
215 * know if ext3_truncate() actually created an orphan record.
216 * (Well, we could do this if we need to, but heck - it works)
218 ext3_orphan_del(handle, inode);
219 EXT3_I(inode)->i_dtime = get_seconds();
222 * One subtle ordering requirement: if anything has gone wrong
223 * (transaction abort, IO errors, whatever), then we can still
224 * do these next steps (the fs will already have been marked as
225 * having errors), but we can't free the inode if the mark_dirty
228 if (ext3_mark_inode_dirty(handle, inode))
229 /* If that failed, just do the required in-core inode clear. */
232 ext3_free_inode(handle, inode);
233 ext3_journal_stop(handle);
236 clear_inode(inode); /* We must guarantee clearing of inode... */
239 static int ext3_alloc_block (handle_t *handle,
240 struct inode * inode, unsigned long goal, int *err)
242 unsigned long result;
244 result = ext3_new_block(handle, inode, goal, err);
252 struct buffer_head *bh;
255 static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
257 p->key = *(p->p = v);
261 static inline int verify_chain(Indirect *from, Indirect *to)
263 while (from <= to && from->key == *from->p)
269 * ext3_block_to_path - parse the block number into array of offsets
270 * @inode: inode in question (we are only interested in its superblock)
271 * @i_block: block number to be parsed
272 * @offsets: array to store the offsets in
273 * @boundary: set this non-zero if the referred-to block is likely to be
274 * followed (on disk) by an indirect block.
276 * To store the locations of file's data ext3 uses a data structure common
277 * for UNIX filesystems - tree of pointers anchored in the inode, with
278 * data blocks at leaves and indirect blocks in intermediate nodes.
279 * This function translates the block number into path in that tree -
280 * return value is the path length and @offsets[n] is the offset of
281 * pointer to (n+1)th node in the nth one. If @block is out of range
282 * (negative or too large) warning is printed and zero returned.
284 * Note: function doesn't find node addresses, so no IO is needed. All
285 * we need to know is the capacity of indirect blocks (taken from the
290 * Portability note: the last comparison (check that we fit into triple
291 * indirect block) is spelled differently, because otherwise on an
292 * architecture with 32-bit longs and 8Kb pages we might get into trouble
293 * if our filesystem had 8Kb blocks. We might use long long, but that would
294 * kill us on x86. Oh, well, at least the sign propagation does not matter -
295 * i_block would have to be negative in the very beginning, so we would not
299 static int ext3_block_to_path(struct inode *inode,
300 long i_block, int offsets[4], int *boundary)
302 int ptrs = EXT3_ADDR_PER_BLOCK(inode->i_sb);
303 int ptrs_bits = EXT3_ADDR_PER_BLOCK_BITS(inode->i_sb);
304 const long direct_blocks = EXT3_NDIR_BLOCKS,
305 indirect_blocks = ptrs,
306 double_blocks = (1 << (ptrs_bits * 2));
311 ext3_warning (inode->i_sb, "ext3_block_to_path", "block < 0");
312 } else if (i_block < direct_blocks) {
313 offsets[n++] = i_block;
314 final = direct_blocks;
315 } else if ( (i_block -= direct_blocks) < indirect_blocks) {
316 offsets[n++] = EXT3_IND_BLOCK;
317 offsets[n++] = i_block;
319 } else if ((i_block -= indirect_blocks) < double_blocks) {
320 offsets[n++] = EXT3_DIND_BLOCK;
321 offsets[n++] = i_block >> ptrs_bits;
322 offsets[n++] = i_block & (ptrs - 1);
324 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
325 offsets[n++] = EXT3_TIND_BLOCK;
326 offsets[n++] = i_block >> (ptrs_bits * 2);
327 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
328 offsets[n++] = i_block & (ptrs - 1);
331 ext3_warning (inode->i_sb, "ext3_block_to_path", "block > big");
334 *boundary = (i_block & (ptrs - 1)) == (final - 1);
339 * ext3_get_branch - read the chain of indirect blocks leading to data
340 * @inode: inode in question
341 * @depth: depth of the chain (1 - direct pointer, etc.)
342 * @offsets: offsets of pointers in inode/indirect blocks
343 * @chain: place to store the result
344 * @err: here we store the error value
346 * Function fills the array of triples <key, p, bh> and returns %NULL
347 * if everything went OK or the pointer to the last filled triple
348 * (incomplete one) otherwise. Upon the return chain[i].key contains
349 * the number of (i+1)-th block in the chain (as it is stored in memory,
350 * i.e. little-endian 32-bit), chain[i].p contains the address of that
351 * number (it points into struct inode for i==0 and into the bh->b_data
352 * for i>0) and chain[i].bh points to the buffer_head of i-th indirect
353 * block for i>0 and NULL for i==0. In other words, it holds the block
354 * numbers of the chain, addresses they were taken from (and where we can
355 * verify that chain did not change) and buffer_heads hosting these
358 * Function stops when it stumbles upon zero pointer (absent block)
359 * (pointer to last triple returned, *@err == 0)
360 * or when it gets an IO error reading an indirect block
361 * (ditto, *@err == -EIO)
362 * or when it notices that chain had been changed while it was reading
363 * (ditto, *@err == -EAGAIN)
364 * or when it reads all @depth-1 indirect blocks successfully and finds
365 * the whole chain, all way to the data (returns %NULL, *err == 0).
367 static Indirect *ext3_get_branch(struct inode *inode, int depth, int *offsets,
368 Indirect chain[4], int *err)
370 struct super_block *sb = inode->i_sb;
372 struct buffer_head *bh;
375 /* i_data is not going away, no lock needed */
376 add_chain (chain, NULL, EXT3_I(inode)->i_data + *offsets);
380 bh = sb_bread(sb, le32_to_cpu(p->key));
383 /* Reader: pointers */
384 if (!verify_chain(chain, p))
386 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
404 * ext3_find_near - find a place for allocation with sufficient locality
406 * @ind: descriptor of indirect block.
408 * This function returns the prefered place for block allocation.
409 * It is used when heuristic for sequential allocation fails.
411 * + if there is a block to the left of our position - allocate near it.
412 * + if pointer will live in indirect block - allocate near that block.
413 * + if pointer will live in inode - allocate in the same
416 * In the latter case we colour the starting block by the callers PID to
417 * prevent it from clashing with concurrent allocations for a different inode
418 * in the same block group. The PID is used here so that functionally related
419 * files will be close-by on-disk.
421 * Caller must make sure that @ind is valid and will stay that way.
424 static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)
426 struct ext3_inode_info *ei = EXT3_I(inode);
427 __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
429 unsigned long bg_start;
430 unsigned long colour;
432 /* Try to find previous block */
433 for (p = ind->p - 1; p >= start; p--)
435 return le32_to_cpu(*p);
437 /* No such thing, so let's try location of indirect block */
439 return ind->bh->b_blocknr;
442 * It is going to be refered from inode itself? OK, just put it into
443 * the same cylinder group then.
445 bg_start = (ei->i_block_group * EXT3_BLOCKS_PER_GROUP(inode->i_sb)) +
446 le32_to_cpu(EXT3_SB(inode->i_sb)->s_es->s_first_data_block);
447 colour = (current->pid % 16) *
448 (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
449 return bg_start + colour;
453 * ext3_find_goal - find a prefered place for allocation.
455 * @block: block we want
456 * @chain: chain of indirect blocks
457 * @partial: pointer to the last triple within a chain
458 * @goal: place to store the result.
460 * Normally this function find the prefered place for block allocation,
461 * stores it in *@goal and returns zero.
464 static unsigned long ext3_find_goal(struct inode *inode, long block,
465 Indirect chain[4], Indirect *partial)
467 struct ext3_block_alloc_info *block_i = EXT3_I(inode)->i_block_alloc_info;
470 * try the heuristic for sequential allocation,
471 * failing that at least try to get decent locality.
473 if (block_i && (block == block_i->last_alloc_logical_block + 1)
474 && (block_i->last_alloc_physical_block != 0)) {
475 return block_i->last_alloc_physical_block + 1;
478 return ext3_find_near(inode, partial);
482 * ext3_alloc_branch - allocate and set up a chain of blocks.
484 * @num: depth of the chain (number of blocks to allocate)
485 * @offsets: offsets (in the blocks) to store the pointers to next.
486 * @branch: place to store the chain in.
488 * This function allocates @num blocks, zeroes out all but the last one,
489 * links them into chain and (if we are synchronous) writes them to disk.
490 * In other words, it prepares a branch that can be spliced onto the
491 * inode. It stores the information about that chain in the branch[], in
492 * the same format as ext3_get_branch() would do. We are calling it after
493 * we had read the existing part of chain and partial points to the last
494 * triple of that (one with zero ->key). Upon the exit we have the same
495 * picture as after the successful ext3_get_block(), except that in one
496 * place chain is disconnected - *branch->p is still zero (we did not
497 * set the last link), but branch->key contains the number that should
498 * be placed into *branch->p to fill that gap.
500 * If allocation fails we free all blocks we've allocated (and forget
501 * their buffer_heads) and return the error value the from failed
502 * ext3_alloc_block() (normally -ENOSPC). Otherwise we set the chain
503 * as described above and return 0.
506 static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
512 int blocksize = inode->i_sb->s_blocksize;
516 int parent = ext3_alloc_block(handle, inode, goal, &err);
518 branch[0].key = cpu_to_le32(parent);
520 for (n = 1; n < num; n++) {
521 struct buffer_head *bh;
522 /* Allocate the next block */
523 int nr = ext3_alloc_block(handle, inode, parent, &err);
526 branch[n].key = cpu_to_le32(nr);
529 * Get buffer_head for parent block, zero it out
530 * and set the pointer to new one, then send
533 bh = sb_getblk(inode->i_sb, parent);
539 BUFFER_TRACE(bh, "call get_create_access");
540 err = ext3_journal_get_create_access(handle, bh);
547 memset(bh->b_data, 0, blocksize);
548 branch[n].p = (__le32*) bh->b_data + offsets[n];
549 *branch[n].p = branch[n].key;
550 BUFFER_TRACE(bh, "marking uptodate");
551 set_buffer_uptodate(bh);
554 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
555 err = ext3_journal_dirty_metadata(handle, bh);
565 /* Allocation failed, free what we already allocated */
566 for (i = 1; i < keys; i++) {
567 BUFFER_TRACE(branch[i].bh, "call journal_forget");
568 ext3_journal_forget(handle, branch[i].bh);
570 for (i = 0; i < keys; i++)
571 ext3_free_blocks(handle, inode, le32_to_cpu(branch[i].key), 1);
576 * ext3_splice_branch - splice the allocated branch onto inode.
578 * @block: (logical) number of block we are adding
579 * @chain: chain of indirect blocks (with a missing link - see
581 * @where: location of missing link
582 * @num: number of blocks we are adding
584 * This function fills the missing link and does all housekeeping needed in
585 * inode (->i_blocks, etc.). In case of success we end up with the full
586 * chain to new block and return 0.
589 static int ext3_splice_branch(handle_t *handle, struct inode *inode, long block,
590 Indirect chain[4], Indirect *where, int num)
594 struct ext3_block_alloc_info *block_i = EXT3_I(inode)->i_block_alloc_info;
597 * If we're splicing into a [td]indirect block (as opposed to the
598 * inode) then we need to get write access to the [td]indirect block
602 BUFFER_TRACE(where->bh, "get_write_access");
603 err = ext3_journal_get_write_access(handle, where->bh);
609 *where->p = where->key;
612 * update the most recently allocated logical & physical block
613 * in i_block_alloc_info, to assist find the proper goal block for next
617 block_i->last_alloc_logical_block = block;
618 block_i->last_alloc_physical_block = le32_to_cpu(where[num-1].key);
621 /* We are done with atomic stuff, now do the rest of housekeeping */
623 inode->i_ctime = CURRENT_TIME_SEC;
624 ext3_mark_inode_dirty(handle, inode);
626 /* had we spliced it onto indirect block? */
629 * akpm: If we spliced it onto an indirect block, we haven't
630 * altered the inode. Note however that if it is being spliced
631 * onto an indirect block at the very end of the file (the
632 * file is growing) then we *will* alter the inode to reflect
633 * the new i_size. But that is not done here - it is done in
634 * generic_commit_write->__mark_inode_dirty->ext3_dirty_inode.
636 jbd_debug(5, "splicing indirect only\n");
637 BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
638 err = ext3_journal_dirty_metadata(handle, where->bh);
643 * OK, we spliced it into the inode itself on a direct block.
644 * Inode was dirtied above.
646 jbd_debug(5, "splicing direct\n");
651 for (i = 1; i < num; i++) {
652 BUFFER_TRACE(where[i].bh, "call journal_forget");
653 ext3_journal_forget(handle, where[i].bh);
659 * Allocation strategy is simple: if we have to allocate something, we will
660 * have to go the whole way to leaf. So let's do it before attaching anything
661 * to tree, set linkage between the newborn blocks, write them if sync is
662 * required, recheck the path, free and repeat if check fails, otherwise
663 * set the last missing link (that will protect us from any truncate-generated
664 * removals - all blocks on the path are immune now) and possibly force the
665 * write on the parent block.
666 * That has a nice additional property: no special recovery from the failed
667 * allocations is needed - we simply release blocks and do not touch anything
668 * reachable from inode.
670 * akpm: `handle' can be NULL if create == 0.
672 * The BKL may not be held on entry here. Be sure to take it early.
676 ext3_get_block_handle(handle_t *handle, struct inode *inode, sector_t iblock,
677 struct buffer_head *bh_result, int create, int extend_disksize)
686 const int depth = ext3_block_to_path(inode, iblock, offsets, &boundary);
687 struct ext3_inode_info *ei = EXT3_I(inode);
689 J_ASSERT(handle != NULL || create == 0);
694 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
696 /* Simplest case - block found, no allocation needed */
698 clear_buffer_new(bh_result);
702 /* Next simple case - plain lookup or failed read of indirect block */
703 if (!create || err == -EIO)
706 down(&ei->truncate_sem);
709 * If the indirect block is missing while we are reading
710 * the chain(ext3_get_branch() returns -EAGAIN err), or
711 * if the chain has been changed after we grab the semaphore,
712 * (either because another process truncated this branch, or
713 * another get_block allocated this branch) re-grab the chain to see if
714 * the request block has been allocated or not.
716 * Since we already block the truncate/other get_block
717 * at this point, we will have the current copy of the chain when we
718 * splice the branch into the tree.
720 if (err == -EAGAIN || !verify_chain(chain, partial)) {
721 while (partial > chain) {
725 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
727 up(&ei->truncate_sem);
730 clear_buffer_new(bh_result);
736 * Okay, we need to do block allocation. Lazily initialize the block
737 * allocation info here if necessary
739 if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
740 ext3_init_block_alloc_info(inode);
742 goal = ext3_find_goal(inode, iblock, chain, partial);
744 left = (chain + depth) - partial;
747 * Block out ext3_truncate while we alter the tree
749 err = ext3_alloc_branch(handle, inode, left, goal,
750 offsets + (partial - chain), partial);
753 * The ext3_splice_branch call will free and forget any buffers
754 * on the new chain if there is a failure, but that risks using
755 * up transaction credits, especially for bitmaps where the
756 * credits cannot be returned. Can we handle this somehow? We
757 * may need to return -EAGAIN upwards in the worst case. --sct
760 err = ext3_splice_branch(handle, inode, iblock, chain,
763 * i_disksize growing is protected by truncate_sem. Don't forget to
764 * protect it if you're about to implement concurrent
765 * ext3_get_block() -bzzz
767 if (!err && extend_disksize && inode->i_size > ei->i_disksize)
768 ei->i_disksize = inode->i_size;
769 up(&ei->truncate_sem);
773 set_buffer_new(bh_result);
775 map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
777 set_buffer_boundary(bh_result);
778 /* Clean up and exit */
779 partial = chain + depth - 1; /* the whole chain */
781 while (partial > chain) {
782 BUFFER_TRACE(partial->bh, "call brelse");
786 BUFFER_TRACE(bh_result, "returned");
791 static int ext3_get_block(struct inode *inode, sector_t iblock,
792 struct buffer_head *bh_result, int create)
794 handle_t *handle = NULL;
798 handle = ext3_journal_current_handle();
799 J_ASSERT(handle != 0);
801 ret = ext3_get_block_handle(handle, inode, iblock,
802 bh_result, create, 1);
806 #define DIO_CREDITS (EXT3_RESERVE_TRANS_BLOCKS + 32)
809 ext3_direct_io_get_blocks(struct inode *inode, sector_t iblock,
810 unsigned long max_blocks, struct buffer_head *bh_result,
813 handle_t *handle = journal_current_handle();
817 goto get_block; /* A read */
819 if (handle->h_transaction->t_state == T_LOCKED) {
821 * Huge direct-io writes can hold off commits for long
822 * periods of time. Let this commit run.
824 ext3_journal_stop(handle);
825 handle = ext3_journal_start(inode, DIO_CREDITS);
827 ret = PTR_ERR(handle);
831 if (handle->h_buffer_credits <= EXT3_RESERVE_TRANS_BLOCKS) {
833 * Getting low on buffer credits...
835 ret = ext3_journal_extend(handle, DIO_CREDITS);
838 * Couldn't extend the transaction. Start a new one.
840 ret = ext3_journal_restart(handle, DIO_CREDITS);
846 ret = ext3_get_block_handle(handle, inode, iblock,
847 bh_result, create, 0);
848 bh_result->b_size = (1 << inode->i_blkbits);
853 * `handle' can be NULL if create is zero
855 struct buffer_head *ext3_getblk(handle_t *handle, struct inode * inode,
856 long block, int create, int * errp)
858 struct buffer_head dummy;
861 J_ASSERT(handle != NULL || create == 0);
864 dummy.b_blocknr = -1000;
865 buffer_trace_init(&dummy.b_history);
866 *errp = ext3_get_block_handle(handle, inode, block, &dummy, create, 1);
867 if (!*errp && buffer_mapped(&dummy)) {
868 struct buffer_head *bh;
869 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
874 if (buffer_new(&dummy)) {
875 J_ASSERT(create != 0);
876 J_ASSERT(handle != 0);
878 /* Now that we do not always journal data, we
879 should keep in mind whether this should
880 always journal the new buffer as metadata.
881 For now, regular file writes use
882 ext3_get_block instead, so it's not a
885 BUFFER_TRACE(bh, "call get_create_access");
886 fatal = ext3_journal_get_create_access(handle, bh);
887 if (!fatal && !buffer_uptodate(bh)) {
888 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
889 set_buffer_uptodate(bh);
892 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
893 err = ext3_journal_dirty_metadata(handle, bh);
897 BUFFER_TRACE(bh, "not a new buffer");
910 struct buffer_head *ext3_bread(handle_t *handle, struct inode * inode,
911 int block, int create, int *err)
913 struct buffer_head * bh;
915 bh = ext3_getblk(handle, inode, block, create, err);
918 if (buffer_uptodate(bh))
920 ll_rw_block(READ, 1, &bh);
922 if (buffer_uptodate(bh))
929 static int walk_page_buffers( handle_t *handle,
930 struct buffer_head *head,
934 int (*fn)( handle_t *handle,
935 struct buffer_head *bh))
937 struct buffer_head *bh;
938 unsigned block_start, block_end;
939 unsigned blocksize = head->b_size;
941 struct buffer_head *next;
943 for ( bh = head, block_start = 0;
944 ret == 0 && (bh != head || !block_start);
945 block_start = block_end, bh = next)
947 next = bh->b_this_page;
948 block_end = block_start + blocksize;
949 if (block_end <= from || block_start >= to) {
950 if (partial && !buffer_uptodate(bh))
954 err = (*fn)(handle, bh);
962 * To preserve ordering, it is essential that the hole instantiation and
963 * the data write be encapsulated in a single transaction. We cannot
964 * close off a transaction and start a new one between the ext3_get_block()
965 * and the commit_write(). So doing the journal_start at the start of
966 * prepare_write() is the right place.
968 * Also, this function can nest inside ext3_writepage() ->
969 * block_write_full_page(). In that case, we *know* that ext3_writepage()
970 * has generated enough buffer credits to do the whole page. So we won't
971 * block on the journal in that case, which is good, because the caller may
974 * By accident, ext3 can be reentered when a transaction is open via
975 * quota file writes. If we were to commit the transaction while thus
976 * reentered, there can be a deadlock - we would be holding a quota
977 * lock, and the commit would never complete if another thread had a
978 * transaction open and was blocking on the quota lock - a ranking
981 * So what we do is to rely on the fact that journal_stop/journal_start
982 * will _not_ run commit under these circumstances because handle->h_ref
983 * is elevated. We'll still have enough credits for the tiny quotafile
987 static int do_journal_get_write_access(handle_t *handle,
988 struct buffer_head *bh)
990 if (!buffer_mapped(bh) || buffer_freed(bh))
992 return ext3_journal_get_write_access(handle, bh);
995 static int ext3_prepare_write(struct file *file, struct page *page,
996 unsigned from, unsigned to)
998 struct inode *inode = page->mapping->host;
999 int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
1004 handle = ext3_journal_start(inode, needed_blocks);
1005 if (IS_ERR(handle)) {
1006 ret = PTR_ERR(handle);
1009 if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
1010 ret = nobh_prepare_write(page, from, to, ext3_get_block);
1012 ret = block_prepare_write(page, from, to, ext3_get_block);
1014 goto prepare_write_failed;
1016 if (ext3_should_journal_data(inode)) {
1017 ret = walk_page_buffers(handle, page_buffers(page),
1018 from, to, NULL, do_journal_get_write_access);
1020 prepare_write_failed:
1022 ext3_journal_stop(handle);
1023 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1030 ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1032 int err = journal_dirty_data(handle, bh);
1034 ext3_journal_abort_handle(__FUNCTION__, __FUNCTION__,
1039 /* For commit_write() in data=journal mode */
1040 static int commit_write_fn(handle_t *handle, struct buffer_head *bh)
1042 if (!buffer_mapped(bh) || buffer_freed(bh))
1044 set_buffer_uptodate(bh);
1045 return ext3_journal_dirty_metadata(handle, bh);
1049 * We need to pick up the new inode size which generic_commit_write gave us
1050 * `file' can be NULL - eg, when called from page_symlink().
1052 * ext3 never places buffers on inode->i_mapping->private_list. metadata
1053 * buffers are managed internally.
1056 static int ext3_ordered_commit_write(struct file *file, struct page *page,
1057 unsigned from, unsigned to)
1059 handle_t *handle = ext3_journal_current_handle();
1060 struct inode *inode = page->mapping->host;
1063 ret = walk_page_buffers(handle, page_buffers(page),
1064 from, to, NULL, ext3_journal_dirty_data);
1068 * generic_commit_write() will run mark_inode_dirty() if i_size
1069 * changes. So let's piggyback the i_disksize mark_inode_dirty
1074 new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1075 if (new_i_size > EXT3_I(inode)->i_disksize)
1076 EXT3_I(inode)->i_disksize = new_i_size;
1077 ret = generic_commit_write(file, page, from, to);
1079 ret2 = ext3_journal_stop(handle);
1085 static int ext3_writeback_commit_write(struct file *file, struct page *page,
1086 unsigned from, unsigned to)
1088 handle_t *handle = ext3_journal_current_handle();
1089 struct inode *inode = page->mapping->host;
1093 new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1094 if (new_i_size > EXT3_I(inode)->i_disksize)
1095 EXT3_I(inode)->i_disksize = new_i_size;
1097 if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
1098 ret = nobh_commit_write(file, page, from, to);
1100 ret = generic_commit_write(file, page, from, to);
1102 ret2 = ext3_journal_stop(handle);
1108 static int ext3_journalled_commit_write(struct file *file,
1109 struct page *page, unsigned from, unsigned to)
1111 handle_t *handle = ext3_journal_current_handle();
1112 struct inode *inode = page->mapping->host;
1118 * Here we duplicate the generic_commit_write() functionality
1120 pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1122 ret = walk_page_buffers(handle, page_buffers(page), from,
1123 to, &partial, commit_write_fn);
1125 SetPageUptodate(page);
1126 if (pos > inode->i_size)
1127 i_size_write(inode, pos);
1128 EXT3_I(inode)->i_state |= EXT3_STATE_JDATA;
1129 if (inode->i_size > EXT3_I(inode)->i_disksize) {
1130 EXT3_I(inode)->i_disksize = inode->i_size;
1131 ret2 = ext3_mark_inode_dirty(handle, inode);
1135 ret2 = ext3_journal_stop(handle);
1142 * bmap() is special. It gets used by applications such as lilo and by
1143 * the swapper to find the on-disk block of a specific piece of data.
1145 * Naturally, this is dangerous if the block concerned is still in the
1146 * journal. If somebody makes a swapfile on an ext3 data-journaling
1147 * filesystem and enables swap, then they may get a nasty shock when the
1148 * data getting swapped to that swapfile suddenly gets overwritten by
1149 * the original zero's written out previously to the journal and
1150 * awaiting writeback in the kernel's buffer cache.
1152 * So, if we see any bmap calls here on a modified, data-journaled file,
1153 * take extra steps to flush any blocks which might be in the cache.
1155 static sector_t ext3_bmap(struct address_space *mapping, sector_t block)
1157 struct inode *inode = mapping->host;
1161 if (EXT3_I(inode)->i_state & EXT3_STATE_JDATA) {
1163 * This is a REALLY heavyweight approach, but the use of
1164 * bmap on dirty files is expected to be extremely rare:
1165 * only if we run lilo or swapon on a freshly made file
1166 * do we expect this to happen.
1168 * (bmap requires CAP_SYS_RAWIO so this does not
1169 * represent an unprivileged user DOS attack --- we'd be
1170 * in trouble if mortal users could trigger this path at
1173 * NB. EXT3_STATE_JDATA is not set on files other than
1174 * regular files. If somebody wants to bmap a directory
1175 * or symlink and gets confused because the buffer
1176 * hasn't yet been flushed to disk, they deserve
1177 * everything they get.
1180 EXT3_I(inode)->i_state &= ~EXT3_STATE_JDATA;
1181 journal = EXT3_JOURNAL(inode);
1182 journal_lock_updates(journal);
1183 err = journal_flush(journal);
1184 journal_unlock_updates(journal);
1190 return generic_block_bmap(mapping,block,ext3_get_block);
1193 static int bget_one(handle_t *handle, struct buffer_head *bh)
1199 static int bput_one(handle_t *handle, struct buffer_head *bh)
1205 static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
1207 if (buffer_mapped(bh))
1208 return ext3_journal_dirty_data(handle, bh);
1213 * Note that we always start a transaction even if we're not journalling
1214 * data. This is to preserve ordering: any hole instantiation within
1215 * __block_write_full_page -> ext3_get_block() should be journalled
1216 * along with the data so we don't crash and then get metadata which
1217 * refers to old data.
1219 * In all journalling modes block_write_full_page() will start the I/O.
1223 * ext3_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1228 * ext3_file_write() -> generic_file_write() -> __alloc_pages() -> ...
1230 * Same applies to ext3_get_block(). We will deadlock on various things like
1231 * lock_journal and i_truncate_sem.
1233 * Setting PF_MEMALLOC here doesn't work - too many internal memory
1236 * 16May01: If we're reentered then journal_current_handle() will be
1237 * non-zero. We simply *return*.
1239 * 1 July 2001: @@@ FIXME:
1240 * In journalled data mode, a data buffer may be metadata against the
1241 * current transaction. But the same file is part of a shared mapping
1242 * and someone does a writepage() on it.
1244 * We will move the buffer onto the async_data list, but *after* it has
1245 * been dirtied. So there's a small window where we have dirty data on
1248 * Note that this only applies to the last partial page in the file. The
1249 * bit which block_write_full_page() uses prepare/commit for. (That's
1250 * broken code anyway: it's wrong for msync()).
1252 * It's a rare case: affects the final partial page, for journalled data
1253 * where the file is subject to bith write() and writepage() in the same
1254 * transction. To fix it we'll need a custom block_write_full_page().
1255 * We'll probably need that anyway for journalling writepage() output.
1257 * We don't honour synchronous mounts for writepage(). That would be
1258 * disastrous. Any write() or metadata operation will sync the fs for
1261 * AKPM2: if all the page's buffers are mapped to disk and !data=journal,
1262 * we don't need to open a transaction here.
1264 static int ext3_ordered_writepage(struct page *page,
1265 struct writeback_control *wbc)
1267 struct inode *inode = page->mapping->host;
1268 struct buffer_head *page_bufs;
1269 handle_t *handle = NULL;
1273 J_ASSERT(PageLocked(page));
1276 * We give up here if we're reentered, because it might be for a
1277 * different filesystem.
1279 if (ext3_journal_current_handle())
1282 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1284 if (IS_ERR(handle)) {
1285 ret = PTR_ERR(handle);
1289 if (!page_has_buffers(page)) {
1290 create_empty_buffers(page, inode->i_sb->s_blocksize,
1291 (1 << BH_Dirty)|(1 << BH_Uptodate));
1293 page_bufs = page_buffers(page);
1294 walk_page_buffers(handle, page_bufs, 0,
1295 PAGE_CACHE_SIZE, NULL, bget_one);
1297 ret = block_write_full_page(page, ext3_get_block, wbc);
1300 * The page can become unlocked at any point now, and
1301 * truncate can then come in and change things. So we
1302 * can't touch *page from now on. But *page_bufs is
1303 * safe due to elevated refcount.
1307 * And attach them to the current transaction. But only if
1308 * block_write_full_page() succeeded. Otherwise they are unmapped,
1309 * and generally junk.
1312 err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
1313 NULL, journal_dirty_data_fn);
1317 walk_page_buffers(handle, page_bufs, 0,
1318 PAGE_CACHE_SIZE, NULL, bput_one);
1319 err = ext3_journal_stop(handle);
1325 redirty_page_for_writepage(wbc, page);
1330 static int ext3_writeback_writepage(struct page *page,
1331 struct writeback_control *wbc)
1333 struct inode *inode = page->mapping->host;
1334 handle_t *handle = NULL;
1338 if (ext3_journal_current_handle())
1341 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1342 if (IS_ERR(handle)) {
1343 ret = PTR_ERR(handle);
1347 if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
1348 ret = nobh_writepage(page, ext3_get_block, wbc);
1350 ret = block_write_full_page(page, ext3_get_block, wbc);
1352 err = ext3_journal_stop(handle);
1358 redirty_page_for_writepage(wbc, page);
1363 static int ext3_journalled_writepage(struct page *page,
1364 struct writeback_control *wbc)
1366 struct inode *inode = page->mapping->host;
1367 handle_t *handle = NULL;
1371 if (ext3_journal_current_handle())
1374 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1375 if (IS_ERR(handle)) {
1376 ret = PTR_ERR(handle);
1380 if (!page_has_buffers(page) || PageChecked(page)) {
1382 * It's mmapped pagecache. Add buffers and journal it. There
1383 * doesn't seem much point in redirtying the page here.
1385 ClearPageChecked(page);
1386 ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
1389 ext3_journal_stop(handle);
1392 ret = walk_page_buffers(handle, page_buffers(page), 0,
1393 PAGE_CACHE_SIZE, NULL, do_journal_get_write_access);
1395 err = walk_page_buffers(handle, page_buffers(page), 0,
1396 PAGE_CACHE_SIZE, NULL, commit_write_fn);
1399 EXT3_I(inode)->i_state |= EXT3_STATE_JDATA;
1403 * It may be a page full of checkpoint-mode buffers. We don't
1404 * really know unless we go poke around in the buffer_heads.
1405 * But block_write_full_page will do the right thing.
1407 ret = block_write_full_page(page, ext3_get_block, wbc);
1409 err = ext3_journal_stop(handle);
1416 redirty_page_for_writepage(wbc, page);
1422 static int ext3_readpage(struct file *file, struct page *page)
1424 return mpage_readpage(page, ext3_get_block);
1428 ext3_readpages(struct file *file, struct address_space *mapping,
1429 struct list_head *pages, unsigned nr_pages)
1431 return mpage_readpages(mapping, pages, nr_pages, ext3_get_block);
1434 static int ext3_invalidatepage(struct page *page, unsigned long offset)
1436 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1439 * If it's a full truncate we just forget about the pending dirtying
1442 ClearPageChecked(page);
1444 return journal_invalidatepage(journal, page, offset);
1447 static int ext3_releasepage(struct page *page, gfp_t wait)
1449 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1451 WARN_ON(PageChecked(page));
1452 if (!page_has_buffers(page))
1454 return journal_try_to_free_buffers(journal, page, wait);
1458 * If the O_DIRECT write will extend the file then add this inode to the
1459 * orphan list. So recovery will truncate it back to the original size
1460 * if the machine crashes during the write.
1462 * If the O_DIRECT write is intantiating holes inside i_size and the machine
1463 * crashes then stale disk data _may_ be exposed inside the file.
1465 static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
1466 const struct iovec *iov, loff_t offset,
1467 unsigned long nr_segs)
1469 struct file *file = iocb->ki_filp;
1470 struct inode *inode = file->f_mapping->host;
1471 struct ext3_inode_info *ei = EXT3_I(inode);
1472 handle_t *handle = NULL;
1475 size_t count = iov_length(iov, nr_segs);
1478 loff_t final_size = offset + count;
1480 handle = ext3_journal_start(inode, DIO_CREDITS);
1481 if (IS_ERR(handle)) {
1482 ret = PTR_ERR(handle);
1485 if (final_size > inode->i_size) {
1486 ret = ext3_orphan_add(handle, inode);
1490 ei->i_disksize = inode->i_size;
1494 ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
1496 ext3_direct_io_get_blocks, NULL);
1499 * Reacquire the handle: ext3_direct_io_get_block() can restart the
1502 handle = journal_current_handle();
1508 if (orphan && inode->i_nlink)
1509 ext3_orphan_del(handle, inode);
1510 if (orphan && ret > 0) {
1511 loff_t end = offset + ret;
1512 if (end > inode->i_size) {
1513 ei->i_disksize = end;
1514 i_size_write(inode, end);
1516 * We're going to return a positive `ret'
1517 * here due to non-zero-length I/O, so there's
1518 * no way of reporting error returns from
1519 * ext3_mark_inode_dirty() to userspace. So
1522 ext3_mark_inode_dirty(handle, inode);
1525 err = ext3_journal_stop(handle);
1534 * Pages can be marked dirty completely asynchronously from ext3's journalling
1535 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
1536 * much here because ->set_page_dirty is called under VFS locks. The page is
1537 * not necessarily locked.
1539 * We cannot just dirty the page and leave attached buffers clean, because the
1540 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
1541 * or jbddirty because all the journalling code will explode.
1543 * So what we do is to mark the page "pending dirty" and next time writepage
1544 * is called, propagate that into the buffers appropriately.
1546 static int ext3_journalled_set_page_dirty(struct page *page)
1548 SetPageChecked(page);
1549 return __set_page_dirty_nobuffers(page);
1552 static struct address_space_operations ext3_ordered_aops = {
1553 .readpage = ext3_readpage,
1554 .readpages = ext3_readpages,
1555 .writepage = ext3_ordered_writepage,
1556 .sync_page = block_sync_page,
1557 .prepare_write = ext3_prepare_write,
1558 .commit_write = ext3_ordered_commit_write,
1560 .invalidatepage = ext3_invalidatepage,
1561 .releasepage = ext3_releasepage,
1562 .direct_IO = ext3_direct_IO,
1563 .migratepage = buffer_migrate_page,
1566 static struct address_space_operations ext3_writeback_aops = {
1567 .readpage = ext3_readpage,
1568 .readpages = ext3_readpages,
1569 .writepage = ext3_writeback_writepage,
1570 .sync_page = block_sync_page,
1571 .prepare_write = ext3_prepare_write,
1572 .commit_write = ext3_writeback_commit_write,
1574 .invalidatepage = ext3_invalidatepage,
1575 .releasepage = ext3_releasepage,
1576 .direct_IO = ext3_direct_IO,
1577 .migratepage = buffer_migrate_page,
1580 static struct address_space_operations ext3_journalled_aops = {
1581 .readpage = ext3_readpage,
1582 .readpages = ext3_readpages,
1583 .writepage = ext3_journalled_writepage,
1584 .sync_page = block_sync_page,
1585 .prepare_write = ext3_prepare_write,
1586 .commit_write = ext3_journalled_commit_write,
1587 .set_page_dirty = ext3_journalled_set_page_dirty,
1589 .invalidatepage = ext3_invalidatepage,
1590 .releasepage = ext3_releasepage,
1593 void ext3_set_aops(struct inode *inode)
1595 if (ext3_should_order_data(inode))
1596 inode->i_mapping->a_ops = &ext3_ordered_aops;
1597 else if (ext3_should_writeback_data(inode))
1598 inode->i_mapping->a_ops = &ext3_writeback_aops;
1600 inode->i_mapping->a_ops = &ext3_journalled_aops;
1604 * ext3_block_truncate_page() zeroes out a mapping from file offset `from'
1605 * up to the end of the block which corresponds to `from'.
1606 * This required during truncate. We need to physically zero the tail end
1607 * of that block so it doesn't yield old data if the file is later grown.
1609 static int ext3_block_truncate_page(handle_t *handle, struct page *page,
1610 struct address_space *mapping, loff_t from)
1612 unsigned long index = from >> PAGE_CACHE_SHIFT;
1613 unsigned offset = from & (PAGE_CACHE_SIZE-1);
1614 unsigned blocksize, iblock, length, pos;
1615 struct inode *inode = mapping->host;
1616 struct buffer_head *bh;
1620 blocksize = inode->i_sb->s_blocksize;
1621 length = blocksize - (offset & (blocksize - 1));
1622 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1625 * For "nobh" option, we can only work if we don't need to
1626 * read-in the page - otherwise we create buffers to do the IO.
1628 if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
1629 ext3_should_writeback_data(inode) && PageUptodate(page)) {
1630 kaddr = kmap_atomic(page, KM_USER0);
1631 memset(kaddr + offset, 0, length);
1632 flush_dcache_page(page);
1633 kunmap_atomic(kaddr, KM_USER0);
1634 set_page_dirty(page);
1638 if (!page_has_buffers(page))
1639 create_empty_buffers(page, blocksize, 0);
1641 /* Find the buffer that contains "offset" */
1642 bh = page_buffers(page);
1644 while (offset >= pos) {
1645 bh = bh->b_this_page;
1651 if (buffer_freed(bh)) {
1652 BUFFER_TRACE(bh, "freed: skip");
1656 if (!buffer_mapped(bh)) {
1657 BUFFER_TRACE(bh, "unmapped");
1658 ext3_get_block(inode, iblock, bh, 0);
1659 /* unmapped? It's a hole - nothing to do */
1660 if (!buffer_mapped(bh)) {
1661 BUFFER_TRACE(bh, "still unmapped");
1666 /* Ok, it's mapped. Make sure it's up-to-date */
1667 if (PageUptodate(page))
1668 set_buffer_uptodate(bh);
1670 if (!buffer_uptodate(bh)) {
1672 ll_rw_block(READ, 1, &bh);
1674 /* Uhhuh. Read error. Complain and punt. */
1675 if (!buffer_uptodate(bh))
1679 if (ext3_should_journal_data(inode)) {
1680 BUFFER_TRACE(bh, "get write access");
1681 err = ext3_journal_get_write_access(handle, bh);
1686 kaddr = kmap_atomic(page, KM_USER0);
1687 memset(kaddr + offset, 0, length);
1688 flush_dcache_page(page);
1689 kunmap_atomic(kaddr, KM_USER0);
1691 BUFFER_TRACE(bh, "zeroed end of block");
1694 if (ext3_should_journal_data(inode)) {
1695 err = ext3_journal_dirty_metadata(handle, bh);
1697 if (ext3_should_order_data(inode))
1698 err = ext3_journal_dirty_data(handle, bh);
1699 mark_buffer_dirty(bh);
1704 page_cache_release(page);
1709 * Probably it should be a library function... search for first non-zero word
1710 * or memcmp with zero_page, whatever is better for particular architecture.
1713 static inline int all_zeroes(__le32 *p, __le32 *q)
1722 * ext3_find_shared - find the indirect blocks for partial truncation.
1723 * @inode: inode in question
1724 * @depth: depth of the affected branch
1725 * @offsets: offsets of pointers in that branch (see ext3_block_to_path)
1726 * @chain: place to store the pointers to partial indirect blocks
1727 * @top: place to the (detached) top of branch
1729 * This is a helper function used by ext3_truncate().
1731 * When we do truncate() we may have to clean the ends of several
1732 * indirect blocks but leave the blocks themselves alive. Block is
1733 * partially truncated if some data below the new i_size is refered
1734 * from it (and it is on the path to the first completely truncated
1735 * data block, indeed). We have to free the top of that path along
1736 * with everything to the right of the path. Since no allocation
1737 * past the truncation point is possible until ext3_truncate()
1738 * finishes, we may safely do the latter, but top of branch may
1739 * require special attention - pageout below the truncation point
1740 * might try to populate it.
1742 * We atomically detach the top of branch from the tree, store the
1743 * block number of its root in *@top, pointers to buffer_heads of
1744 * partially truncated blocks - in @chain[].bh and pointers to
1745 * their last elements that should not be removed - in
1746 * @chain[].p. Return value is the pointer to last filled element
1749 * The work left to caller to do the actual freeing of subtrees:
1750 * a) free the subtree starting from *@top
1751 * b) free the subtrees whose roots are stored in
1752 * (@chain[i].p+1 .. end of @chain[i].bh->b_data)
1753 * c) free the subtrees growing from the inode past the @chain[0].
1754 * (no partially truncated stuff there). */
1756 static Indirect *ext3_find_shared(struct inode *inode,
1762 Indirect *partial, *p;
1766 /* Make k index the deepest non-null offest + 1 */
1767 for (k = depth; k > 1 && !offsets[k-1]; k--)
1769 partial = ext3_get_branch(inode, k, offsets, chain, &err);
1770 /* Writer: pointers */
1772 partial = chain + k-1;
1774 * If the branch acquired continuation since we've looked at it -
1775 * fine, it should all survive and (new) top doesn't belong to us.
1777 if (!partial->key && *partial->p)
1780 for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
1783 * OK, we've found the last block that must survive. The rest of our
1784 * branch should be detached before unlocking. However, if that rest
1785 * of branch is all ours and does not grow immediately from the inode
1786 * it's easier to cheat and just decrement partial->p.
1788 if (p == chain + k - 1 && p > chain) {
1792 /* Nope, don't do this in ext3. Must leave the tree intact */
1801 brelse(partial->bh);
1809 * Zero a number of block pointers in either an inode or an indirect block.
1810 * If we restart the transaction we must again get write access to the
1811 * indirect block for further modification.
1813 * We release `count' blocks on disk, but (last - first) may be greater
1814 * than `count' because there can be holes in there.
1817 ext3_clear_blocks(handle_t *handle, struct inode *inode, struct buffer_head *bh,
1818 unsigned long block_to_free, unsigned long count,
1819 __le32 *first, __le32 *last)
1822 if (try_to_extend_transaction(handle, inode)) {
1824 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
1825 ext3_journal_dirty_metadata(handle, bh);
1827 ext3_mark_inode_dirty(handle, inode);
1828 ext3_journal_test_restart(handle, inode);
1830 BUFFER_TRACE(bh, "retaking write access");
1831 ext3_journal_get_write_access(handle, bh);
1836 * Any buffers which are on the journal will be in memory. We find
1837 * them on the hash table so journal_revoke() will run journal_forget()
1838 * on them. We've already detached each block from the file, so
1839 * bforget() in journal_forget() should be safe.
1841 * AKPM: turn on bforget in journal_forget()!!!
1843 for (p = first; p < last; p++) {
1844 u32 nr = le32_to_cpu(*p);
1846 struct buffer_head *bh;
1849 bh = sb_find_get_block(inode->i_sb, nr);
1850 ext3_forget(handle, 0, inode, bh, nr);
1854 ext3_free_blocks(handle, inode, block_to_free, count);
1858 * ext3_free_data - free a list of data blocks
1859 * @handle: handle for this transaction
1860 * @inode: inode we are dealing with
1861 * @this_bh: indirect buffer_head which contains *@first and *@last
1862 * @first: array of block numbers
1863 * @last: points immediately past the end of array
1865 * We are freeing all blocks refered from that array (numbers are stored as
1866 * little-endian 32-bit) and updating @inode->i_blocks appropriately.
1868 * We accumulate contiguous runs of blocks to free. Conveniently, if these
1869 * blocks are contiguous then releasing them at one time will only affect one
1870 * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
1871 * actually use a lot of journal space.
1873 * @this_bh will be %NULL if @first and @last point into the inode's direct
1876 static void ext3_free_data(handle_t *handle, struct inode *inode,
1877 struct buffer_head *this_bh,
1878 __le32 *first, __le32 *last)
1880 unsigned long block_to_free = 0; /* Starting block # of a run */
1881 unsigned long count = 0; /* Number of blocks in the run */
1882 __le32 *block_to_free_p = NULL; /* Pointer into inode/ind
1885 unsigned long nr; /* Current block # */
1886 __le32 *p; /* Pointer into inode/ind
1887 for current block */
1890 if (this_bh) { /* For indirect block */
1891 BUFFER_TRACE(this_bh, "get_write_access");
1892 err = ext3_journal_get_write_access(handle, this_bh);
1893 /* Important: if we can't update the indirect pointers
1894 * to the blocks, we can't free them. */
1899 for (p = first; p < last; p++) {
1900 nr = le32_to_cpu(*p);
1902 /* accumulate blocks to free if they're contiguous */
1905 block_to_free_p = p;
1907 } else if (nr == block_to_free + count) {
1910 ext3_clear_blocks(handle, inode, this_bh,
1912 count, block_to_free_p, p);
1914 block_to_free_p = p;
1921 ext3_clear_blocks(handle, inode, this_bh, block_to_free,
1922 count, block_to_free_p, p);
1925 BUFFER_TRACE(this_bh, "call ext3_journal_dirty_metadata");
1926 ext3_journal_dirty_metadata(handle, this_bh);
1931 * ext3_free_branches - free an array of branches
1932 * @handle: JBD handle for this transaction
1933 * @inode: inode we are dealing with
1934 * @parent_bh: the buffer_head which contains *@first and *@last
1935 * @first: array of block numbers
1936 * @last: pointer immediately past the end of array
1937 * @depth: depth of the branches to free
1939 * We are freeing all blocks refered from these branches (numbers are
1940 * stored as little-endian 32-bit) and updating @inode->i_blocks
1943 static void ext3_free_branches(handle_t *handle, struct inode *inode,
1944 struct buffer_head *parent_bh,
1945 __le32 *first, __le32 *last, int depth)
1950 if (is_handle_aborted(handle))
1954 struct buffer_head *bh;
1955 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
1957 while (--p >= first) {
1958 nr = le32_to_cpu(*p);
1960 continue; /* A hole */
1962 /* Go read the buffer for the next level down */
1963 bh = sb_bread(inode->i_sb, nr);
1966 * A read failure? Report error and clear slot
1970 ext3_error(inode->i_sb, "ext3_free_branches",
1971 "Read failure, inode=%ld, block=%ld",
1976 /* This zaps the entire block. Bottom up. */
1977 BUFFER_TRACE(bh, "free child branches");
1978 ext3_free_branches(handle, inode, bh,
1979 (__le32*)bh->b_data,
1980 (__le32*)bh->b_data + addr_per_block,
1984 * We've probably journalled the indirect block several
1985 * times during the truncate. But it's no longer
1986 * needed and we now drop it from the transaction via
1989 * That's easy if it's exclusively part of this
1990 * transaction. But if it's part of the committing
1991 * transaction then journal_forget() will simply
1992 * brelse() it. That means that if the underlying
1993 * block is reallocated in ext3_get_block(),
1994 * unmap_underlying_metadata() will find this block
1995 * and will try to get rid of it. damn, damn.
1997 * If this block has already been committed to the
1998 * journal, a revoke record will be written. And
1999 * revoke records must be emitted *before* clearing
2000 * this block's bit in the bitmaps.
2002 ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
2005 * Everything below this this pointer has been
2006 * released. Now let this top-of-subtree go.
2008 * We want the freeing of this indirect block to be
2009 * atomic in the journal with the updating of the
2010 * bitmap block which owns it. So make some room in
2013 * We zero the parent pointer *after* freeing its
2014 * pointee in the bitmaps, so if extend_transaction()
2015 * for some reason fails to put the bitmap changes and
2016 * the release into the same transaction, recovery
2017 * will merely complain about releasing a free block,
2018 * rather than leaking blocks.
2020 if (is_handle_aborted(handle))
2022 if (try_to_extend_transaction(handle, inode)) {
2023 ext3_mark_inode_dirty(handle, inode);
2024 ext3_journal_test_restart(handle, inode);
2027 ext3_free_blocks(handle, inode, nr, 1);
2031 * The block which we have just freed is
2032 * pointed to by an indirect block: journal it
2034 BUFFER_TRACE(parent_bh, "get_write_access");
2035 if (!ext3_journal_get_write_access(handle,
2038 BUFFER_TRACE(parent_bh,
2039 "call ext3_journal_dirty_metadata");
2040 ext3_journal_dirty_metadata(handle,
2046 /* We have reached the bottom of the tree. */
2047 BUFFER_TRACE(parent_bh, "free data blocks");
2048 ext3_free_data(handle, inode, parent_bh, first, last);
2055 * We block out ext3_get_block() block instantiations across the entire
2056 * transaction, and VFS/VM ensures that ext3_truncate() cannot run
2057 * simultaneously on behalf of the same inode.
2059 * As we work through the truncate and commmit bits of it to the journal there
2060 * is one core, guiding principle: the file's tree must always be consistent on
2061 * disk. We must be able to restart the truncate after a crash.
2063 * The file's tree may be transiently inconsistent in memory (although it
2064 * probably isn't), but whenever we close off and commit a journal transaction,
2065 * the contents of (the filesystem + the journal) must be consistent and
2066 * restartable. It's pretty simple, really: bottom up, right to left (although
2067 * left-to-right works OK too).
2069 * Note that at recovery time, journal replay occurs *before* the restart of
2070 * truncate against the orphan inode list.
2072 * The committed inode has the new, desired i_size (which is the same as
2073 * i_disksize in this case). After a crash, ext3_orphan_cleanup() will see
2074 * that this inode's truncate did not complete and it will again call
2075 * ext3_truncate() to have another go. So there will be instantiated blocks
2076 * to the right of the truncation point in a crashed ext3 filesystem. But
2077 * that's fine - as long as they are linked from the inode, the post-crash
2078 * ext3_truncate() run will find them and release them.
2081 void ext3_truncate(struct inode * inode)
2084 struct ext3_inode_info *ei = EXT3_I(inode);
2085 __le32 *i_data = ei->i_data;
2086 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2087 struct address_space *mapping = inode->i_mapping;
2094 unsigned blocksize = inode->i_sb->s_blocksize;
2097 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
2098 S_ISLNK(inode->i_mode)))
2100 if (ext3_inode_is_fast_symlink(inode))
2102 if (IS_APPEND(inode) || IS_IXORUNLINK(inode))
2106 * We have to lock the EOF page here, because lock_page() nests
2107 * outside journal_start().
2109 if ((inode->i_size & (blocksize - 1)) == 0) {
2110 /* Block boundary? Nothing to do */
2113 page = grab_cache_page(mapping,
2114 inode->i_size >> PAGE_CACHE_SHIFT);
2119 handle = start_transaction(inode);
2120 if (IS_ERR(handle)) {
2122 clear_highpage(page);
2123 flush_dcache_page(page);
2125 page_cache_release(page);
2127 return; /* AKPM: return what? */
2130 last_block = (inode->i_size + blocksize-1)
2131 >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
2134 ext3_block_truncate_page(handle, page, mapping, inode->i_size);
2136 n = ext3_block_to_path(inode, last_block, offsets, NULL);
2138 goto out_stop; /* error */
2141 * OK. This truncate is going to happen. We add the inode to the
2142 * orphan list, so that if this truncate spans multiple transactions,
2143 * and we crash, we will resume the truncate when the filesystem
2144 * recovers. It also marks the inode dirty, to catch the new size.
2146 * Implication: the file must always be in a sane, consistent
2147 * truncatable state while each transaction commits.
2149 if (ext3_orphan_add(handle, inode))
2153 * The orphan list entry will now protect us from any crash which
2154 * occurs before the truncate completes, so it is now safe to propagate
2155 * the new, shorter inode size (held for now in i_size) into the
2156 * on-disk inode. We do this via i_disksize, which is the value which
2157 * ext3 *really* writes onto the disk inode.
2159 ei->i_disksize = inode->i_size;
2162 * From here we block out all ext3_get_block() callers who want to
2163 * modify the block allocation tree.
2165 down(&ei->truncate_sem);
2167 if (n == 1) { /* direct blocks */
2168 ext3_free_data(handle, inode, NULL, i_data+offsets[0],
2169 i_data + EXT3_NDIR_BLOCKS);
2173 partial = ext3_find_shared(inode, n, offsets, chain, &nr);
2174 /* Kill the top of shared branch (not detached) */
2176 if (partial == chain) {
2177 /* Shared branch grows from the inode */
2178 ext3_free_branches(handle, inode, NULL,
2179 &nr, &nr+1, (chain+n-1) - partial);
2182 * We mark the inode dirty prior to restart,
2183 * and prior to stop. No need for it here.
2186 /* Shared branch grows from an indirect block */
2187 BUFFER_TRACE(partial->bh, "get_write_access");
2188 ext3_free_branches(handle, inode, partial->bh,
2190 partial->p+1, (chain+n-1) - partial);
2193 /* Clear the ends of indirect blocks on the shared branch */
2194 while (partial > chain) {
2195 ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2196 (__le32*)partial->bh->b_data+addr_per_block,
2197 (chain+n-1) - partial);
2198 BUFFER_TRACE(partial->bh, "call brelse");
2199 brelse (partial->bh);
2203 /* Kill the remaining (whole) subtrees */
2204 switch (offsets[0]) {
2206 nr = i_data[EXT3_IND_BLOCK];
2208 ext3_free_branches(handle, inode, NULL,
2210 i_data[EXT3_IND_BLOCK] = 0;
2212 case EXT3_IND_BLOCK:
2213 nr = i_data[EXT3_DIND_BLOCK];
2215 ext3_free_branches(handle, inode, NULL,
2217 i_data[EXT3_DIND_BLOCK] = 0;
2219 case EXT3_DIND_BLOCK:
2220 nr = i_data[EXT3_TIND_BLOCK];
2222 ext3_free_branches(handle, inode, NULL,
2224 i_data[EXT3_TIND_BLOCK] = 0;
2226 case EXT3_TIND_BLOCK:
2230 ext3_discard_reservation(inode);
2232 up(&ei->truncate_sem);
2233 inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
2234 ext3_mark_inode_dirty(handle, inode);
2236 /* In a multi-transaction truncate, we only make the final
2237 * transaction synchronous */
2242 * If this was a simple ftruncate(), and the file will remain alive
2243 * then we need to clear up the orphan record which we created above.
2244 * However, if this was a real unlink then we were called by
2245 * ext3_delete_inode(), and we allow that function to clean up the
2246 * orphan info for us.
2249 ext3_orphan_del(handle, inode);
2251 ext3_journal_stop(handle);
2254 static unsigned long ext3_get_inode_block(struct super_block *sb,
2255 unsigned long ino, struct ext3_iloc *iloc)
2257 unsigned long desc, group_desc, block_group;
2258 unsigned long offset, block;
2259 struct buffer_head *bh;
2260 struct ext3_group_desc * gdp;
2263 if (!ext3_valid_inum(sb, ino)) {
2265 * This error is already checked for in namei.c unless we are
2266 * looking at an NFS filehandle, in which case no error
2272 block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
2273 if (block_group >= EXT3_SB(sb)->s_groups_count) {
2274 ext3_error (sb, "ext3_get_inode_block",
2275 "group >= groups count");
2279 group_desc = block_group >> EXT3_DESC_PER_BLOCK_BITS(sb);
2280 desc = block_group & (EXT3_DESC_PER_BLOCK(sb) - 1);
2281 bh = EXT3_SB(sb)->s_group_desc[group_desc];
2283 ext3_error (sb, "ext3_get_inode_block",
2284 "Descriptor not loaded");
2288 gdp = (struct ext3_group_desc *) bh->b_data;
2290 * Figure out the offset within the block group inode table
2292 offset = ((ino - 1) % EXT3_INODES_PER_GROUP(sb)) *
2293 EXT3_INODE_SIZE(sb);
2294 block = le32_to_cpu(gdp[desc].bg_inode_table) +
2295 (offset >> EXT3_BLOCK_SIZE_BITS(sb));
2297 iloc->block_group = block_group;
2298 iloc->offset = offset & (EXT3_BLOCK_SIZE(sb) - 1);
2303 * ext3_get_inode_loc returns with an extra refcount against the inode's
2304 * underlying buffer_head on success. If 'in_mem' is true, we have all
2305 * data in memory that is needed to recreate the on-disk version of this
2308 static int __ext3_get_inode_loc(struct inode *inode,
2309 struct ext3_iloc *iloc, int in_mem)
2311 unsigned long block;
2312 struct buffer_head *bh;
2314 block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
2318 bh = sb_getblk(inode->i_sb, block);
2320 ext3_error (inode->i_sb, "ext3_get_inode_loc",
2321 "unable to read inode block - "
2322 "inode=%lu, block=%lu", inode->i_ino, block);
2325 if (!buffer_uptodate(bh)) {
2327 if (buffer_uptodate(bh)) {
2328 /* someone brought it uptodate while we waited */
2334 * If we have all information of the inode in memory and this
2335 * is the only valid inode in the block, we need not read the
2339 struct buffer_head *bitmap_bh;
2340 struct ext3_group_desc *desc;
2341 int inodes_per_buffer;
2342 int inode_offset, i;
2346 block_group = (inode->i_ino - 1) /
2347 EXT3_INODES_PER_GROUP(inode->i_sb);
2348 inodes_per_buffer = bh->b_size /
2349 EXT3_INODE_SIZE(inode->i_sb);
2350 inode_offset = ((inode->i_ino - 1) %
2351 EXT3_INODES_PER_GROUP(inode->i_sb));
2352 start = inode_offset & ~(inodes_per_buffer - 1);
2354 /* Is the inode bitmap in cache? */
2355 desc = ext3_get_group_desc(inode->i_sb,
2360 bitmap_bh = sb_getblk(inode->i_sb,
2361 le32_to_cpu(desc->bg_inode_bitmap));
2366 * If the inode bitmap isn't in cache then the
2367 * optimisation may end up performing two reads instead
2368 * of one, so skip it.
2370 if (!buffer_uptodate(bitmap_bh)) {
2374 for (i = start; i < start + inodes_per_buffer; i++) {
2375 if (i == inode_offset)
2377 if (ext3_test_bit(i, bitmap_bh->b_data))
2381 if (i == start + inodes_per_buffer) {
2382 /* all other inodes are free, so skip I/O */
2383 memset(bh->b_data, 0, bh->b_size);
2384 set_buffer_uptodate(bh);
2392 * There are other valid inodes in the buffer, this inode
2393 * has in-inode xattrs, or we don't have this inode in memory.
2394 * Read the block from disk.
2397 bh->b_end_io = end_buffer_read_sync;
2398 submit_bh(READ, bh);
2400 if (!buffer_uptodate(bh)) {
2401 ext3_error(inode->i_sb, "ext3_get_inode_loc",
2402 "unable to read inode block - "
2403 "inode=%lu, block=%lu",
2404 inode->i_ino, block);
2414 int ext3_get_inode_loc(struct inode *inode, struct ext3_iloc *iloc)
2416 /* We have all inode data except xattrs in memory here. */
2417 return __ext3_get_inode_loc(inode, iloc,
2418 !(EXT3_I(inode)->i_state & EXT3_STATE_XATTR));
2421 void ext3_set_inode_flags(struct inode *inode)
2423 unsigned int flags = EXT3_I(inode)->i_flags;
2425 inode->i_flags &= ~(S_IMMUTABLE | S_IUNLINK | S_BARRIER |
2426 S_SYNC | S_APPEND | S_NOATIME | S_DIRSYNC);
2428 if (flags & EXT3_IMMUTABLE_FL)
2429 inode->i_flags |= S_IMMUTABLE;
2430 if (flags & EXT3_IUNLINK_FL)
2431 inode->i_flags |= S_IUNLINK;
2432 if (flags & EXT3_BARRIER_FL)
2433 inode->i_flags |= S_BARRIER;
2435 if (flags & EXT3_SYNC_FL)
2436 inode->i_flags |= S_SYNC;
2437 if (flags & EXT3_APPEND_FL)
2438 inode->i_flags |= S_APPEND;
2439 if (flags & EXT3_NOATIME_FL)
2440 inode->i_flags |= S_NOATIME;
2441 if (flags & EXT3_DIRSYNC_FL)
2442 inode->i_flags |= S_DIRSYNC;
2445 int ext3_sync_flags(struct inode *inode)
2447 unsigned int oldflags, newflags;
2450 oldflags = EXT3_I(inode)->i_flags;
2451 newflags = oldflags & ~(EXT3_APPEND_FL |
2452 EXT3_IMMUTABLE_FL | EXT3_IUNLINK_FL |
2453 EXT3_BARRIER_FL | EXT3_NOATIME_FL |
2454 EXT3_SYNC_FL | EXT3_DIRSYNC_FL);
2456 if (IS_APPEND(inode))
2457 newflags |= EXT3_APPEND_FL;
2458 if (IS_IMMUTABLE(inode))
2459 newflags |= EXT3_IMMUTABLE_FL;
2460 if (IS_IUNLINK(inode))
2461 newflags |= EXT3_IUNLINK_FL;
2462 if (IS_BARRIER(inode))
2463 newflags |= EXT3_BARRIER_FL;
2465 /* we do not want to copy superblock flags */
2466 if (inode->i_flags & S_NOATIME)
2467 newflags |= EXT3_NOATIME_FL;
2468 if (inode->i_flags & S_SYNC)
2469 newflags |= EXT3_SYNC_FL;
2470 if (inode->i_flags & S_DIRSYNC)
2471 newflags |= EXT3_DIRSYNC_FL;
2473 if (oldflags ^ newflags) {
2475 struct ext3_iloc iloc;
2477 handle = ext3_journal_start(inode, 1);
2479 return PTR_ERR(handle);
2482 err = ext3_reserve_inode_write(handle, inode, &iloc);
2486 EXT3_I(inode)->i_flags = newflags;
2487 inode->i_ctime = CURRENT_TIME;
2489 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
2491 ext3_journal_stop(handle);
2496 void ext3_read_inode(struct inode * inode)
2498 struct ext3_iloc iloc;
2499 struct ext3_inode *raw_inode;
2500 struct ext3_inode_info *ei = EXT3_I(inode);
2501 struct buffer_head *bh;
2506 #ifdef CONFIG_EXT3_FS_POSIX_ACL
2507 ei->i_acl = EXT3_ACL_NOT_CACHED;
2508 ei->i_default_acl = EXT3_ACL_NOT_CACHED;
2510 ei->i_block_alloc_info = NULL;
2512 if (__ext3_get_inode_loc(inode, &iloc, 0))
2515 raw_inode = ext3_raw_inode(&iloc);
2516 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
2517 uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
2518 gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
2519 if(!(test_opt (inode->i_sb, NO_UID32))) {
2520 uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
2521 gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
2523 inode->i_uid = INOXID_UID(XID_TAG(inode), uid, gid);
2524 inode->i_gid = INOXID_GID(XID_TAG(inode), uid, gid);
2525 inode->i_xid = INOXID_XID(XID_TAG(inode), uid, gid,
2526 le16_to_cpu(raw_inode->i_raw_xid));
2528 inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
2529 inode->i_size = le32_to_cpu(raw_inode->i_size);
2530 inode->i_atime.tv_sec = le32_to_cpu(raw_inode->i_atime);
2531 inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->i_ctime);
2532 inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->i_mtime);
2533 inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
2536 ei->i_dir_start_lookup = 0;
2537 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
2538 /* We now have enough fields to check if the inode was active or not.
2539 * This is needed because nfsd might try to access dead inodes
2540 * the test is that same one that e2fsck uses
2541 * NeilBrown 1999oct15
2543 if (inode->i_nlink == 0) {
2544 if (inode->i_mode == 0 ||
2545 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
2546 /* this inode is deleted */
2550 /* The only unlinked inodes we let through here have
2551 * valid i_mode and are being read by the orphan
2552 * recovery code: that's fine, we're about to complete
2553 * the process of deleting those. */
2555 inode->i_blksize = PAGE_SIZE; /* This is the optimal IO size
2556 * (for stat), not the fs block
2558 inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
2559 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
2560 #ifdef EXT3_FRAGMENTS
2561 ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
2562 ei->i_frag_no = raw_inode->i_frag;
2563 ei->i_frag_size = raw_inode->i_fsize;
2565 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
2566 if (!S_ISREG(inode->i_mode)) {
2567 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
2570 ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
2572 ei->i_disksize = inode->i_size;
2573 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
2574 ei->i_block_group = iloc.block_group;
2576 * NOTE! The in-memory inode i_data array is in little-endian order
2577 * even on big-endian machines: we do NOT byteswap the block numbers!
2579 for (block = 0; block < EXT3_N_BLOCKS; block++)
2580 ei->i_data[block] = raw_inode->i_block[block];
2581 INIT_LIST_HEAD(&ei->i_orphan);
2583 if (inode->i_ino >= EXT3_FIRST_INO(inode->i_sb) + 1 &&
2584 EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) {
2586 * When mke2fs creates big inodes it does not zero out
2587 * the unused bytes above EXT3_GOOD_OLD_INODE_SIZE,
2588 * so ignore those first few inodes.
2590 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
2591 if (EXT3_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
2592 EXT3_INODE_SIZE(inode->i_sb))
2594 if (ei->i_extra_isize == 0) {
2595 /* The extra space is currently unused. Use it. */
2596 ei->i_extra_isize = sizeof(struct ext3_inode) -
2597 EXT3_GOOD_OLD_INODE_SIZE;
2599 __le32 *magic = (void *)raw_inode +
2600 EXT3_GOOD_OLD_INODE_SIZE +
2602 if (*magic == cpu_to_le32(EXT3_XATTR_MAGIC))
2603 ei->i_state |= EXT3_STATE_XATTR;
2606 ei->i_extra_isize = 0;
2608 if (S_ISREG(inode->i_mode)) {
2609 inode->i_op = &ext3_file_inode_operations;
2610 inode->i_fop = &ext3_file_operations;
2611 ext3_set_aops(inode);
2612 } else if (S_ISDIR(inode->i_mode)) {
2613 inode->i_op = &ext3_dir_inode_operations;
2614 inode->i_fop = &ext3_dir_operations;
2615 } else if (S_ISLNK(inode->i_mode)) {
2616 if (ext3_inode_is_fast_symlink(inode))
2617 inode->i_op = &ext3_fast_symlink_inode_operations;
2619 inode->i_op = &ext3_symlink_inode_operations;
2620 ext3_set_aops(inode);
2623 inode->i_op = &ext3_special_inode_operations;
2624 if (raw_inode->i_block[0])
2625 init_special_inode(inode, inode->i_mode,
2626 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
2628 init_special_inode(inode, inode->i_mode,
2629 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
2632 ext3_set_inode_flags(inode);
2636 make_bad_inode(inode);
2641 * Post the struct inode info into an on-disk inode location in the
2642 * buffer-cache. This gobbles the caller's reference to the
2643 * buffer_head in the inode location struct.
2645 * The caller must have write access to iloc->bh.
2647 static int ext3_do_update_inode(handle_t *handle,
2648 struct inode *inode,
2649 struct ext3_iloc *iloc)
2651 struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
2652 struct ext3_inode_info *ei = EXT3_I(inode);
2653 struct buffer_head *bh = iloc->bh;
2654 uid_t uid = XIDINO_UID(XID_TAG(inode), inode->i_uid, inode->i_xid);
2655 gid_t gid = XIDINO_GID(XID_TAG(inode), inode->i_gid, inode->i_xid);
2656 int err = 0, rc, block;
2658 /* For fields not not tracking in the in-memory inode,
2659 * initialise them to zero for new inodes. */
2660 if (ei->i_state & EXT3_STATE_NEW)
2661 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
2663 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
2664 if(!(test_opt(inode->i_sb, NO_UID32))) {
2665 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(uid));
2666 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(gid));
2668 * Fix up interoperability with old kernels. Otherwise, old inodes get
2669 * re-used with the upper 16 bits of the uid/gid intact
2672 raw_inode->i_uid_high =
2673 cpu_to_le16(high_16_bits(uid));
2674 raw_inode->i_gid_high =
2675 cpu_to_le16(high_16_bits(gid));
2677 raw_inode->i_uid_high = 0;
2678 raw_inode->i_gid_high = 0;
2681 raw_inode->i_uid_low =
2682 cpu_to_le16(fs_high2lowuid(uid));
2683 raw_inode->i_gid_low =
2684 cpu_to_le16(fs_high2lowgid(gid));
2685 raw_inode->i_uid_high = 0;
2686 raw_inode->i_gid_high = 0;
2688 #ifdef CONFIG_INOXID_INTERN
2689 raw_inode->i_raw_xid = cpu_to_le16(inode->i_xid);
2691 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
2692 raw_inode->i_size = cpu_to_le32(ei->i_disksize);
2693 raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
2694 raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
2695 raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
2696 raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
2697 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
2698 raw_inode->i_flags = cpu_to_le32(ei->i_flags);
2699 #ifdef EXT3_FRAGMENTS
2700 raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
2701 raw_inode->i_frag = ei->i_frag_no;
2702 raw_inode->i_fsize = ei->i_frag_size;
2704 raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
2705 if (!S_ISREG(inode->i_mode)) {
2706 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
2708 raw_inode->i_size_high =
2709 cpu_to_le32(ei->i_disksize >> 32);
2710 if (ei->i_disksize > 0x7fffffffULL) {
2711 struct super_block *sb = inode->i_sb;
2712 if (!EXT3_HAS_RO_COMPAT_FEATURE(sb,
2713 EXT3_FEATURE_RO_COMPAT_LARGE_FILE) ||
2714 EXT3_SB(sb)->s_es->s_rev_level ==
2715 cpu_to_le32(EXT3_GOOD_OLD_REV)) {
2716 /* If this is the first large file
2717 * created, add a flag to the superblock.
2719 err = ext3_journal_get_write_access(handle,
2720 EXT3_SB(sb)->s_sbh);
2723 ext3_update_dynamic_rev(sb);
2724 EXT3_SET_RO_COMPAT_FEATURE(sb,
2725 EXT3_FEATURE_RO_COMPAT_LARGE_FILE);
2728 err = ext3_journal_dirty_metadata(handle,
2729 EXT3_SB(sb)->s_sbh);
2733 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
2734 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
2735 if (old_valid_dev(inode->i_rdev)) {
2736 raw_inode->i_block[0] =
2737 cpu_to_le32(old_encode_dev(inode->i_rdev));
2738 raw_inode->i_block[1] = 0;
2740 raw_inode->i_block[0] = 0;
2741 raw_inode->i_block[1] =
2742 cpu_to_le32(new_encode_dev(inode->i_rdev));
2743 raw_inode->i_block[2] = 0;
2745 } else for (block = 0; block < EXT3_N_BLOCKS; block++)
2746 raw_inode->i_block[block] = ei->i_data[block];
2748 if (ei->i_extra_isize)
2749 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
2751 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2752 rc = ext3_journal_dirty_metadata(handle, bh);
2755 ei->i_state &= ~EXT3_STATE_NEW;
2759 ext3_std_error(inode->i_sb, err);
2764 * ext3_write_inode()
2766 * We are called from a few places:
2768 * - Within generic_file_write() for O_SYNC files.
2769 * Here, there will be no transaction running. We wait for any running
2770 * trasnaction to commit.
2772 * - Within sys_sync(), kupdate and such.
2773 * We wait on commit, if tol to.
2775 * - Within prune_icache() (PF_MEMALLOC == true)
2776 * Here we simply return. We can't afford to block kswapd on the
2779 * In all cases it is actually safe for us to return without doing anything,
2780 * because the inode has been copied into a raw inode buffer in
2781 * ext3_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
2784 * Note that we are absolutely dependent upon all inode dirtiers doing the
2785 * right thing: they *must* call mark_inode_dirty() after dirtying info in
2786 * which we are interested.
2788 * It would be a bug for them to not do this. The code:
2790 * mark_inode_dirty(inode)
2792 * inode->i_size = expr;
2794 * is in error because a kswapd-driven write_inode() could occur while
2795 * `stuff()' is running, and the new i_size will be lost. Plus the inode
2796 * will no longer be on the superblock's dirty inode list.
2798 int ext3_write_inode(struct inode *inode, int wait)
2800 if (current->flags & PF_MEMALLOC)
2803 if (ext3_journal_current_handle()) {
2804 jbd_debug(0, "called recursively, non-PF_MEMALLOC!\n");
2812 return ext3_force_commit(inode->i_sb);
2818 * Called from notify_change.
2820 * We want to trap VFS attempts to truncate the file as soon as
2821 * possible. In particular, we want to make sure that when the VFS
2822 * shrinks i_size, we put the inode on the orphan list and modify
2823 * i_disksize immediately, so that during the subsequent flushing of
2824 * dirty pages and freeing of disk blocks, we can guarantee that any
2825 * commit will leave the blocks being flushed in an unused state on
2826 * disk. (On recovery, the inode will get truncated and the blocks will
2827 * be freed, so we have a strong guarantee that no future commit will
2828 * leave these blocks visible to the user.)
2830 * Called with inode->sem down.
2832 int ext3_setattr(struct dentry *dentry, struct iattr *attr)
2834 struct inode *inode = dentry->d_inode;
2836 const unsigned int ia_valid = attr->ia_valid;
2838 error = inode_change_ok(inode, attr);
2842 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2843 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid) ||
2844 (ia_valid & ATTR_XID && attr->ia_xid != inode->i_xid)) {
2847 /* (user+group)*(old+new) structure, inode write (sb,
2848 * inode block, ? - but truncate inode update has it) */
2849 handle = ext3_journal_start(inode, 2*(EXT3_QUOTA_INIT_BLOCKS(inode->i_sb)+
2850 EXT3_QUOTA_DEL_BLOCKS(inode->i_sb))+3);
2851 if (IS_ERR(handle)) {
2852 error = PTR_ERR(handle);
2855 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2857 ext3_journal_stop(handle);
2860 /* Update corresponding info in inode so that everything is in
2861 * one transaction */
2862 if (attr->ia_valid & ATTR_UID)
2863 inode->i_uid = attr->ia_uid;
2864 if (attr->ia_valid & ATTR_GID)
2865 inode->i_gid = attr->ia_gid;
2866 if ((attr->ia_valid & ATTR_XID) && IS_TAGXID(inode))
2867 inode->i_xid = attr->ia_xid;
2868 error = ext3_mark_inode_dirty(handle, inode);
2869 ext3_journal_stop(handle);
2872 if (S_ISREG(inode->i_mode) &&
2873 attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
2876 handle = ext3_journal_start(inode, 3);
2877 if (IS_ERR(handle)) {
2878 error = PTR_ERR(handle);
2882 error = ext3_orphan_add(handle, inode);
2883 EXT3_I(inode)->i_disksize = attr->ia_size;
2884 rc = ext3_mark_inode_dirty(handle, inode);
2887 ext3_journal_stop(handle);
2890 rc = inode_setattr(inode, attr);
2892 /* If inode_setattr's call to ext3_truncate failed to get a
2893 * transaction handle at all, we need to clean up the in-core
2894 * orphan list manually. */
2896 ext3_orphan_del(NULL, inode);
2898 if (!rc && (ia_valid & ATTR_MODE))
2899 rc = ext3_acl_chmod(inode);
2902 ext3_std_error(inode->i_sb, error);
2910 * akpm: how many blocks doth make a writepage()?
2912 * With N blocks per page, it may be:
2917 * N+5 bitmap blocks (from the above)
2918 * N+5 group descriptor summary blocks
2921 * 2 * EXT3_SINGLEDATA_TRANS_BLOCKS for the quote files
2923 * 3 * (N + 5) + 2 + 2 * EXT3_SINGLEDATA_TRANS_BLOCKS
2925 * With ordered or writeback data it's the same, less the N data blocks.
2927 * If the inode's direct blocks can hold an integral number of pages then a
2928 * page cannot straddle two indirect blocks, and we can only touch one indirect
2929 * and dindirect block, and the "5" above becomes "3".
2931 * This still overestimates under most circumstances. If we were to pass the
2932 * start and end offsets in here as well we could do block_to_path() on each
2933 * block and work out the exact number of indirects which are touched. Pah.
2936 static int ext3_writepage_trans_blocks(struct inode *inode)
2938 int bpp = ext3_journal_blocks_per_page(inode);
2939 int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
2942 if (ext3_should_journal_data(inode))
2943 ret = 3 * (bpp + indirects) + 2;
2945 ret = 2 * (bpp + indirects) + 2;
2948 /* We know that structure was already allocated during DQUOT_INIT so
2949 * we will be updating only the data blocks + inodes */
2950 ret += 2*EXT3_QUOTA_TRANS_BLOCKS(inode->i_sb);
2957 * The caller must have previously called ext3_reserve_inode_write().
2958 * Give this, we know that the caller already has write access to iloc->bh.
2960 int ext3_mark_iloc_dirty(handle_t *handle,
2961 struct inode *inode, struct ext3_iloc *iloc)
2965 /* the do_update_inode consumes one bh->b_count */
2968 /* ext3_do_update_inode() does journal_dirty_metadata */
2969 err = ext3_do_update_inode(handle, inode, iloc);
2975 * On success, We end up with an outstanding reference count against
2976 * iloc->bh. This _must_ be cleaned up later.
2980 ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
2981 struct ext3_iloc *iloc)
2985 err = ext3_get_inode_loc(inode, iloc);
2987 BUFFER_TRACE(iloc->bh, "get_write_access");
2988 err = ext3_journal_get_write_access(handle, iloc->bh);
2995 ext3_std_error(inode->i_sb, err);
3000 * akpm: What we do here is to mark the in-core inode as clean
3001 * with respect to inode dirtiness (it may still be data-dirty).
3002 * This means that the in-core inode may be reaped by prune_icache
3003 * without having to perform any I/O. This is a very good thing,
3004 * because *any* task may call prune_icache - even ones which
3005 * have a transaction open against a different journal.
3007 * Is this cheating? Not really. Sure, we haven't written the
3008 * inode out, but prune_icache isn't a user-visible syncing function.
3009 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
3010 * we start and wait on commits.
3012 * Is this efficient/effective? Well, we're being nice to the system
3013 * by cleaning up our inodes proactively so they can be reaped
3014 * without I/O. But we are potentially leaving up to five seconds'
3015 * worth of inodes floating about which prune_icache wants us to
3016 * write out. One way to fix that would be to get prune_icache()
3017 * to do a write_super() to free up some memory. It has the desired
3020 int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
3022 struct ext3_iloc iloc;
3026 err = ext3_reserve_inode_write(handle, inode, &iloc);
3028 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
3033 * akpm: ext3_dirty_inode() is called from __mark_inode_dirty()
3035 * We're really interested in the case where a file is being extended.
3036 * i_size has been changed by generic_commit_write() and we thus need
3037 * to include the updated inode in the current transaction.
3039 * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks
3040 * are allocated to the file.
3042 * If the inode is marked synchronous, we don't honour that here - doing
3043 * so would cause a commit on atime updates, which we don't bother doing.
3044 * We handle synchronous inodes at the highest possible level.
3046 void ext3_dirty_inode(struct inode *inode)
3048 handle_t *current_handle = ext3_journal_current_handle();
3051 handle = ext3_journal_start(inode, 2);
3054 if (current_handle &&
3055 current_handle->h_transaction != handle->h_transaction) {
3056 /* This task has a transaction open against a different fs */
3057 printk(KERN_EMERG "%s: transactions do not match!\n",
3060 jbd_debug(5, "marking dirty. outer handle=%p\n",
3062 ext3_mark_inode_dirty(handle, inode);
3064 ext3_journal_stop(handle);
3071 * Bind an inode's backing buffer_head into this transaction, to prevent
3072 * it from being flushed to disk early. Unlike
3073 * ext3_reserve_inode_write, this leaves behind no bh reference and
3074 * returns no iloc structure, so the caller needs to repeat the iloc
3075 * lookup to mark the inode dirty later.
3078 ext3_pin_inode(handle_t *handle, struct inode *inode)
3080 struct ext3_iloc iloc;
3084 err = ext3_get_inode_loc(inode, &iloc);
3086 BUFFER_TRACE(iloc.bh, "get_write_access");
3087 err = journal_get_write_access(handle, iloc.bh);
3089 err = ext3_journal_dirty_metadata(handle,
3094 ext3_std_error(inode->i_sb, err);
3099 int ext3_change_inode_journal_flag(struct inode *inode, int val)
3106 * We have to be very careful here: changing a data block's
3107 * journaling status dynamically is dangerous. If we write a
3108 * data block to the journal, change the status and then delete
3109 * that block, we risk forgetting to revoke the old log record
3110 * from the journal and so a subsequent replay can corrupt data.
3111 * So, first we make sure that the journal is empty and that
3112 * nobody is changing anything.
3115 journal = EXT3_JOURNAL(inode);
3116 if (is_journal_aborted(journal) || IS_RDONLY(inode))
3119 journal_lock_updates(journal);
3120 journal_flush(journal);
3123 * OK, there are no updates running now, and all cached data is
3124 * synced to disk. We are now in a completely consistent state
3125 * which doesn't have anything in the journal, and we know that
3126 * no filesystem updates are running, so it is safe to modify
3127 * the inode's in-core data-journaling state flag now.
3131 EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
3133 EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
3134 ext3_set_aops(inode);
3136 journal_unlock_updates(journal);
3138 /* Finally we can mark the inode as dirty. */
3140 handle = ext3_journal_start(inode, 1);
3142 return PTR_ERR(handle);
3144 err = ext3_mark_inode_dirty(handle, inode);
3146 ext3_journal_stop(handle);
3147 ext3_std_error(inode->i_sb, err);