44b53386ab8b2e0f756e8fefc7d4db861bb191f5
[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. Bail out and pretend
1789                          * the write failed... */
1790                         ret = PTR_ERR(handle);
1791                         goto out;
1792                 }
1793                 if (inode->i_nlink)
1794                         ext3_orphan_del(handle, inode);
1795                 if (ret > 0) {
1796                         loff_t end = offset + ret;
1797                         if (end > inode->i_size) {
1798                                 ei->i_disksize = end;
1799                                 i_size_write(inode, end);
1800                                 /*
1801                                  * We're going to return a positive `ret'
1802                                  * here due to non-zero-length I/O, so there's
1803                                  * no way of reporting error returns from
1804                                  * ext3_mark_inode_dirty() to userspace.  So
1805                                  * ignore it.
1806                                  */
1807                                 ext3_mark_inode_dirty(handle, inode);
1808                         }
1809                 }
1810                 err = ext3_journal_stop(handle);
1811                 if (ret == 0)
1812                         ret = err;
1813         }
1814 out:
1815         return ret;
1816 }
1817
1818 /*
1819  * Pages can be marked dirty completely asynchronously from ext3's journalling
1820  * activity.  By filemap_sync_pte(), try_to_unmap_one(), etc.  We cannot do
1821  * much here because ->set_page_dirty is called under VFS locks.  The page is
1822  * not necessarily locked.
1823  *
1824  * We cannot just dirty the page and leave attached buffers clean, because the
1825  * buffers' dirty state is "definitive".  We cannot just set the buffers dirty
1826  * or jbddirty because all the journalling code will explode.
1827  *
1828  * So what we do is to mark the page "pending dirty" and next time writepage
1829  * is called, propagate that into the buffers appropriately.
1830  */
1831 static int ext3_journalled_set_page_dirty(struct page *page)
1832 {
1833         SetPageChecked(page);
1834         return __set_page_dirty_nobuffers(page);
1835 }
1836
1837 static const struct address_space_operations ext3_ordered_aops = {
1838         .readpage               = ext3_readpage,
1839         .readpages              = ext3_readpages,
1840         .writepage              = ext3_ordered_writepage,
1841         .sync_page              = block_sync_page,
1842         .write_begin            = ext3_write_begin,
1843         .write_end              = ext3_ordered_write_end,
1844         .bmap                   = ext3_bmap,
1845         .invalidatepage         = ext3_invalidatepage,
1846         .releasepage            = ext3_releasepage,
1847         .direct_IO              = ext3_direct_IO,
1848         .migratepage            = buffer_migrate_page,
1849         .is_partially_uptodate  = block_is_partially_uptodate,
1850         .error_remove_page      = generic_error_remove_page,
1851 };
1852
1853 static const struct address_space_operations ext3_writeback_aops = {
1854         .readpage               = ext3_readpage,
1855         .readpages              = ext3_readpages,
1856         .writepage              = ext3_writeback_writepage,
1857         .sync_page              = block_sync_page,
1858         .write_begin            = ext3_write_begin,
1859         .write_end              = ext3_writeback_write_end,
1860         .bmap                   = ext3_bmap,
1861         .invalidatepage         = ext3_invalidatepage,
1862         .releasepage            = ext3_releasepage,
1863         .direct_IO              = ext3_direct_IO,
1864         .migratepage            = buffer_migrate_page,
1865         .is_partially_uptodate  = block_is_partially_uptodate,
1866         .error_remove_page      = generic_error_remove_page,
1867 };
1868
1869 static const struct address_space_operations ext3_journalled_aops = {
1870         .readpage               = ext3_readpage,
1871         .readpages              = ext3_readpages,
1872         .writepage              = ext3_journalled_writepage,
1873         .sync_page              = block_sync_page,
1874         .write_begin            = ext3_write_begin,
1875         .write_end              = ext3_journalled_write_end,
1876         .set_page_dirty         = ext3_journalled_set_page_dirty,
1877         .bmap                   = ext3_bmap,
1878         .invalidatepage         = ext3_invalidatepage,
1879         .releasepage            = ext3_releasepage,
1880         .is_partially_uptodate  = block_is_partially_uptodate,
1881         .error_remove_page      = generic_error_remove_page,
1882 };
1883
1884 void ext3_set_aops(struct inode *inode)
1885 {
1886         if (ext3_should_order_data(inode))
1887                 inode->i_mapping->a_ops = &ext3_ordered_aops;
1888         else if (ext3_should_writeback_data(inode))
1889                 inode->i_mapping->a_ops = &ext3_writeback_aops;
1890         else
1891                 inode->i_mapping->a_ops = &ext3_journalled_aops;
1892 }
1893
1894 /*
1895  * ext3_block_truncate_page() zeroes out a mapping from file offset `from'
1896  * up to the end of the block which corresponds to `from'.
1897  * This required during truncate. We need to physically zero the tail end
1898  * of that block so it doesn't yield old data if the file is later grown.
1899  */
1900 static int ext3_block_truncate_page(handle_t *handle, struct page *page,
1901                 struct address_space *mapping, loff_t from)
1902 {
1903         ext3_fsblk_t index = from >> PAGE_CACHE_SHIFT;
1904         unsigned offset = from & (PAGE_CACHE_SIZE-1);
1905         unsigned blocksize, iblock, length, pos;
1906         struct inode *inode = mapping->host;
1907         struct buffer_head *bh;
1908         int err = 0;
1909
1910         blocksize = inode->i_sb->s_blocksize;
1911         length = blocksize - (offset & (blocksize - 1));
1912         iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1913
1914         /*
1915          * For "nobh" option,  we can only work if we don't need to
1916          * read-in the page - otherwise we create buffers to do the IO.
1917          */
1918         if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
1919              ext3_should_writeback_data(inode) && PageUptodate(page)) {
1920                 zero_user(page, offset, length);
1921                 set_page_dirty(page);
1922                 goto unlock;
1923         }
1924
1925         if (!page_has_buffers(page))
1926                 create_empty_buffers(page, blocksize, 0);
1927
1928         /* Find the buffer that contains "offset" */
1929         bh = page_buffers(page);
1930         pos = blocksize;
1931         while (offset >= pos) {
1932                 bh = bh->b_this_page;
1933                 iblock++;
1934                 pos += blocksize;
1935         }
1936
1937         err = 0;
1938         if (buffer_freed(bh)) {
1939                 BUFFER_TRACE(bh, "freed: skip");
1940                 goto unlock;
1941         }
1942
1943         if (!buffer_mapped(bh)) {
1944                 BUFFER_TRACE(bh, "unmapped");
1945                 ext3_get_block(inode, iblock, bh, 0);
1946                 /* unmapped? It's a hole - nothing to do */
1947                 if (!buffer_mapped(bh)) {
1948                         BUFFER_TRACE(bh, "still unmapped");
1949                         goto unlock;
1950                 }
1951         }
1952
1953         /* Ok, it's mapped. Make sure it's up-to-date */
1954         if (PageUptodate(page))
1955                 set_buffer_uptodate(bh);
1956
1957         if (!buffer_uptodate(bh)) {
1958                 err = -EIO;
1959                 ll_rw_block(READ, 1, &bh);
1960                 wait_on_buffer(bh);
1961                 /* Uhhuh. Read error. Complain and punt. */
1962                 if (!buffer_uptodate(bh))
1963                         goto unlock;
1964         }
1965
1966         if (ext3_should_journal_data(inode)) {
1967                 BUFFER_TRACE(bh, "get write access");
1968                 err = ext3_journal_get_write_access(handle, bh);
1969                 if (err)
1970                         goto unlock;
1971         }
1972
1973         zero_user(page, offset, length);
1974         BUFFER_TRACE(bh, "zeroed end of block");
1975
1976         err = 0;
1977         if (ext3_should_journal_data(inode)) {
1978                 err = ext3_journal_dirty_metadata(handle, bh);
1979         } else {
1980                 if (ext3_should_order_data(inode))
1981                         err = ext3_journal_dirty_data(handle, bh);
1982                 mark_buffer_dirty(bh);
1983         }
1984
1985 unlock:
1986         unlock_page(page);
1987         page_cache_release(page);
1988         return err;
1989 }
1990
1991 /*
1992  * Probably it should be a library function... search for first non-zero word
1993  * or memcmp with zero_page, whatever is better for particular architecture.
1994  * Linus?
1995  */
1996 static inline int all_zeroes(__le32 *p, __le32 *q)
1997 {
1998         while (p < q)
1999                 if (*p++)
2000                         return 0;
2001         return 1;
2002 }
2003
2004 /**
2005  *      ext3_find_shared - find the indirect blocks for partial truncation.
2006  *      @inode:   inode in question
2007  *      @depth:   depth of the affected branch
2008  *      @offsets: offsets of pointers in that branch (see ext3_block_to_path)
2009  *      @chain:   place to store the pointers to partial indirect blocks
2010  *      @top:     place to the (detached) top of branch
2011  *
2012  *      This is a helper function used by ext3_truncate().
2013  *
2014  *      When we do truncate() we may have to clean the ends of several
2015  *      indirect blocks but leave the blocks themselves alive. Block is
2016  *      partially truncated if some data below the new i_size is refered
2017  *      from it (and it is on the path to the first completely truncated
2018  *      data block, indeed).  We have to free the top of that path along
2019  *      with everything to the right of the path. Since no allocation
2020  *      past the truncation point is possible until ext3_truncate()
2021  *      finishes, we may safely do the latter, but top of branch may
2022  *      require special attention - pageout below the truncation point
2023  *      might try to populate it.
2024  *
2025  *      We atomically detach the top of branch from the tree, store the
2026  *      block number of its root in *@top, pointers to buffer_heads of
2027  *      partially truncated blocks - in @chain[].bh and pointers to
2028  *      their last elements that should not be removed - in
2029  *      @chain[].p. Return value is the pointer to last filled element
2030  *      of @chain.
2031  *
2032  *      The work left to caller to do the actual freeing of subtrees:
2033  *              a) free the subtree starting from *@top
2034  *              b) free the subtrees whose roots are stored in
2035  *                      (@chain[i].p+1 .. end of @chain[i].bh->b_data)
2036  *              c) free the subtrees growing from the inode past the @chain[0].
2037  *                      (no partially truncated stuff there).  */
2038
2039 static Indirect *ext3_find_shared(struct inode *inode, int depth,
2040                         int offsets[4], Indirect chain[4], __le32 *top)
2041 {
2042         Indirect *partial, *p;
2043         int k, err;
2044
2045         *top = 0;
2046         /* Make k index the deepest non-null offset + 1 */
2047         for (k = depth; k > 1 && !offsets[k-1]; k--)
2048                 ;
2049         partial = ext3_get_branch(inode, k, offsets, chain, &err);
2050         /* Writer: pointers */
2051         if (!partial)
2052                 partial = chain + k-1;
2053         /*
2054          * If the branch acquired continuation since we've looked at it -
2055          * fine, it should all survive and (new) top doesn't belong to us.
2056          */
2057         if (!partial->key && *partial->p)
2058                 /* Writer: end */
2059                 goto no_top;
2060         for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
2061                 ;
2062         /*
2063          * OK, we've found the last block that must survive. The rest of our
2064          * branch should be detached before unlocking. However, if that rest
2065          * of branch is all ours and does not grow immediately from the inode
2066          * it's easier to cheat and just decrement partial->p.
2067          */
2068         if (p == chain + k - 1 && p > chain) {
2069                 p->p--;
2070         } else {
2071                 *top = *p->p;
2072                 /* Nope, don't do this in ext3.  Must leave the tree intact */
2073 #if 0
2074                 *p->p = 0;
2075 #endif
2076         }
2077         /* Writer: end */
2078
2079         while(partial > p) {
2080                 brelse(partial->bh);
2081                 partial--;
2082         }
2083 no_top:
2084         return partial;
2085 }
2086
2087 /*
2088  * Zero a number of block pointers in either an inode or an indirect block.
2089  * If we restart the transaction we must again get write access to the
2090  * indirect block for further modification.
2091  *
2092  * We release `count' blocks on disk, but (last - first) may be greater
2093  * than `count' because there can be holes in there.
2094  */
2095 static void ext3_clear_blocks(handle_t *handle, struct inode *inode,
2096                 struct buffer_head *bh, ext3_fsblk_t block_to_free,
2097                 unsigned long count, __le32 *first, __le32 *last)
2098 {
2099         __le32 *p;
2100         if (try_to_extend_transaction(handle, inode)) {
2101                 if (bh) {
2102                         BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2103                         ext3_journal_dirty_metadata(handle, bh);
2104                 }
2105                 ext3_mark_inode_dirty(handle, inode);
2106                 truncate_restart_transaction(handle, inode);
2107                 if (bh) {
2108                         BUFFER_TRACE(bh, "retaking write access");
2109                         ext3_journal_get_write_access(handle, bh);
2110                 }
2111         }
2112
2113         /*
2114          * Any buffers which are on the journal will be in memory. We find
2115          * them on the hash table so journal_revoke() will run journal_forget()
2116          * on them.  We've already detached each block from the file, so
2117          * bforget() in journal_forget() should be safe.
2118          *
2119          * AKPM: turn on bforget in journal_forget()!!!
2120          */
2121         for (p = first; p < last; p++) {
2122                 u32 nr = le32_to_cpu(*p);
2123                 if (nr) {
2124                         struct buffer_head *bh;
2125
2126                         *p = 0;
2127                         bh = sb_find_get_block(inode->i_sb, nr);
2128                         ext3_forget(handle, 0, inode, bh, nr);
2129                 }
2130         }
2131
2132         ext3_free_blocks(handle, inode, block_to_free, count);
2133 }
2134
2135 /**
2136  * ext3_free_data - free a list of data blocks
2137  * @handle:     handle for this transaction
2138  * @inode:      inode we are dealing with
2139  * @this_bh:    indirect buffer_head which contains *@first and *@last
2140  * @first:      array of block numbers
2141  * @last:       points immediately past the end of array
2142  *
2143  * We are freeing all blocks refered from that array (numbers are stored as
2144  * little-endian 32-bit) and updating @inode->i_blocks appropriately.
2145  *
2146  * We accumulate contiguous runs of blocks to free.  Conveniently, if these
2147  * blocks are contiguous then releasing them at one time will only affect one
2148  * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
2149  * actually use a lot of journal space.
2150  *
2151  * @this_bh will be %NULL if @first and @last point into the inode's direct
2152  * block pointers.
2153  */
2154 static void ext3_free_data(handle_t *handle, struct inode *inode,
2155                            struct buffer_head *this_bh,
2156                            __le32 *first, __le32 *last)
2157 {
2158         ext3_fsblk_t block_to_free = 0;    /* Starting block # of a run */
2159         unsigned long count = 0;            /* Number of blocks in the run */
2160         __le32 *block_to_free_p = NULL;     /* Pointer into inode/ind
2161                                                corresponding to
2162                                                block_to_free */
2163         ext3_fsblk_t nr;                    /* Current block # */
2164         __le32 *p;                          /* Pointer into inode/ind
2165                                                for current block */
2166         int err;
2167
2168         if (this_bh) {                          /* For indirect block */
2169                 BUFFER_TRACE(this_bh, "get_write_access");
2170                 err = ext3_journal_get_write_access(handle, this_bh);
2171                 /* Important: if we can't update the indirect pointers
2172                  * to the blocks, we can't free them. */
2173                 if (err)
2174                         return;
2175         }
2176
2177         for (p = first; p < last; p++) {
2178                 nr = le32_to_cpu(*p);
2179                 if (nr) {
2180                         /* accumulate blocks to free if they're contiguous */
2181                         if (count == 0) {
2182                                 block_to_free = nr;
2183                                 block_to_free_p = p;
2184                                 count = 1;
2185                         } else if (nr == block_to_free + count) {
2186                                 count++;
2187                         } else {
2188                                 ext3_clear_blocks(handle, inode, this_bh,
2189                                                   block_to_free,
2190                                                   count, block_to_free_p, p);
2191                                 block_to_free = nr;
2192                                 block_to_free_p = p;
2193                                 count = 1;
2194                         }
2195                 }
2196         }
2197
2198         if (count > 0)
2199                 ext3_clear_blocks(handle, inode, this_bh, block_to_free,
2200                                   count, block_to_free_p, p);
2201
2202         if (this_bh) {
2203                 BUFFER_TRACE(this_bh, "call ext3_journal_dirty_metadata");
2204
2205                 /*
2206                  * The buffer head should have an attached journal head at this
2207                  * point. However, if the data is corrupted and an indirect
2208                  * block pointed to itself, it would have been detached when
2209                  * the block was cleared. Check for this instead of OOPSing.
2210                  */
2211                 if (bh2jh(this_bh))
2212                         ext3_journal_dirty_metadata(handle, this_bh);
2213                 else
2214                         ext3_error(inode->i_sb, "ext3_free_data",
2215                                    "circular indirect block detected, "
2216                                    "inode=%lu, block=%llu",
2217                                    inode->i_ino,
2218                                    (unsigned long long)this_bh->b_blocknr);
2219         }
2220 }
2221
2222 /**
2223  *      ext3_free_branches - free an array of branches
2224  *      @handle: JBD handle for this transaction
2225  *      @inode: inode we are dealing with
2226  *      @parent_bh: the buffer_head which contains *@first and *@last
2227  *      @first: array of block numbers
2228  *      @last:  pointer immediately past the end of array
2229  *      @depth: depth of the branches to free
2230  *
2231  *      We are freeing all blocks refered from these branches (numbers are
2232  *      stored as little-endian 32-bit) and updating @inode->i_blocks
2233  *      appropriately.
2234  */
2235 static void ext3_free_branches(handle_t *handle, struct inode *inode,
2236                                struct buffer_head *parent_bh,
2237                                __le32 *first, __le32 *last, int depth)
2238 {
2239         ext3_fsblk_t nr;
2240         __le32 *p;
2241
2242         if (is_handle_aborted(handle))
2243                 return;
2244
2245         if (depth--) {
2246                 struct buffer_head *bh;
2247                 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2248                 p = last;
2249                 while (--p >= first) {
2250                         nr = le32_to_cpu(*p);
2251                         if (!nr)
2252                                 continue;               /* A hole */
2253
2254                         /* Go read the buffer for the next level down */
2255                         bh = sb_bread(inode->i_sb, nr);
2256
2257                         /*
2258                          * A read failure? Report error and clear slot
2259                          * (should be rare).
2260                          */
2261                         if (!bh) {
2262                                 ext3_error(inode->i_sb, "ext3_free_branches",
2263                                            "Read failure, inode=%lu, block="E3FSBLK,
2264                                            inode->i_ino, nr);
2265                                 continue;
2266                         }
2267
2268                         /* This zaps the entire block.  Bottom up. */
2269                         BUFFER_TRACE(bh, "free child branches");
2270                         ext3_free_branches(handle, inode, bh,
2271                                            (__le32*)bh->b_data,
2272                                            (__le32*)bh->b_data + addr_per_block,
2273                                            depth);
2274
2275                         /*
2276                          * We've probably journalled the indirect block several
2277                          * times during the truncate.  But it's no longer
2278                          * needed and we now drop it from the transaction via
2279                          * journal_revoke().
2280                          *
2281                          * That's easy if it's exclusively part of this
2282                          * transaction.  But if it's part of the committing
2283                          * transaction then journal_forget() will simply
2284                          * brelse() it.  That means that if the underlying
2285                          * block is reallocated in ext3_get_block(),
2286                          * unmap_underlying_metadata() will find this block
2287                          * and will try to get rid of it.  damn, damn.
2288                          *
2289                          * If this block has already been committed to the
2290                          * journal, a revoke record will be written.  And
2291                          * revoke records must be emitted *before* clearing
2292                          * this block's bit in the bitmaps.
2293                          */
2294                         ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
2295
2296                         /*
2297                          * Everything below this this pointer has been
2298                          * released.  Now let this top-of-subtree go.
2299                          *
2300                          * We want the freeing of this indirect block to be
2301                          * atomic in the journal with the updating of the
2302                          * bitmap block which owns it.  So make some room in
2303                          * the journal.
2304                          *
2305                          * We zero the parent pointer *after* freeing its
2306                          * pointee in the bitmaps, so if extend_transaction()
2307                          * for some reason fails to put the bitmap changes and
2308                          * the release into the same transaction, recovery
2309                          * will merely complain about releasing a free block,
2310                          * rather than leaking blocks.
2311                          */
2312                         if (is_handle_aborted(handle))
2313                                 return;
2314                         if (try_to_extend_transaction(handle, inode)) {
2315                                 ext3_mark_inode_dirty(handle, inode);
2316                                 truncate_restart_transaction(handle, inode);
2317                         }
2318
2319                         ext3_free_blocks(handle, inode, nr, 1);
2320
2321                         if (parent_bh) {
2322                                 /*
2323                                  * The block which we have just freed is
2324                                  * pointed to by an indirect block: journal it
2325                                  */
2326                                 BUFFER_TRACE(parent_bh, "get_write_access");
2327                                 if (!ext3_journal_get_write_access(handle,
2328                                                                    parent_bh)){
2329                                         *p = 0;
2330                                         BUFFER_TRACE(parent_bh,
2331                                         "call ext3_journal_dirty_metadata");
2332                                         ext3_journal_dirty_metadata(handle,
2333                                                                     parent_bh);
2334                                 }
2335                         }
2336                 }
2337         } else {
2338                 /* We have reached the bottom of the tree. */
2339                 BUFFER_TRACE(parent_bh, "free data blocks");
2340                 ext3_free_data(handle, inode, parent_bh, first, last);
2341         }
2342 }
2343
2344 int ext3_can_truncate(struct inode *inode)
2345 {
2346         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2347                 return 0;
2348         if (S_ISREG(inode->i_mode))
2349                 return 1;
2350         if (S_ISDIR(inode->i_mode))
2351                 return 1;
2352         if (S_ISLNK(inode->i_mode))
2353                 return !ext3_inode_is_fast_symlink(inode);
2354         return 0;
2355 }
2356
2357 /*
2358  * ext3_truncate()
2359  *
2360  * We block out ext3_get_block() block instantiations across the entire
2361  * transaction, and VFS/VM ensures that ext3_truncate() cannot run
2362  * simultaneously on behalf of the same inode.
2363  *
2364  * As we work through the truncate and commmit bits of it to the journal there
2365  * is one core, guiding principle: the file's tree must always be consistent on
2366  * disk.  We must be able to restart the truncate after a crash.
2367  *
2368  * The file's tree may be transiently inconsistent in memory (although it
2369  * probably isn't), but whenever we close off and commit a journal transaction,
2370  * the contents of (the filesystem + the journal) must be consistent and
2371  * restartable.  It's pretty simple, really: bottom up, right to left (although
2372  * left-to-right works OK too).
2373  *
2374  * Note that at recovery time, journal replay occurs *before* the restart of
2375  * truncate against the orphan inode list.
2376  *
2377  * The committed inode has the new, desired i_size (which is the same as
2378  * i_disksize in this case).  After a crash, ext3_orphan_cleanup() will see
2379  * that this inode's truncate did not complete and it will again call
2380  * ext3_truncate() to have another go.  So there will be instantiated blocks
2381  * to the right of the truncation point in a crashed ext3 filesystem.  But
2382  * that's fine - as long as they are linked from the inode, the post-crash
2383  * ext3_truncate() run will find them and release them.
2384  */
2385 void ext3_truncate(struct inode *inode)
2386 {
2387         handle_t *handle;
2388         struct ext3_inode_info *ei = EXT3_I(inode);
2389         __le32 *i_data = ei->i_data;
2390         int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2391         struct address_space *mapping = inode->i_mapping;
2392         int offsets[4];
2393         Indirect chain[4];
2394         Indirect *partial;
2395         __le32 nr = 0;
2396         int n;
2397         long last_block;
2398         unsigned blocksize = inode->i_sb->s_blocksize;
2399         struct page *page;
2400
2401         if (!ext3_can_truncate(inode))
2402                 goto out_notrans;
2403
2404         if (inode->i_size == 0 && ext3_should_writeback_data(inode))
2405                 ext3_set_inode_state(inode, EXT3_STATE_FLUSH_ON_CLOSE);
2406
2407         /*
2408          * We have to lock the EOF page here, because lock_page() nests
2409          * outside journal_start().
2410          */
2411         if ((inode->i_size & (blocksize - 1)) == 0) {
2412                 /* Block boundary? Nothing to do */
2413                 page = NULL;
2414         } else {
2415                 page = grab_cache_page(mapping,
2416                                 inode->i_size >> PAGE_CACHE_SHIFT);
2417                 if (!page)
2418                         goto out_notrans;
2419         }
2420
2421         handle = start_transaction(inode);
2422         if (IS_ERR(handle)) {
2423                 if (page) {
2424                         clear_highpage(page);
2425                         flush_dcache_page(page);
2426                         unlock_page(page);
2427                         page_cache_release(page);
2428                 }
2429                 goto out_notrans;
2430         }
2431
2432         last_block = (inode->i_size + blocksize-1)
2433                                         >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
2434
2435         if (page)
2436                 ext3_block_truncate_page(handle, page, mapping, inode->i_size);
2437
2438         n = ext3_block_to_path(inode, last_block, offsets, NULL);
2439         if (n == 0)
2440                 goto out_stop;  /* error */
2441
2442         /*
2443          * OK.  This truncate is going to happen.  We add the inode to the
2444          * orphan list, so that if this truncate spans multiple transactions,
2445          * and we crash, we will resume the truncate when the filesystem
2446          * recovers.  It also marks the inode dirty, to catch the new size.
2447          *
2448          * Implication: the file must always be in a sane, consistent
2449          * truncatable state while each transaction commits.
2450          */
2451         if (ext3_orphan_add(handle, inode))
2452                 goto out_stop;
2453
2454         /*
2455          * The orphan list entry will now protect us from any crash which
2456          * occurs before the truncate completes, so it is now safe to propagate
2457          * the new, shorter inode size (held for now in i_size) into the
2458          * on-disk inode. We do this via i_disksize, which is the value which
2459          * ext3 *really* writes onto the disk inode.
2460          */
2461         ei->i_disksize = inode->i_size;
2462
2463         /*
2464          * From here we block out all ext3_get_block() callers who want to
2465          * modify the block allocation tree.
2466          */
2467         mutex_lock(&ei->truncate_mutex);
2468
2469         if (n == 1) {           /* direct blocks */
2470                 ext3_free_data(handle, inode, NULL, i_data+offsets[0],
2471                                i_data + EXT3_NDIR_BLOCKS);
2472                 goto do_indirects;
2473         }
2474
2475         partial = ext3_find_shared(inode, n, offsets, chain, &nr);
2476         /* Kill the top of shared branch (not detached) */
2477         if (nr) {
2478                 if (partial == chain) {
2479                         /* Shared branch grows from the inode */
2480                         ext3_free_branches(handle, inode, NULL,
2481                                            &nr, &nr+1, (chain+n-1) - partial);
2482                         *partial->p = 0;
2483                         /*
2484                          * We mark the inode dirty prior to restart,
2485                          * and prior to stop.  No need for it here.
2486                          */
2487                 } else {
2488                         /* Shared branch grows from an indirect block */
2489                         BUFFER_TRACE(partial->bh, "get_write_access");
2490                         ext3_free_branches(handle, inode, partial->bh,
2491                                         partial->p,
2492                                         partial->p+1, (chain+n-1) - partial);
2493                 }
2494         }
2495         /* Clear the ends of indirect blocks on the shared branch */
2496         while (partial > chain) {
2497                 ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2498                                    (__le32*)partial->bh->b_data+addr_per_block,
2499                                    (chain+n-1) - partial);
2500                 BUFFER_TRACE(partial->bh, "call brelse");
2501                 brelse (partial->bh);
2502                 partial--;
2503         }
2504 do_indirects:
2505         /* Kill the remaining (whole) subtrees */
2506         switch (offsets[0]) {
2507         default:
2508                 nr = i_data[EXT3_IND_BLOCK];
2509                 if (nr) {
2510                         ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
2511                         i_data[EXT3_IND_BLOCK] = 0;
2512                 }
2513         case EXT3_IND_BLOCK:
2514                 nr = i_data[EXT3_DIND_BLOCK];
2515                 if (nr) {
2516                         ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
2517                         i_data[EXT3_DIND_BLOCK] = 0;
2518                 }
2519         case EXT3_DIND_BLOCK:
2520                 nr = i_data[EXT3_TIND_BLOCK];
2521                 if (nr) {
2522                         ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
2523                         i_data[EXT3_TIND_BLOCK] = 0;
2524                 }
2525         case EXT3_TIND_BLOCK:
2526                 ;
2527         }
2528
2529         ext3_discard_reservation(inode);
2530
2531         mutex_unlock(&ei->truncate_mutex);
2532         inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
2533         ext3_mark_inode_dirty(handle, inode);
2534
2535         /*
2536          * In a multi-transaction truncate, we only make the final transaction
2537          * synchronous
2538          */
2539         if (IS_SYNC(inode))
2540                 handle->h_sync = 1;
2541 out_stop:
2542         /*
2543          * If this was a simple ftruncate(), and the file will remain alive
2544          * then we need to clear up the orphan record which we created above.
2545          * However, if this was a real unlink then we were called by
2546          * ext3_delete_inode(), and we allow that function to clean up the
2547          * orphan info for us.
2548          */
2549         if (inode->i_nlink)
2550                 ext3_orphan_del(handle, inode);
2551
2552         ext3_journal_stop(handle);
2553         return;
2554 out_notrans:
2555         /*
2556          * Delete the inode from orphan list so that it doesn't stay there
2557          * forever and trigger assertion on umount.
2558          */
2559         if (inode->i_nlink)
2560                 ext3_orphan_del(NULL, inode);
2561 }
2562
2563 static ext3_fsblk_t ext3_get_inode_block(struct super_block *sb,
2564                 unsigned long ino, struct ext3_iloc *iloc)
2565 {
2566         unsigned long block_group;
2567         unsigned long offset;
2568         ext3_fsblk_t block;
2569         struct ext3_group_desc *gdp;
2570
2571         if (!ext3_valid_inum(sb, ino)) {
2572                 /*
2573                  * This error is already checked for in namei.c unless we are
2574                  * looking at an NFS filehandle, in which case no error
2575                  * report is needed
2576                  */
2577                 return 0;
2578         }
2579
2580         block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
2581         gdp = ext3_get_group_desc(sb, block_group, NULL);
2582         if (!gdp)
2583                 return 0;
2584         /*
2585          * Figure out the offset within the block group inode table
2586          */
2587         offset = ((ino - 1) % EXT3_INODES_PER_GROUP(sb)) *
2588                 EXT3_INODE_SIZE(sb);
2589         block = le32_to_cpu(gdp->bg_inode_table) +
2590                 (offset >> EXT3_BLOCK_SIZE_BITS(sb));
2591
2592         iloc->block_group = block_group;
2593         iloc->offset = offset & (EXT3_BLOCK_SIZE(sb) - 1);
2594         return block;
2595 }
2596
2597 /*
2598  * ext3_get_inode_loc returns with an extra refcount against the inode's
2599  * underlying buffer_head on success. If 'in_mem' is true, we have all
2600  * data in memory that is needed to recreate the on-disk version of this
2601  * inode.
2602  */
2603 static int __ext3_get_inode_loc(struct inode *inode,
2604                                 struct ext3_iloc *iloc, int in_mem)
2605 {
2606         ext3_fsblk_t block;
2607         struct buffer_head *bh;
2608
2609         block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
2610         if (!block)
2611                 return -EIO;
2612
2613         bh = sb_getblk(inode->i_sb, block);
2614         if (!bh) {
2615                 ext3_error (inode->i_sb, "ext3_get_inode_loc",
2616                                 "unable to read inode block - "
2617                                 "inode=%lu, block="E3FSBLK,
2618                                  inode->i_ino, block);
2619                 return -EIO;
2620         }
2621         if (!buffer_uptodate(bh)) {
2622                 lock_buffer(bh);
2623
2624                 /*
2625                  * If the buffer has the write error flag, we have failed
2626                  * to write out another inode in the same block.  In this
2627                  * case, we don't have to read the block because we may
2628                  * read the old inode data successfully.
2629                  */
2630                 if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
2631                         set_buffer_uptodate(bh);
2632
2633                 if (buffer_uptodate(bh)) {
2634                         /* someone brought it uptodate while we waited */
2635                         unlock_buffer(bh);
2636                         goto has_buffer;
2637                 }
2638
2639                 /*
2640                  * If we have all information of the inode in memory and this
2641                  * is the only valid inode in the block, we need not read the
2642                  * block.
2643                  */
2644                 if (in_mem) {
2645                         struct buffer_head *bitmap_bh;
2646                         struct ext3_group_desc *desc;
2647                         int inodes_per_buffer;
2648                         int inode_offset, i;
2649                         int block_group;
2650                         int start;
2651
2652                         block_group = (inode->i_ino - 1) /
2653                                         EXT3_INODES_PER_GROUP(inode->i_sb);
2654                         inodes_per_buffer = bh->b_size /
2655                                 EXT3_INODE_SIZE(inode->i_sb);
2656                         inode_offset = ((inode->i_ino - 1) %
2657                                         EXT3_INODES_PER_GROUP(inode->i_sb));
2658                         start = inode_offset & ~(inodes_per_buffer - 1);
2659
2660                         /* Is the inode bitmap in cache? */
2661                         desc = ext3_get_group_desc(inode->i_sb,
2662                                                 block_group, NULL);
2663                         if (!desc)
2664                                 goto make_io;
2665
2666                         bitmap_bh = sb_getblk(inode->i_sb,
2667                                         le32_to_cpu(desc->bg_inode_bitmap));
2668                         if (!bitmap_bh)
2669                                 goto make_io;
2670
2671                         /*
2672                          * If the inode bitmap isn't in cache then the
2673                          * optimisation may end up performing two reads instead
2674                          * of one, so skip it.
2675                          */
2676                         if (!buffer_uptodate(bitmap_bh)) {
2677                                 brelse(bitmap_bh);
2678                                 goto make_io;
2679                         }
2680                         for (i = start; i < start + inodes_per_buffer; i++) {
2681                                 if (i == inode_offset)
2682                                         continue;
2683                                 if (ext3_test_bit(i, bitmap_bh->b_data))
2684                                         break;
2685                         }
2686                         brelse(bitmap_bh);
2687                         if (i == start + inodes_per_buffer) {
2688                                 /* all other inodes are free, so skip I/O */
2689                                 memset(bh->b_data, 0, bh->b_size);
2690                                 set_buffer_uptodate(bh);
2691                                 unlock_buffer(bh);
2692                                 goto has_buffer;
2693                         }
2694                 }
2695
2696 make_io:
2697                 /*
2698                  * There are other valid inodes in the buffer, this inode
2699                  * has in-inode xattrs, or we don't have this inode in memory.
2700                  * Read the block from disk.
2701                  */
2702                 get_bh(bh);
2703                 bh->b_end_io = end_buffer_read_sync;
2704                 submit_bh(READ_META, bh);
2705                 wait_on_buffer(bh);
2706                 if (!buffer_uptodate(bh)) {
2707                         ext3_error(inode->i_sb, "ext3_get_inode_loc",
2708                                         "unable to read inode block - "
2709                                         "inode=%lu, block="E3FSBLK,
2710                                         inode->i_ino, block);
2711                         brelse(bh);
2712                         return -EIO;
2713                 }
2714         }
2715 has_buffer:
2716         iloc->bh = bh;
2717         return 0;
2718 }
2719
2720 int ext3_get_inode_loc(struct inode *inode, struct ext3_iloc *iloc)
2721 {
2722         /* We have all inode data except xattrs in memory here. */
2723         return __ext3_get_inode_loc(inode, iloc,
2724                 !ext3_test_inode_state(inode, EXT3_STATE_XATTR));
2725 }
2726
2727 void ext3_set_inode_flags(struct inode *inode)
2728 {
2729         unsigned int flags = EXT3_I(inode)->i_flags;
2730
2731         inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
2732         if (flags & EXT3_SYNC_FL)
2733                 inode->i_flags |= S_SYNC;
2734         if (flags & EXT3_APPEND_FL)
2735                 inode->i_flags |= S_APPEND;
2736         if (flags & EXT3_IMMUTABLE_FL)
2737                 inode->i_flags |= S_IMMUTABLE;
2738         if (flags & EXT3_NOATIME_FL)
2739                 inode->i_flags |= S_NOATIME;
2740         if (flags & EXT3_DIRSYNC_FL)
2741                 inode->i_flags |= S_DIRSYNC;
2742 }
2743
2744 /* Propagate flags from i_flags to EXT3_I(inode)->i_flags */
2745 void ext3_get_inode_flags(struct ext3_inode_info *ei)
2746 {
2747         unsigned int flags = ei->vfs_inode.i_flags;
2748
2749         ei->i_flags &= ~(EXT3_SYNC_FL|EXT3_APPEND_FL|
2750                         EXT3_IMMUTABLE_FL|EXT3_NOATIME_FL|EXT3_DIRSYNC_FL);
2751         if (flags & S_SYNC)
2752                 ei->i_flags |= EXT3_SYNC_FL;
2753         if (flags & S_APPEND)
2754                 ei->i_flags |= EXT3_APPEND_FL;
2755         if (flags & S_IMMUTABLE)
2756                 ei->i_flags |= EXT3_IMMUTABLE_FL;
2757         if (flags & S_NOATIME)
2758                 ei->i_flags |= EXT3_NOATIME_FL;
2759         if (flags & S_DIRSYNC)
2760                 ei->i_flags |= EXT3_DIRSYNC_FL;
2761 }
2762
2763 struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
2764 {
2765         struct ext3_iloc iloc;
2766         struct ext3_inode *raw_inode;
2767         struct ext3_inode_info *ei;
2768         struct buffer_head *bh;
2769         struct inode *inode;
2770         journal_t *journal = EXT3_SB(sb)->s_journal;
2771         transaction_t *transaction;
2772         long ret;
2773         int block;
2774
2775         inode = iget_locked(sb, ino);
2776         if (!inode)
2777                 return ERR_PTR(-ENOMEM);
2778         if (!(inode->i_state & I_NEW))
2779                 return inode;
2780
2781         ei = EXT3_I(inode);
2782         ei->i_block_alloc_info = NULL;
2783
2784         ret = __ext3_get_inode_loc(inode, &iloc, 0);
2785         if (ret < 0)
2786                 goto bad_inode;
2787         bh = iloc.bh;
2788         raw_inode = ext3_raw_inode(&iloc);
2789         inode->i_mode = le16_to_cpu(raw_inode->i_mode);
2790         inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
2791         inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
2792         if(!(test_opt (inode->i_sb, NO_UID32))) {
2793                 inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
2794                 inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
2795         }
2796         inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
2797         inode->i_size = le32_to_cpu(raw_inode->i_size);
2798         inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
2799         inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
2800         inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
2801         inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
2802
2803         ei->i_state = 0;
2804         ei->i_dir_start_lookup = 0;
2805         ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
2806         /* We now have enough fields to check if the inode was active or not.
2807          * This is needed because nfsd might try to access dead inodes
2808          * the test is that same one that e2fsck uses
2809          * NeilBrown 1999oct15
2810          */
2811         if (inode->i_nlink == 0) {
2812                 if (inode->i_mode == 0 ||
2813                     !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
2814                         /* this inode is deleted */
2815                         brelse (bh);
2816                         ret = -ESTALE;
2817                         goto bad_inode;
2818                 }
2819                 /* The only unlinked inodes we let through here have
2820                  * valid i_mode and are being read by the orphan
2821                  * recovery code: that's fine, we're about to complete
2822                  * the process of deleting those. */
2823         }
2824         inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
2825         ei->i_flags = le32_to_cpu(raw_inode->i_flags);
2826 #ifdef EXT3_FRAGMENTS
2827         ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
2828         ei->i_frag_no = raw_inode->i_frag;
2829         ei->i_frag_size = raw_inode->i_fsize;
2830 #endif
2831         ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
2832         if (!S_ISREG(inode->i_mode)) {
2833                 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
2834         } else {
2835                 inode->i_size |=
2836                         ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
2837         }
2838         ei->i_disksize = inode->i_size;
2839         inode->i_generation = le32_to_cpu(raw_inode->i_generation);
2840         ei->i_block_group = iloc.block_group;
2841         /*
2842          * NOTE! The in-memory inode i_data array is in little-endian order
2843          * even on big-endian machines: we do NOT byteswap the block numbers!
2844          */
2845         for (block = 0; block < EXT3_N_BLOCKS; block++)
2846                 ei->i_data[block] = raw_inode->i_block[block];
2847         INIT_LIST_HEAD(&ei->i_orphan);
2848
2849         /*
2850          * Set transaction id's of transactions that have to be committed
2851          * to finish f[data]sync. We set them to currently running transaction
2852          * as we cannot be sure that the inode or some of its metadata isn't
2853          * part of the transaction - the inode could have been reclaimed and
2854          * now it is reread from disk.
2855          */
2856         if (journal) {
2857                 tid_t tid;
2858
2859                 spin_lock(&journal->j_state_lock);
2860                 if (journal->j_running_transaction)
2861                         transaction = journal->j_running_transaction;
2862                 else
2863                         transaction = journal->j_committing_transaction;
2864                 if (transaction)
2865                         tid = transaction->t_tid;
2866                 else
2867                         tid = journal->j_commit_sequence;
2868                 spin_unlock(&journal->j_state_lock);
2869                 atomic_set(&ei->i_sync_tid, tid);
2870                 atomic_set(&ei->i_datasync_tid, tid);
2871         }
2872
2873         if (inode->i_ino >= EXT3_FIRST_INO(inode->i_sb) + 1 &&
2874             EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) {
2875                 /*
2876                  * When mke2fs creates big inodes it does not zero out
2877                  * the unused bytes above EXT3_GOOD_OLD_INODE_SIZE,
2878                  * so ignore those first few inodes.
2879                  */
2880                 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
2881                 if (EXT3_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
2882                     EXT3_INODE_SIZE(inode->i_sb)) {
2883                         brelse (bh);
2884                         ret = -EIO;
2885                         goto bad_inode;
2886                 }
2887                 if (ei->i_extra_isize == 0) {
2888                         /* The extra space is currently unused. Use it. */
2889                         ei->i_extra_isize = sizeof(struct ext3_inode) -
2890                                             EXT3_GOOD_OLD_INODE_SIZE;
2891                 } else {
2892                         __le32 *magic = (void *)raw_inode +
2893                                         EXT3_GOOD_OLD_INODE_SIZE +
2894                                         ei->i_extra_isize;
2895                         if (*magic == cpu_to_le32(EXT3_XATTR_MAGIC))
2896                                  ext3_set_inode_state(inode, EXT3_STATE_XATTR);
2897                 }
2898         } else
2899                 ei->i_extra_isize = 0;
2900
2901         if (S_ISREG(inode->i_mode)) {
2902                 inode->i_op = &ext3_file_inode_operations;
2903                 inode->i_fop = &ext3_file_operations;
2904                 ext3_set_aops(inode);
2905         } else if (S_ISDIR(inode->i_mode)) {
2906                 inode->i_op = &ext3_dir_inode_operations;
2907                 inode->i_fop = &ext3_dir_operations;
2908         } else if (S_ISLNK(inode->i_mode)) {
2909                 if (ext3_inode_is_fast_symlink(inode)) {
2910                         inode->i_op = &ext3_fast_symlink_inode_operations;
2911                         nd_terminate_link(ei->i_data, inode->i_size,
2912                                 sizeof(ei->i_data) - 1);
2913                 } else {
2914                         inode->i_op = &ext3_symlink_inode_operations;
2915                         ext3_set_aops(inode);
2916                 }
2917         } else {
2918                 inode->i_op = &ext3_special_inode_operations;
2919                 if (raw_inode->i_block[0])
2920                         init_special_inode(inode, inode->i_mode,
2921                            old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
2922                 else
2923                         init_special_inode(inode, inode->i_mode,
2924                            new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
2925         }
2926         brelse (iloc.bh);
2927         ext3_set_inode_flags(inode);
2928         unlock_new_inode(inode);
2929         return inode;
2930
2931 bad_inode:
2932         iget_failed(inode);
2933         return ERR_PTR(ret);
2934 }
2935
2936 /*
2937  * Post the struct inode info into an on-disk inode location in the
2938  * buffer-cache.  This gobbles the caller's reference to the
2939  * buffer_head in the inode location struct.
2940  *
2941  * The caller must have write access to iloc->bh.
2942  */
2943 static int ext3_do_update_inode(handle_t *handle,
2944                                 struct inode *inode,
2945                                 struct ext3_iloc *iloc)
2946 {
2947         struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
2948         struct ext3_inode_info *ei = EXT3_I(inode);
2949         struct buffer_head *bh = iloc->bh;
2950         int err = 0, rc, block;
2951
2952 again:
2953         /* we can't allow multiple procs in here at once, its a bit racey */
2954         lock_buffer(bh);
2955
2956         /* For fields not not tracking in the in-memory inode,
2957          * initialise them to zero for new inodes. */
2958         if (ext3_test_inode_state(inode, EXT3_STATE_NEW))
2959                 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
2960
2961         ext3_get_inode_flags(ei);
2962         raw_inode->i_mode = cpu_to_le16(inode->i_mode);
2963         if(!(test_opt(inode->i_sb, NO_UID32))) {
2964                 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
2965                 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
2966 /*
2967  * Fix up interoperability with old kernels. Otherwise, old inodes get
2968  * re-used with the upper 16 bits of the uid/gid intact
2969  */
2970                 if(!ei->i_dtime) {
2971                         raw_inode->i_uid_high =
2972                                 cpu_to_le16(high_16_bits(inode->i_uid));
2973                         raw_inode->i_gid_high =
2974                                 cpu_to_le16(high_16_bits(inode->i_gid));
2975                 } else {
2976                         raw_inode->i_uid_high = 0;
2977                         raw_inode->i_gid_high = 0;
2978                 }
2979         } else {
2980                 raw_inode->i_uid_low =
2981                         cpu_to_le16(fs_high2lowuid(inode->i_uid));
2982                 raw_inode->i_gid_low =
2983                         cpu_to_le16(fs_high2lowgid(inode->i_gid));
2984                 raw_inode->i_uid_high = 0;
2985                 raw_inode->i_gid_high = 0;
2986         }
2987         raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
2988         raw_inode->i_size = cpu_to_le32(ei->i_disksize);
2989         raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
2990         raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
2991         raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
2992         raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
2993         raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
2994         raw_inode->i_flags = cpu_to_le32(ei->i_flags);
2995 #ifdef EXT3_FRAGMENTS
2996         raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
2997         raw_inode->i_frag = ei->i_frag_no;
2998         raw_inode->i_fsize = ei->i_frag_size;
2999 #endif
3000         raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
3001         if (!S_ISREG(inode->i_mode)) {
3002                 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
3003         } else {
3004                 raw_inode->i_size_high =
3005                         cpu_to_le32(ei->i_disksize >> 32);
3006                 if (ei->i_disksize > 0x7fffffffULL) {
3007                         struct super_block *sb = inode->i_sb;
3008                         if (!EXT3_HAS_RO_COMPAT_FEATURE(sb,
3009                                         EXT3_FEATURE_RO_COMPAT_LARGE_FILE) ||
3010                             EXT3_SB(sb)->s_es->s_rev_level ==
3011                                         cpu_to_le32(EXT3_GOOD_OLD_REV)) {
3012                                /* If this is the first large file
3013                                 * created, add a flag to the superblock.
3014                                 */
3015                                 unlock_buffer(bh);
3016                                 err = ext3_journal_get_write_access(handle,
3017                                                 EXT3_SB(sb)->s_sbh);
3018                                 if (err)
3019                                         goto out_brelse;
3020
3021                                 ext3_update_dynamic_rev(sb);
3022                                 EXT3_SET_RO_COMPAT_FEATURE(sb,
3023                                         EXT3_FEATURE_RO_COMPAT_LARGE_FILE);
3024                                 handle->h_sync = 1;
3025                                 err = ext3_journal_dirty_metadata(handle,
3026                                                 EXT3_SB(sb)->s_sbh);
3027                                 /* get our lock and start over */
3028                                 goto again;
3029                         }
3030                 }
3031         }
3032         raw_inode->i_generation = cpu_to_le32(inode->i_generation);
3033         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
3034                 if (old_valid_dev(inode->i_rdev)) {
3035                         raw_inode->i_block[0] =
3036                                 cpu_to_le32(old_encode_dev(inode->i_rdev));
3037                         raw_inode->i_block[1] = 0;
3038                 } else {
3039                         raw_inode->i_block[0] = 0;
3040                         raw_inode->i_block[1] =
3041                                 cpu_to_le32(new_encode_dev(inode->i_rdev));
3042                         raw_inode->i_block[2] = 0;
3043                 }
3044         } else for (block = 0; block < EXT3_N_BLOCKS; block++)
3045                 raw_inode->i_block[block] = ei->i_data[block];
3046
3047         if (ei->i_extra_isize)
3048                 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
3049
3050         BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
3051         unlock_buffer(bh);
3052         rc = ext3_journal_dirty_metadata(handle, bh);
3053         if (!err)
3054                 err = rc;
3055         ext3_clear_inode_state(inode, EXT3_STATE_NEW);
3056
3057         atomic_set(&ei->i_sync_tid, handle->h_transaction->t_tid);
3058 out_brelse:
3059         brelse (bh);
3060         ext3_std_error(inode->i_sb, err);
3061         return err;
3062 }
3063
3064 /*
3065  * ext3_write_inode()
3066  *
3067  * We are called from a few places:
3068  *
3069  * - Within generic_file_write() for O_SYNC files.
3070  *   Here, there will be no transaction running. We wait for any running
3071  *   trasnaction to commit.
3072  *
3073  * - Within sys_sync(), kupdate and such.
3074  *   We wait on commit, if tol to.
3075  *
3076  * - Within prune_icache() (PF_MEMALLOC == true)
3077  *   Here we simply return.  We can't afford to block kswapd on the
3078  *   journal commit.
3079  *
3080  * In all cases it is actually safe for us to return without doing anything,
3081  * because the inode has been copied into a raw inode buffer in
3082  * ext3_mark_inode_dirty().  This is a correctness thing for O_SYNC and for
3083  * knfsd.
3084  *
3085  * Note that we are absolutely dependent upon all inode dirtiers doing the
3086  * right thing: they *must* call mark_inode_dirty() after dirtying info in
3087  * which we are interested.
3088  *
3089  * It would be a bug for them to not do this.  The code:
3090  *
3091  *      mark_inode_dirty(inode)
3092  *      stuff();
3093  *      inode->i_size = expr;
3094  *
3095  * is in error because a kswapd-driven write_inode() could occur while
3096  * `stuff()' is running, and the new i_size will be lost.  Plus the inode
3097  * will no longer be on the superblock's dirty inode list.
3098  */
3099 int ext3_write_inode(struct inode *inode, int wait)
3100 {
3101         if (current->flags & PF_MEMALLOC)
3102                 return 0;
3103
3104         if (ext3_journal_current_handle()) {
3105                 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
3106                 dump_stack();
3107                 return -EIO;
3108         }
3109
3110         if (!wait)
3111                 return 0;
3112
3113         return ext3_force_commit(inode->i_sb);
3114 }
3115
3116 /*
3117  * ext3_setattr()
3118  *
3119  * Called from notify_change.
3120  *
3121  * We want to trap VFS attempts to truncate the file as soon as
3122  * possible.  In particular, we want to make sure that when the VFS
3123  * shrinks i_size, we put the inode on the orphan list and modify
3124  * i_disksize immediately, so that during the subsequent flushing of
3125  * dirty pages and freeing of disk blocks, we can guarantee that any
3126  * commit will leave the blocks being flushed in an unused state on
3127  * disk.  (On recovery, the inode will get truncated and the blocks will
3128  * be freed, so we have a strong guarantee that no future commit will
3129  * leave these blocks visible to the user.)
3130  *
3131  * Called with inode->sem down.
3132  */
3133 int ext3_setattr(struct dentry *dentry, struct iattr *attr)
3134 {
3135         struct inode *inode = dentry->d_inode;
3136         int error, rc = 0;
3137         const unsigned int ia_valid = attr->ia_valid;
3138
3139         error = inode_change_ok(inode, attr);
3140         if (error)
3141                 return error;
3142
3143         if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
3144                 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
3145                 handle_t *handle;
3146
3147                 /* (user+group)*(old+new) structure, inode write (sb,
3148                  * inode block, ? - but truncate inode update has it) */
3149                 handle = ext3_journal_start(inode, EXT3_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
3150                                         EXT3_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)+3);
3151                 if (IS_ERR(handle)) {
3152                         error = PTR_ERR(handle);
3153                         goto err_out;
3154                 }
3155                 error = vfs_dq_transfer(inode, attr) ? -EDQUOT : 0;
3156                 if (error) {
3157                         ext3_journal_stop(handle);
3158                         return error;
3159                 }
3160                 /* Update corresponding info in inode so that everything is in
3161                  * one transaction */
3162                 if (attr->ia_valid & ATTR_UID)
3163                         inode->i_uid = attr->ia_uid;
3164                 if (attr->ia_valid & ATTR_GID)
3165                         inode->i_gid = attr->ia_gid;
3166                 error = ext3_mark_inode_dirty(handle, inode);
3167                 ext3_journal_stop(handle);
3168         }
3169
3170         if (S_ISREG(inode->i_mode) &&
3171             attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
3172                 handle_t *handle;
3173
3174                 handle = ext3_journal_start(inode, 3);
3175                 if (IS_ERR(handle)) {
3176                         error = PTR_ERR(handle);
3177                         goto err_out;
3178                 }
3179
3180                 error = ext3_orphan_add(handle, inode);
3181                 EXT3_I(inode)->i_disksize = attr->ia_size;
3182                 rc = ext3_mark_inode_dirty(handle, inode);
3183                 if (!error)
3184                         error = rc;
3185                 ext3_journal_stop(handle);
3186         }
3187
3188         rc = inode_setattr(inode, attr);
3189
3190         if (!rc && (ia_valid & ATTR_MODE))
3191                 rc = ext3_acl_chmod(inode);
3192
3193 err_out:
3194         ext3_std_error(inode->i_sb, error);
3195         if (!error)
3196                 error = rc;
3197         return error;
3198 }
3199
3200
3201 /*
3202  * How many blocks doth make a writepage()?
3203  *
3204  * With N blocks per page, it may be:
3205  * N data blocks
3206  * 2 indirect block
3207  * 2 dindirect
3208  * 1 tindirect
3209  * N+5 bitmap blocks (from the above)
3210  * N+5 group descriptor summary blocks
3211  * 1 inode block
3212  * 1 superblock.
3213  * 2 * EXT3_SINGLEDATA_TRANS_BLOCKS for the quote files
3214  *
3215  * 3 * (N + 5) + 2 + 2 * EXT3_SINGLEDATA_TRANS_BLOCKS
3216  *
3217  * With ordered or writeback data it's the same, less the N data blocks.
3218  *
3219  * If the inode's direct blocks can hold an integral number of pages then a
3220  * page cannot straddle two indirect blocks, and we can only touch one indirect
3221  * and dindirect block, and the "5" above becomes "3".
3222  *
3223  * This still overestimates under most circumstances.  If we were to pass the
3224  * start and end offsets in here as well we could do block_to_path() on each
3225  * block and work out the exact number of indirects which are touched.  Pah.
3226  */
3227
3228 static int ext3_writepage_trans_blocks(struct inode *inode)
3229 {
3230         int bpp = ext3_journal_blocks_per_page(inode);
3231         int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
3232         int ret;
3233
3234         if (ext3_should_journal_data(inode))
3235                 ret = 3 * (bpp + indirects) + 2;
3236         else
3237                 ret = 2 * (bpp + indirects) + 2;
3238
3239 #ifdef CONFIG_QUOTA
3240         /* We know that structure was already allocated during vfs_dq_init so
3241          * we will be updating only the data blocks + inodes */
3242         ret += EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
3243 #endif
3244
3245         return ret;
3246 }
3247
3248 /*
3249  * The caller must have previously called ext3_reserve_inode_write().
3250  * Give this, we know that the caller already has write access to iloc->bh.
3251  */
3252 int ext3_mark_iloc_dirty(handle_t *handle,
3253                 struct inode *inode, struct ext3_iloc *iloc)
3254 {
3255         int err = 0;
3256
3257         /* the do_update_inode consumes one bh->b_count */
3258         get_bh(iloc->bh);
3259
3260         /* ext3_do_update_inode() does journal_dirty_metadata */
3261         err = ext3_do_update_inode(handle, inode, iloc);
3262         put_bh(iloc->bh);
3263         return err;
3264 }
3265
3266 /*
3267  * On success, We end up with an outstanding reference count against
3268  * iloc->bh.  This _must_ be cleaned up later.
3269  */
3270
3271 int
3272 ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
3273                          struct ext3_iloc *iloc)
3274 {
3275         int err = 0;
3276         if (handle) {
3277                 err = ext3_get_inode_loc(inode, iloc);
3278                 if (!err) {
3279                         BUFFER_TRACE(iloc->bh, "get_write_access");
3280                         err = ext3_journal_get_write_access(handle, iloc->bh);
3281                         if (err) {
3282                                 brelse(iloc->bh);
3283                                 iloc->bh = NULL;
3284                         }
3285                 }
3286         }
3287         ext3_std_error(inode->i_sb, err);
3288         return err;
3289 }
3290
3291 /*
3292  * What we do here is to mark the in-core inode as clean with respect to inode
3293  * dirtiness (it may still be data-dirty).
3294  * This means that the in-core inode may be reaped by prune_icache
3295  * without having to perform any I/O.  This is a very good thing,
3296  * because *any* task may call prune_icache - even ones which
3297  * have a transaction open against a different journal.
3298  *
3299  * Is this cheating?  Not really.  Sure, we haven't written the
3300  * inode out, but prune_icache isn't a user-visible syncing function.
3301  * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
3302  * we start and wait on commits.
3303  *
3304  * Is this efficient/effective?  Well, we're being nice to the system
3305  * by cleaning up our inodes proactively so they can be reaped
3306  * without I/O.  But we are potentially leaving up to five seconds'
3307  * worth of inodes floating about which prune_icache wants us to
3308  * write out.  One way to fix that would be to get prune_icache()
3309  * to do a write_super() to free up some memory.  It has the desired
3310  * effect.
3311  */
3312 int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
3313 {
3314         struct ext3_iloc iloc;
3315         int err;
3316
3317         might_sleep();
3318         err = ext3_reserve_inode_write(handle, inode, &iloc);
3319         if (!err)
3320                 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
3321         return err;
3322 }
3323
3324 /*
3325  * ext3_dirty_inode() is called from __mark_inode_dirty()
3326  *
3327  * We're really interested in the case where a file is being extended.
3328  * i_size has been changed by generic_commit_write() and we thus need
3329  * to include the updated inode in the current transaction.
3330  *
3331  * Also, vfs_dq_alloc_space() will always dirty the inode when blocks
3332  * are allocated to the file.
3333  *
3334  * If the inode is marked synchronous, we don't honour that here - doing
3335  * so would cause a commit on atime updates, which we don't bother doing.
3336  * We handle synchronous inodes at the highest possible level.
3337  */
3338 void ext3_dirty_inode(struct inode *inode)
3339 {
3340         handle_t *current_handle = ext3_journal_current_handle();
3341         handle_t *handle;
3342
3343         handle = ext3_journal_start(inode, 2);
3344         if (IS_ERR(handle))
3345                 goto out;
3346         if (current_handle &&
3347                 current_handle->h_transaction != handle->h_transaction) {
3348                 /* This task has a transaction open against a different fs */
3349                 printk(KERN_EMERG "%s: transactions do not match!\n",
3350                        __func__);
3351         } else {
3352                 jbd_debug(5, "marking dirty.  outer handle=%p\n",
3353                                 current_handle);
3354                 ext3_mark_inode_dirty(handle, inode);
3355         }
3356         ext3_journal_stop(handle);
3357 out:
3358         return;
3359 }
3360
3361 #if 0
3362 /*
3363  * Bind an inode's backing buffer_head into this transaction, to prevent
3364  * it from being flushed to disk early.  Unlike
3365  * ext3_reserve_inode_write, this leaves behind no bh reference and
3366  * returns no iloc structure, so the caller needs to repeat the iloc
3367  * lookup to mark the inode dirty later.
3368  */
3369 static int ext3_pin_inode(handle_t *handle, struct inode *inode)
3370 {
3371         struct ext3_iloc iloc;
3372
3373         int err = 0;
3374         if (handle) {
3375                 err = ext3_get_inode_loc(inode, &iloc);
3376                 if (!err) {
3377                         BUFFER_TRACE(iloc.bh, "get_write_access");
3378                         err = journal_get_write_access(handle, iloc.bh);
3379                         if (!err)
3380                                 err = ext3_journal_dirty_metadata(handle,
3381                                                                   iloc.bh);
3382                         brelse(iloc.bh);
3383                 }
3384         }
3385         ext3_std_error(inode->i_sb, err);
3386         return err;
3387 }
3388 #endif
3389
3390 int ext3_change_inode_journal_flag(struct inode *inode, int val)
3391 {
3392         journal_t *journal;
3393         handle_t *handle;
3394         int err;
3395
3396         /*
3397          * We have to be very careful here: changing a data block's
3398          * journaling status dynamically is dangerous.  If we write a
3399          * data block to the journal, change the status and then delete
3400          * that block, we risk forgetting to revoke the old log record
3401          * from the journal and so a subsequent replay can corrupt data.
3402          * So, first we make sure that the journal is empty and that
3403          * nobody is changing anything.
3404          */
3405
3406         journal = EXT3_JOURNAL(inode);
3407         if (is_journal_aborted(journal))
3408                 return -EROFS;
3409
3410         journal_lock_updates(journal);
3411         journal_flush(journal);
3412
3413         /*
3414          * OK, there are no updates running now, and all cached data is
3415          * synced to disk.  We are now in a completely consistent state
3416          * which doesn't have anything in the journal, and we know that
3417          * no filesystem updates are running, so it is safe to modify
3418          * the inode's in-core data-journaling state flag now.
3419          */
3420
3421         if (val)
3422                 EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
3423         else
3424                 EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
3425         ext3_set_aops(inode);
3426
3427         journal_unlock_updates(journal);
3428
3429         /* Finally we can mark the inode as dirty. */
3430
3431         handle = ext3_journal_start(inode, 1);
3432         if (IS_ERR(handle))
3433                 return PTR_ERR(handle);
3434
3435         err = ext3_mark_inode_dirty(handle, inode);
3436         handle->h_sync = 1;
3437         ext3_journal_stop(handle);
3438         ext3_std_error(inode->i_sb, err);
3439
3440         return err;
3441 }