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