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