ext3: Truncate allocated blocks if direct IO write fails to update i_size
[linux-2.6.git] / fs / ext3 / inode.c
1 /*
2  *  linux/fs/ext3/inode.c
3  *
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)
8  *
9  *  from
10  *
11  *  linux/fs/minix/inode.c
12  *
13  *  Copyright (C) 1991, 1992  Linus Torvalds
14  *
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)
21  *
22  *  Assorted race fixes, rewrite of ext3_get_block() by Al Viro, 2000
23  */
24
25 #include <linux/module.h>
26 #include <linux/fs.h>
27 #include <linux/time.h>
28 #include <linux/ext3_jbd.h>
29 #include <linux/jbd.h>
30 #include <linux/highuid.h>
31 #include <linux/pagemap.h>
32 #include <linux/quotaops.h>
33 #include <linux/string.h>
34 #include <linux/buffer_head.h>
35 #include <linux/writeback.h>
36 #include <linux/mpage.h>
37 #include <linux/uio.h>
38 #include <linux/bio.h>
39 #include <linux/fiemap.h>
40 #include <linux/namei.h>
41 #include "xattr.h"
42 #include "acl.h"
43
44 static int ext3_writepage_trans_blocks(struct inode *inode);
45
46 /*
47  * Test whether an inode is a fast symlink.
48  */
49 static int ext3_inode_is_fast_symlink(struct inode *inode)
50 {
51         int ea_blocks = EXT3_I(inode)->i_file_acl ?
52                 (inode->i_sb->s_blocksize >> 9) : 0;
53
54         return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
55 }
56
57 /*
58  * The ext3 forget function must perform a revoke if we are freeing data
59  * which has been journaled.  Metadata (eg. indirect blocks) must be
60  * revoked in all cases.
61  *
62  * "bh" may be NULL: a metadata block may have been freed from memory
63  * but there may still be a record of it in the journal, and that record
64  * still needs to be revoked.
65  */
66 int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
67                         struct buffer_head *bh, ext3_fsblk_t blocknr)
68 {
69         int err;
70
71         might_sleep();
72
73         BUFFER_TRACE(bh, "enter");
74
75         jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
76                   "data mode %lx\n",
77                   bh, is_metadata, inode->i_mode,
78                   test_opt(inode->i_sb, DATA_FLAGS));
79
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
83          * data blocks. */
84
85         if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ||
86             (!is_metadata && !ext3_should_journal_data(inode))) {
87                 if (bh) {
88                         BUFFER_TRACE(bh, "call journal_forget");
89                         return ext3_journal_forget(handle, bh);
90                 }
91                 return 0;
92         }
93
94         /*
95          * data!=journal && (is_metadata || should_journal_data(inode))
96          */
97         BUFFER_TRACE(bh, "call ext3_journal_revoke");
98         err = ext3_journal_revoke(handle, blocknr, bh);
99         if (err)
100                 ext3_abort(inode->i_sb, __func__,
101                            "error %d when attempting revoke", err);
102         BUFFER_TRACE(bh, "exit");
103         return err;
104 }
105
106 /*
107  * Work out how many blocks we need to proceed with the next chunk of a
108  * truncate transaction.
109  */
110 static unsigned long blocks_for_truncate(struct inode *inode)
111 {
112         unsigned long needed;
113
114         needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
115
116         /* Give ourselves just enough room to cope with inodes in which
117          * i_blocks is corrupt: we've seen disk corruptions in the past
118          * which resulted in random data in an inode which looked enough
119          * like a regular file for ext3 to try to delete it.  Things
120          * will go a bit crazy if that happens, but at least we should
121          * try not to panic the whole kernel. */
122         if (needed < 2)
123                 needed = 2;
124
125         /* But we need to bound the transaction so we don't overflow the
126          * journal. */
127         if (needed > EXT3_MAX_TRANS_DATA)
128                 needed = EXT3_MAX_TRANS_DATA;
129
130         return EXT3_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
131 }
132
133 /*
134  * Truncate transactions can be complex and absolutely huge.  So we need to
135  * be able to restart the transaction at a conventient checkpoint to make
136  * sure we don't overflow the journal.
137  *
138  * start_transaction gets us a new handle for a truncate transaction,
139  * and extend_transaction tries to extend the existing one a bit.  If
140  * extend fails, we need to propagate the failure up and restart the
141  * transaction in the top-level truncate loop. --sct
142  */
143 static handle_t *start_transaction(struct inode *inode)
144 {
145         handle_t *result;
146
147         result = ext3_journal_start(inode, blocks_for_truncate(inode));
148         if (!IS_ERR(result))
149                 return result;
150
151         ext3_std_error(inode->i_sb, PTR_ERR(result));
152         return result;
153 }
154
155 /*
156  * Try to extend this transaction for the purposes of truncation.
157  *
158  * Returns 0 if we managed to create more room.  If we can't create more
159  * room, and the transaction must be restarted we return 1.
160  */
161 static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
162 {
163         if (handle->h_buffer_credits > EXT3_RESERVE_TRANS_BLOCKS)
164                 return 0;
165         if (!ext3_journal_extend(handle, blocks_for_truncate(inode)))
166                 return 0;
167         return 1;
168 }
169
170 /*
171  * Restart the transaction associated with *handle.  This does a commit,
172  * so before we call here everything must be consistently dirtied against
173  * this transaction.
174  */
175 static int truncate_restart_transaction(handle_t *handle, struct inode *inode)
176 {
177         int ret;
178
179         jbd_debug(2, "restarting handle %p\n", handle);
180         /*
181          * Drop truncate_mutex to avoid deadlock with ext3_get_blocks_handle
182          * At this moment, get_block can be called only for blocks inside
183          * i_size since page cache has been already dropped and writes are
184          * blocked by i_mutex. So we can safely drop the truncate_mutex.
185          */
186         mutex_unlock(&EXT3_I(inode)->truncate_mutex);
187         ret = ext3_journal_restart(handle, blocks_for_truncate(inode));
188         mutex_lock(&EXT3_I(inode)->truncate_mutex);
189         return ret;
190 }
191
192 /*
193  * Called at the last iput() if i_nlink is zero.
194  */
195 void ext3_delete_inode (struct inode * inode)
196 {
197         handle_t *handle;
198
199         truncate_inode_pages(&inode->i_data, 0);
200
201         if (is_bad_inode(inode))
202                 goto no_delete;
203
204         handle = start_transaction(inode);
205         if (IS_ERR(handle)) {
206                 /*
207                  * If we're going to skip the normal cleanup, we still need to
208                  * make sure that the in-core orphan linked list is properly
209                  * cleaned up.
210                  */
211                 ext3_orphan_del(NULL, inode);
212                 goto no_delete;
213         }
214
215         if (IS_SYNC(inode))
216                 handle->h_sync = 1;
217         inode->i_size = 0;
218         if (inode->i_blocks)
219                 ext3_truncate(inode);
220         /*
221          * Kill off the orphan record which ext3_truncate created.
222          * AKPM: I think this can be inside the above `if'.
223          * Note that ext3_orphan_del() has to be able to cope with the
224          * deletion of a non-existent orphan - this is because we don't
225          * know if ext3_truncate() actually created an orphan record.
226          * (Well, we could do this if we need to, but heck - it works)
227          */
228         ext3_orphan_del(handle, inode);
229         EXT3_I(inode)->i_dtime  = get_seconds();
230
231         /*
232          * One subtle ordering requirement: if anything has gone wrong
233          * (transaction abort, IO errors, whatever), then we can still
234          * do these next steps (the fs will already have been marked as
235          * having errors), but we can't free the inode if the mark_dirty
236          * fails.
237          */
238         if (ext3_mark_inode_dirty(handle, inode))
239                 /* If that failed, just do the required in-core inode clear. */
240                 clear_inode(inode);
241         else
242                 ext3_free_inode(handle, inode);
243         ext3_journal_stop(handle);
244         return;
245 no_delete:
246         clear_inode(inode);     /* We must guarantee clearing of inode... */
247 }
248
249 typedef struct {
250         __le32  *p;
251         __le32  key;
252         struct buffer_head *bh;
253 } Indirect;
254
255 static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
256 {
257         p->key = *(p->p = v);
258         p->bh = bh;
259 }
260
261 static int verify_chain(Indirect *from, Indirect *to)
262 {
263         while (from <= to && from->key == *from->p)
264                 from++;
265         return (from > to);
266 }
267
268 /**
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.
275  *
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.
283  *
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
286  *      inode->i_sb).
287  */
288
289 /*
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
296  * get there at all.
297  */
298
299 static int ext3_block_to_path(struct inode *inode,
300                         long i_block, int offsets[4], int *boundary)
301 {
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));
307         int n = 0;
308         int final = 0;
309
310         if (i_block < 0) {
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;
318                 final = ptrs;
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);
323                 final = ptrs;
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);
329                 final = ptrs;
330         } else {
331                 ext3_warning(inode->i_sb, "ext3_block_to_path", "block > big");
332         }
333         if (boundary)
334                 *boundary = final - 1 - (i_block & (ptrs - 1));
335         return n;
336 }
337
338 /**
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
345  *
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
356  *      numbers.
357  *
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).
366  */
367 static Indirect *ext3_get_branch(struct inode *inode, int depth, int *offsets,
368                                  Indirect chain[4], int *err)
369 {
370         struct super_block *sb = inode->i_sb;
371         Indirect *p = chain;
372         struct buffer_head *bh;
373
374         *err = 0;
375         /* i_data is not going away, no lock needed */
376         add_chain (chain, NULL, EXT3_I(inode)->i_data + *offsets);
377         if (!p->key)
378                 goto no_block;
379         while (--depth) {
380                 bh = sb_bread(sb, le32_to_cpu(p->key));
381                 if (!bh)
382                         goto failure;
383                 /* Reader: pointers */
384                 if (!verify_chain(chain, p))
385                         goto changed;
386                 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
387                 /* Reader: end */
388                 if (!p->key)
389                         goto no_block;
390         }
391         return NULL;
392
393 changed:
394         brelse(bh);
395         *err = -EAGAIN;
396         goto no_block;
397 failure:
398         *err = -EIO;
399 no_block:
400         return p;
401 }
402
403 /**
404  *      ext3_find_near - find a place for allocation with sufficient locality
405  *      @inode: owner
406  *      @ind: descriptor of indirect block.
407  *
408  *      This function returns the preferred place for block allocation.
409  *      It is used when heuristic for sequential allocation fails.
410  *      Rules are:
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
414  *          cylinder group.
415  *
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.
420  *
421  *      Caller must make sure that @ind is valid and will stay that way.
422  */
423 static ext3_fsblk_t ext3_find_near(struct inode *inode, Indirect *ind)
424 {
425         struct ext3_inode_info *ei = EXT3_I(inode);
426         __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
427         __le32 *p;
428         ext3_fsblk_t bg_start;
429         ext3_grpblk_t colour;
430
431         /* Try to find previous block */
432         for (p = ind->p - 1; p >= start; p--) {
433                 if (*p)
434                         return le32_to_cpu(*p);
435         }
436
437         /* No such thing, so let's try location of indirect block */
438         if (ind->bh)
439                 return ind->bh->b_blocknr;
440
441         /*
442          * It is going to be referred to from the inode itself? OK, just put it
443          * into the same cylinder group then.
444          */
445         bg_start = ext3_group_first_block_no(inode->i_sb, ei->i_block_group);
446         colour = (current->pid % 16) *
447                         (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
448         return bg_start + colour;
449 }
450
451 /**
452  *      ext3_find_goal - find a preferred place for allocation.
453  *      @inode: owner
454  *      @block:  block we want
455  *      @partial: pointer to the last triple within a chain
456  *
457  *      Normally this function find the preferred place for block allocation,
458  *      returns it.
459  */
460
461 static ext3_fsblk_t ext3_find_goal(struct inode *inode, long block,
462                                    Indirect *partial)
463 {
464         struct ext3_block_alloc_info *block_i;
465
466         block_i =  EXT3_I(inode)->i_block_alloc_info;
467
468         /*
469          * try the heuristic for sequential allocation,
470          * failing that at least try to get decent locality.
471          */
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;
475         }
476
477         return ext3_find_near(inode, partial);
478 }
479
480 /**
481  *      ext3_blks_to_allocate: Look up the block map and count the number
482  *      of direct blocks need to be allocated for the given branch.
483  *
484  *      @branch: chain of indirect blocks
485  *      @k: number of blocks need for indirect blocks
486  *      @blks: number of data blocks to be mapped.
487  *      @blocks_to_boundary:  the offset in the indirect block
488  *
489  *      return the total number of blocks to be allocate, including the
490  *      direct and indirect blocks.
491  */
492 static int ext3_blks_to_allocate(Indirect *branch, int k, unsigned long blks,
493                 int blocks_to_boundary)
494 {
495         unsigned long count = 0;
496
497         /*
498          * Simple case, [t,d]Indirect block(s) has not allocated yet
499          * then it's clear blocks on that path have not allocated
500          */
501         if (k > 0) {
502                 /* right now we don't handle cross boundary allocation */
503                 if (blks < blocks_to_boundary + 1)
504                         count += blks;
505                 else
506                         count += blocks_to_boundary + 1;
507                 return count;
508         }
509
510         count++;
511         while (count < blks && count <= blocks_to_boundary &&
512                 le32_to_cpu(*(branch[0].p + count)) == 0) {
513                 count++;
514         }
515         return count;
516 }
517
518 /**
519  *      ext3_alloc_blocks: multiple allocate blocks needed for a branch
520  *      @indirect_blks: the number of blocks need to allocate for indirect
521  *                      blocks
522  *
523  *      @new_blocks: on return it will store the new block numbers for
524  *      the indirect blocks(if needed) and the first direct block,
525  *      @blks:  on return it will store the total number of allocated
526  *              direct blocks
527  */
528 static int ext3_alloc_blocks(handle_t *handle, struct inode *inode,
529                         ext3_fsblk_t goal, int indirect_blks, int blks,
530                         ext3_fsblk_t new_blocks[4], int *err)
531 {
532         int target, i;
533         unsigned long count = 0;
534         int index = 0;
535         ext3_fsblk_t current_block = 0;
536         int ret = 0;
537
538         /*
539          * Here we try to allocate the requested multiple blocks at once,
540          * on a best-effort basis.
541          * To build a branch, we should allocate blocks for
542          * the indirect blocks(if not allocated yet), and at least
543          * the first direct block of this branch.  That's the
544          * minimum number of blocks need to allocate(required)
545          */
546         target = blks + indirect_blks;
547
548         while (1) {
549                 count = target;
550                 /* allocating blocks for indirect blocks and direct blocks */
551                 current_block = ext3_new_blocks(handle,inode,goal,&count,err);
552                 if (*err)
553                         goto failed_out;
554
555                 target -= count;
556                 /* allocate blocks for indirect blocks */
557                 while (index < indirect_blks && count) {
558                         new_blocks[index++] = current_block++;
559                         count--;
560                 }
561
562                 if (count > 0)
563                         break;
564         }
565
566         /* save the new block number for the first direct block */
567         new_blocks[index] = current_block;
568
569         /* total number of blocks allocated for direct blocks */
570         ret = count;
571         *err = 0;
572         return ret;
573 failed_out:
574         for (i = 0; i <index; i++)
575                 ext3_free_blocks(handle, inode, new_blocks[i], 1);
576         return ret;
577 }
578
579 /**
580  *      ext3_alloc_branch - allocate and set up a chain of blocks.
581  *      @inode: owner
582  *      @indirect_blks: number of allocated indirect blocks
583  *      @blks: number of allocated direct blocks
584  *      @offsets: offsets (in the blocks) to store the pointers to next.
585  *      @branch: place to store the chain in.
586  *
587  *      This function allocates blocks, zeroes out all but the last one,
588  *      links them into chain and (if we are synchronous) writes them to disk.
589  *      In other words, it prepares a branch that can be spliced onto the
590  *      inode. It stores the information about that chain in the branch[], in
591  *      the same format as ext3_get_branch() would do. We are calling it after
592  *      we had read the existing part of chain and partial points to the last
593  *      triple of that (one with zero ->key). Upon the exit we have the same
594  *      picture as after the successful ext3_get_block(), except that in one
595  *      place chain is disconnected - *branch->p is still zero (we did not
596  *      set the last link), but branch->key contains the number that should
597  *      be placed into *branch->p to fill that gap.
598  *
599  *      If allocation fails we free all blocks we've allocated (and forget
600  *      their buffer_heads) and return the error value the from failed
601  *      ext3_alloc_block() (normally -ENOSPC). Otherwise we set the chain
602  *      as described above and return 0.
603  */
604 static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
605                         int indirect_blks, int *blks, ext3_fsblk_t goal,
606                         int *offsets, Indirect *branch)
607 {
608         int blocksize = inode->i_sb->s_blocksize;
609         int i, n = 0;
610         int err = 0;
611         struct buffer_head *bh;
612         int num;
613         ext3_fsblk_t new_blocks[4];
614         ext3_fsblk_t current_block;
615
616         num = ext3_alloc_blocks(handle, inode, goal, indirect_blks,
617                                 *blks, new_blocks, &err);
618         if (err)
619                 return err;
620
621         branch[0].key = cpu_to_le32(new_blocks[0]);
622         /*
623          * metadata blocks and data blocks are allocated.
624          */
625         for (n = 1; n <= indirect_blks;  n++) {
626                 /*
627                  * Get buffer_head for parent block, zero it out
628                  * and set the pointer to new one, then send
629                  * parent to disk.
630                  */
631                 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
632                 branch[n].bh = bh;
633                 lock_buffer(bh);
634                 BUFFER_TRACE(bh, "call get_create_access");
635                 err = ext3_journal_get_create_access(handle, bh);
636                 if (err) {
637                         unlock_buffer(bh);
638                         brelse(bh);
639                         goto failed;
640                 }
641
642                 memset(bh->b_data, 0, blocksize);
643                 branch[n].p = (__le32 *) bh->b_data + offsets[n];
644                 branch[n].key = cpu_to_le32(new_blocks[n]);
645                 *branch[n].p = branch[n].key;
646                 if ( n == indirect_blks) {
647                         current_block = new_blocks[n];
648                         /*
649                          * End of chain, update the last new metablock of
650                          * the chain to point to the new allocated
651                          * data blocks numbers
652                          */
653                         for (i=1; i < num; i++)
654                                 *(branch[n].p + i) = cpu_to_le32(++current_block);
655                 }
656                 BUFFER_TRACE(bh, "marking uptodate");
657                 set_buffer_uptodate(bh);
658                 unlock_buffer(bh);
659
660                 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
661                 err = ext3_journal_dirty_metadata(handle, bh);
662                 if (err)
663                         goto failed;
664         }
665         *blks = num;
666         return err;
667 failed:
668         /* Allocation failed, free what we already allocated */
669         for (i = 1; i <= n ; i++) {
670                 BUFFER_TRACE(branch[i].bh, "call journal_forget");
671                 ext3_journal_forget(handle, branch[i].bh);
672         }
673         for (i = 0; i <indirect_blks; i++)
674                 ext3_free_blocks(handle, inode, new_blocks[i], 1);
675
676         ext3_free_blocks(handle, inode, new_blocks[i], num);
677
678         return err;
679 }
680
681 /**
682  * ext3_splice_branch - splice the allocated branch onto inode.
683  * @inode: owner
684  * @block: (logical) number of block we are adding
685  * @chain: chain of indirect blocks (with a missing link - see
686  *      ext3_alloc_branch)
687  * @where: location of missing link
688  * @num:   number of indirect blocks we are adding
689  * @blks:  number of direct blocks we are adding
690  *
691  * This function fills the missing link and does all housekeeping needed in
692  * inode (->i_blocks, etc.). In case of success we end up with the full
693  * chain to new block and return 0.
694  */
695 static int ext3_splice_branch(handle_t *handle, struct inode *inode,
696                         long block, Indirect *where, int num, int blks)
697 {
698         int i;
699         int err = 0;
700         struct ext3_block_alloc_info *block_i;
701         ext3_fsblk_t current_block;
702         struct ext3_inode_info *ei = EXT3_I(inode);
703
704         block_i = ei->i_block_alloc_info;
705         /*
706          * If we're splicing into a [td]indirect block (as opposed to the
707          * inode) then we need to get write access to the [td]indirect block
708          * before the splice.
709          */
710         if (where->bh) {
711                 BUFFER_TRACE(where->bh, "get_write_access");
712                 err = ext3_journal_get_write_access(handle, where->bh);
713                 if (err)
714                         goto err_out;
715         }
716         /* That's it */
717
718         *where->p = where->key;
719
720         /*
721          * Update the host buffer_head or inode to point to more just allocated
722          * direct blocks blocks
723          */
724         if (num == 0 && blks > 1) {
725                 current_block = le32_to_cpu(where->key) + 1;
726                 for (i = 1; i < blks; i++)
727                         *(where->p + i ) = cpu_to_le32(current_block++);
728         }
729
730         /*
731          * update the most recently allocated logical & physical block
732          * in i_block_alloc_info, to assist find the proper goal block for next
733          * allocation
734          */
735         if (block_i) {
736                 block_i->last_alloc_logical_block = block + blks - 1;
737                 block_i->last_alloc_physical_block =
738                                 le32_to_cpu(where[num].key) + blks - 1;
739         }
740
741         /* We are done with atomic stuff, now do the rest of housekeeping */
742
743         inode->i_ctime = CURRENT_TIME_SEC;
744         ext3_mark_inode_dirty(handle, inode);
745         /* ext3_mark_inode_dirty already updated i_sync_tid */
746         atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
747
748         /* had we spliced it onto indirect block? */
749         if (where->bh) {
750                 /*
751                  * If we spliced it onto an indirect block, we haven't
752                  * altered the inode.  Note however that if it is being spliced
753                  * onto an indirect block at the very end of the file (the
754                  * file is growing) then we *will* alter the inode to reflect
755                  * the new i_size.  But that is not done here - it is done in
756                  * generic_commit_write->__mark_inode_dirty->ext3_dirty_inode.
757                  */
758                 jbd_debug(5, "splicing indirect only\n");
759                 BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
760                 err = ext3_journal_dirty_metadata(handle, where->bh);
761                 if (err)
762                         goto err_out;
763         } else {
764                 /*
765                  * OK, we spliced it into the inode itself on a direct block.
766                  * Inode was dirtied above.
767                  */
768                 jbd_debug(5, "splicing direct\n");
769         }
770         return err;
771
772 err_out:
773         for (i = 1; i <= num; i++) {
774                 BUFFER_TRACE(where[i].bh, "call journal_forget");
775                 ext3_journal_forget(handle, where[i].bh);
776                 ext3_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1);
777         }
778         ext3_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks);
779
780         return err;
781 }
782
783 /*
784  * Allocation strategy is simple: if we have to allocate something, we will
785  * have to go the whole way to leaf. So let's do it before attaching anything
786  * to tree, set linkage between the newborn blocks, write them if sync is
787  * required, recheck the path, free and repeat if check fails, otherwise
788  * set the last missing link (that will protect us from any truncate-generated
789  * removals - all blocks on the path are immune now) and possibly force the
790  * write on the parent block.
791  * That has a nice additional property: no special recovery from the failed
792  * allocations is needed - we simply release blocks and do not touch anything
793  * reachable from inode.
794  *
795  * `handle' can be NULL if create == 0.
796  *
797  * The BKL may not be held on entry here.  Be sure to take it early.
798  * return > 0, # of blocks mapped or allocated.
799  * return = 0, if plain lookup failed.
800  * return < 0, error case.
801  */
802 int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
803                 sector_t iblock, unsigned long maxblocks,
804                 struct buffer_head *bh_result,
805                 int create)
806 {
807         int err = -EIO;
808         int offsets[4];
809         Indirect chain[4];
810         Indirect *partial;
811         ext3_fsblk_t goal;
812         int indirect_blks;
813         int blocks_to_boundary = 0;
814         int depth;
815         struct ext3_inode_info *ei = EXT3_I(inode);
816         int count = 0;
817         ext3_fsblk_t first_block = 0;
818
819
820         J_ASSERT(handle != NULL || create == 0);
821         depth = ext3_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
822
823         if (depth == 0)
824                 goto out;
825
826         partial = ext3_get_branch(inode, depth, offsets, chain, &err);
827
828         /* Simplest case - block found, no allocation needed */
829         if (!partial) {
830                 first_block = le32_to_cpu(chain[depth - 1].key);
831                 clear_buffer_new(bh_result);
832                 count++;
833                 /*map more blocks*/
834                 while (count < maxblocks && count <= blocks_to_boundary) {
835                         ext3_fsblk_t blk;
836
837                         if (!verify_chain(chain, chain + depth - 1)) {
838                                 /*
839                                  * Indirect block might be removed by
840                                  * truncate while we were reading it.
841                                  * Handling of that case: forget what we've
842                                  * got now. Flag the err as EAGAIN, so it
843                                  * will reread.
844                                  */
845                                 err = -EAGAIN;
846                                 count = 0;
847                                 break;
848                         }
849                         blk = le32_to_cpu(*(chain[depth-1].p + count));
850
851                         if (blk == first_block + count)
852                                 count++;
853                         else
854                                 break;
855                 }
856                 if (err != -EAGAIN)
857                         goto got_it;
858         }
859
860         /* Next simple case - plain lookup or failed read of indirect block */
861         if (!create || err == -EIO)
862                 goto cleanup;
863
864         mutex_lock(&ei->truncate_mutex);
865
866         /*
867          * If the indirect block is missing while we are reading
868          * the chain(ext3_get_branch() returns -EAGAIN err), or
869          * if the chain has been changed after we grab the semaphore,
870          * (either because another process truncated this branch, or
871          * another get_block allocated this branch) re-grab the chain to see if
872          * the request block has been allocated or not.
873          *
874          * Since we already block the truncate/other get_block
875          * at this point, we will have the current copy of the chain when we
876          * splice the branch into the tree.
877          */
878         if (err == -EAGAIN || !verify_chain(chain, partial)) {
879                 while (partial > chain) {
880                         brelse(partial->bh);
881                         partial--;
882                 }
883                 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
884                 if (!partial) {
885                         count++;
886                         mutex_unlock(&ei->truncate_mutex);
887                         if (err)
888                                 goto cleanup;
889                         clear_buffer_new(bh_result);
890                         goto got_it;
891                 }
892         }
893
894         /*
895          * Okay, we need to do block allocation.  Lazily initialize the block
896          * allocation info here if necessary
897         */
898         if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
899                 ext3_init_block_alloc_info(inode);
900
901         goal = ext3_find_goal(inode, iblock, partial);
902
903         /* the number of blocks need to allocate for [d,t]indirect blocks */
904         indirect_blks = (chain + depth) - partial - 1;
905
906         /*
907          * Next look up the indirect map to count the totoal number of
908          * direct blocks to allocate for this branch.
909          */
910         count = ext3_blks_to_allocate(partial, indirect_blks,
911                                         maxblocks, blocks_to_boundary);
912         /*
913          * Block out ext3_truncate while we alter the tree
914          */
915         err = ext3_alloc_branch(handle, inode, indirect_blks, &count, goal,
916                                 offsets + (partial - chain), partial);
917
918         /*
919          * The ext3_splice_branch call will free and forget any buffers
920          * on the new chain if there is a failure, but that risks using
921          * up transaction credits, especially for bitmaps where the
922          * credits cannot be returned.  Can we handle this somehow?  We
923          * may need to return -EAGAIN upwards in the worst case.  --sct
924          */
925         if (!err)
926                 err = ext3_splice_branch(handle, inode, iblock,
927                                         partial, indirect_blks, count);
928         mutex_unlock(&ei->truncate_mutex);
929         if (err)
930                 goto cleanup;
931
932         set_buffer_new(bh_result);
933 got_it:
934         map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
935         if (count > blocks_to_boundary)
936                 set_buffer_boundary(bh_result);
937         err = count;
938         /* Clean up and exit */
939         partial = chain + depth - 1;    /* the whole chain */
940 cleanup:
941         while (partial > chain) {
942                 BUFFER_TRACE(partial->bh, "call brelse");
943                 brelse(partial->bh);
944                 partial--;
945         }
946         BUFFER_TRACE(bh_result, "returned");
947 out:
948         return err;
949 }
950
951 /* Maximum number of blocks we map for direct IO at once. */
952 #define DIO_MAX_BLOCKS 4096
953 /*
954  * Number of credits we need for writing DIO_MAX_BLOCKS:
955  * We need sb + group descriptor + bitmap + inode -> 4
956  * For B blocks with A block pointers per block we need:
957  * 1 (triple ind.) + (B/A/A + 2) (doubly ind.) + (B/A + 2) (indirect).
958  * If we plug in 4096 for B and 256 for A (for 1KB block size), we get 25.
959  */
960 #define DIO_CREDITS 25
961
962 static int ext3_get_block(struct inode *inode, sector_t iblock,
963                         struct buffer_head *bh_result, int create)
964 {
965         handle_t *handle = ext3_journal_current_handle();
966         int ret = 0, started = 0;
967         unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
968
969         if (create && !handle) {        /* Direct IO write... */
970                 if (max_blocks > DIO_MAX_BLOCKS)
971                         max_blocks = DIO_MAX_BLOCKS;
972                 handle = ext3_journal_start(inode, DIO_CREDITS +
973                                 EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb));
974                 if (IS_ERR(handle)) {
975                         ret = PTR_ERR(handle);
976                         goto out;
977                 }
978                 started = 1;
979         }
980
981         ret = ext3_get_blocks_handle(handle, inode, iblock,
982                                         max_blocks, bh_result, create);
983         if (ret > 0) {
984                 bh_result->b_size = (ret << inode->i_blkbits);
985                 ret = 0;
986         }
987         if (started)
988                 ext3_journal_stop(handle);
989 out:
990         return ret;
991 }
992
993 int ext3_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
994                 u64 start, u64 len)
995 {
996         return generic_block_fiemap(inode, fieinfo, start, len,
997                                     ext3_get_block);
998 }
999
1000 /*
1001  * `handle' can be NULL if create is zero
1002  */
1003 struct buffer_head *ext3_getblk(handle_t *handle, struct inode *inode,
1004                                 long block, int create, int *errp)
1005 {
1006         struct buffer_head dummy;
1007         int fatal = 0, err;
1008
1009         J_ASSERT(handle != NULL || create == 0);
1010
1011         dummy.b_state = 0;
1012         dummy.b_blocknr = -1000;
1013         buffer_trace_init(&dummy.b_history);
1014         err = ext3_get_blocks_handle(handle, inode, block, 1,
1015                                         &dummy, create);
1016         /*
1017          * ext3_get_blocks_handle() returns number of blocks
1018          * mapped. 0 in case of a HOLE.
1019          */
1020         if (err > 0) {
1021                 if (err > 1)
1022                         WARN_ON(1);
1023                 err = 0;
1024         }
1025         *errp = err;
1026         if (!err && buffer_mapped(&dummy)) {
1027                 struct buffer_head *bh;
1028                 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
1029                 if (!bh) {
1030                         *errp = -EIO;
1031                         goto err;
1032                 }
1033                 if (buffer_new(&dummy)) {
1034                         J_ASSERT(create != 0);
1035                         J_ASSERT(handle != NULL);
1036
1037                         /*
1038                          * Now that we do not always journal data, we should
1039                          * keep in mind whether this should always journal the
1040                          * new buffer as metadata.  For now, regular file
1041                          * writes use ext3_get_block instead, so it's not a
1042                          * problem.
1043                          */
1044                         lock_buffer(bh);
1045                         BUFFER_TRACE(bh, "call get_create_access");
1046                         fatal = ext3_journal_get_create_access(handle, bh);
1047                         if (!fatal && !buffer_uptodate(bh)) {
1048                                 memset(bh->b_data,0,inode->i_sb->s_blocksize);
1049                                 set_buffer_uptodate(bh);
1050                         }
1051                         unlock_buffer(bh);
1052                         BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
1053                         err = ext3_journal_dirty_metadata(handle, bh);
1054                         if (!fatal)
1055                                 fatal = err;
1056                 } else {
1057                         BUFFER_TRACE(bh, "not a new buffer");
1058                 }
1059                 if (fatal) {
1060                         *errp = fatal;
1061                         brelse(bh);
1062                         bh = NULL;
1063                 }
1064                 return bh;
1065         }
1066 err:
1067         return NULL;
1068 }
1069
1070 struct buffer_head *ext3_bread(handle_t *handle, struct inode *inode,
1071                                int block, int create, int *err)
1072 {
1073         struct buffer_head * bh;
1074
1075         bh = ext3_getblk(handle, inode, block, create, err);
1076         if (!bh)
1077                 return bh;
1078         if (buffer_uptodate(bh))
1079                 return bh;
1080         ll_rw_block(READ_META, 1, &bh);
1081         wait_on_buffer(bh);
1082         if (buffer_uptodate(bh))
1083                 return bh;
1084         put_bh(bh);
1085         *err = -EIO;
1086         return NULL;
1087 }
1088
1089 static int walk_page_buffers(   handle_t *handle,
1090                                 struct buffer_head *head,
1091                                 unsigned from,
1092                                 unsigned to,
1093                                 int *partial,
1094                                 int (*fn)(      handle_t *handle,
1095                                                 struct buffer_head *bh))
1096 {
1097         struct buffer_head *bh;
1098         unsigned block_start, block_end;
1099         unsigned blocksize = head->b_size;
1100         int err, ret = 0;
1101         struct buffer_head *next;
1102
1103         for (   bh = head, block_start = 0;
1104                 ret == 0 && (bh != head || !block_start);
1105                 block_start = block_end, bh = next)
1106         {
1107                 next = bh->b_this_page;
1108                 block_end = block_start + blocksize;
1109                 if (block_end <= from || block_start >= to) {
1110                         if (partial && !buffer_uptodate(bh))
1111                                 *partial = 1;
1112                         continue;
1113                 }
1114                 err = (*fn)(handle, bh);
1115                 if (!ret)
1116                         ret = err;
1117         }
1118         return ret;
1119 }
1120
1121 /*
1122  * To preserve ordering, it is essential that the hole instantiation and
1123  * the data write be encapsulated in a single transaction.  We cannot
1124  * close off a transaction and start a new one between the ext3_get_block()
1125  * and the commit_write().  So doing the journal_start at the start of
1126  * prepare_write() is the right place.
1127  *
1128  * Also, this function can nest inside ext3_writepage() ->
1129  * block_write_full_page(). In that case, we *know* that ext3_writepage()
1130  * has generated enough buffer credits to do the whole page.  So we won't
1131  * block on the journal in that case, which is good, because the caller may
1132  * be PF_MEMALLOC.
1133  *
1134  * By accident, ext3 can be reentered when a transaction is open via
1135  * quota file writes.  If we were to commit the transaction while thus
1136  * reentered, there can be a deadlock - we would be holding a quota
1137  * lock, and the commit would never complete if another thread had a
1138  * transaction open and was blocking on the quota lock - a ranking
1139  * violation.
1140  *
1141  * So what we do is to rely on the fact that journal_stop/journal_start
1142  * will _not_ run commit under these circumstances because handle->h_ref
1143  * is elevated.  We'll still have enough credits for the tiny quotafile
1144  * write.
1145  */
1146 static int do_journal_get_write_access(handle_t *handle,
1147                                         struct buffer_head *bh)
1148 {
1149         if (!buffer_mapped(bh) || buffer_freed(bh))
1150                 return 0;
1151         return ext3_journal_get_write_access(handle, bh);
1152 }
1153
1154 /*
1155  * Truncate blocks that were not used by write. We have to truncate the
1156  * pagecache as well so that corresponding buffers get properly unmapped.
1157  */
1158 static void ext3_truncate_failed_write(struct inode *inode)
1159 {
1160         truncate_inode_pages(inode->i_mapping, inode->i_size);
1161         ext3_truncate(inode);
1162 }
1163
1164 static int ext3_write_begin(struct file *file, struct address_space *mapping,
1165                                 loff_t pos, unsigned len, unsigned flags,
1166                                 struct page **pagep, void **fsdata)
1167 {
1168         struct inode *inode = mapping->host;
1169         int ret;
1170         handle_t *handle;
1171         int retries = 0;
1172         struct page *page;
1173         pgoff_t index;
1174         unsigned from, to;
1175         /* Reserve one block more for addition to orphan list in case
1176          * we allocate blocks but write fails for some reason */
1177         int needed_blocks = ext3_writepage_trans_blocks(inode) + 1;
1178
1179         index = pos >> PAGE_CACHE_SHIFT;
1180         from = pos & (PAGE_CACHE_SIZE - 1);
1181         to = from + len;
1182
1183 retry:
1184         page = grab_cache_page_write_begin(mapping, index, flags);
1185         if (!page)
1186                 return -ENOMEM;
1187         *pagep = page;
1188
1189         handle = ext3_journal_start(inode, needed_blocks);
1190         if (IS_ERR(handle)) {
1191                 unlock_page(page);
1192                 page_cache_release(page);
1193                 ret = PTR_ERR(handle);
1194                 goto out;
1195         }
1196         ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
1197                                                         ext3_get_block);
1198         if (ret)
1199                 goto write_begin_failed;
1200
1201         if (ext3_should_journal_data(inode)) {
1202                 ret = walk_page_buffers(handle, page_buffers(page),
1203                                 from, to, NULL, do_journal_get_write_access);
1204         }
1205 write_begin_failed:
1206         if (ret) {
1207                 /*
1208                  * block_write_begin may have instantiated a few blocks
1209                  * outside i_size.  Trim these off again. Don't need
1210                  * i_size_read because we hold i_mutex.
1211                  *
1212                  * Add inode to orphan list in case we crash before truncate
1213                  * finishes. Do this only if ext3_can_truncate() agrees so
1214                  * that orphan processing code is happy.
1215                  */
1216                 if (pos + len > inode->i_size && ext3_can_truncate(inode))
1217                         ext3_orphan_add(handle, inode);
1218                 ext3_journal_stop(handle);
1219                 unlock_page(page);
1220                 page_cache_release(page);
1221                 if (pos + len > inode->i_size)
1222                         ext3_truncate_failed_write(inode);
1223         }
1224         if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1225                 goto retry;
1226 out:
1227         return ret;
1228 }
1229
1230
1231 int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1232 {
1233         int err = journal_dirty_data(handle, bh);
1234         if (err)
1235                 ext3_journal_abort_handle(__func__, __func__,
1236                                                 bh, handle, err);
1237         return err;
1238 }
1239
1240 /* For ordered writepage and write_end functions */
1241 static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
1242 {
1243         /*
1244          * Write could have mapped the buffer but it didn't copy the data in
1245          * yet. So avoid filing such buffer into a transaction.
1246          */
1247         if (buffer_mapped(bh) && buffer_uptodate(bh))
1248                 return ext3_journal_dirty_data(handle, bh);
1249         return 0;
1250 }
1251
1252 /* For write_end() in data=journal mode */
1253 static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1254 {
1255         if (!buffer_mapped(bh) || buffer_freed(bh))
1256                 return 0;
1257         set_buffer_uptodate(bh);
1258         return ext3_journal_dirty_metadata(handle, bh);
1259 }
1260
1261 /*
1262  * This is nasty and subtle: ext3_write_begin() could have allocated blocks
1263  * for the whole page but later we failed to copy the data in. Update inode
1264  * size according to what we managed to copy. The rest is going to be
1265  * truncated in write_end function.
1266  */
1267 static void update_file_sizes(struct inode *inode, loff_t pos, unsigned copied)
1268 {
1269         /* What matters to us is i_disksize. We don't write i_size anywhere */
1270         if (pos + copied > inode->i_size)
1271                 i_size_write(inode, pos + copied);
1272         if (pos + copied > EXT3_I(inode)->i_disksize) {
1273                 EXT3_I(inode)->i_disksize = pos + copied;
1274                 mark_inode_dirty(inode);
1275         }
1276 }
1277
1278 /*
1279  * We need to pick up the new inode size which generic_commit_write gave us
1280  * `file' can be NULL - eg, when called from page_symlink().
1281  *
1282  * ext3 never places buffers on inode->i_mapping->private_list.  metadata
1283  * buffers are managed internally.
1284  */
1285 static int ext3_ordered_write_end(struct file *file,
1286                                 struct address_space *mapping,
1287                                 loff_t pos, unsigned len, unsigned copied,
1288                                 struct page *page, void *fsdata)
1289 {
1290         handle_t *handle = ext3_journal_current_handle();
1291         struct inode *inode = file->f_mapping->host;
1292         unsigned from, to;
1293         int ret = 0, ret2;
1294
1295         copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1296
1297         from = pos & (PAGE_CACHE_SIZE - 1);
1298         to = from + copied;
1299         ret = walk_page_buffers(handle, page_buffers(page),
1300                 from, to, NULL, journal_dirty_data_fn);
1301
1302         if (ret == 0)
1303                 update_file_sizes(inode, pos, copied);
1304         /*
1305          * There may be allocated blocks outside of i_size because
1306          * we failed to copy some data. Prepare for truncate.
1307          */
1308         if (pos + len > inode->i_size && ext3_can_truncate(inode))
1309                 ext3_orphan_add(handle, inode);
1310         ret2 = ext3_journal_stop(handle);
1311         if (!ret)
1312                 ret = ret2;
1313         unlock_page(page);
1314         page_cache_release(page);
1315
1316         if (pos + len > inode->i_size)
1317                 ext3_truncate_failed_write(inode);
1318         return ret ? ret : copied;
1319 }
1320
1321 static int ext3_writeback_write_end(struct file *file,
1322                                 struct address_space *mapping,
1323                                 loff_t pos, unsigned len, unsigned copied,
1324                                 struct page *page, void *fsdata)
1325 {
1326         handle_t *handle = ext3_journal_current_handle();
1327         struct inode *inode = file->f_mapping->host;
1328         int ret;
1329
1330         copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1331         update_file_sizes(inode, pos, copied);
1332         /*
1333          * There may be allocated blocks outside of i_size because
1334          * we failed to copy some data. Prepare for truncate.
1335          */
1336         if (pos + len > inode->i_size && ext3_can_truncate(inode))
1337                 ext3_orphan_add(handle, inode);
1338         ret = ext3_journal_stop(handle);
1339         unlock_page(page);
1340         page_cache_release(page);
1341
1342         if (pos + len > inode->i_size)
1343                 ext3_truncate_failed_write(inode);
1344         return ret ? ret : copied;
1345 }
1346
1347 static int ext3_journalled_write_end(struct file *file,
1348                                 struct address_space *mapping,
1349                                 loff_t pos, unsigned len, unsigned copied,
1350                                 struct page *page, void *fsdata)
1351 {
1352         handle_t *handle = ext3_journal_current_handle();
1353         struct inode *inode = mapping->host;
1354         int ret = 0, ret2;
1355         int partial = 0;
1356         unsigned from, to;
1357
1358         from = pos & (PAGE_CACHE_SIZE - 1);
1359         to = from + len;
1360
1361         if (copied < len) {
1362                 if (!PageUptodate(page))
1363                         copied = 0;
1364                 page_zero_new_buffers(page, from + copied, to);
1365                 to = from + copied;
1366         }
1367
1368         ret = walk_page_buffers(handle, page_buffers(page), from,
1369                                 to, &partial, write_end_fn);
1370         if (!partial)
1371                 SetPageUptodate(page);
1372
1373         if (pos + copied > inode->i_size)
1374                 i_size_write(inode, pos + copied);
1375         /*
1376          * There may be allocated blocks outside of i_size because
1377          * we failed to copy some data. Prepare for truncate.
1378          */
1379         if (pos + len > inode->i_size && ext3_can_truncate(inode))
1380                 ext3_orphan_add(handle, inode);
1381         ext3_set_inode_state(inode, EXT3_STATE_JDATA);
1382         if (inode->i_size > EXT3_I(inode)->i_disksize) {
1383                 EXT3_I(inode)->i_disksize = inode->i_size;
1384                 ret2 = ext3_mark_inode_dirty(handle, inode);
1385                 if (!ret)
1386                         ret = ret2;
1387         }
1388
1389         ret2 = ext3_journal_stop(handle);
1390         if (!ret)
1391                 ret = ret2;
1392         unlock_page(page);
1393         page_cache_release(page);
1394
1395         if (pos + len > inode->i_size)
1396                 ext3_truncate_failed_write(inode);
1397         return ret ? ret : copied;
1398 }
1399
1400 /*
1401  * bmap() is special.  It gets used by applications such as lilo and by
1402  * the swapper to find the on-disk block of a specific piece of data.
1403  *
1404  * Naturally, this is dangerous if the block concerned is still in the
1405  * journal.  If somebody makes a swapfile on an ext3 data-journaling
1406  * filesystem and enables swap, then they may get a nasty shock when the
1407  * data getting swapped to that swapfile suddenly gets overwritten by
1408  * the original zero's written out previously to the journal and
1409  * awaiting writeback in the kernel's buffer cache.
1410  *
1411  * So, if we see any bmap calls here on a modified, data-journaled file,
1412  * take extra steps to flush any blocks which might be in the cache.
1413  */
1414 static sector_t ext3_bmap(struct address_space *mapping, sector_t block)
1415 {
1416         struct inode *inode = mapping->host;
1417         journal_t *journal;
1418         int err;
1419
1420         if (ext3_test_inode_state(inode, EXT3_STATE_JDATA)) {
1421                 /*
1422                  * This is a REALLY heavyweight approach, but the use of
1423                  * bmap on dirty files is expected to be extremely rare:
1424                  * only if we run lilo or swapon on a freshly made file
1425                  * do we expect this to happen.
1426                  *
1427                  * (bmap requires CAP_SYS_RAWIO so this does not
1428                  * represent an unprivileged user DOS attack --- we'd be
1429                  * in trouble if mortal users could trigger this path at
1430                  * will.)
1431                  *
1432                  * NB. EXT3_STATE_JDATA is not set on files other than
1433                  * regular files.  If somebody wants to bmap a directory
1434                  * or symlink and gets confused because the buffer
1435                  * hasn't yet been flushed to disk, they deserve
1436                  * everything they get.
1437                  */
1438
1439                 ext3_clear_inode_state(inode, EXT3_STATE_JDATA);
1440                 journal = EXT3_JOURNAL(inode);
1441                 journal_lock_updates(journal);
1442                 err = journal_flush(journal);
1443                 journal_unlock_updates(journal);
1444
1445                 if (err)
1446                         return 0;
1447         }
1448
1449         return generic_block_bmap(mapping,block,ext3_get_block);
1450 }
1451
1452 static int bget_one(handle_t *handle, struct buffer_head *bh)
1453 {
1454         get_bh(bh);
1455         return 0;
1456 }
1457
1458 static int bput_one(handle_t *handle, struct buffer_head *bh)
1459 {
1460         put_bh(bh);
1461         return 0;
1462 }
1463
1464 static int buffer_unmapped(handle_t *handle, struct buffer_head *bh)
1465 {
1466         return !buffer_mapped(bh);
1467 }
1468
1469 /*
1470  * Note that we always start a transaction even if we're not journalling
1471  * data.  This is to preserve ordering: any hole instantiation within
1472  * __block_write_full_page -> ext3_get_block() should be journalled
1473  * along with the data so we don't crash and then get metadata which
1474  * refers to old data.
1475  *
1476  * In all journalling modes block_write_full_page() will start the I/O.
1477  *
1478  * Problem:
1479  *
1480  *      ext3_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1481  *              ext3_writepage()
1482  *
1483  * Similar for:
1484  *
1485  *      ext3_file_write() -> generic_file_write() -> __alloc_pages() -> ...
1486  *
1487  * Same applies to ext3_get_block().  We will deadlock on various things like
1488  * lock_journal and i_truncate_mutex.
1489  *
1490  * Setting PF_MEMALLOC here doesn't work - too many internal memory
1491  * allocations fail.
1492  *
1493  * 16May01: If we're reentered then journal_current_handle() will be
1494  *          non-zero. We simply *return*.
1495  *
1496  * 1 July 2001: @@@ FIXME:
1497  *   In journalled data mode, a data buffer may be metadata against the
1498  *   current transaction.  But the same file is part of a shared mapping
1499  *   and someone does a writepage() on it.
1500  *
1501  *   We will move the buffer onto the async_data list, but *after* it has
1502  *   been dirtied. So there's a small window where we have dirty data on
1503  *   BJ_Metadata.
1504  *
1505  *   Note that this only applies to the last partial page in the file.  The
1506  *   bit which block_write_full_page() uses prepare/commit for.  (That's
1507  *   broken code anyway: it's wrong for msync()).
1508  *
1509  *   It's a rare case: affects the final partial page, for journalled data
1510  *   where the file is subject to bith write() and writepage() in the same
1511  *   transction.  To fix it we'll need a custom block_write_full_page().
1512  *   We'll probably need that anyway for journalling writepage() output.
1513  *
1514  * We don't honour synchronous mounts for writepage().  That would be
1515  * disastrous.  Any write() or metadata operation will sync the fs for
1516  * us.
1517  *
1518  * AKPM2: if all the page's buffers are mapped to disk and !data=journal,
1519  * we don't need to open a transaction here.
1520  */
1521 static int ext3_ordered_writepage(struct page *page,
1522                                 struct writeback_control *wbc)
1523 {
1524         struct inode *inode = page->mapping->host;
1525         struct buffer_head *page_bufs;
1526         handle_t *handle = NULL;
1527         int ret = 0;
1528         int err;
1529
1530         J_ASSERT(PageLocked(page));
1531
1532         /*
1533          * We give up here if we're reentered, because it might be for a
1534          * different filesystem.
1535          */
1536         if (ext3_journal_current_handle())
1537                 goto out_fail;
1538
1539         if (!page_has_buffers(page)) {
1540                 create_empty_buffers(page, inode->i_sb->s_blocksize,
1541                                 (1 << BH_Dirty)|(1 << BH_Uptodate));
1542                 page_bufs = page_buffers(page);
1543         } else {
1544                 page_bufs = page_buffers(page);
1545                 if (!walk_page_buffers(NULL, page_bufs, 0, PAGE_CACHE_SIZE,
1546                                        NULL, buffer_unmapped)) {
1547                         /* Provide NULL get_block() to catch bugs if buffers
1548                          * weren't really mapped */
1549                         return block_write_full_page(page, NULL, wbc);
1550                 }
1551         }
1552         handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1553
1554         if (IS_ERR(handle)) {
1555                 ret = PTR_ERR(handle);
1556                 goto out_fail;
1557         }
1558
1559         walk_page_buffers(handle, page_bufs, 0,
1560                         PAGE_CACHE_SIZE, NULL, bget_one);
1561
1562         ret = block_write_full_page(page, ext3_get_block, wbc);
1563
1564         /*
1565          * The page can become unlocked at any point now, and
1566          * truncate can then come in and change things.  So we
1567          * can't touch *page from now on.  But *page_bufs is
1568          * safe due to elevated refcount.
1569          */
1570
1571         /*
1572          * And attach them to the current transaction.  But only if
1573          * block_write_full_page() succeeded.  Otherwise they are unmapped,
1574          * and generally junk.
1575          */
1576         if (ret == 0) {
1577                 err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
1578                                         NULL, journal_dirty_data_fn);
1579                 if (!ret)
1580                         ret = err;
1581         }
1582         walk_page_buffers(handle, page_bufs, 0,
1583                         PAGE_CACHE_SIZE, NULL, bput_one);
1584         err = ext3_journal_stop(handle);
1585         if (!ret)
1586                 ret = err;
1587         return ret;
1588
1589 out_fail:
1590         redirty_page_for_writepage(wbc, page);
1591         unlock_page(page);
1592         return ret;
1593 }
1594
1595 static int ext3_writeback_writepage(struct page *page,
1596                                 struct writeback_control *wbc)
1597 {
1598         struct inode *inode = page->mapping->host;
1599         handle_t *handle = NULL;
1600         int ret = 0;
1601         int err;
1602
1603         if (ext3_journal_current_handle())
1604                 goto out_fail;
1605
1606         if (page_has_buffers(page)) {
1607                 if (!walk_page_buffers(NULL, page_buffers(page), 0,
1608                                       PAGE_CACHE_SIZE, NULL, buffer_unmapped)) {
1609                         /* Provide NULL get_block() to catch bugs if buffers
1610                          * weren't really mapped */
1611                         return block_write_full_page(page, NULL, wbc);
1612                 }
1613         }
1614
1615         handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1616         if (IS_ERR(handle)) {
1617                 ret = PTR_ERR(handle);
1618                 goto out_fail;
1619         }
1620
1621         if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
1622                 ret = nobh_writepage(page, ext3_get_block, wbc);
1623         else
1624                 ret = block_write_full_page(page, ext3_get_block, wbc);
1625
1626         err = ext3_journal_stop(handle);
1627         if (!ret)
1628                 ret = err;
1629         return ret;
1630
1631 out_fail:
1632         redirty_page_for_writepage(wbc, page);
1633         unlock_page(page);
1634         return ret;
1635 }
1636
1637 static int ext3_journalled_writepage(struct page *page,
1638                                 struct writeback_control *wbc)
1639 {
1640         struct inode *inode = page->mapping->host;
1641         handle_t *handle = NULL;
1642         int ret = 0;
1643         int err;
1644
1645         if (ext3_journal_current_handle())
1646                 goto no_write;
1647
1648         handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1649         if (IS_ERR(handle)) {
1650                 ret = PTR_ERR(handle);
1651                 goto no_write;
1652         }
1653
1654         if (!page_has_buffers(page) || PageChecked(page)) {
1655                 /*
1656                  * It's mmapped pagecache.  Add buffers and journal it.  There
1657                  * doesn't seem much point in redirtying the page here.
1658                  */
1659                 ClearPageChecked(page);
1660                 ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
1661                                         ext3_get_block);
1662                 if (ret != 0) {
1663                         ext3_journal_stop(handle);
1664                         goto out_unlock;
1665                 }
1666                 ret = walk_page_buffers(handle, page_buffers(page), 0,
1667                         PAGE_CACHE_SIZE, NULL, do_journal_get_write_access);
1668
1669                 err = walk_page_buffers(handle, page_buffers(page), 0,
1670                                 PAGE_CACHE_SIZE, NULL, write_end_fn);
1671                 if (ret == 0)
1672                         ret = err;
1673                 ext3_set_inode_state(inode, EXT3_STATE_JDATA);
1674                 unlock_page(page);
1675         } else {
1676                 /*
1677                  * It may be a page full of checkpoint-mode buffers.  We don't
1678                  * really know unless we go poke around in the buffer_heads.
1679                  * But block_write_full_page will do the right thing.
1680                  */
1681                 ret = block_write_full_page(page, ext3_get_block, wbc);
1682         }
1683         err = ext3_journal_stop(handle);
1684         if (!ret)
1685                 ret = err;
1686 out:
1687         return ret;
1688
1689 no_write:
1690         redirty_page_for_writepage(wbc, page);
1691 out_unlock:
1692         unlock_page(page);
1693         goto out;
1694 }
1695
1696 static int ext3_readpage(struct file *file, struct page *page)
1697 {
1698         return mpage_readpage(page, ext3_get_block);
1699 }
1700
1701 static int
1702 ext3_readpages(struct file *file, struct address_space *mapping,
1703                 struct list_head *pages, unsigned nr_pages)
1704 {
1705         return mpage_readpages(mapping, pages, nr_pages, ext3_get_block);
1706 }
1707
1708 static void ext3_invalidatepage(struct page *page, unsigned long offset)
1709 {
1710         journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1711
1712         /*
1713          * If it's a full truncate we just forget about the pending dirtying
1714          */
1715         if (offset == 0)
1716                 ClearPageChecked(page);
1717
1718         journal_invalidatepage(journal, page, offset);
1719 }
1720
1721 static int ext3_releasepage(struct page *page, gfp_t wait)
1722 {
1723         journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1724
1725         WARN_ON(PageChecked(page));
1726         if (!page_has_buffers(page))
1727                 return 0;
1728         return journal_try_to_free_buffers(journal, page, wait);
1729 }
1730
1731 /*
1732  * If the O_DIRECT write will extend the file then add this inode to the
1733  * orphan list.  So recovery will truncate it back to the original size
1734  * if the machine crashes during the write.
1735  *
1736  * If the O_DIRECT write is intantiating holes inside i_size and the machine
1737  * crashes then stale disk data _may_ be exposed inside the file. But current
1738  * VFS code falls back into buffered path in that case so we are safe.
1739  */
1740 static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
1741                         const struct iovec *iov, loff_t offset,
1742                         unsigned long nr_segs)
1743 {
1744         struct file *file = iocb->ki_filp;
1745         struct inode *inode = file->f_mapping->host;
1746         struct ext3_inode_info *ei = EXT3_I(inode);
1747         handle_t *handle;
1748         ssize_t ret;
1749         int orphan = 0;
1750         size_t count = iov_length(iov, nr_segs);
1751         int retries = 0;
1752
1753         if (rw == WRITE) {
1754                 loff_t final_size = offset + count;
1755
1756                 if (final_size > inode->i_size) {
1757                         /* Credits for sb + inode write */
1758                         handle = ext3_journal_start(inode, 2);
1759                         if (IS_ERR(handle)) {
1760                                 ret = PTR_ERR(handle);
1761                                 goto out;
1762                         }
1763                         ret = ext3_orphan_add(handle, inode);
1764                         if (ret) {
1765                                 ext3_journal_stop(handle);
1766                                 goto out;
1767                         }
1768                         orphan = 1;
1769                         ei->i_disksize = inode->i_size;
1770                         ext3_journal_stop(handle);
1771                 }
1772         }
1773
1774 retry:
1775         ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
1776                                  offset, nr_segs,
1777                                  ext3_get_block, NULL);
1778         if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1779                 goto retry;
1780
1781         if (orphan) {
1782                 int err;
1783
1784                 /* Credits for sb + inode write */
1785                 handle = ext3_journal_start(inode, 2);
1786                 if (IS_ERR(handle)) {
1787                         /* This is really bad luck. We've written the data
1788                          * but cannot extend i_size. Truncate allocated blocks
1789                          * and pretend the write failed... */
1790                         ext3_truncate(inode);
1791                         ret = PTR_ERR(handle);
1792                         goto out;
1793                 }
1794                 if (inode->i_nlink)
1795                         ext3_orphan_del(handle, inode);
1796                 if (ret > 0) {
1797                         loff_t end = offset + ret;
1798                         if (end > inode->i_size) {
1799                                 ei->i_disksize = end;
1800                                 i_size_write(inode, end);
1801                                 /*
1802                                  * We're going to return a positive `ret'
1803                                  * here due to non-zero-length I/O, so there's
1804                                  * no way of reporting error returns from
1805                                  * ext3_mark_inode_dirty() to userspace.  So
1806                                  * ignore it.
1807                                  */
1808                                 ext3_mark_inode_dirty(handle, inode);
1809                         }
1810                 }
1811                 err = ext3_journal_stop(handle);
1812                 if (ret == 0)
1813                         ret = err;
1814         }
1815 out:
1816         return ret;
1817 }
1818
1819 /*
1820  * Pages can be marked dirty completely asynchronously from ext3's journalling
1821  * activity.  By filemap_sync_pte(), try_to_unmap_one(), etc.  We cannot do
1822  * much here because ->set_page_dirty is called under VFS locks.  The page is
1823  * not necessarily locked.
1824  *
1825  * We cannot just dirty the page and leave attached buffers clean, because the
1826  * buffers' dirty state is "definitive".  We cannot just set the buffers dirty
1827  * or jbddirty because all the journalling code will explode.
1828  *
1829  * So what we do is to mark the page "pending dirty" and next time writepage
1830  * is called, propagate that into the buffers appropriately.
1831  */
1832 static int ext3_journalled_set_page_dirty(struct page *page)
1833 {
1834         SetPageChecked(page);
1835         return __set_page_dirty_nobuffers(page);
1836 }
1837
1838 static const struct address_space_operations ext3_ordered_aops = {
1839         .readpage               = ext3_readpage,
1840         .readpages              = ext3_readpages,
1841         .writepage              = ext3_ordered_writepage,
1842         .sync_page              = block_sync_page,
1843         .write_begin            = ext3_write_begin,
1844         .write_end              = ext3_ordered_write_end,
1845         .bmap                   = ext3_bmap,
1846         .invalidatepage         = ext3_invalidatepage,
1847         .releasepage            = ext3_releasepage,
1848         .direct_IO              = ext3_direct_IO,
1849         .migratepage            = buffer_migrate_page,
1850         .is_partially_uptodate  = block_is_partially_uptodate,
1851         .error_remove_page      = generic_error_remove_page,
1852 };
1853
1854 static const struct address_space_operations ext3_writeback_aops = {
1855         .readpage               = ext3_readpage,
1856         .readpages              = ext3_readpages,
1857         .writepage              = ext3_writeback_writepage,
1858         .sync_page              = block_sync_page,
1859         .write_begin            = ext3_write_begin,
1860         .write_end              = ext3_writeback_write_end,
1861         .bmap                   = ext3_bmap,
1862         .invalidatepage         = ext3_invalidatepage,
1863         .releasepage            = ext3_releasepage,
1864         .direct_IO              = ext3_direct_IO,
1865         .migratepage            = buffer_migrate_page,
1866         .is_partially_uptodate  = block_is_partially_uptodate,
1867         .error_remove_page      = generic_error_remove_page,
1868 };
1869
1870 static const struct address_space_operations ext3_journalled_aops = {
1871         .readpage               = ext3_readpage,
1872         .readpages              = ext3_readpages,
1873         .writepage              = ext3_journalled_writepage,
1874         .sync_page              = block_sync_page,
1875         .write_begin            = ext3_write_begin,
1876         .write_end              = ext3_journalled_write_end,
1877         .set_page_dirty         = ext3_journalled_set_page_dirty,
1878         .bmap                   = ext3_bmap,
1879         .invalidatepage         = ext3_invalidatepage,
1880         .releasepage            = ext3_releasepage,
1881         .is_partially_uptodate  = block_is_partially_uptodate,
1882         .error_remove_page      = generic_error_remove_page,
1883 };
1884
1885 void ext3_set_aops(struct inode *inode)
1886 {
1887         if (ext3_should_order_data(inode))
1888                 inode->i_mapping->a_ops = &ext3_ordered_aops;
1889         else if (ext3_should_writeback_data(inode))
1890                 inode->i_mapping->a_ops = &ext3_writeback_aops;
1891         else
1892                 inode->i_mapping->a_ops = &ext3_journalled_aops;
1893 }
1894
1895 /*
1896  * ext3_block_truncate_page() zeroes out a mapping from file offset `from'
1897  * up to the end of the block which corresponds to `from'.
1898  * This required during truncate. We need to physically zero the tail end
1899  * of that block so it doesn't yield old data if the file is later grown.
1900  */
1901 static int ext3_block_truncate_page(handle_t *handle, struct page *page,
1902                 struct address_space *mapping, loff_t from)
1903 {
1904         ext3_fsblk_t index = from >> PAGE_CACHE_SHIFT;
1905         unsigned offset = from & (PAGE_CACHE_SIZE-1);
1906         unsigned blocksize, iblock, length, pos;
1907         struct inode *inode = mapping->host;
1908         struct buffer_head *bh;
1909         int err = 0;
1910
1911         blocksize = inode->i_sb->s_blocksize;
1912         length = blocksize - (offset & (blocksize - 1));
1913         iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1914
1915         /*
1916          * For "nobh" option,  we can only work if we don't need to
1917          * read-in the page - otherwise we create buffers to do the IO.
1918          */
1919         if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
1920              ext3_should_writeback_data(inode) && PageUptodate(page)) {
1921                 zero_user(page, offset, length);
1922                 set_page_dirty(page);
1923                 goto unlock;
1924         }
1925
1926         if (!page_has_buffers(page))
1927                 create_empty_buffers(page, blocksize, 0);
1928
1929         /* Find the buffer that contains "offset" */
1930         bh = page_buffers(page);
1931         pos = blocksize;
1932         while (offset >= pos) {
1933                 bh = bh->b_this_page;
1934                 iblock++;
1935                 pos += blocksize;
1936         }
1937
1938         err = 0;
1939         if (buffer_freed(bh)) {
1940                 BUFFER_TRACE(bh, "freed: skip");
1941                 goto unlock;
1942         }
1943
1944         if (!buffer_mapped(bh)) {
1945                 BUFFER_TRACE(bh, "unmapped");
1946                 ext3_get_block(inode, iblock, bh, 0);
1947                 /* unmapped? It's a hole - nothing to do */
1948                 if (!buffer_mapped(bh)) {
1949                         BUFFER_TRACE(bh, "still unmapped");
1950                         goto unlock;
1951                 }
1952         }
1953
1954         /* Ok, it's mapped. Make sure it's up-to-date */
1955         if (PageUptodate(page))
1956                 set_buffer_uptodate(bh);
1957
1958         if (!buffer_uptodate(bh)) {
1959                 err = -EIO;
1960                 ll_rw_block(READ, 1, &bh);
1961                 wait_on_buffer(bh);
1962                 /* Uhhuh. Read error. Complain and punt. */
1963                 if (!buffer_uptodate(bh))
1964                         goto unlock;
1965         }
1966
1967         if (ext3_should_journal_data(inode)) {
1968                 BUFFER_TRACE(bh, "get write access");
1969                 err = ext3_journal_get_write_access(handle, bh);
1970                 if (err)
1971                         goto unlock;
1972         }
1973
1974         zero_user(page, offset, length);
1975         BUFFER_TRACE(bh, "zeroed end of block");
1976
1977         err = 0;
1978         if (ext3_should_journal_data(inode)) {
1979                 err = ext3_journal_dirty_metadata(handle, bh);
1980         } else {
1981                 if (ext3_should_order_data(inode))
1982                         err = ext3_journal_dirty_data(handle, bh);
1983                 mark_buffer_dirty(bh);
1984         }
1985
1986 unlock:
1987         unlock_page(page);
1988         page_cache_release(page);
1989         return err;
1990 }
1991
1992 /*
1993  * Probably it should be a library function... search for first non-zero word
1994  * or memcmp with zero_page, whatever is better for particular architecture.
1995  * Linus?
1996  */
1997 static inline int all_zeroes(__le32 *p, __le32 *q)
1998 {
1999         while (p < q)
2000                 if (*p++)
2001                         return 0;
2002         return 1;
2003 }
2004
2005 /**
2006  *      ext3_find_shared - find the indirect blocks for partial truncation.
2007  *      @inode:   inode in question
2008  *      @depth:   depth of the affected branch
2009  *      @offsets: offsets of pointers in that branch (see ext3_block_to_path)
2010  *      @chain:   place to store the pointers to partial indirect blocks
2011  *      @top:     place to the (detached) top of branch
2012  *
2013  *      This is a helper function used by ext3_truncate().
2014  *
2015  *      When we do truncate() we may have to clean the ends of several
2016  *      indirect blocks but leave the blocks themselves alive. Block is
2017  *      partially truncated if some data below the new i_size is refered
2018  *      from it (and it is on the path to the first completely truncated
2019  *      data block, indeed).  We have to free the top of that path along
2020  *      with everything to the right of the path. Since no allocation
2021  *      past the truncation point is possible until ext3_truncate()
2022  *      finishes, we may safely do the latter, but top of branch may
2023  *      require special attention - pageout below the truncation point
2024  *      might try to populate it.
2025  *
2026  *      We atomically detach the top of branch from the tree, store the
2027  *      block number of its root in *@top, pointers to buffer_heads of
2028  *      partially truncated blocks - in @chain[].bh and pointers to
2029  *      their last elements that should not be removed - in
2030  *      @chain[].p. Return value is the pointer to last filled element
2031  *      of @chain.
2032  *
2033  *      The work left to caller to do the actual freeing of subtrees:
2034  *              a) free the subtree starting from *@top
2035  *              b) free the subtrees whose roots are stored in
2036  *                      (@chain[i].p+1 .. end of @chain[i].bh->b_data)
2037  *              c) free the subtrees growing from the inode past the @chain[0].
2038  *                      (no partially truncated stuff there).  */
2039
2040 static Indirect *ext3_find_shared(struct inode *inode, int depth,
2041                         int offsets[4], Indirect chain[4], __le32 *top)
2042 {
2043         Indirect *partial, *p;
2044         int k, err;
2045
2046         *top = 0;
2047         /* Make k index the deepest non-null offset + 1 */
2048         for (k = depth; k > 1 && !offsets[k-1]; k--)
2049                 ;
2050         partial = ext3_get_branch(inode, k, offsets, chain, &err);
2051         /* Writer: pointers */
2052         if (!partial)
2053                 partial = chain + k-1;
2054         /*
2055          * If the branch acquired continuation since we've looked at it -
2056          * fine, it should all survive and (new) top doesn't belong to us.
2057          */
2058         if (!partial->key && *partial->p)
2059                 /* Writer: end */
2060                 goto no_top;
2061         for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
2062                 ;
2063         /*
2064          * OK, we've found the last block that must survive. The rest of our
2065          * branch should be detached before unlocking. However, if that rest
2066          * of branch is all ours and does not grow immediately from the inode
2067          * it's easier to cheat and just decrement partial->p.
2068          */
2069         if (p == chain + k - 1 && p > chain) {
2070                 p->p--;
2071         } else {
2072                 *top = *p->p;
2073                 /* Nope, don't do this in ext3.  Must leave the tree intact */
2074 #if 0
2075                 *p->p = 0;
2076 #endif
2077         }
2078         /* Writer: end */
2079
2080         while(partial > p) {
2081                 brelse(partial->bh);
2082                 partial--;
2083         }
2084 no_top:
2085         return partial;
2086 }
2087
2088 /*
2089  * Zero a number of block pointers in either an inode or an indirect block.
2090  * If we restart the transaction we must again get write access to the
2091  * indirect block for further modification.
2092  *
2093  * We release `count' blocks on disk, but (last - first) may be greater
2094  * than `count' because there can be holes in there.
2095  */
2096 static void ext3_clear_blocks(handle_t *handle, struct inode *inode,
2097                 struct buffer_head *bh, ext3_fsblk_t block_to_free,
2098                 unsigned long count, __le32 *first, __le32 *last)
2099 {
2100         __le32 *p;
2101         if (try_to_extend_transaction(handle, inode)) {
2102                 if (bh) {
2103                         BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2104                         ext3_journal_dirty_metadata(handle, bh);
2105                 }
2106                 ext3_mark_inode_dirty(handle, inode);
2107                 truncate_restart_transaction(handle, inode);
2108                 if (bh) {
2109                         BUFFER_TRACE(bh, "retaking write access");
2110                         ext3_journal_get_write_access(handle, bh);
2111                 }
2112         }
2113
2114         /*
2115          * Any buffers which are on the journal will be in memory. We find
2116          * them on the hash table so journal_revoke() will run journal_forget()
2117          * on them.  We've already detached each block from the file, so
2118          * bforget() in journal_forget() should be safe.
2119          *
2120          * AKPM: turn on bforget in journal_forget()!!!
2121          */
2122         for (p = first; p < last; p++) {
2123                 u32 nr = le32_to_cpu(*p);
2124                 if (nr) {
2125                         struct buffer_head *bh;
2126
2127                         *p = 0;
2128                         bh = sb_find_get_block(inode->i_sb, nr);
2129                         ext3_forget(handle, 0, inode, bh, nr);
2130                 }
2131         }
2132
2133         ext3_free_blocks(handle, inode, block_to_free, count);
2134 }
2135
2136 /**
2137  * ext3_free_data - free a list of data blocks
2138  * @handle:     handle for this transaction
2139  * @inode:      inode we are dealing with
2140  * @this_bh:    indirect buffer_head which contains *@first and *@last
2141  * @first:      array of block numbers
2142  * @last:       points immediately past the end of array
2143  *
2144  * We are freeing all blocks refered from that array (numbers are stored as
2145  * little-endian 32-bit) and updating @inode->i_blocks appropriately.
2146  *
2147  * We accumulate contiguous runs of blocks to free.  Conveniently, if these
2148  * blocks are contiguous then releasing them at one time will only affect one
2149  * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
2150  * actually use a lot of journal space.
2151  *
2152  * @this_bh will be %NULL if @first and @last point into the inode's direct
2153  * block pointers.
2154  */
2155 static void ext3_free_data(handle_t *handle, struct inode *inode,
2156                            struct buffer_head *this_bh,
2157                            __le32 *first, __le32 *last)
2158 {
2159         ext3_fsblk_t block_to_free = 0;    /* Starting block # of a run */
2160         unsigned long count = 0;            /* Number of blocks in the run */
2161         __le32 *block_to_free_p = NULL;     /* Pointer into inode/ind
2162                                                corresponding to
2163                                                block_to_free */
2164         ext3_fsblk_t nr;                    /* Current block # */
2165         __le32 *p;                          /* Pointer into inode/ind
2166                                                for current block */
2167         int err;
2168
2169         if (this_bh) {                          /* For indirect block */
2170                 BUFFER_TRACE(this_bh, "get_write_access");
2171                 err = ext3_journal_get_write_access(handle, this_bh);
2172                 /* Important: if we can't update the indirect pointers
2173                  * to the blocks, we can't free them. */
2174                 if (err)
2175                         return;
2176         }
2177
2178         for (p = first; p < last; p++) {
2179                 nr = le32_to_cpu(*p);
2180                 if (nr) {
2181                         /* accumulate blocks to free if they're contiguous */
2182                         if (count == 0) {
2183                                 block_to_free = nr;
2184                                 block_to_free_p = p;
2185                                 count = 1;
2186                         } else if (nr == block_to_free + count) {
2187                                 count++;
2188                         } else {
2189                                 ext3_clear_blocks(handle, inode, this_bh,
2190                                                   block_to_free,
2191                                                   count, block_to_free_p, p);
2192                                 block_to_free = nr;
2193                                 block_to_free_p = p;
2194                                 count = 1;
2195                         }
2196                 }
2197         }
2198
2199         if (count > 0)
2200                 ext3_clear_blocks(handle, inode, this_bh, block_to_free,
2201                                   count, block_to_free_p, p);
2202
2203         if (this_bh) {
2204                 BUFFER_TRACE(this_bh, "call ext3_journal_dirty_metadata");
2205
2206                 /*
2207                  * The buffer head should have an attached journal head at this
2208                  * point. However, if the data is corrupted and an indirect
2209                  * block pointed to itself, it would have been detached when
2210                  * the block was cleared. Check for this instead of OOPSing.
2211                  */
2212                 if (bh2jh(this_bh))
2213                         ext3_journal_dirty_metadata(handle, this_bh);
2214                 else
2215                         ext3_error(inode->i_sb, "ext3_free_data",
2216                                    "circular indirect block detected, "
2217                                    "inode=%lu, block=%llu",
2218                                    inode->i_ino,
2219                                    (unsigned long long)this_bh->b_blocknr);
2220         }
2221 }
2222
2223 /**
2224  *      ext3_free_branches - free an array of branches
2225  *      @handle: JBD handle for this transaction
2226  *      @inode: inode we are dealing with
2227  *      @parent_bh: the buffer_head which contains *@first and *@last
2228  *      @first: array of block numbers
2229  *      @last:  pointer immediately past the end of array
2230  *      @depth: depth of the branches to free
2231  *
2232  *      We are freeing all blocks refered from these branches (numbers are
2233  *      stored as little-endian 32-bit) and updating @inode->i_blocks
2234  *      appropriately.
2235  */
2236 static void ext3_free_branches(handle_t *handle, struct inode *inode,
2237                                struct buffer_head *parent_bh,
2238                                __le32 *first, __le32 *last, int depth)
2239 {
2240         ext3_fsblk_t nr;
2241         __le32 *p;
2242
2243         if (is_handle_aborted(handle))
2244                 return;
2245
2246         if (depth--) {
2247                 struct buffer_head *bh;
2248                 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2249                 p = last;
2250                 while (--p >= first) {
2251                         nr = le32_to_cpu(*p);
2252                         if (!nr)
2253                                 continue;               /* A hole */
2254
2255                         /* Go read the buffer for the next level down */
2256                         bh = sb_bread(inode->i_sb, nr);
2257
2258                         /*
2259                          * A read failure? Report error and clear slot
2260                          * (should be rare).
2261                          */
2262                         if (!bh) {
2263                                 ext3_error(inode->i_sb, "ext3_free_branches",
2264                                            "Read failure, inode=%lu, block="E3FSBLK,
2265                                            inode->i_ino, nr);
2266                                 continue;
2267                         }
2268
2269                         /* This zaps the entire block.  Bottom up. */
2270                         BUFFER_TRACE(bh, "free child branches");
2271                         ext3_free_branches(handle, inode, bh,
2272                                            (__le32*)bh->b_data,
2273                                            (__le32*)bh->b_data + addr_per_block,
2274                                            depth);
2275
2276                         /*
2277                          * We've probably journalled the indirect block several
2278                          * times during the truncate.  But it's no longer
2279                          * needed and we now drop it from the transaction via
2280                          * journal_revoke().
2281                          *
2282                          * That's easy if it's exclusively part of this
2283                          * transaction.  But if it's part of the committing
2284                          * transaction then journal_forget() will simply
2285                          * brelse() it.  That means that if the underlying
2286                          * block is reallocated in ext3_get_block(),
2287                          * unmap_underlying_metadata() will find this block
2288                          * and will try to get rid of it.  damn, damn.
2289                          *
2290                          * If this block has already been committed to the
2291                          * journal, a revoke record will be written.  And
2292                          * revoke records must be emitted *before* clearing
2293                          * this block's bit in the bitmaps.
2294                          */
2295                         ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
2296
2297                         /*
2298                          * Everything below this this pointer has been
2299                          * released.  Now let this top-of-subtree go.
2300                          *
2301                          * We want the freeing of this indirect block to be
2302                          * atomic in the journal with the updating of the
2303                          * bitmap block which owns it.  So make some room in
2304                          * the journal.
2305                          *
2306                          * We zero the parent pointer *after* freeing its
2307                          * pointee in the bitmaps, so if extend_transaction()
2308                          * for some reason fails to put the bitmap changes and
2309                          * the release into the same transaction, recovery
2310                          * will merely complain about releasing a free block,
2311                          * rather than leaking blocks.
2312                          */
2313                         if (is_handle_aborted(handle))
2314                                 return;
2315                         if (try_to_extend_transaction(handle, inode)) {
2316                                 ext3_mark_inode_dirty(handle, inode);
2317                                 truncate_restart_transaction(handle, inode);
2318                         }
2319
2320                         ext3_free_blocks(handle, inode, nr, 1);
2321
2322                         if (parent_bh) {
2323                                 /*
2324                                  * The block which we have just freed is
2325                                  * pointed to by an indirect block: journal it
2326                                  */
2327                                 BUFFER_TRACE(parent_bh, "get_write_access");
2328                                 if (!ext3_journal_get_write_access(handle,
2329                                                                    parent_bh)){
2330                                         *p = 0;
2331                                         BUFFER_TRACE(parent_bh,
2332                                         "call ext3_journal_dirty_metadata");
2333                                         ext3_journal_dirty_metadata(handle,
2334                                                                     parent_bh);
2335                                 }
2336                         }
2337                 }
2338         } else {
2339                 /* We have reached the bottom of the tree. */
2340                 BUFFER_TRACE(parent_bh, "free data blocks");
2341                 ext3_free_data(handle, inode, parent_bh, first, last);
2342         }
2343 }
2344
2345 int ext3_can_truncate(struct inode *inode)
2346 {
2347         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2348                 return 0;
2349         if (S_ISREG(inode->i_mode))
2350                 return 1;
2351         if (S_ISDIR(inode->i_mode))
2352                 return 1;
2353         if (S_ISLNK(inode->i_mode))
2354                 return !ext3_inode_is_fast_symlink(inode);
2355         return 0;
2356 }
2357
2358 /*
2359  * ext3_truncate()
2360  *
2361  * We block out ext3_get_block() block instantiations across the entire
2362  * transaction, and VFS/VM ensures that ext3_truncate() cannot run
2363  * simultaneously on behalf of the same inode.
2364  *
2365  * As we work through the truncate and commmit bits of it to the journal there
2366  * is one core, guiding principle: the file's tree must always be consistent on
2367  * disk.  We must be able to restart the truncate after a crash.
2368  *
2369  * The file's tree may be transiently inconsistent in memory (although it
2370  * probably isn't), but whenever we close off and commit a journal transaction,
2371  * the contents of (the filesystem + the journal) must be consistent and
2372  * restartable.  It's pretty simple, really: bottom up, right to left (although
2373  * left-to-right works OK too).
2374  *
2375  * Note that at recovery time, journal replay occurs *before* the restart of
2376  * truncate against the orphan inode list.
2377  *
2378  * The committed inode has the new, desired i_size (which is the same as
2379  * i_disksize in this case).  After a crash, ext3_orphan_cleanup() will see
2380  * that this inode's truncate did not complete and it will again call
2381  * ext3_truncate() to have another go.  So there will be instantiated blocks
2382  * to the right of the truncation point in a crashed ext3 filesystem.  But
2383  * that's fine - as long as they are linked from the inode, the post-crash
2384  * ext3_truncate() run will find them and release them.
2385  */
2386 void ext3_truncate(struct inode *inode)
2387 {
2388         handle_t *handle;
2389         struct ext3_inode_info *ei = EXT3_I(inode);
2390         __le32 *i_data = ei->i_data;
2391         int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2392         struct address_space *mapping = inode->i_mapping;
2393         int offsets[4];
2394         Indirect chain[4];
2395         Indirect *partial;
2396         __le32 nr = 0;
2397         int n;
2398         long last_block;
2399         unsigned blocksize = inode->i_sb->s_blocksize;
2400         struct page *page;
2401
2402         if (!ext3_can_truncate(inode))
2403                 goto out_notrans;
2404
2405         if (inode->i_size == 0 && ext3_should_writeback_data(inode))
2406                 ext3_set_inode_state(inode, EXT3_STATE_FLUSH_ON_CLOSE);
2407
2408         /*
2409          * We have to lock the EOF page here, because lock_page() nests
2410          * outside journal_start().
2411          */
2412         if ((inode->i_size & (blocksize - 1)) == 0) {
2413                 /* Block boundary? Nothing to do */
2414                 page = NULL;
2415         } else {
2416                 page = grab_cache_page(mapping,
2417                                 inode->i_size >> PAGE_CACHE_SHIFT);
2418                 if (!page)
2419                         goto out_notrans;
2420         }
2421
2422         handle = start_transaction(inode);
2423         if (IS_ERR(handle)) {
2424                 if (page) {
2425                         clear_highpage(page);
2426                         flush_dcache_page(page);
2427                         unlock_page(page);
2428                         page_cache_release(page);
2429                 }
2430                 goto out_notrans;
2431         }
2432
2433         last_block = (inode->i_size + blocksize-1)
2434                                         >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
2435
2436         if (page)
2437                 ext3_block_truncate_page(handle, page, mapping, inode->i_size);
2438
2439         n = ext3_block_to_path(inode, last_block, offsets, NULL);
2440         if (n == 0)
2441                 goto out_stop;  /* error */
2442
2443         /*
2444          * OK.  This truncate is going to happen.  We add the inode to the
2445          * orphan list, so that if this truncate spans multiple transactions,
2446          * and we crash, we will resume the truncate when the filesystem
2447          * recovers.  It also marks the inode dirty, to catch the new size.
2448          *
2449          * Implication: the file must always be in a sane, consistent
2450          * truncatable state while each transaction commits.
2451          */
2452         if (ext3_orphan_add(handle, inode))
2453                 goto out_stop;
2454
2455         /*
2456          * The orphan list entry will now protect us from any crash which
2457          * occurs before the truncate completes, so it is now safe to propagate
2458          * the new, shorter inode size (held for now in i_size) into the
2459          * on-disk inode. We do this via i_disksize, which is the value which
2460          * ext3 *really* writes onto the disk inode.
2461          */
2462         ei->i_disksize = inode->i_size;
2463
2464         /*
2465          * From here we block out all ext3_get_block() callers who want to
2466          * modify the block allocation tree.
2467          */
2468         mutex_lock(&ei->truncate_mutex);
2469
2470         if (n == 1) {           /* direct blocks */
2471                 ext3_free_data(handle, inode, NULL, i_data+offsets[0],
2472                                i_data + EXT3_NDIR_BLOCKS);
2473                 goto do_indirects;
2474         }
2475
2476         partial = ext3_find_shared(inode, n, offsets, chain, &nr);
2477         /* Kill the top of shared branch (not detached) */
2478         if (nr) {
2479                 if (partial == chain) {
2480                         /* Shared branch grows from the inode */
2481                         ext3_free_branches(handle, inode, NULL,
2482                                            &nr, &nr+1, (chain+n-1) - partial);
2483                         *partial->p = 0;
2484                         /*
2485                          * We mark the inode dirty prior to restart,
2486                          * and prior to stop.  No need for it here.
2487                          */
2488                 } else {
2489                         /* Shared branch grows from an indirect block */
2490                         BUFFER_TRACE(partial->bh, "get_write_access");
2491                         ext3_free_branches(handle, inode, partial->bh,
2492                                         partial->p,
2493                                         partial->p+1, (chain+n-1) - partial);
2494                 }
2495         }
2496         /* Clear the ends of indirect blocks on the shared branch */
2497         while (partial > chain) {
2498                 ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2499                                    (__le32*)partial->bh->b_data+addr_per_block,
2500                                    (chain+n-1) - partial);
2501                 BUFFER_TRACE(partial->bh, "call brelse");
2502                 brelse (partial->bh);
2503                 partial--;
2504         }
2505 do_indirects:
2506         /* Kill the remaining (whole) subtrees */
2507         switch (offsets[0]) {
2508         default:
2509                 nr = i_data[EXT3_IND_BLOCK];
2510                 if (nr) {
2511                         ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
2512                         i_data[EXT3_IND_BLOCK] = 0;
2513                 }
2514         case EXT3_IND_BLOCK:
2515                 nr = i_data[EXT3_DIND_BLOCK];
2516                 if (nr) {
2517                         ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
2518                         i_data[EXT3_DIND_BLOCK] = 0;
2519                 }
2520         case EXT3_DIND_BLOCK:
2521                 nr = i_data[EXT3_TIND_BLOCK];
2522                 if (nr) {
2523                         ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
2524                         i_data[EXT3_TIND_BLOCK] = 0;
2525                 }
2526         case EXT3_TIND_BLOCK:
2527                 ;
2528         }
2529
2530         ext3_discard_reservation(inode);
2531
2532         mutex_unlock(&ei->truncate_mutex);
2533         inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
2534         ext3_mark_inode_dirty(handle, inode);
2535
2536         /*
2537          * In a multi-transaction truncate, we only make the final transaction
2538          * synchronous
2539          */
2540         if (IS_SYNC(inode))
2541                 handle->h_sync = 1;
2542 out_stop:
2543         /*
2544          * If this was a simple ftruncate(), and the file will remain alive
2545          * then we need to clear up the orphan record which we created above.
2546          * However, if this was a real unlink then we were called by
2547          * ext3_delete_inode(), and we allow that function to clean up the
2548          * orphan info for us.
2549          */
2550         if (inode->i_nlink)
2551                 ext3_orphan_del(handle, inode);
2552
2553         ext3_journal_stop(handle);
2554         return;
2555 out_notrans:
2556         /*
2557          * Delete the inode from orphan list so that it doesn't stay there
2558          * forever and trigger assertion on umount.
2559          */
2560         if (inode->i_nlink)
2561                 ext3_orphan_del(NULL, inode);
2562 }
2563
2564 static ext3_fsblk_t ext3_get_inode_block(struct super_block *sb,
2565                 unsigned long ino, struct ext3_iloc *iloc)
2566 {
2567         unsigned long block_group;
2568         unsigned long offset;
2569         ext3_fsblk_t block;
2570         struct ext3_group_desc *gdp;
2571
2572         if (!ext3_valid_inum(sb, ino)) {
2573                 /*
2574                  * This error is already checked for in namei.c unless we are
2575                  * looking at an NFS filehandle, in which case no error
2576                  * report is needed
2577                  */
2578                 return 0;
2579         }
2580
2581         block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
2582         gdp = ext3_get_group_desc(sb, block_group, NULL);
2583         if (!gdp)
2584                 return 0;
2585         /*
2586          * Figure out the offset within the block group inode table
2587          */
2588         offset = ((ino - 1) % EXT3_INODES_PER_GROUP(sb)) *
2589                 EXT3_INODE_SIZE(sb);
2590         block = le32_to_cpu(gdp->bg_inode_table) +
2591                 (offset >> EXT3_BLOCK_SIZE_BITS(sb));
2592
2593         iloc->block_group = block_group;
2594         iloc->offset = offset & (EXT3_BLOCK_SIZE(sb) - 1);
2595         return block;
2596 }
2597
2598 /*
2599  * ext3_get_inode_loc returns with an extra refcount against the inode's
2600  * underlying buffer_head on success. If 'in_mem' is true, we have all
2601  * data in memory that is needed to recreate the on-disk version of this
2602  * inode.
2603  */
2604 static int __ext3_get_inode_loc(struct inode *inode,
2605                                 struct ext3_iloc *iloc, int in_mem)
2606 {
2607         ext3_fsblk_t block;
2608         struct buffer_head *bh;
2609
2610         block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
2611         if (!block)
2612                 return -EIO;
2613
2614         bh = sb_getblk(inode->i_sb, block);
2615         if (!bh) {
2616                 ext3_error (inode->i_sb, "ext3_get_inode_loc",
2617                                 "unable to read inode block - "
2618                                 "inode=%lu, block="E3FSBLK,
2619                                  inode->i_ino, block);
2620                 return -EIO;
2621         }
2622         if (!buffer_uptodate(bh)) {
2623                 lock_buffer(bh);
2624
2625                 /*
2626                  * If the buffer has the write error flag, we have failed
2627                  * to write out another inode in the same block.  In this
2628                  * case, we don't have to read the block because we may
2629                  * read the old inode data successfully.
2630                  */
2631                 if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
2632                         set_buffer_uptodate(bh);
2633
2634                 if (buffer_uptodate(bh)) {
2635                         /* someone brought it uptodate while we waited */
2636                         unlock_buffer(bh);
2637                         goto has_buffer;
2638                 }
2639
2640                 /*
2641                  * If we have all information of the inode in memory and this
2642                  * is the only valid inode in the block, we need not read the
2643                  * block.
2644                  */
2645                 if (in_mem) {
2646                         struct buffer_head *bitmap_bh;
2647                         struct ext3_group_desc *desc;
2648                         int inodes_per_buffer;
2649                         int inode_offset, i;
2650                         int block_group;
2651                         int start;
2652
2653                         block_group = (inode->i_ino - 1) /
2654                                         EXT3_INODES_PER_GROUP(inode->i_sb);
2655                         inodes_per_buffer = bh->b_size /
2656                                 EXT3_INODE_SIZE(inode->i_sb);
2657                         inode_offset = ((inode->i_ino - 1) %
2658                                         EXT3_INODES_PER_GROUP(inode->i_sb));
2659                         start = inode_offset & ~(inodes_per_buffer - 1);
2660
2661                         /* Is the inode bitmap in cache? */
2662                         desc = ext3_get_group_desc(inode->i_sb,
2663                                                 block_group, NULL);
2664                         if (!desc)
2665                                 goto make_io;
2666
2667                         bitmap_bh = sb_getblk(inode->i_sb,
2668                                         le32_to_cpu(desc->bg_inode_bitmap));
2669                         if (!bitmap_bh)
2670                                 goto make_io;
2671
2672                         /*
2673                          * If the inode bitmap isn't in cache then the
2674                          * optimisation may end up performing two reads instead
2675                          * of one, so skip it.
2676                          */
2677                         if (!buffer_uptodate(bitmap_bh)) {
2678                                 brelse(bitmap_bh);
2679                                 goto make_io;
2680                         }
2681                         for (i = start; i < start + inodes_per_buffer; i++) {
2682                                 if (i == inode_offset)
2683                                         continue;
2684                                 if (ext3_test_bit(i, bitmap_bh->b_data))
2685                                         break;
2686                         }
2687                         brelse(bitmap_bh);
2688                         if (i == start + inodes_per_buffer) {
2689                                 /* all other inodes are free, so skip I/O */
2690                                 memset(bh->b_data, 0, bh->b_size);
2691                                 set_buffer_uptodate(bh);
2692                                 unlock_buffer(bh);
2693                                 goto has_buffer;
2694                         }
2695                 }
2696
2697 make_io:
2698                 /*
2699                  * There are other valid inodes in the buffer, this inode
2700                  * has in-inode xattrs, or we don't have this inode in memory.
2701                  * Read the block from disk.
2702                  */
2703                 get_bh(bh);
2704                 bh->b_end_io = end_buffer_read_sync;
2705                 submit_bh(READ_META, bh);
2706                 wait_on_buffer(bh);
2707                 if (!buffer_uptodate(bh)) {
2708                         ext3_error(inode->i_sb, "ext3_get_inode_loc",
2709                                         "unable to read inode block - "
2710                                         "inode=%lu, block="E3FSBLK,
2711                                         inode->i_ino, block);
2712                         brelse(bh);
2713                         return -EIO;
2714                 }
2715         }
2716 has_buffer:
2717         iloc->bh = bh;
2718         return 0;
2719 }
2720
2721 int ext3_get_inode_loc(struct inode *inode, struct ext3_iloc *iloc)
2722 {
2723         /* We have all inode data except xattrs in memory here. */
2724         return __ext3_get_inode_loc(inode, iloc,
2725                 !ext3_test_inode_state(inode, EXT3_STATE_XATTR));
2726 }
2727
2728 void ext3_set_inode_flags(struct inode *inode)
2729 {
2730         unsigned int flags = EXT3_I(inode)->i_flags;
2731
2732         inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
2733         if (flags & EXT3_SYNC_FL)
2734                 inode->i_flags |= S_SYNC;
2735         if (flags & EXT3_APPEND_FL)
2736                 inode->i_flags |= S_APPEND;
2737         if (flags & EXT3_IMMUTABLE_FL)
2738                 inode->i_flags |= S_IMMUTABLE;
2739         if (flags & EXT3_NOATIME_FL)
2740                 inode->i_flags |= S_NOATIME;
2741         if (flags & EXT3_DIRSYNC_FL)
2742                 inode->i_flags |= S_DIRSYNC;
2743 }
2744
2745 /* Propagate flags from i_flags to EXT3_I(inode)->i_flags */
2746 void ext3_get_inode_flags(struct ext3_inode_info *ei)
2747 {
2748         unsigned int flags = ei->vfs_inode.i_flags;
2749
2750         ei->i_flags &= ~(EXT3_SYNC_FL|EXT3_APPEND_FL|
2751                         EXT3_IMMUTABLE_FL|EXT3_NOATIME_FL|EXT3_DIRSYNC_FL);
2752         if (flags & S_SYNC)
2753                 ei->i_flags |= EXT3_SYNC_FL;
2754         if (flags & S_APPEND)
2755                 ei->i_flags |= EXT3_APPEND_FL;
2756         if (flags & S_IMMUTABLE)
2757                 ei->i_flags |= EXT3_IMMUTABLE_FL;
2758         if (flags & S_NOATIME)
2759                 ei->i_flags |= EXT3_NOATIME_FL;
2760         if (flags & S_DIRSYNC)
2761                 ei->i_flags |= EXT3_DIRSYNC_FL;
2762 }
2763
2764 struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
2765 {
2766         struct ext3_iloc iloc;
2767         struct ext3_inode *raw_inode;
2768         struct ext3_inode_info *ei;
2769         struct buffer_head *bh;
2770         struct inode *inode;
2771         journal_t *journal = EXT3_SB(sb)->s_journal;
2772         transaction_t *transaction;
2773         long ret;
2774         int block;
2775
2776         inode = iget_locked(sb, ino);
2777         if (!inode)
2778                 return ERR_PTR(-ENOMEM);
2779         if (!(inode->i_state & I_NEW))
2780                 return inode;
2781
2782         ei = EXT3_I(inode);
2783         ei->i_block_alloc_info = NULL;
2784
2785         ret = __ext3_get_inode_loc(inode, &iloc, 0);
2786         if (ret < 0)
2787                 goto bad_inode;
2788         bh = iloc.bh;
2789         raw_inode = ext3_raw_inode(&iloc);
2790         inode->i_mode = le16_to_cpu(raw_inode->i_mode);
2791         inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
2792         inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
2793         if(!(test_opt (inode->i_sb, NO_UID32))) {
2794                 inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
2795                 inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
2796         }
2797         inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
2798         inode->i_size = le32_to_cpu(raw_inode->i_size);
2799         inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
2800         inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
2801         inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
2802         inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
2803
2804         ei->i_state = 0;
2805         ei->i_dir_start_lookup = 0;
2806         ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
2807         /* We now have enough fields to check if the inode was active or not.
2808          * This is needed because nfsd might try to access dead inodes
2809          * the test is that same one that e2fsck uses
2810          * NeilBrown 1999oct15
2811          */
2812         if (inode->i_nlink == 0) {
2813                 if (inode->i_mode == 0 ||
2814                     !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
2815                         /* this inode is deleted */
2816                         brelse (bh);
2817                         ret = -ESTALE;
2818                         goto bad_inode;
2819                 }
2820                 /* The only unlinked inodes we let through here have
2821                  * valid i_mode and are being read by the orphan
2822                  * recovery code: that's fine, we're about to complete
2823                  * the process of deleting those. */
2824         }
2825         inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
2826         ei->i_flags = le32_to_cpu(raw_inode->i_flags);
2827 #ifdef EXT3_FRAGMENTS
2828         ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
2829         ei->i_frag_no = raw_inode->i_frag;
2830         ei->i_frag_size = raw_inode->i_fsize;
2831 #endif
2832         ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
2833         if (!S_ISREG(inode->i_mode)) {
2834                 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
2835         } else {
2836                 inode->i_size |=
2837                         ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
2838         }
2839         ei->i_disksize = inode->i_size;
2840         inode->i_generation = le32_to_cpu(raw_inode->i_generation);
2841         ei->i_block_group = iloc.block_group;
2842         /*
2843          * NOTE! The in-memory inode i_data array is in little-endian order
2844          * even on big-endian machines: we do NOT byteswap the block numbers!
2845          */
2846         for (block = 0; block < EXT3_N_BLOCKS; block++)
2847                 ei->i_data[block] = raw_inode->i_block[block];
2848         INIT_LIST_HEAD(&ei->i_orphan);
2849
2850         /*
2851          * Set transaction id's of transactions that have to be committed
2852          * to finish f[data]sync. We set them to currently running transaction
2853          * as we cannot be sure that the inode or some of its metadata isn't
2854          * part of the transaction - the inode could have been reclaimed and
2855          * now it is reread from disk.
2856          */
2857         if (journal) {
2858                 tid_t tid;
2859
2860                 spin_lock(&journal->j_state_lock);
2861                 if (journal->j_running_transaction)
2862                         transaction = journal->j_running_transaction;
2863                 else
2864                         transaction = journal->j_committing_transaction;
2865                 if (transaction)
2866                         tid = transaction->t_tid;
2867                 else
2868                         tid = journal->j_commit_sequence;
2869                 spin_unlock(&journal->j_state_lock);
2870                 atomic_set(&ei->i_sync_tid, tid);
2871                 atomic_set(&ei->i_datasync_tid, tid);
2872         }
2873
2874         if (inode->i_ino >= EXT3_FIRST_INO(inode->i_sb) + 1 &&
2875             EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) {
2876                 /*
2877                  * When mke2fs creates big inodes it does not zero out
2878                  * the unused bytes above EXT3_GOOD_OLD_INODE_SIZE,
2879                  * so ignore those first few inodes.
2880                  */
2881                 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
2882                 if (EXT3_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
2883                     EXT3_INODE_SIZE(inode->i_sb)) {
2884                         brelse (bh);
2885                         ret = -EIO;
2886                         goto bad_inode;
2887                 }
2888                 if (ei->i_extra_isize == 0) {
2889                         /* The extra space is currently unused. Use it. */
2890                         ei->i_extra_isize = sizeof(struct ext3_inode) -
2891                                             EXT3_GOOD_OLD_INODE_SIZE;
2892                 } else {
2893                         __le32 *magic = (void *)raw_inode +
2894                                         EXT3_GOOD_OLD_INODE_SIZE +
2895                                         ei->i_extra_isize;
2896                         if (*magic == cpu_to_le32(EXT3_XATTR_MAGIC))
2897                                  ext3_set_inode_state(inode, EXT3_STATE_XATTR);
2898                 }
2899         } else
2900                 ei->i_extra_isize = 0;
2901
2902         if (S_ISREG(inode->i_mode)) {
2903                 inode->i_op = &ext3_file_inode_operations;
2904                 inode->i_fop = &ext3_file_operations;
2905                 ext3_set_aops(inode);
2906         } else if (S_ISDIR(inode->i_mode)) {
2907                 inode->i_op = &ext3_dir_inode_operations;
2908                 inode->i_fop = &ext3_dir_operations;
2909         } else if (S_ISLNK(inode->i_mode)) {
2910                 if (ext3_inode_is_fast_symlink(inode)) {
2911                         inode->i_op = &ext3_fast_symlink_inode_operations;
2912                         nd_terminate_link(ei->i_data, inode->i_size,
2913                                 sizeof(ei->i_data) - 1);
2914                 } else {
2915                         inode->i_op = &ext3_symlink_inode_operations;
2916                         ext3_set_aops(inode);
2917                 }
2918         } else {
2919                 inode->i_op = &ext3_special_inode_operations;
2920                 if (raw_inode->i_block[0])
2921                         init_special_inode(inode, inode->i_mode,
2922                            old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
2923                 else
2924                         init_special_inode(inode, inode->i_mode,
2925                            new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
2926         }
2927         brelse (iloc.bh);
2928         ext3_set_inode_flags(inode);
2929         unlock_new_inode(inode);
2930         return inode;
2931
2932 bad_inode:
2933         iget_failed(inode);
2934         return ERR_PTR(ret);
2935 }
2936
2937 /*
2938  * Post the struct inode info into an on-disk inode location in the
2939  * buffer-cache.  This gobbles the caller's reference to the
2940  * buffer_head in the inode location struct.
2941  *
2942  * The caller must have write access to iloc->bh.
2943  */
2944 static int ext3_do_update_inode(handle_t *handle,
2945                                 struct inode *inode,
2946                                 struct ext3_iloc *iloc)
2947 {
2948         struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
2949         struct ext3_inode_info *ei = EXT3_I(inode);
2950         struct buffer_head *bh = iloc->bh;
2951         int err = 0, rc, block;
2952
2953 again:
2954         /* we can't allow multiple procs in here at once, its a bit racey */
2955         lock_buffer(bh);
2956
2957         /* For fields not not tracking in the in-memory inode,
2958          * initialise them to zero for new inodes. */
2959         if (ext3_test_inode_state(inode, EXT3_STATE_NEW))
2960                 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
2961
2962         ext3_get_inode_flags(ei);
2963         raw_inode->i_mode = cpu_to_le16(inode->i_mode);
2964         if(!(test_opt(inode->i_sb, NO_UID32))) {
2965                 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
2966                 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
2967 /*
2968  * Fix up interoperability with old kernels. Otherwise, old inodes get
2969  * re-used with the upper 16 bits of the uid/gid intact
2970  */
2971                 if(!ei->i_dtime) {
2972                         raw_inode->i_uid_high =
2973                                 cpu_to_le16(high_16_bits(inode->i_uid));
2974                         raw_inode->i_gid_high =
2975                                 cpu_to_le16(high_16_bits(inode->i_gid));
2976                 } else {
2977                         raw_inode->i_uid_high = 0;
2978                         raw_inode->i_gid_high = 0;
2979                 }
2980         } else {
2981                 raw_inode->i_uid_low =
2982                         cpu_to_le16(fs_high2lowuid(inode->i_uid));
2983                 raw_inode->i_gid_low =
2984                         cpu_to_le16(fs_high2lowgid(inode->i_gid));
2985                 raw_inode->i_uid_high = 0;
2986                 raw_inode->i_gid_high = 0;
2987         }
2988         raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
2989         raw_inode->i_size = cpu_to_le32(ei->i_disksize);
2990         raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
2991         raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
2992         raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
2993         raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
2994         raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
2995         raw_inode->i_flags = cpu_to_le32(ei->i_flags);
2996 #ifdef EXT3_FRAGMENTS
2997         raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
2998         raw_inode->i_frag = ei->i_frag_no;
2999         raw_inode->i_fsize = ei->i_frag_size;
3000 #endif
3001         raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
3002         if (!S_ISREG(inode->i_mode)) {
3003                 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
3004         } else {
3005                 raw_inode->i_size_high =
3006                         cpu_to_le32(ei->i_disksize >> 32);
3007                 if (ei->i_disksize > 0x7fffffffULL) {
3008                         struct super_block *sb = inode->i_sb;
3009                         if (!EXT3_HAS_RO_COMPAT_FEATURE(sb,
3010                                         EXT3_FEATURE_RO_COMPAT_LARGE_FILE) ||
3011                             EXT3_SB(sb)->s_es->s_rev_level ==
3012                                         cpu_to_le32(EXT3_GOOD_OLD_REV)) {
3013                                /* If this is the first large file
3014                                 * created, add a flag to the superblock.
3015                                 */
3016                                 unlock_buffer(bh);
3017                                 err = ext3_journal_get_write_access(handle,
3018                                                 EXT3_SB(sb)->s_sbh);
3019                                 if (err)
3020                                         goto out_brelse;
3021
3022                                 ext3_update_dynamic_rev(sb);
3023                                 EXT3_SET_RO_COMPAT_FEATURE(sb,
3024                                         EXT3_FEATURE_RO_COMPAT_LARGE_FILE);
3025                                 handle->h_sync = 1;
3026                                 err = ext3_journal_dirty_metadata(handle,
3027                                                 EXT3_SB(sb)->s_sbh);
3028                                 /* get our lock and start over */
3029                                 goto again;
3030                         }
3031                 }
3032         }
3033         raw_inode->i_generation = cpu_to_le32(inode->i_generation);
3034         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
3035                 if (old_valid_dev(inode->i_rdev)) {
3036                         raw_inode->i_block[0] =
3037                                 cpu_to_le32(old_encode_dev(inode->i_rdev));
3038                         raw_inode->i_block[1] = 0;
3039                 } else {
3040                         raw_inode->i_block[0] = 0;
3041                         raw_inode->i_block[1] =
3042                                 cpu_to_le32(new_encode_dev(inode->i_rdev));
3043                         raw_inode->i_block[2] = 0;
3044                 }
3045         } else for (block = 0; block < EXT3_N_BLOCKS; block++)
3046                 raw_inode->i_block[block] = ei->i_data[block];
3047
3048         if (ei->i_extra_isize)
3049                 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
3050
3051         BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
3052         unlock_buffer(bh);
3053         rc = ext3_journal_dirty_metadata(handle, bh);
3054         if (!err)
3055                 err = rc;
3056         ext3_clear_inode_state(inode, EXT3_STATE_NEW);
3057
3058         atomic_set(&ei->i_sync_tid, handle->h_transaction->t_tid);
3059 out_brelse:
3060         brelse (bh);
3061         ext3_std_error(inode->i_sb, err);
3062         return err;
3063 }
3064
3065 /*
3066  * ext3_write_inode()
3067  *
3068  * We are called from a few places:
3069  *
3070  * - Within generic_file_write() for O_SYNC files.
3071  *   Here, there will be no transaction running. We wait for any running
3072  *   trasnaction to commit.
3073  *
3074  * - Within sys_sync(), kupdate and such.
3075  *   We wait on commit, if tol to.
3076  *
3077  * - Within prune_icache() (PF_MEMALLOC == true)
3078  *   Here we simply return.  We can't afford to block kswapd on the
3079  *   journal commit.
3080  *
3081  * In all cases it is actually safe for us to return without doing anything,
3082  * because the inode has been copied into a raw inode buffer in
3083  * ext3_mark_inode_dirty().  This is a correctness thing for O_SYNC and for
3084  * knfsd.
3085  *
3086  * Note that we are absolutely dependent upon all inode dirtiers doing the
3087  * right thing: they *must* call mark_inode_dirty() after dirtying info in
3088  * which we are interested.
3089  *
3090  * It would be a bug for them to not do this.  The code:
3091  *
3092  *      mark_inode_dirty(inode)
3093  *      stuff();
3094  *      inode->i_size = expr;
3095  *
3096  * is in error because a kswapd-driven write_inode() could occur while
3097  * `stuff()' is running, and the new i_size will be lost.  Plus the inode
3098  * will no longer be on the superblock's dirty inode list.
3099  */
3100 int ext3_write_inode(struct inode *inode, int wait)
3101 {
3102         if (current->flags & PF_MEMALLOC)
3103                 return 0;
3104
3105         if (ext3_journal_current_handle()) {
3106                 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
3107                 dump_stack();
3108                 return -EIO;
3109         }
3110
3111         if (!wait)
3112                 return 0;
3113
3114         return ext3_force_commit(inode->i_sb);
3115 }
3116
3117 /*
3118  * ext3_setattr()
3119  *
3120  * Called from notify_change.
3121  *
3122  * We want to trap VFS attempts to truncate the file as soon as
3123  * possible.  In particular, we want to make sure that when the VFS
3124  * shrinks i_size, we put the inode on the orphan list and modify
3125  * i_disksize immediately, so that during the subsequent flushing of
3126  * dirty pages and freeing of disk blocks, we can guarantee that any
3127  * commit will leave the blocks being flushed in an unused state on
3128  * disk.  (On recovery, the inode will get truncated and the blocks will
3129  * be freed, so we have a strong guarantee that no future commit will
3130  * leave these blocks visible to the user.)
3131  *
3132  * Called with inode->sem down.
3133  */
3134 int ext3_setattr(struct dentry *dentry, struct iattr *attr)
3135 {
3136         struct inode *inode = dentry->d_inode;
3137         int error, rc = 0;
3138         const unsigned int ia_valid = attr->ia_valid;
3139
3140         error = inode_change_ok(inode, attr);
3141         if (error)
3142                 return error;
3143
3144         if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
3145                 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
3146                 handle_t *handle;
3147
3148                 /* (user+group)*(old+new) structure, inode write (sb,
3149                  * inode block, ? - but truncate inode update has it) */
3150                 handle = ext3_journal_start(inode, EXT3_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
3151                                         EXT3_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)+3);
3152                 if (IS_ERR(handle)) {
3153                         error = PTR_ERR(handle);
3154                         goto err_out;
3155                 }
3156                 error = vfs_dq_transfer(inode, attr) ? -EDQUOT : 0;
3157                 if (error) {
3158                         ext3_journal_stop(handle);
3159                         return error;
3160                 }
3161                 /* Update corresponding info in inode so that everything is in
3162                  * one transaction */
3163                 if (attr->ia_valid & ATTR_UID)
3164                         inode->i_uid = attr->ia_uid;
3165                 if (attr->ia_valid & ATTR_GID)
3166                         inode->i_gid = attr->ia_gid;
3167                 error = ext3_mark_inode_dirty(handle, inode);
3168                 ext3_journal_stop(handle);
3169         }
3170
3171         if (S_ISREG(inode->i_mode) &&
3172             attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
3173                 handle_t *handle;
3174
3175                 handle = ext3_journal_start(inode, 3);
3176                 if (IS_ERR(handle)) {
3177                         error = PTR_ERR(handle);
3178                         goto err_out;
3179                 }
3180
3181                 error = ext3_orphan_add(handle, inode);
3182                 EXT3_I(inode)->i_disksize = attr->ia_size;
3183                 rc = ext3_mark_inode_dirty(handle, inode);
3184                 if (!error)
3185                         error = rc;
3186                 ext3_journal_stop(handle);
3187         }
3188
3189         rc = inode_setattr(inode, attr);
3190
3191         if (!rc && (ia_valid & ATTR_MODE))
3192                 rc = ext3_acl_chmod(inode);
3193
3194 err_out:
3195         ext3_std_error(inode->i_sb, error);
3196         if (!error)
3197                 error = rc;
3198         return error;
3199 }
3200
3201
3202 /*
3203  * How many blocks doth make a writepage()?
3204  *
3205  * With N blocks per page, it may be:
3206  * N data blocks
3207  * 2 indirect block
3208  * 2 dindirect
3209  * 1 tindirect
3210  * N+5 bitmap blocks (from the above)
3211  * N+5 group descriptor summary blocks
3212  * 1 inode block
3213  * 1 superblock.
3214  * 2 * EXT3_SINGLEDATA_TRANS_BLOCKS for the quote files
3215  *
3216  * 3 * (N + 5) + 2 + 2 * EXT3_SINGLEDATA_TRANS_BLOCKS
3217  *
3218  * With ordered or writeback data it's the same, less the N data blocks.
3219  *
3220  * If the inode's direct blocks can hold an integral number of pages then a
3221  * page cannot straddle two indirect blocks, and we can only touch one indirect
3222  * and dindirect block, and the "5" above becomes "3".
3223  *
3224  * This still overestimates under most circumstances.  If we were to pass the
3225  * start and end offsets in here as well we could do block_to_path() on each
3226  * block and work out the exact number of indirects which are touched.  Pah.
3227  */
3228
3229 static int ext3_writepage_trans_blocks(struct inode *inode)
3230 {
3231         int bpp = ext3_journal_blocks_per_page(inode);
3232         int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
3233         int ret;
3234
3235         if (ext3_should_journal_data(inode))
3236                 ret = 3 * (bpp + indirects) + 2;
3237         else
3238                 ret = 2 * (bpp + indirects) + 2;
3239
3240 #ifdef CONFIG_QUOTA
3241         /* We know that structure was already allocated during vfs_dq_init so
3242          * we will be updating only the data blocks + inodes */
3243         ret += EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
3244 #endif
3245
3246         return ret;
3247 }
3248
3249 /*
3250  * The caller must have previously called ext3_reserve_inode_write().
3251  * Give this, we know that the caller already has write access to iloc->bh.
3252  */
3253 int ext3_mark_iloc_dirty(handle_t *handle,
3254                 struct inode *inode, struct ext3_iloc *iloc)
3255 {
3256         int err = 0;
3257
3258         /* the do_update_inode consumes one bh->b_count */
3259         get_bh(iloc->bh);
3260
3261         /* ext3_do_update_inode() does journal_dirty_metadata */
3262         err = ext3_do_update_inode(handle, inode, iloc);
3263         put_bh(iloc->bh);
3264         return err;
3265 }
3266
3267 /*
3268  * On success, We end up with an outstanding reference count against
3269  * iloc->bh.  This _must_ be cleaned up later.
3270  */
3271
3272 int
3273 ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
3274                          struct ext3_iloc *iloc)
3275 {
3276         int err = 0;
3277         if (handle) {
3278                 err = ext3_get_inode_loc(inode, iloc);
3279                 if (!err) {
3280                         BUFFER_TRACE(iloc->bh, "get_write_access");
3281                         err = ext3_journal_get_write_access(handle, iloc->bh);
3282                         if (err) {
3283                                 brelse(iloc->bh);
3284                                 iloc->bh = NULL;
3285                         }
3286                 }
3287         }
3288         ext3_std_error(inode->i_sb, err);
3289         return err;
3290 }
3291
3292 /*
3293  * What we do here is to mark the in-core inode as clean with respect to inode
3294  * dirtiness (it may still be data-dirty).
3295  * This means that the in-core inode may be reaped by prune_icache
3296  * without having to perform any I/O.  This is a very good thing,
3297  * because *any* task may call prune_icache - even ones which
3298  * have a transaction open against a different journal.
3299  *
3300  * Is this cheating?  Not really.  Sure, we haven't written the
3301  * inode out, but prune_icache isn't a user-visible syncing function.
3302  * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
3303  * we start and wait on commits.
3304  *
3305  * Is this efficient/effective?  Well, we're being nice to the system
3306  * by cleaning up our inodes proactively so they can be reaped
3307  * without I/O.  But we are potentially leaving up to five seconds'
3308  * worth of inodes floating about which prune_icache wants us to
3309  * write out.  One way to fix that would be to get prune_icache()
3310  * to do a write_super() to free up some memory.  It has the desired
3311  * effect.
3312  */
3313 int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
3314 {
3315         struct ext3_iloc iloc;
3316         int err;
3317
3318         might_sleep();
3319         err = ext3_reserve_inode_write(handle, inode, &iloc);
3320         if (!err)
3321                 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
3322         return err;
3323 }
3324
3325 /*
3326  * ext3_dirty_inode() is called from __mark_inode_dirty()
3327  *
3328  * We're really interested in the case where a file is being extended.
3329  * i_size has been changed by generic_commit_write() and we thus need
3330  * to include the updated inode in the current transaction.
3331  *
3332  * Also, vfs_dq_alloc_space() will always dirty the inode when blocks
3333  * are allocated to the file.
3334  *
3335  * If the inode is marked synchronous, we don't honour that here - doing
3336  * so would cause a commit on atime updates, which we don't bother doing.
3337  * We handle synchronous inodes at the highest possible level.
3338  */
3339 void ext3_dirty_inode(struct inode *inode)
3340 {
3341         handle_t *current_handle = ext3_journal_current_handle();
3342         handle_t *handle;
3343
3344         handle = ext3_journal_start(inode, 2);
3345         if (IS_ERR(handle))
3346                 goto out;
3347         if (current_handle &&
3348                 current_handle->h_transaction != handle->h_transaction) {
3349                 /* This task has a transaction open against a different fs */
3350                 printk(KERN_EMERG "%s: transactions do not match!\n",
3351                        __func__);
3352         } else {
3353                 jbd_debug(5, "marking dirty.  outer handle=%p\n",
3354                                 current_handle);
3355                 ext3_mark_inode_dirty(handle, inode);
3356         }
3357         ext3_journal_stop(handle);
3358 out:
3359         return;
3360 }
3361
3362 #if 0
3363 /*
3364  * Bind an inode's backing buffer_head into this transaction, to prevent
3365  * it from being flushed to disk early.  Unlike
3366  * ext3_reserve_inode_write, this leaves behind no bh reference and
3367  * returns no iloc structure, so the caller needs to repeat the iloc
3368  * lookup to mark the inode dirty later.
3369  */
3370 static int ext3_pin_inode(handle_t *handle, struct inode *inode)
3371 {
3372         struct ext3_iloc iloc;
3373
3374         int err = 0;
3375         if (handle) {
3376                 err = ext3_get_inode_loc(inode, &iloc);
3377                 if (!err) {
3378                         BUFFER_TRACE(iloc.bh, "get_write_access");
3379                         err = journal_get_write_access(handle, iloc.bh);
3380                         if (!err)
3381                                 err = ext3_journal_dirty_metadata(handle,
3382                                                                   iloc.bh);
3383                         brelse(iloc.bh);
3384                 }
3385         }
3386         ext3_std_error(inode->i_sb, err);
3387         return err;
3388 }
3389 #endif
3390
3391 int ext3_change_inode_journal_flag(struct inode *inode, int val)
3392 {
3393         journal_t *journal;
3394         handle_t *handle;
3395         int err;
3396
3397         /*
3398          * We have to be very careful here: changing a data block's
3399          * journaling status dynamically is dangerous.  If we write a
3400          * data block to the journal, change the status and then delete
3401          * that block, we risk forgetting to revoke the old log record
3402          * from the journal and so a subsequent replay can corrupt data.
3403          * So, first we make sure that the journal is empty and that
3404          * nobody is changing anything.
3405          */
3406
3407         journal = EXT3_JOURNAL(inode);
3408         if (is_journal_aborted(journal))
3409                 return -EROFS;
3410
3411         journal_lock_updates(journal);
3412         journal_flush(journal);
3413
3414         /*
3415          * OK, there are no updates running now, and all cached data is
3416          * synced to disk.  We are now in a completely consistent state
3417          * which doesn't have anything in the journal, and we know that
3418          * no filesystem updates are running, so it is safe to modify
3419          * the inode's in-core data-journaling state flag now.
3420          */
3421
3422         if (val)
3423                 EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
3424         else
3425                 EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
3426         ext3_set_aops(inode);
3427
3428         journal_unlock_updates(journal);
3429
3430         /* Finally we can mark the inode as dirty. */
3431
3432         handle = ext3_journal_start(inode, 1);
3433         if (IS_ERR(handle))
3434                 return PTR_ERR(handle);
3435
3436         err = ext3_mark_inode_dirty(handle, inode);
3437         handle->h_sync = 1;
3438         ext3_journal_stop(handle);
3439         ext3_std_error(inode->i_sb, err);
3440
3441         return err;
3442 }