kdump: update kdump documentation as kexec-tools-resting has been renamed kexec-tools
[linux-2.6.git] / fs / ext4 / inode.c
1 /*
2  *  linux/fs/ext4/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 ext4_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/jbd2.h>
29 #include <linux/highuid.h>
30 #include <linux/pagemap.h>
31 #include <linux/quotaops.h>
32 #include <linux/string.h>
33 #include <linux/buffer_head.h>
34 #include <linux/writeback.h>
35 #include <linux/pagevec.h>
36 #include <linux/mpage.h>
37 #include <linux/uio.h>
38 #include <linux/bio.h>
39 #include "ext4_jbd2.h"
40 #include "xattr.h"
41 #include "acl.h"
42 #include "ext4_extents.h"
43
44 static inline int ext4_begin_ordered_truncate(struct inode *inode,
45                                               loff_t new_size)
46 {
47         return jbd2_journal_begin_ordered_truncate(&EXT4_I(inode)->jinode,
48                                                    new_size);
49 }
50
51 static void ext4_invalidatepage(struct page *page, unsigned long offset);
52
53 /*
54  * Test whether an inode is a fast symlink.
55  */
56 static int ext4_inode_is_fast_symlink(struct inode *inode)
57 {
58         int ea_blocks = EXT4_I(inode)->i_file_acl ?
59                 (inode->i_sb->s_blocksize >> 9) : 0;
60
61         return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
62 }
63
64 /*
65  * The ext4 forget function must perform a revoke if we are freeing data
66  * which has been journaled.  Metadata (eg. indirect blocks) must be
67  * revoked in all cases.
68  *
69  * "bh" may be NULL: a metadata block may have been freed from memory
70  * but there may still be a record of it in the journal, and that record
71  * still needs to be revoked.
72  */
73 int ext4_forget(handle_t *handle, int is_metadata, struct inode *inode,
74                         struct buffer_head *bh, ext4_fsblk_t blocknr)
75 {
76         int err;
77
78         might_sleep();
79
80         BUFFER_TRACE(bh, "enter");
81
82         jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
83                   "data mode %lx\n",
84                   bh, is_metadata, inode->i_mode,
85                   test_opt(inode->i_sb, DATA_FLAGS));
86
87         /* Never use the revoke function if we are doing full data
88          * journaling: there is no need to, and a V1 superblock won't
89          * support it.  Otherwise, only skip the revoke on un-journaled
90          * data blocks. */
91
92         if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA ||
93             (!is_metadata && !ext4_should_journal_data(inode))) {
94                 if (bh) {
95                         BUFFER_TRACE(bh, "call jbd2_journal_forget");
96                         return ext4_journal_forget(handle, bh);
97                 }
98                 return 0;
99         }
100
101         /*
102          * data!=journal && (is_metadata || should_journal_data(inode))
103          */
104         BUFFER_TRACE(bh, "call ext4_journal_revoke");
105         err = ext4_journal_revoke(handle, blocknr, bh);
106         if (err)
107                 ext4_abort(inode->i_sb, __func__,
108                            "error %d when attempting revoke", err);
109         BUFFER_TRACE(bh, "exit");
110         return err;
111 }
112
113 /*
114  * Work out how many blocks we need to proceed with the next chunk of a
115  * truncate transaction.
116  */
117 static unsigned long blocks_for_truncate(struct inode *inode)
118 {
119         ext4_lblk_t needed;
120
121         needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
122
123         /* Give ourselves just enough room to cope with inodes in which
124          * i_blocks is corrupt: we've seen disk corruptions in the past
125          * which resulted in random data in an inode which looked enough
126          * like a regular file for ext4 to try to delete it.  Things
127          * will go a bit crazy if that happens, but at least we should
128          * try not to panic the whole kernel. */
129         if (needed < 2)
130                 needed = 2;
131
132         /* But we need to bound the transaction so we don't overflow the
133          * journal. */
134         if (needed > EXT4_MAX_TRANS_DATA)
135                 needed = EXT4_MAX_TRANS_DATA;
136
137         return EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
138 }
139
140 /*
141  * Truncate transactions can be complex and absolutely huge.  So we need to
142  * be able to restart the transaction at a conventient checkpoint to make
143  * sure we don't overflow the journal.
144  *
145  * start_transaction gets us a new handle for a truncate transaction,
146  * and extend_transaction tries to extend the existing one a bit.  If
147  * extend fails, we need to propagate the failure up and restart the
148  * transaction in the top-level truncate loop. --sct
149  */
150 static handle_t *start_transaction(struct inode *inode)
151 {
152         handle_t *result;
153
154         result = ext4_journal_start(inode, blocks_for_truncate(inode));
155         if (!IS_ERR(result))
156                 return result;
157
158         ext4_std_error(inode->i_sb, PTR_ERR(result));
159         return result;
160 }
161
162 /*
163  * Try to extend this transaction for the purposes of truncation.
164  *
165  * Returns 0 if we managed to create more room.  If we can't create more
166  * room, and the transaction must be restarted we return 1.
167  */
168 static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
169 {
170         if (handle->h_buffer_credits > EXT4_RESERVE_TRANS_BLOCKS)
171                 return 0;
172         if (!ext4_journal_extend(handle, blocks_for_truncate(inode)))
173                 return 0;
174         return 1;
175 }
176
177 /*
178  * Restart the transaction associated with *handle.  This does a commit,
179  * so before we call here everything must be consistently dirtied against
180  * this transaction.
181  */
182 static int ext4_journal_test_restart(handle_t *handle, struct inode *inode)
183 {
184         jbd_debug(2, "restarting handle %p\n", handle);
185         return ext4_journal_restart(handle, blocks_for_truncate(inode));
186 }
187
188 /*
189  * Called at the last iput() if i_nlink is zero.
190  */
191 void ext4_delete_inode (struct inode * inode)
192 {
193         handle_t *handle;
194
195         if (ext4_should_order_data(inode))
196                 ext4_begin_ordered_truncate(inode, 0);
197         truncate_inode_pages(&inode->i_data, 0);
198
199         if (is_bad_inode(inode))
200                 goto no_delete;
201
202         handle = start_transaction(inode);
203         if (IS_ERR(handle)) {
204                 /*
205                  * If we're going to skip the normal cleanup, we still need to
206                  * make sure that the in-core orphan linked list is properly
207                  * cleaned up.
208                  */
209                 ext4_orphan_del(NULL, inode);
210                 goto no_delete;
211         }
212
213         if (IS_SYNC(inode))
214                 handle->h_sync = 1;
215         inode->i_size = 0;
216         if (inode->i_blocks)
217                 ext4_truncate(inode);
218         /*
219          * Kill off the orphan record which ext4_truncate created.
220          * AKPM: I think this can be inside the above `if'.
221          * Note that ext4_orphan_del() has to be able to cope with the
222          * deletion of a non-existent orphan - this is because we don't
223          * know if ext4_truncate() actually created an orphan record.
224          * (Well, we could do this if we need to, but heck - it works)
225          */
226         ext4_orphan_del(handle, inode);
227         EXT4_I(inode)->i_dtime  = get_seconds();
228
229         /*
230          * One subtle ordering requirement: if anything has gone wrong
231          * (transaction abort, IO errors, whatever), then we can still
232          * do these next steps (the fs will already have been marked as
233          * having errors), but we can't free the inode if the mark_dirty
234          * fails.
235          */
236         if (ext4_mark_inode_dirty(handle, inode))
237                 /* If that failed, just do the required in-core inode clear. */
238                 clear_inode(inode);
239         else
240                 ext4_free_inode(handle, inode);
241         ext4_journal_stop(handle);
242         return;
243 no_delete:
244         clear_inode(inode);     /* We must guarantee clearing of inode... */
245 }
246
247 typedef struct {
248         __le32  *p;
249         __le32  key;
250         struct buffer_head *bh;
251 } Indirect;
252
253 static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
254 {
255         p->key = *(p->p = v);
256         p->bh = bh;
257 }
258
259 /**
260  *      ext4_block_to_path - parse the block number into array of offsets
261  *      @inode: inode in question (we are only interested in its superblock)
262  *      @i_block: block number to be parsed
263  *      @offsets: array to store the offsets in
264  *      @boundary: set this non-zero if the referred-to block is likely to be
265  *             followed (on disk) by an indirect block.
266  *
267  *      To store the locations of file's data ext4 uses a data structure common
268  *      for UNIX filesystems - tree of pointers anchored in the inode, with
269  *      data blocks at leaves and indirect blocks in intermediate nodes.
270  *      This function translates the block number into path in that tree -
271  *      return value is the path length and @offsets[n] is the offset of
272  *      pointer to (n+1)th node in the nth one. If @block is out of range
273  *      (negative or too large) warning is printed and zero returned.
274  *
275  *      Note: function doesn't find node addresses, so no IO is needed. All
276  *      we need to know is the capacity of indirect blocks (taken from the
277  *      inode->i_sb).
278  */
279
280 /*
281  * Portability note: the last comparison (check that we fit into triple
282  * indirect block) is spelled differently, because otherwise on an
283  * architecture with 32-bit longs and 8Kb pages we might get into trouble
284  * if our filesystem had 8Kb blocks. We might use long long, but that would
285  * kill us on x86. Oh, well, at least the sign propagation does not matter -
286  * i_block would have to be negative in the very beginning, so we would not
287  * get there at all.
288  */
289
290 static int ext4_block_to_path(struct inode *inode,
291                         ext4_lblk_t i_block,
292                         ext4_lblk_t offsets[4], int *boundary)
293 {
294         int ptrs = EXT4_ADDR_PER_BLOCK(inode->i_sb);
295         int ptrs_bits = EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb);
296         const long direct_blocks = EXT4_NDIR_BLOCKS,
297                 indirect_blocks = ptrs,
298                 double_blocks = (1 << (ptrs_bits * 2));
299         int n = 0;
300         int final = 0;
301
302         if (i_block < 0) {
303                 ext4_warning (inode->i_sb, "ext4_block_to_path", "block < 0");
304         } else if (i_block < direct_blocks) {
305                 offsets[n++] = i_block;
306                 final = direct_blocks;
307         } else if ( (i_block -= direct_blocks) < indirect_blocks) {
308                 offsets[n++] = EXT4_IND_BLOCK;
309                 offsets[n++] = i_block;
310                 final = ptrs;
311         } else if ((i_block -= indirect_blocks) < double_blocks) {
312                 offsets[n++] = EXT4_DIND_BLOCK;
313                 offsets[n++] = i_block >> ptrs_bits;
314                 offsets[n++] = i_block & (ptrs - 1);
315                 final = ptrs;
316         } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
317                 offsets[n++] = EXT4_TIND_BLOCK;
318                 offsets[n++] = i_block >> (ptrs_bits * 2);
319                 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
320                 offsets[n++] = i_block & (ptrs - 1);
321                 final = ptrs;
322         } else {
323                 ext4_warning(inode->i_sb, "ext4_block_to_path",
324                                 "block %lu > max",
325                                 i_block + direct_blocks +
326                                 indirect_blocks + double_blocks);
327         }
328         if (boundary)
329                 *boundary = final - 1 - (i_block & (ptrs - 1));
330         return n;
331 }
332
333 /**
334  *      ext4_get_branch - read the chain of indirect blocks leading to data
335  *      @inode: inode in question
336  *      @depth: depth of the chain (1 - direct pointer, etc.)
337  *      @offsets: offsets of pointers in inode/indirect blocks
338  *      @chain: place to store the result
339  *      @err: here we store the error value
340  *
341  *      Function fills the array of triples <key, p, bh> and returns %NULL
342  *      if everything went OK or the pointer to the last filled triple
343  *      (incomplete one) otherwise. Upon the return chain[i].key contains
344  *      the number of (i+1)-th block in the chain (as it is stored in memory,
345  *      i.e. little-endian 32-bit), chain[i].p contains the address of that
346  *      number (it points into struct inode for i==0 and into the bh->b_data
347  *      for i>0) and chain[i].bh points to the buffer_head of i-th indirect
348  *      block for i>0 and NULL for i==0. In other words, it holds the block
349  *      numbers of the chain, addresses they were taken from (and where we can
350  *      verify that chain did not change) and buffer_heads hosting these
351  *      numbers.
352  *
353  *      Function stops when it stumbles upon zero pointer (absent block)
354  *              (pointer to last triple returned, *@err == 0)
355  *      or when it gets an IO error reading an indirect block
356  *              (ditto, *@err == -EIO)
357  *      or when it reads all @depth-1 indirect blocks successfully and finds
358  *      the whole chain, all way to the data (returns %NULL, *err == 0).
359  *
360  *      Need to be called with
361  *      down_read(&EXT4_I(inode)->i_data_sem)
362  */
363 static Indirect *ext4_get_branch(struct inode *inode, int depth,
364                                  ext4_lblk_t  *offsets,
365                                  Indirect chain[4], int *err)
366 {
367         struct super_block *sb = inode->i_sb;
368         Indirect *p = chain;
369         struct buffer_head *bh;
370
371         *err = 0;
372         /* i_data is not going away, no lock needed */
373         add_chain (chain, NULL, EXT4_I(inode)->i_data + *offsets);
374         if (!p->key)
375                 goto no_block;
376         while (--depth) {
377                 bh = sb_bread(sb, le32_to_cpu(p->key));
378                 if (!bh)
379                         goto failure;
380                 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
381                 /* Reader: end */
382                 if (!p->key)
383                         goto no_block;
384         }
385         return NULL;
386
387 failure:
388         *err = -EIO;
389 no_block:
390         return p;
391 }
392
393 /**
394  *      ext4_find_near - find a place for allocation with sufficient locality
395  *      @inode: owner
396  *      @ind: descriptor of indirect block.
397  *
398  *      This function returns the preferred place for block allocation.
399  *      It is used when heuristic for sequential allocation fails.
400  *      Rules are:
401  *        + if there is a block to the left of our position - allocate near it.
402  *        + if pointer will live in indirect block - allocate near that block.
403  *        + if pointer will live in inode - allocate in the same
404  *          cylinder group.
405  *
406  * In the latter case we colour the starting block by the callers PID to
407  * prevent it from clashing with concurrent allocations for a different inode
408  * in the same block group.   The PID is used here so that functionally related
409  * files will be close-by on-disk.
410  *
411  *      Caller must make sure that @ind is valid and will stay that way.
412  */
413 static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind)
414 {
415         struct ext4_inode_info *ei = EXT4_I(inode);
416         __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
417         __le32 *p;
418         ext4_fsblk_t bg_start;
419         ext4_fsblk_t last_block;
420         ext4_grpblk_t colour;
421
422         /* Try to find previous block */
423         for (p = ind->p - 1; p >= start; p--) {
424                 if (*p)
425                         return le32_to_cpu(*p);
426         }
427
428         /* No such thing, so let's try location of indirect block */
429         if (ind->bh)
430                 return ind->bh->b_blocknr;
431
432         /*
433          * It is going to be referred to from the inode itself? OK, just put it
434          * into the same cylinder group then.
435          */
436         bg_start = ext4_group_first_block_no(inode->i_sb, ei->i_block_group);
437         last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
438
439         if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
440                 colour = (current->pid % 16) *
441                         (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
442         else
443                 colour = (current->pid % 16) * ((last_block - bg_start) / 16);
444         return bg_start + colour;
445 }
446
447 /**
448  *      ext4_find_goal - find a preferred place for allocation.
449  *      @inode: owner
450  *      @block:  block we want
451  *      @partial: pointer to the last triple within a chain
452  *
453  *      Normally this function find the preferred place for block allocation,
454  *      returns it.
455  */
456 static ext4_fsblk_t ext4_find_goal(struct inode *inode, ext4_lblk_t block,
457                 Indirect *partial)
458 {
459         struct ext4_block_alloc_info *block_i;
460
461         block_i =  EXT4_I(inode)->i_block_alloc_info;
462
463         /*
464          * try the heuristic for sequential allocation,
465          * failing that at least try to get decent locality.
466          */
467         if (block_i && (block == block_i->last_alloc_logical_block + 1)
468                 && (block_i->last_alloc_physical_block != 0)) {
469                 return block_i->last_alloc_physical_block + 1;
470         }
471
472         return ext4_find_near(inode, partial);
473 }
474
475 /**
476  *      ext4_blks_to_allocate: Look up the block map and count the number
477  *      of direct blocks need to be allocated for the given branch.
478  *
479  *      @branch: chain of indirect blocks
480  *      @k: number of blocks need for indirect blocks
481  *      @blks: number of data blocks to be mapped.
482  *      @blocks_to_boundary:  the offset in the indirect block
483  *
484  *      return the total number of blocks to be allocate, including the
485  *      direct and indirect blocks.
486  */
487 static int ext4_blks_to_allocate(Indirect *branch, int k, unsigned long blks,
488                 int blocks_to_boundary)
489 {
490         unsigned long count = 0;
491
492         /*
493          * Simple case, [t,d]Indirect block(s) has not allocated yet
494          * then it's clear blocks on that path have not allocated
495          */
496         if (k > 0) {
497                 /* right now we don't handle cross boundary allocation */
498                 if (blks < blocks_to_boundary + 1)
499                         count += blks;
500                 else
501                         count += blocks_to_boundary + 1;
502                 return count;
503         }
504
505         count++;
506         while (count < blks && count <= blocks_to_boundary &&
507                 le32_to_cpu(*(branch[0].p + count)) == 0) {
508                 count++;
509         }
510         return count;
511 }
512
513 /**
514  *      ext4_alloc_blocks: multiple allocate blocks needed for a branch
515  *      @indirect_blks: the number of blocks need to allocate for indirect
516  *                      blocks
517  *
518  *      @new_blocks: on return it will store the new block numbers for
519  *      the indirect blocks(if needed) and the first direct block,
520  *      @blks:  on return it will store the total number of allocated
521  *              direct blocks
522  */
523 static int ext4_alloc_blocks(handle_t *handle, struct inode *inode,
524                                 ext4_lblk_t iblock, ext4_fsblk_t goal,
525                                 int indirect_blks, int blks,
526                                 ext4_fsblk_t new_blocks[4], int *err)
527 {
528         int target, i;
529         unsigned long count = 0, blk_allocated = 0;
530         int index = 0;
531         ext4_fsblk_t current_block = 0;
532         int ret = 0;
533
534         /*
535          * Here we try to allocate the requested multiple blocks at once,
536          * on a best-effort basis.
537          * To build a branch, we should allocate blocks for
538          * the indirect blocks(if not allocated yet), and at least
539          * the first direct block of this branch.  That's the
540          * minimum number of blocks need to allocate(required)
541          */
542         /* first we try to allocate the indirect blocks */
543         target = indirect_blks;
544         while (target > 0) {
545                 count = target;
546                 /* allocating blocks for indirect blocks and direct blocks */
547                 current_block = ext4_new_meta_blocks(handle, inode,
548                                                         goal, &count, err);
549                 if (*err)
550                         goto failed_out;
551
552                 target -= count;
553                 /* allocate blocks for indirect blocks */
554                 while (index < indirect_blks && count) {
555                         new_blocks[index++] = current_block++;
556                         count--;
557                 }
558                 if (count > 0) {
559                         /*
560                          * save the new block number
561                          * for the first direct block
562                          */
563                         new_blocks[index] = current_block;
564                         printk(KERN_INFO "%s returned more blocks than "
565                                                 "requested\n", __func__);
566                         WARN_ON(1);
567                         break;
568                 }
569         }
570
571         target = blks - count ;
572         blk_allocated = count;
573         if (!target)
574                 goto allocated;
575         /* Now allocate data blocks */
576         count = target;
577         /* allocating blocks for data blocks */
578         current_block = ext4_new_blocks(handle, inode, iblock,
579                                                 goal, &count, err);
580         if (*err && (target == blks)) {
581                 /*
582                  * if the allocation failed and we didn't allocate
583                  * any blocks before
584                  */
585                 goto failed_out;
586         }
587         if (!*err) {
588                 if (target == blks) {
589                 /*
590                  * save the new block number
591                  * for the first direct block
592                  */
593                         new_blocks[index] = current_block;
594                 }
595                 blk_allocated += count;
596         }
597 allocated:
598         /* total number of blocks allocated for direct blocks */
599         ret = blk_allocated;
600         *err = 0;
601         return ret;
602 failed_out:
603         for (i = 0; i <index; i++)
604                 ext4_free_blocks(handle, inode, new_blocks[i], 1, 0);
605         return ret;
606 }
607
608 /**
609  *      ext4_alloc_branch - allocate and set up a chain of blocks.
610  *      @inode: owner
611  *      @indirect_blks: number of allocated indirect blocks
612  *      @blks: number of allocated direct blocks
613  *      @offsets: offsets (in the blocks) to store the pointers to next.
614  *      @branch: place to store the chain in.
615  *
616  *      This function allocates blocks, zeroes out all but the last one,
617  *      links them into chain and (if we are synchronous) writes them to disk.
618  *      In other words, it prepares a branch that can be spliced onto the
619  *      inode. It stores the information about that chain in the branch[], in
620  *      the same format as ext4_get_branch() would do. We are calling it after
621  *      we had read the existing part of chain and partial points to the last
622  *      triple of that (one with zero ->key). Upon the exit we have the same
623  *      picture as after the successful ext4_get_block(), except that in one
624  *      place chain is disconnected - *branch->p is still zero (we did not
625  *      set the last link), but branch->key contains the number that should
626  *      be placed into *branch->p to fill that gap.
627  *
628  *      If allocation fails we free all blocks we've allocated (and forget
629  *      their buffer_heads) and return the error value the from failed
630  *      ext4_alloc_block() (normally -ENOSPC). Otherwise we set the chain
631  *      as described above and return 0.
632  */
633 static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
634                                 ext4_lblk_t iblock, int indirect_blks,
635                                 int *blks, ext4_fsblk_t goal,
636                                 ext4_lblk_t *offsets, Indirect *branch)
637 {
638         int blocksize = inode->i_sb->s_blocksize;
639         int i, n = 0;
640         int err = 0;
641         struct buffer_head *bh;
642         int num;
643         ext4_fsblk_t new_blocks[4];
644         ext4_fsblk_t current_block;
645
646         num = ext4_alloc_blocks(handle, inode, iblock, goal, indirect_blks,
647                                 *blks, new_blocks, &err);
648         if (err)
649                 return err;
650
651         branch[0].key = cpu_to_le32(new_blocks[0]);
652         /*
653          * metadata blocks and data blocks are allocated.
654          */
655         for (n = 1; n <= indirect_blks;  n++) {
656                 /*
657                  * Get buffer_head for parent block, zero it out
658                  * and set the pointer to new one, then send
659                  * parent to disk.
660                  */
661                 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
662                 branch[n].bh = bh;
663                 lock_buffer(bh);
664                 BUFFER_TRACE(bh, "call get_create_access");
665                 err = ext4_journal_get_create_access(handle, bh);
666                 if (err) {
667                         unlock_buffer(bh);
668                         brelse(bh);
669                         goto failed;
670                 }
671
672                 memset(bh->b_data, 0, blocksize);
673                 branch[n].p = (__le32 *) bh->b_data + offsets[n];
674                 branch[n].key = cpu_to_le32(new_blocks[n]);
675                 *branch[n].p = branch[n].key;
676                 if ( n == indirect_blks) {
677                         current_block = new_blocks[n];
678                         /*
679                          * End of chain, update the last new metablock of
680                          * the chain to point to the new allocated
681                          * data blocks numbers
682                          */
683                         for (i=1; i < num; i++)
684                                 *(branch[n].p + i) = cpu_to_le32(++current_block);
685                 }
686                 BUFFER_TRACE(bh, "marking uptodate");
687                 set_buffer_uptodate(bh);
688                 unlock_buffer(bh);
689
690                 BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata");
691                 err = ext4_journal_dirty_metadata(handle, bh);
692                 if (err)
693                         goto failed;
694         }
695         *blks = num;
696         return err;
697 failed:
698         /* Allocation failed, free what we already allocated */
699         for (i = 1; i <= n ; i++) {
700                 BUFFER_TRACE(branch[i].bh, "call jbd2_journal_forget");
701                 ext4_journal_forget(handle, branch[i].bh);
702         }
703         for (i = 0; i <indirect_blks; i++)
704                 ext4_free_blocks(handle, inode, new_blocks[i], 1, 0);
705
706         ext4_free_blocks(handle, inode, new_blocks[i], num, 0);
707
708         return err;
709 }
710
711 /**
712  * ext4_splice_branch - splice the allocated branch onto inode.
713  * @inode: owner
714  * @block: (logical) number of block we are adding
715  * @chain: chain of indirect blocks (with a missing link - see
716  *      ext4_alloc_branch)
717  * @where: location of missing link
718  * @num:   number of indirect blocks we are adding
719  * @blks:  number of direct blocks we are adding
720  *
721  * This function fills the missing link and does all housekeeping needed in
722  * inode (->i_blocks, etc.). In case of success we end up with the full
723  * chain to new block and return 0.
724  */
725 static int ext4_splice_branch(handle_t *handle, struct inode *inode,
726                         ext4_lblk_t block, Indirect *where, int num, int blks)
727 {
728         int i;
729         int err = 0;
730         struct ext4_block_alloc_info *block_i;
731         ext4_fsblk_t current_block;
732
733         block_i = EXT4_I(inode)->i_block_alloc_info;
734         /*
735          * If we're splicing into a [td]indirect block (as opposed to the
736          * inode) then we need to get write access to the [td]indirect block
737          * before the splice.
738          */
739         if (where->bh) {
740                 BUFFER_TRACE(where->bh, "get_write_access");
741                 err = ext4_journal_get_write_access(handle, where->bh);
742                 if (err)
743                         goto err_out;
744         }
745         /* That's it */
746
747         *where->p = where->key;
748
749         /*
750          * Update the host buffer_head or inode to point to more just allocated
751          * direct blocks blocks
752          */
753         if (num == 0 && blks > 1) {
754                 current_block = le32_to_cpu(where->key) + 1;
755                 for (i = 1; i < blks; i++)
756                         *(where->p + i ) = cpu_to_le32(current_block++);
757         }
758
759         /*
760          * update the most recently allocated logical & physical block
761          * in i_block_alloc_info, to assist find the proper goal block for next
762          * allocation
763          */
764         if (block_i) {
765                 block_i->last_alloc_logical_block = block + blks - 1;
766                 block_i->last_alloc_physical_block =
767                                 le32_to_cpu(where[num].key) + blks - 1;
768         }
769
770         /* We are done with atomic stuff, now do the rest of housekeeping */
771
772         inode->i_ctime = ext4_current_time(inode);
773         ext4_mark_inode_dirty(handle, inode);
774
775         /* had we spliced it onto indirect block? */
776         if (where->bh) {
777                 /*
778                  * If we spliced it onto an indirect block, we haven't
779                  * altered the inode.  Note however that if it is being spliced
780                  * onto an indirect block at the very end of the file (the
781                  * file is growing) then we *will* alter the inode to reflect
782                  * the new i_size.  But that is not done here - it is done in
783                  * generic_commit_write->__mark_inode_dirty->ext4_dirty_inode.
784                  */
785                 jbd_debug(5, "splicing indirect only\n");
786                 BUFFER_TRACE(where->bh, "call ext4_journal_dirty_metadata");
787                 err = ext4_journal_dirty_metadata(handle, where->bh);
788                 if (err)
789                         goto err_out;
790         } else {
791                 /*
792                  * OK, we spliced it into the inode itself on a direct block.
793                  * Inode was dirtied above.
794                  */
795                 jbd_debug(5, "splicing direct\n");
796         }
797         return err;
798
799 err_out:
800         for (i = 1; i <= num; i++) {
801                 BUFFER_TRACE(where[i].bh, "call jbd2_journal_forget");
802                 ext4_journal_forget(handle, where[i].bh);
803                 ext4_free_blocks(handle, inode,
804                                         le32_to_cpu(where[i-1].key), 1, 0);
805         }
806         ext4_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks, 0);
807
808         return err;
809 }
810
811 /*
812  * Allocation strategy is simple: if we have to allocate something, we will
813  * have to go the whole way to leaf. So let's do it before attaching anything
814  * to tree, set linkage between the newborn blocks, write them if sync is
815  * required, recheck the path, free and repeat if check fails, otherwise
816  * set the last missing link (that will protect us from any truncate-generated
817  * removals - all blocks on the path are immune now) and possibly force the
818  * write on the parent block.
819  * That has a nice additional property: no special recovery from the failed
820  * allocations is needed - we simply release blocks and do not touch anything
821  * reachable from inode.
822  *
823  * `handle' can be NULL if create == 0.
824  *
825  * return > 0, # of blocks mapped or allocated.
826  * return = 0, if plain lookup failed.
827  * return < 0, error case.
828  *
829  *
830  * Need to be called with
831  * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
832  * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
833  */
834 int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
835                 ext4_lblk_t iblock, unsigned long maxblocks,
836                 struct buffer_head *bh_result,
837                 int create, int extend_disksize)
838 {
839         int err = -EIO;
840         ext4_lblk_t offsets[4];
841         Indirect chain[4];
842         Indirect *partial;
843         ext4_fsblk_t goal;
844         int indirect_blks;
845         int blocks_to_boundary = 0;
846         int depth;
847         struct ext4_inode_info *ei = EXT4_I(inode);
848         int count = 0;
849         ext4_fsblk_t first_block = 0;
850         loff_t disksize;
851
852
853         J_ASSERT(!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL));
854         J_ASSERT(handle != NULL || create == 0);
855         depth = ext4_block_to_path(inode, iblock, offsets,
856                                         &blocks_to_boundary);
857
858         if (depth == 0)
859                 goto out;
860
861         partial = ext4_get_branch(inode, depth, offsets, chain, &err);
862
863         /* Simplest case - block found, no allocation needed */
864         if (!partial) {
865                 first_block = le32_to_cpu(chain[depth - 1].key);
866                 clear_buffer_new(bh_result);
867                 count++;
868                 /*map more blocks*/
869                 while (count < maxblocks && count <= blocks_to_boundary) {
870                         ext4_fsblk_t blk;
871
872                         blk = le32_to_cpu(*(chain[depth-1].p + count));
873
874                         if (blk == first_block + count)
875                                 count++;
876                         else
877                                 break;
878                 }
879                 goto got_it;
880         }
881
882         /* Next simple case - plain lookup or failed read of indirect block */
883         if (!create || err == -EIO)
884                 goto cleanup;
885
886         /*
887          * Okay, we need to do block allocation.  Lazily initialize the block
888          * allocation info here if necessary
889         */
890         if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
891                 ext4_init_block_alloc_info(inode);
892
893         goal = ext4_find_goal(inode, iblock, partial);
894
895         /* the number of blocks need to allocate for [d,t]indirect blocks */
896         indirect_blks = (chain + depth) - partial - 1;
897
898         /*
899          * Next look up the indirect map to count the totoal number of
900          * direct blocks to allocate for this branch.
901          */
902         count = ext4_blks_to_allocate(partial, indirect_blks,
903                                         maxblocks, blocks_to_boundary);
904         /*
905          * Block out ext4_truncate while we alter the tree
906          */
907         err = ext4_alloc_branch(handle, inode, iblock, indirect_blks,
908                                         &count, goal,
909                                         offsets + (partial - chain), partial);
910
911         /*
912          * The ext4_splice_branch call will free and forget any buffers
913          * on the new chain if there is a failure, but that risks using
914          * up transaction credits, especially for bitmaps where the
915          * credits cannot be returned.  Can we handle this somehow?  We
916          * may need to return -EAGAIN upwards in the worst case.  --sct
917          */
918         if (!err)
919                 err = ext4_splice_branch(handle, inode, iblock,
920                                         partial, indirect_blks, count);
921         /*
922          * i_disksize growing is protected by i_data_sem.  Don't forget to
923          * protect it if you're about to implement concurrent
924          * ext4_get_block() -bzzz
925         */
926         if (!err && extend_disksize) {
927                 disksize = ((loff_t) iblock + count) << inode->i_blkbits;
928                 if (disksize > i_size_read(inode))
929                         disksize = i_size_read(inode);
930                 if (disksize > ei->i_disksize)
931                         ei->i_disksize = disksize;
932         }
933         if (err)
934                 goto cleanup;
935
936         set_buffer_new(bh_result);
937 got_it:
938         map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
939         if (count > blocks_to_boundary)
940                 set_buffer_boundary(bh_result);
941         err = count;
942         /* Clean up and exit */
943         partial = chain + depth - 1;    /* the whole chain */
944 cleanup:
945         while (partial > chain) {
946                 BUFFER_TRACE(partial->bh, "call brelse");
947                 brelse(partial->bh);
948                 partial--;
949         }
950         BUFFER_TRACE(bh_result, "returned");
951 out:
952         return err;
953 }
954
955 /* Maximum number of blocks we map for direct IO at once. */
956 #define DIO_MAX_BLOCKS 4096
957 /*
958  * Number of credits we need for writing DIO_MAX_BLOCKS:
959  * We need sb + group descriptor + bitmap + inode -> 4
960  * For B blocks with A block pointers per block we need:
961  * 1 (triple ind.) + (B/A/A + 2) (doubly ind.) + (B/A + 2) (indirect).
962  * If we plug in 4096 for B and 256 for A (for 1KB block size), we get 25.
963  */
964 #define DIO_CREDITS 25
965
966
967 /*
968  *
969  *
970  * ext4_ext4 get_block() wrapper function
971  * It will do a look up first, and returns if the blocks already mapped.
972  * Otherwise it takes the write lock of the i_data_sem and allocate blocks
973  * and store the allocated blocks in the result buffer head and mark it
974  * mapped.
975  *
976  * If file type is extents based, it will call ext4_ext_get_blocks(),
977  * Otherwise, call with ext4_get_blocks_handle() to handle indirect mapping
978  * based files
979  *
980  * On success, it returns the number of blocks being mapped or allocate.
981  * if create==0 and the blocks are pre-allocated and uninitialized block,
982  * the result buffer head is unmapped. If the create ==1, it will make sure
983  * the buffer head is mapped.
984  *
985  * It returns 0 if plain look up failed (blocks have not been allocated), in
986  * that casem, buffer head is unmapped
987  *
988  * It returns the error in case of allocation failure.
989  */
990 int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
991                         unsigned long max_blocks, struct buffer_head *bh,
992                         int create, int extend_disksize, int flag)
993 {
994         int retval;
995
996         clear_buffer_mapped(bh);
997
998         /*
999          * Try to see if we can get  the block without requesting
1000          * for new file system block.
1001          */
1002         down_read((&EXT4_I(inode)->i_data_sem));
1003         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
1004                 retval =  ext4_ext_get_blocks(handle, inode, block, max_blocks,
1005                                 bh, 0, 0);
1006         } else {
1007                 retval = ext4_get_blocks_handle(handle,
1008                                 inode, block, max_blocks, bh, 0, 0);
1009         }
1010         up_read((&EXT4_I(inode)->i_data_sem));
1011
1012         /* If it is only a block(s) look up */
1013         if (!create)
1014                 return retval;
1015
1016         /*
1017          * Returns if the blocks have already allocated
1018          *
1019          * Note that if blocks have been preallocated
1020          * ext4_ext_get_block() returns th create = 0
1021          * with buffer head unmapped.
1022          */
1023         if (retval > 0 && buffer_mapped(bh))
1024                 return retval;
1025
1026         /*
1027          * New blocks allocate and/or writing to uninitialized extent
1028          * will possibly result in updating i_data, so we take
1029          * the write lock of i_data_sem, and call get_blocks()
1030          * with create == 1 flag.
1031          */
1032         down_write((&EXT4_I(inode)->i_data_sem));
1033
1034         /*
1035          * if the caller is from delayed allocation writeout path
1036          * we have already reserved fs blocks for allocation
1037          * let the underlying get_block() function know to
1038          * avoid double accounting
1039          */
1040         if (flag)
1041                 EXT4_I(inode)->i_delalloc_reserved_flag = 1;
1042         /*
1043          * We need to check for EXT4 here because migrate
1044          * could have changed the inode type in between
1045          */
1046         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
1047                 retval =  ext4_ext_get_blocks(handle, inode, block, max_blocks,
1048                                 bh, create, extend_disksize);
1049         } else {
1050                 retval = ext4_get_blocks_handle(handle, inode, block,
1051                                 max_blocks, bh, create, extend_disksize);
1052
1053                 if (retval > 0 && buffer_new(bh)) {
1054                         /*
1055                          * We allocated new blocks which will result in
1056                          * i_data's format changing.  Force the migrate
1057                          * to fail by clearing migrate flags
1058                          */
1059                         EXT4_I(inode)->i_flags = EXT4_I(inode)->i_flags &
1060                                                         ~EXT4_EXT_MIGRATE;
1061                 }
1062         }
1063
1064         if (flag) {
1065                 EXT4_I(inode)->i_delalloc_reserved_flag = 0;
1066                 /*
1067                  * Update reserved blocks/metadata blocks
1068                  * after successful block allocation
1069                  * which were deferred till now
1070                  */
1071                 if ((retval > 0) && buffer_delay(bh))
1072                         ext4_da_release_space(inode, retval, 0);
1073         }
1074
1075         up_write((&EXT4_I(inode)->i_data_sem));
1076         return retval;
1077 }
1078
1079 static int ext4_get_block(struct inode *inode, sector_t iblock,
1080                         struct buffer_head *bh_result, int create)
1081 {
1082         handle_t *handle = ext4_journal_current_handle();
1083         int ret = 0, started = 0;
1084         unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
1085
1086         if (create && !handle) {
1087                 /* Direct IO write... */
1088                 if (max_blocks > DIO_MAX_BLOCKS)
1089                         max_blocks = DIO_MAX_BLOCKS;
1090                 handle = ext4_journal_start(inode, DIO_CREDITS +
1091                               2 * EXT4_QUOTA_TRANS_BLOCKS(inode->i_sb));
1092                 if (IS_ERR(handle)) {
1093                         ret = PTR_ERR(handle);
1094                         goto out;
1095                 }
1096                 started = 1;
1097         }
1098
1099         ret = ext4_get_blocks_wrap(handle, inode, iblock,
1100                                         max_blocks, bh_result, create, 0, 0);
1101         if (ret > 0) {
1102                 bh_result->b_size = (ret << inode->i_blkbits);
1103                 ret = 0;
1104         }
1105         if (started)
1106                 ext4_journal_stop(handle);
1107 out:
1108         return ret;
1109 }
1110
1111 /*
1112  * `handle' can be NULL if create is zero
1113  */
1114 struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
1115                                 ext4_lblk_t block, int create, int *errp)
1116 {
1117         struct buffer_head dummy;
1118         int fatal = 0, err;
1119
1120         J_ASSERT(handle != NULL || create == 0);
1121
1122         dummy.b_state = 0;
1123         dummy.b_blocknr = -1000;
1124         buffer_trace_init(&dummy.b_history);
1125         err = ext4_get_blocks_wrap(handle, inode, block, 1,
1126                                         &dummy, create, 1, 0);
1127         /*
1128          * ext4_get_blocks_handle() returns number of blocks
1129          * mapped. 0 in case of a HOLE.
1130          */
1131         if (err > 0) {
1132                 if (err > 1)
1133                         WARN_ON(1);
1134                 err = 0;
1135         }
1136         *errp = err;
1137         if (!err && buffer_mapped(&dummy)) {
1138                 struct buffer_head *bh;
1139                 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
1140                 if (!bh) {
1141                         *errp = -EIO;
1142                         goto err;
1143                 }
1144                 if (buffer_new(&dummy)) {
1145                         J_ASSERT(create != 0);
1146                         J_ASSERT(handle != NULL);
1147
1148                         /*
1149                          * Now that we do not always journal data, we should
1150                          * keep in mind whether this should always journal the
1151                          * new buffer as metadata.  For now, regular file
1152                          * writes use ext4_get_block instead, so it's not a
1153                          * problem.
1154                          */
1155                         lock_buffer(bh);
1156                         BUFFER_TRACE(bh, "call get_create_access");
1157                         fatal = ext4_journal_get_create_access(handle, bh);
1158                         if (!fatal && !buffer_uptodate(bh)) {
1159                                 memset(bh->b_data,0,inode->i_sb->s_blocksize);
1160                                 set_buffer_uptodate(bh);
1161                         }
1162                         unlock_buffer(bh);
1163                         BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata");
1164                         err = ext4_journal_dirty_metadata(handle, bh);
1165                         if (!fatal)
1166                                 fatal = err;
1167                 } else {
1168                         BUFFER_TRACE(bh, "not a new buffer");
1169                 }
1170                 if (fatal) {
1171                         *errp = fatal;
1172                         brelse(bh);
1173                         bh = NULL;
1174                 }
1175                 return bh;
1176         }
1177 err:
1178         return NULL;
1179 }
1180
1181 struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
1182                                ext4_lblk_t block, int create, int *err)
1183 {
1184         struct buffer_head * bh;
1185
1186         bh = ext4_getblk(handle, inode, block, create, err);
1187         if (!bh)
1188                 return bh;
1189         if (buffer_uptodate(bh))
1190                 return bh;
1191         ll_rw_block(READ_META, 1, &bh);
1192         wait_on_buffer(bh);
1193         if (buffer_uptodate(bh))
1194                 return bh;
1195         put_bh(bh);
1196         *err = -EIO;
1197         return NULL;
1198 }
1199
1200 static int walk_page_buffers(   handle_t *handle,
1201                                 struct buffer_head *head,
1202                                 unsigned from,
1203                                 unsigned to,
1204                                 int *partial,
1205                                 int (*fn)(      handle_t *handle,
1206                                                 struct buffer_head *bh))
1207 {
1208         struct buffer_head *bh;
1209         unsigned block_start, block_end;
1210         unsigned blocksize = head->b_size;
1211         int err, ret = 0;
1212         struct buffer_head *next;
1213
1214         for (   bh = head, block_start = 0;
1215                 ret == 0 && (bh != head || !block_start);
1216                 block_start = block_end, bh = next)
1217         {
1218                 next = bh->b_this_page;
1219                 block_end = block_start + blocksize;
1220                 if (block_end <= from || block_start >= to) {
1221                         if (partial && !buffer_uptodate(bh))
1222                                 *partial = 1;
1223                         continue;
1224                 }
1225                 err = (*fn)(handle, bh);
1226                 if (!ret)
1227                         ret = err;
1228         }
1229         return ret;
1230 }
1231
1232 /*
1233  * To preserve ordering, it is essential that the hole instantiation and
1234  * the data write be encapsulated in a single transaction.  We cannot
1235  * close off a transaction and start a new one between the ext4_get_block()
1236  * and the commit_write().  So doing the jbd2_journal_start at the start of
1237  * prepare_write() is the right place.
1238  *
1239  * Also, this function can nest inside ext4_writepage() ->
1240  * block_write_full_page(). In that case, we *know* that ext4_writepage()
1241  * has generated enough buffer credits to do the whole page.  So we won't
1242  * block on the journal in that case, which is good, because the caller may
1243  * be PF_MEMALLOC.
1244  *
1245  * By accident, ext4 can be reentered when a transaction is open via
1246  * quota file writes.  If we were to commit the transaction while thus
1247  * reentered, there can be a deadlock - we would be holding a quota
1248  * lock, and the commit would never complete if another thread had a
1249  * transaction open and was blocking on the quota lock - a ranking
1250  * violation.
1251  *
1252  * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
1253  * will _not_ run commit under these circumstances because handle->h_ref
1254  * is elevated.  We'll still have enough credits for the tiny quotafile
1255  * write.
1256  */
1257 static int do_journal_get_write_access(handle_t *handle,
1258                                         struct buffer_head *bh)
1259 {
1260         if (!buffer_mapped(bh) || buffer_freed(bh))
1261                 return 0;
1262         return ext4_journal_get_write_access(handle, bh);
1263 }
1264
1265 static int ext4_write_begin(struct file *file, struct address_space *mapping,
1266                                 loff_t pos, unsigned len, unsigned flags,
1267                                 struct page **pagep, void **fsdata)
1268 {
1269         struct inode *inode = mapping->host;
1270         int ret, needed_blocks = ext4_writepage_trans_blocks(inode);
1271         handle_t *handle;
1272         int retries = 0;
1273         struct page *page;
1274         pgoff_t index;
1275         unsigned from, to;
1276
1277         index = pos >> PAGE_CACHE_SHIFT;
1278         from = pos & (PAGE_CACHE_SIZE - 1);
1279         to = from + len;
1280
1281 retry:
1282         handle = ext4_journal_start(inode, needed_blocks);
1283         if (IS_ERR(handle)) {
1284                 ret = PTR_ERR(handle);
1285                 goto out;
1286         }
1287
1288         page = __grab_cache_page(mapping, index);
1289         if (!page) {
1290                 ext4_journal_stop(handle);
1291                 ret = -ENOMEM;
1292                 goto out;
1293         }
1294         *pagep = page;
1295
1296         ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
1297                                                         ext4_get_block);
1298
1299         if (!ret && ext4_should_journal_data(inode)) {
1300                 ret = walk_page_buffers(handle, page_buffers(page),
1301                                 from, to, NULL, do_journal_get_write_access);
1302         }
1303
1304         if (ret) {
1305                 unlock_page(page);
1306                 ext4_journal_stop(handle);
1307                 page_cache_release(page);
1308         }
1309
1310         if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
1311                 goto retry;
1312 out:
1313         return ret;
1314 }
1315
1316 /* For write_end() in data=journal mode */
1317 static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1318 {
1319         if (!buffer_mapped(bh) || buffer_freed(bh))
1320                 return 0;
1321         set_buffer_uptodate(bh);
1322         return ext4_journal_dirty_metadata(handle, bh);
1323 }
1324
1325 /*
1326  * We need to pick up the new inode size which generic_commit_write gave us
1327  * `file' can be NULL - eg, when called from page_symlink().
1328  *
1329  * ext4 never places buffers on inode->i_mapping->private_list.  metadata
1330  * buffers are managed internally.
1331  */
1332 static int ext4_ordered_write_end(struct file *file,
1333                                 struct address_space *mapping,
1334                                 loff_t pos, unsigned len, unsigned copied,
1335                                 struct page *page, void *fsdata)
1336 {
1337         handle_t *handle = ext4_journal_current_handle();
1338         struct inode *inode = mapping->host;
1339         unsigned from, to;
1340         int ret = 0, ret2;
1341
1342         from = pos & (PAGE_CACHE_SIZE - 1);
1343         to = from + len;
1344
1345         ret = ext4_jbd2_file_inode(handle, inode);
1346
1347         if (ret == 0) {
1348                 /*
1349                  * generic_write_end() will run mark_inode_dirty() if i_size
1350                  * changes.  So let's piggyback the i_disksize mark_inode_dirty
1351                  * into that.
1352                  */
1353                 loff_t new_i_size;
1354
1355                 new_i_size = pos + copied;
1356                 if (new_i_size > EXT4_I(inode)->i_disksize)
1357                         EXT4_I(inode)->i_disksize = new_i_size;
1358                 ret2 = generic_write_end(file, mapping, pos, len, copied,
1359                                                         page, fsdata);
1360                 copied = ret2;
1361                 if (ret2 < 0)
1362                         ret = ret2;
1363         }
1364         ret2 = ext4_journal_stop(handle);
1365         if (!ret)
1366                 ret = ret2;
1367
1368         return ret ? ret : copied;
1369 }
1370
1371 static int ext4_writeback_write_end(struct file *file,
1372                                 struct address_space *mapping,
1373                                 loff_t pos, unsigned len, unsigned copied,
1374                                 struct page *page, void *fsdata)
1375 {
1376         handle_t *handle = ext4_journal_current_handle();
1377         struct inode *inode = mapping->host;
1378         int ret = 0, ret2;
1379         loff_t new_i_size;
1380
1381         new_i_size = pos + copied;
1382         if (new_i_size > EXT4_I(inode)->i_disksize)
1383                 EXT4_I(inode)->i_disksize = new_i_size;
1384
1385         ret2 = generic_write_end(file, mapping, pos, len, copied,
1386                                                         page, fsdata);
1387         copied = ret2;
1388         if (ret2 < 0)
1389                 ret = ret2;
1390
1391         ret2 = ext4_journal_stop(handle);
1392         if (!ret)
1393                 ret = ret2;
1394
1395         return ret ? ret : copied;
1396 }
1397
1398 static int ext4_journalled_write_end(struct file *file,
1399                                 struct address_space *mapping,
1400                                 loff_t pos, unsigned len, unsigned copied,
1401                                 struct page *page, void *fsdata)
1402 {
1403         handle_t *handle = ext4_journal_current_handle();
1404         struct inode *inode = mapping->host;
1405         int ret = 0, ret2;
1406         int partial = 0;
1407         unsigned from, to;
1408
1409         from = pos & (PAGE_CACHE_SIZE - 1);
1410         to = from + len;
1411
1412         if (copied < len) {
1413                 if (!PageUptodate(page))
1414                         copied = 0;
1415                 page_zero_new_buffers(page, from+copied, to);
1416         }
1417
1418         ret = walk_page_buffers(handle, page_buffers(page), from,
1419                                 to, &partial, write_end_fn);
1420         if (!partial)
1421                 SetPageUptodate(page);
1422         if (pos+copied > inode->i_size)
1423                 i_size_write(inode, pos+copied);
1424         EXT4_I(inode)->i_state |= EXT4_STATE_JDATA;
1425         if (inode->i_size > EXT4_I(inode)->i_disksize) {
1426                 EXT4_I(inode)->i_disksize = inode->i_size;
1427                 ret2 = ext4_mark_inode_dirty(handle, inode);
1428                 if (!ret)
1429                         ret = ret2;
1430         }
1431
1432         unlock_page(page);
1433         ret2 = ext4_journal_stop(handle);
1434         if (!ret)
1435                 ret = ret2;
1436         page_cache_release(page);
1437
1438         return ret ? ret : copied;
1439 }
1440 /*
1441  * Calculate the number of metadata blocks need to reserve
1442  * to allocate @blocks for non extent file based file
1443  */
1444 static int ext4_indirect_calc_metadata_amount(struct inode *inode, int blocks)
1445 {
1446         int icap = EXT4_ADDR_PER_BLOCK(inode->i_sb);
1447         int ind_blks, dind_blks, tind_blks;
1448
1449         /* number of new indirect blocks needed */
1450         ind_blks = (blocks + icap - 1) / icap;
1451
1452         dind_blks = (ind_blks + icap - 1) / icap;
1453
1454         tind_blks = 1;
1455
1456         return ind_blks + dind_blks + tind_blks;
1457 }
1458
1459 /*
1460  * Calculate the number of metadata blocks need to reserve
1461  * to allocate given number of blocks
1462  */
1463 static int ext4_calc_metadata_amount(struct inode *inode, int blocks)
1464 {
1465         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)
1466                 return ext4_ext_calc_metadata_amount(inode, blocks);
1467
1468         return ext4_indirect_calc_metadata_amount(inode, blocks);
1469 }
1470
1471 static int ext4_da_reserve_space(struct inode *inode, int nrblocks)
1472 {
1473        struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1474        unsigned long md_needed, mdblocks, total = 0;
1475
1476         /*
1477          * recalculate the amount of metadata blocks to reserve
1478          * in order to allocate nrblocks
1479          * worse case is one extent per block
1480          */
1481         spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1482         total = EXT4_I(inode)->i_reserved_data_blocks + nrblocks;
1483         mdblocks = ext4_calc_metadata_amount(inode, total);
1484         BUG_ON(mdblocks < EXT4_I(inode)->i_reserved_meta_blocks);
1485
1486         md_needed = mdblocks - EXT4_I(inode)->i_reserved_meta_blocks;
1487         total = md_needed + nrblocks;
1488
1489         if (ext4_has_free_blocks(sbi, total) < total) {
1490                 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1491                 return -ENOSPC;
1492         }
1493
1494         /* reduce fs free blocks counter */
1495         percpu_counter_sub(&sbi->s_freeblocks_counter, total);
1496
1497         EXT4_I(inode)->i_reserved_data_blocks += nrblocks;
1498         EXT4_I(inode)->i_reserved_meta_blocks = mdblocks;
1499
1500         spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1501         return 0;       /* success */
1502 }
1503
1504 void ext4_da_release_space(struct inode *inode, int used, int to_free)
1505 {
1506         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1507         int total, mdb, mdb_free, release;
1508
1509         spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1510         /* recalculate the number of metablocks still need to be reserved */
1511         total = EXT4_I(inode)->i_reserved_data_blocks - used - to_free;
1512         mdb = ext4_calc_metadata_amount(inode, total);
1513
1514         /* figure out how many metablocks to release */
1515         BUG_ON(mdb > EXT4_I(inode)->i_reserved_meta_blocks);
1516         mdb_free = EXT4_I(inode)->i_reserved_meta_blocks - mdb;
1517
1518         /* Account for allocated meta_blocks */
1519         mdb_free -= EXT4_I(inode)->i_allocated_meta_blocks;
1520
1521         release = to_free + mdb_free;
1522
1523         /* update fs free blocks counter for truncate case */
1524         percpu_counter_add(&sbi->s_freeblocks_counter, release);
1525
1526         /* update per-inode reservations */
1527         BUG_ON(used + to_free > EXT4_I(inode)->i_reserved_data_blocks);
1528         EXT4_I(inode)->i_reserved_data_blocks -= (used + to_free);
1529
1530         BUG_ON(mdb > EXT4_I(inode)->i_reserved_meta_blocks);
1531         EXT4_I(inode)->i_reserved_meta_blocks = mdb;
1532         EXT4_I(inode)->i_allocated_meta_blocks = 0;
1533         spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1534 }
1535
1536 static void ext4_da_page_release_reservation(struct page *page,
1537                                                 unsigned long offset)
1538 {
1539         int to_release = 0;
1540         struct buffer_head *head, *bh;
1541         unsigned int curr_off = 0;
1542
1543         head = page_buffers(page);
1544         bh = head;
1545         do {
1546                 unsigned int next_off = curr_off + bh->b_size;
1547
1548                 if ((offset <= curr_off) && (buffer_delay(bh))) {
1549                         to_release++;
1550                         clear_buffer_delay(bh);
1551                 }
1552                 curr_off = next_off;
1553         } while ((bh = bh->b_this_page) != head);
1554         ext4_da_release_space(page->mapping->host, 0, to_release);
1555 }
1556
1557 /*
1558  * Delayed allocation stuff
1559  */
1560
1561 struct mpage_da_data {
1562         struct inode *inode;
1563         struct buffer_head lbh;                 /* extent of blocks */
1564         unsigned long first_page, next_page;    /* extent of pages */
1565         get_block_t *get_block;
1566         struct writeback_control *wbc;
1567 };
1568
1569 /*
1570  * mpage_da_submit_io - walks through extent of pages and try to write
1571  * them with __mpage_writepage()
1572  *
1573  * @mpd->inode: inode
1574  * @mpd->first_page: first page of the extent
1575  * @mpd->next_page: page after the last page of the extent
1576  * @mpd->get_block: the filesystem's block mapper function
1577  *
1578  * By the time mpage_da_submit_io() is called we expect all blocks
1579  * to be allocated. this may be wrong if allocation failed.
1580  *
1581  * As pages are already locked by write_cache_pages(), we can't use it
1582  */
1583 static int mpage_da_submit_io(struct mpage_da_data *mpd)
1584 {
1585         struct address_space *mapping = mpd->inode->i_mapping;
1586         struct mpage_data mpd_pp = {
1587                 .bio = NULL,
1588                 .last_block_in_bio = 0,
1589                 .get_block = mpd->get_block,
1590                 .use_writepage = 1,
1591         };
1592         int ret = 0, err, nr_pages, i;
1593         unsigned long index, end;
1594         struct pagevec pvec;
1595
1596         BUG_ON(mpd->next_page <= mpd->first_page);
1597
1598         pagevec_init(&pvec, 0);
1599         index = mpd->first_page;
1600         end = mpd->next_page - 1;
1601
1602         while (index <= end) {
1603                 /* XXX: optimize tail */
1604                 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1605                 if (nr_pages == 0)
1606                         break;
1607                 for (i = 0; i < nr_pages; i++) {
1608                         struct page *page = pvec.pages[i];
1609
1610                         index = page->index;
1611                         if (index > end)
1612                                 break;
1613                         index++;
1614
1615                         err = __mpage_writepage(page, mpd->wbc, &mpd_pp);
1616
1617                         /*
1618                          * In error case, we have to continue because
1619                          * remaining pages are still locked
1620                          * XXX: unlock and re-dirty them?
1621                          */
1622                         if (ret == 0)
1623                                 ret = err;
1624                 }
1625                 pagevec_release(&pvec);
1626         }
1627         if (mpd_pp.bio)
1628                 mpage_bio_submit(WRITE, mpd_pp.bio);
1629
1630         return ret;
1631 }
1632
1633 /*
1634  * mpage_put_bnr_to_bhs - walk blocks and assign them actual numbers
1635  *
1636  * @mpd->inode - inode to walk through
1637  * @exbh->b_blocknr - first block on a disk
1638  * @exbh->b_size - amount of space in bytes
1639  * @logical - first logical block to start assignment with
1640  *
1641  * the function goes through all passed space and put actual disk
1642  * block numbers into buffer heads, dropping BH_Delay
1643  */
1644 static void mpage_put_bnr_to_bhs(struct mpage_da_data *mpd, sector_t logical,
1645                                  struct buffer_head *exbh)
1646 {
1647         struct inode *inode = mpd->inode;
1648         struct address_space *mapping = inode->i_mapping;
1649         int blocks = exbh->b_size >> inode->i_blkbits;
1650         sector_t pblock = exbh->b_blocknr, cur_logical;
1651         struct buffer_head *head, *bh;
1652         unsigned long index, end;
1653         struct pagevec pvec;
1654         int nr_pages, i;
1655
1656         index = logical >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
1657         end = (logical + blocks - 1) >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
1658         cur_logical = index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
1659
1660         pagevec_init(&pvec, 0);
1661
1662         while (index <= end) {
1663                 /* XXX: optimize tail */
1664                 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1665                 if (nr_pages == 0)
1666                         break;
1667                 for (i = 0; i < nr_pages; i++) {
1668                         struct page *page = pvec.pages[i];
1669
1670                         index = page->index;
1671                         if (index > end)
1672                                 break;
1673                         index++;
1674
1675                         BUG_ON(!PageLocked(page));
1676                         BUG_ON(PageWriteback(page));
1677                         BUG_ON(!page_has_buffers(page));
1678
1679                         bh = page_buffers(page);
1680                         head = bh;
1681
1682                         /* skip blocks out of the range */
1683                         do {
1684                                 if (cur_logical >= logical)
1685                                         break;
1686                                 cur_logical++;
1687                         } while ((bh = bh->b_this_page) != head);
1688
1689                         do {
1690                                 if (cur_logical >= logical + blocks)
1691                                         break;
1692                                 if (buffer_delay(bh)) {
1693                                         bh->b_blocknr = pblock;
1694                                         clear_buffer_delay(bh);
1695                                 } else if (buffer_mapped(bh))
1696                                         BUG_ON(bh->b_blocknr != pblock);
1697
1698                                 cur_logical++;
1699                                 pblock++;
1700                         } while ((bh = bh->b_this_page) != head);
1701                 }
1702                 pagevec_release(&pvec);
1703         }
1704 }
1705
1706
1707 /*
1708  * __unmap_underlying_blocks - just a helper function to unmap
1709  * set of blocks described by @bh
1710  */
1711 static inline void __unmap_underlying_blocks(struct inode *inode,
1712                                              struct buffer_head *bh)
1713 {
1714         struct block_device *bdev = inode->i_sb->s_bdev;
1715         int blocks, i;
1716
1717         blocks = bh->b_size >> inode->i_blkbits;
1718         for (i = 0; i < blocks; i++)
1719                 unmap_underlying_metadata(bdev, bh->b_blocknr + i);
1720 }
1721
1722 /*
1723  * mpage_da_map_blocks - go through given space
1724  *
1725  * @mpd->lbh - bh describing space
1726  * @mpd->get_block - the filesystem's block mapper function
1727  *
1728  * The function skips space we know is already mapped to disk blocks.
1729  *
1730  * The function ignores errors ->get_block() returns, thus real
1731  * error handling is postponed to __mpage_writepage()
1732  */
1733 static void mpage_da_map_blocks(struct mpage_da_data *mpd)
1734 {
1735         struct buffer_head *lbh = &mpd->lbh;
1736         int err = 0, remain = lbh->b_size;
1737         sector_t next = lbh->b_blocknr;
1738         struct buffer_head new;
1739
1740         /*
1741          * We consider only non-mapped and non-allocated blocks
1742          */
1743         if (buffer_mapped(lbh) && !buffer_delay(lbh))
1744                 return;
1745
1746         while (remain) {
1747                 new.b_state = lbh->b_state;
1748                 new.b_blocknr = 0;
1749                 new.b_size = remain;
1750                 err = mpd->get_block(mpd->inode, next, &new, 1);
1751                 if (err) {
1752                         /*
1753                          * Rather than implement own error handling
1754                          * here, we just leave remaining blocks
1755                          * unallocated and try again with ->writepage()
1756                          */
1757                         break;
1758                 }
1759                 BUG_ON(new.b_size == 0);
1760
1761                 if (buffer_new(&new))
1762                         __unmap_underlying_blocks(mpd->inode, &new);
1763
1764                 /*
1765                  * If blocks are delayed marked, we need to
1766                  * put actual blocknr and drop delayed bit
1767                  */
1768                 if (buffer_delay(lbh))
1769                         mpage_put_bnr_to_bhs(mpd, next, &new);
1770
1771                 /* go for the remaining blocks */
1772                 next += new.b_size >> mpd->inode->i_blkbits;
1773                 remain -= new.b_size;
1774         }
1775 }
1776
1777 #define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | (1 << BH_Delay))
1778
1779 /*
1780  * mpage_add_bh_to_extent - try to add one more block to extent of blocks
1781  *
1782  * @mpd->lbh - extent of blocks
1783  * @logical - logical number of the block in the file
1784  * @bh - bh of the block (used to access block's state)
1785  *
1786  * the function is used to collect contig. blocks in same state
1787  */
1788 static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
1789                                    sector_t logical, struct buffer_head *bh)
1790 {
1791         struct buffer_head *lbh = &mpd->lbh;
1792         sector_t next;
1793
1794         next = lbh->b_blocknr + (lbh->b_size >> mpd->inode->i_blkbits);
1795
1796         /*
1797          * First block in the extent
1798          */
1799         if (lbh->b_size == 0) {
1800                 lbh->b_blocknr = logical;
1801                 lbh->b_size = bh->b_size;
1802                 lbh->b_state = bh->b_state & BH_FLAGS;
1803                 return;
1804         }
1805
1806         /*
1807          * Can we merge the block to our big extent?
1808          */
1809         if (logical == next && (bh->b_state & BH_FLAGS) == lbh->b_state) {
1810                 lbh->b_size += bh->b_size;
1811                 return;
1812         }
1813
1814         /*
1815          * We couldn't merge the block to our extent, so we
1816          * need to flush current  extent and start new one
1817          */
1818         mpage_da_map_blocks(mpd);
1819
1820         /*
1821          * Now start a new extent
1822          */
1823         lbh->b_size = bh->b_size;
1824         lbh->b_state = bh->b_state & BH_FLAGS;
1825         lbh->b_blocknr = logical;
1826 }
1827
1828 /*
1829  * __mpage_da_writepage - finds extent of pages and blocks
1830  *
1831  * @page: page to consider
1832  * @wbc: not used, we just follow rules
1833  * @data: context
1834  *
1835  * The function finds extents of pages and scan them for all blocks.
1836  */
1837 static int __mpage_da_writepage(struct page *page,
1838                                 struct writeback_control *wbc, void *data)
1839 {
1840         struct mpage_da_data *mpd = data;
1841         struct inode *inode = mpd->inode;
1842         struct buffer_head *bh, *head, fake;
1843         sector_t logical;
1844
1845         /*
1846          * Can we merge this page to current extent?
1847          */
1848         if (mpd->next_page != page->index) {
1849                 /*
1850                  * Nope, we can't. So, we map non-allocated blocks
1851                  * and start IO on them using __mpage_writepage()
1852                  */
1853                 if (mpd->next_page != mpd->first_page) {
1854                         mpage_da_map_blocks(mpd);
1855                         mpage_da_submit_io(mpd);
1856                 }
1857
1858                 /*
1859                  * Start next extent of pages ...
1860                  */
1861                 mpd->first_page = page->index;
1862
1863                 /*
1864                  * ... and blocks
1865                  */
1866                 mpd->lbh.b_size = 0;
1867                 mpd->lbh.b_state = 0;
1868                 mpd->lbh.b_blocknr = 0;
1869         }
1870
1871         mpd->next_page = page->index + 1;
1872         logical = (sector_t) page->index <<
1873                   (PAGE_CACHE_SHIFT - inode->i_blkbits);
1874
1875         if (!page_has_buffers(page)) {
1876                 /*
1877                  * There is no attached buffer heads yet (mmap?)
1878                  * we treat the page asfull of dirty blocks
1879                  */
1880                 bh = &fake;
1881                 bh->b_size = PAGE_CACHE_SIZE;
1882                 bh->b_state = 0;
1883                 set_buffer_dirty(bh);
1884                 set_buffer_uptodate(bh);
1885                 mpage_add_bh_to_extent(mpd, logical, bh);
1886         } else {
1887                 /*
1888                  * Page with regular buffer heads, just add all dirty ones
1889                  */
1890                 head = page_buffers(page);
1891                 bh = head;
1892                 do {
1893                         BUG_ON(buffer_locked(bh));
1894                         if (buffer_dirty(bh))
1895                                 mpage_add_bh_to_extent(mpd, logical, bh);
1896                         logical++;
1897                 } while ((bh = bh->b_this_page) != head);
1898         }
1899
1900         return 0;
1901 }
1902
1903 /*
1904  * mpage_da_writepages - walk the list of dirty pages of the given
1905  * address space, allocates non-allocated blocks, maps newly-allocated
1906  * blocks to existing bhs and issue IO them
1907  *
1908  * @mapping: address space structure to write
1909  * @wbc: subtract the number of written pages from *@wbc->nr_to_write
1910  * @get_block: the filesystem's block mapper function.
1911  *
1912  * This is a library function, which implements the writepages()
1913  * address_space_operation.
1914  *
1915  * In order to avoid duplication of logic that deals with partial pages,
1916  * multiple bio per page, etc, we find non-allocated blocks, allocate
1917  * them with minimal calls to ->get_block() and re-use __mpage_writepage()
1918  *
1919  * It's important that we call __mpage_writepage() only once for each
1920  * involved page, otherwise we'd have to implement more complicated logic
1921  * to deal with pages w/o PG_lock or w/ PG_writeback and so on.
1922  *
1923  * See comments to mpage_writepages()
1924  */
1925 static int mpage_da_writepages(struct address_space *mapping,
1926                                struct writeback_control *wbc,
1927                                get_block_t get_block)
1928 {
1929         struct mpage_da_data mpd;
1930         int ret;
1931
1932         if (!get_block)
1933                 return generic_writepages(mapping, wbc);
1934
1935         mpd.wbc = wbc;
1936         mpd.inode = mapping->host;
1937         mpd.lbh.b_size = 0;
1938         mpd.lbh.b_state = 0;
1939         mpd.lbh.b_blocknr = 0;
1940         mpd.first_page = 0;
1941         mpd.next_page = 0;
1942         mpd.get_block = get_block;
1943
1944         ret = write_cache_pages(mapping, wbc, __mpage_da_writepage, &mpd);
1945
1946         /*
1947          * Handle last extent of pages
1948          */
1949         if (mpd.next_page != mpd.first_page) {
1950                 mpage_da_map_blocks(&mpd);
1951                 mpage_da_submit_io(&mpd);
1952         }
1953
1954         return ret;
1955 }
1956
1957 /*
1958  * this is a special callback for ->write_begin() only
1959  * it's intention is to return mapped block or reserve space
1960  */
1961 static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
1962                                   struct buffer_head *bh_result, int create)
1963 {
1964         int ret = 0;
1965
1966         BUG_ON(create == 0);
1967         BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
1968
1969         /*
1970          * first, we need to know whether the block is allocated already
1971          * preallocated blocks are unmapped but should treated
1972          * the same as allocated blocks.
1973          */
1974         ret = ext4_get_blocks_wrap(NULL, inode, iblock, 1,  bh_result, 0, 0, 0);
1975         if ((ret == 0) && !buffer_delay(bh_result)) {
1976                 /* the block isn't (pre)allocated yet, let's reserve space */
1977                 /*
1978                  * XXX: __block_prepare_write() unmaps passed block,
1979                  * is it OK?
1980                  */
1981                 ret = ext4_da_reserve_space(inode, 1);
1982                 if (ret)
1983                         /* not enough space to reserve */
1984                         return ret;
1985
1986                 map_bh(bh_result, inode->i_sb, 0);
1987                 set_buffer_new(bh_result);
1988                 set_buffer_delay(bh_result);
1989         } else if (ret > 0) {
1990                 bh_result->b_size = (ret << inode->i_blkbits);
1991                 ret = 0;
1992         }
1993
1994         return ret;
1995 }
1996 #define         EXT4_DELALLOC_RSVED     1
1997 static int ext4_da_get_block_write(struct inode *inode, sector_t iblock,
1998                                    struct buffer_head *bh_result, int create)
1999 {
2000         int ret;
2001         unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
2002         loff_t disksize = EXT4_I(inode)->i_disksize;
2003         handle_t *handle = NULL;
2004
2005         handle = ext4_journal_current_handle();
2006         if (!handle) {
2007                 ret = ext4_get_blocks_wrap(handle, inode, iblock, max_blocks,
2008                                    bh_result, 0, 0, 0);
2009                 BUG_ON(!ret);
2010         } else {
2011                 ret = ext4_get_blocks_wrap(handle, inode, iblock, max_blocks,
2012                                    bh_result, create, 0, EXT4_DELALLOC_RSVED);
2013         }
2014
2015         if (ret > 0) {
2016                 bh_result->b_size = (ret << inode->i_blkbits);
2017
2018                 /*
2019                  * Update on-disk size along with block allocation
2020                  * we don't use 'extend_disksize' as size may change
2021                  * within already allocated block -bzzz
2022                  */
2023                 disksize = ((loff_t) iblock + ret) << inode->i_blkbits;
2024                 if (disksize > i_size_read(inode))
2025                         disksize = i_size_read(inode);
2026                 if (disksize > EXT4_I(inode)->i_disksize) {
2027                         /*
2028                          * XXX: replace with spinlock if seen contended -bzzz
2029                          */
2030                         down_write(&EXT4_I(inode)->i_data_sem);
2031                         if (disksize > EXT4_I(inode)->i_disksize)
2032                                 EXT4_I(inode)->i_disksize = disksize;
2033                         up_write(&EXT4_I(inode)->i_data_sem);
2034
2035                         if (EXT4_I(inode)->i_disksize == disksize) {
2036                                 ret = ext4_mark_inode_dirty(handle, inode);
2037                                 return ret;
2038                         }
2039                 }
2040                 ret = 0;
2041         }
2042         return ret;
2043 }
2044
2045 static int ext4_bh_unmapped_or_delay(handle_t *handle, struct buffer_head *bh)
2046 {
2047         /*
2048          * unmapped buffer is possible for holes.
2049          * delay buffer is possible with delayed allocation
2050          */
2051         return ((!buffer_mapped(bh) || buffer_delay(bh)) && buffer_dirty(bh));
2052 }
2053
2054 static int ext4_normal_get_block_write(struct inode *inode, sector_t iblock,
2055                                    struct buffer_head *bh_result, int create)
2056 {
2057         int ret = 0;
2058         unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
2059
2060         /*
2061          * we don't want to do block allocation in writepage
2062          * so call get_block_wrap with create = 0
2063          */
2064         ret = ext4_get_blocks_wrap(NULL, inode, iblock, max_blocks,
2065                                    bh_result, 0, 0, 0);
2066         if (ret > 0) {
2067                 bh_result->b_size = (ret << inode->i_blkbits);
2068                 ret = 0;
2069         }
2070         return ret;
2071 }
2072
2073 /*
2074  * get called vi ext4_da_writepages after taking page lock (have journal handle)
2075  * get called via journal_submit_inode_data_buffers (no journal handle)
2076  * get called via shrink_page_list via pdflush (no journal handle)
2077  * or grab_page_cache when doing write_begin (have journal handle)
2078  */
2079 static int ext4_da_writepage(struct page *page,
2080                                 struct writeback_control *wbc)
2081 {
2082         int ret = 0;
2083         loff_t size;
2084         unsigned long len;
2085         struct buffer_head *page_bufs;
2086         struct inode *inode = page->mapping->host;
2087
2088         size = i_size_read(inode);
2089         if (page->index == size >> PAGE_CACHE_SHIFT)
2090                 len = size & ~PAGE_CACHE_MASK;
2091         else
2092                 len = PAGE_CACHE_SIZE;
2093
2094         if (page_has_buffers(page)) {
2095                 page_bufs = page_buffers(page);
2096                 if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
2097                                         ext4_bh_unmapped_or_delay)) {
2098                         /*
2099                          * We don't want to do  block allocation
2100                          * So redirty the page and return
2101                          * We may reach here when we do a journal commit
2102                          * via journal_submit_inode_data_buffers.
2103                          * If we don't have mapping block we just ignore
2104                          * them. We can also reach here via shrink_page_list
2105                          */
2106                         redirty_page_for_writepage(wbc, page);
2107                         unlock_page(page);
2108                         return 0;
2109                 }
2110         } else {
2111                 /*
2112                  * The test for page_has_buffers() is subtle:
2113                  * We know the page is dirty but it lost buffers. That means
2114                  * that at some moment in time after write_begin()/write_end()
2115                  * has been called all buffers have been clean and thus they
2116                  * must have been written at least once. So they are all
2117                  * mapped and we can happily proceed with mapping them
2118                  * and writing the page.
2119                  *
2120                  * Try to initialize the buffer_heads and check whether
2121                  * all are mapped and non delay. We don't want to
2122                  * do block allocation here.
2123                  */
2124                 ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
2125                                                 ext4_normal_get_block_write);
2126                 if (!ret) {
2127                         page_bufs = page_buffers(page);
2128                         /* check whether all are mapped and non delay */
2129                         if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
2130                                                 ext4_bh_unmapped_or_delay)) {
2131                                 redirty_page_for_writepage(wbc, page);
2132                                 unlock_page(page);
2133                                 return 0;
2134                         }
2135                 } else {
2136                         /*
2137                          * We can't do block allocation here
2138                          * so just redity the page and unlock
2139                          * and return
2140                          */
2141                         redirty_page_for_writepage(wbc, page);
2142                         unlock_page(page);
2143                         return 0;
2144                 }
2145         }
2146
2147         if (test_opt(inode->i_sb, NOBH) && ext4_should_writeback_data(inode))
2148                 ret = nobh_writepage(page, ext4_normal_get_block_write, wbc);
2149         else
2150                 ret = block_write_full_page(page,
2151                                                 ext4_normal_get_block_write,
2152                                                 wbc);
2153
2154         return ret;
2155 }
2156
2157 /*
2158  * For now just follow the DIO way to estimate the max credits
2159  * needed to write out EXT4_MAX_WRITEBACK_PAGES.
2160  * todo: need to calculate the max credits need for
2161  * extent based files, currently the DIO credits is based on
2162  * indirect-blocks mapping way.
2163  *
2164  * Probably should have a generic way to calculate credits
2165  * for DIO, writepages, and truncate
2166  */
2167 #define EXT4_MAX_WRITEBACK_PAGES      DIO_MAX_BLOCKS
2168 #define EXT4_MAX_WRITEBACK_CREDITS    DIO_CREDITS
2169
2170 static int ext4_da_writepages(struct address_space *mapping,
2171                                 struct writeback_control *wbc)
2172 {
2173         struct inode *inode = mapping->host;
2174         handle_t *handle = NULL;
2175         int needed_blocks;
2176         int ret = 0;
2177         long to_write;
2178         loff_t range_start = 0;
2179
2180         /*
2181          * No pages to write? This is mainly a kludge to avoid starting
2182          * a transaction for special inodes like journal inode on last iput()
2183          * because that could violate lock ordering on umount
2184          */
2185         if (!mapping->nrpages)
2186                 return 0;
2187
2188         /*
2189          * Estimate the worse case needed credits to write out
2190          * EXT4_MAX_BUF_BLOCKS pages
2191          */
2192         needed_blocks = EXT4_MAX_WRITEBACK_CREDITS;
2193
2194         to_write = wbc->nr_to_write;
2195         if (!wbc->range_cyclic) {
2196                 /*
2197                  * If range_cyclic is not set force range_cont
2198                  * and save the old writeback_index
2199                  */
2200                 wbc->range_cont = 1;
2201                 range_start =  wbc->range_start;
2202         }
2203
2204         while (!ret && to_write) {
2205                 /* start a new transaction*/
2206                 handle = ext4_journal_start(inode, needed_blocks);
2207                 if (IS_ERR(handle)) {
2208                         ret = PTR_ERR(handle);
2209                         goto out_writepages;
2210                 }
2211                 if (ext4_should_order_data(inode)) {
2212                         /*
2213                          * With ordered mode we need to add
2214                          * the inode to the journal handle
2215                          * when we do block allocation.
2216                          */
2217                         ret = ext4_jbd2_file_inode(handle, inode);
2218                         if (ret) {
2219                                 ext4_journal_stop(handle);
2220                                 goto out_writepages;
2221                         }
2222
2223                 }
2224                 /*
2225                  * set the max dirty pages could be write at a time
2226                  * to fit into the reserved transaction credits
2227                  */
2228                 if (wbc->nr_to_write > EXT4_MAX_WRITEBACK_PAGES)
2229                         wbc->nr_to_write = EXT4_MAX_WRITEBACK_PAGES;
2230
2231                 to_write -= wbc->nr_to_write;
2232                 ret = mpage_da_writepages(mapping, wbc,
2233                                                 ext4_da_get_block_write);
2234                 ext4_journal_stop(handle);
2235                 if (wbc->nr_to_write) {
2236                         /*
2237                          * There is no more writeout needed
2238                          * or we requested for a noblocking writeout
2239                          * and we found the device congested
2240                          */
2241                         to_write += wbc->nr_to_write;
2242                         break;
2243                 }
2244                 wbc->nr_to_write = to_write;
2245         }
2246
2247 out_writepages:
2248         wbc->nr_to_write = to_write;
2249         if (range_start)
2250                 wbc->range_start = range_start;
2251         return ret;
2252 }
2253
2254 static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
2255                                 loff_t pos, unsigned len, unsigned flags,
2256                                 struct page **pagep, void **fsdata)
2257 {
2258         int ret, retries = 0;
2259         struct page *page;
2260         pgoff_t index;
2261         unsigned from, to;
2262         struct inode *inode = mapping->host;
2263         handle_t *handle;
2264
2265         index = pos >> PAGE_CACHE_SHIFT;
2266         from = pos & (PAGE_CACHE_SIZE - 1);
2267         to = from + len;
2268
2269 retry:
2270         /*
2271          * With delayed allocation, we don't log the i_disksize update
2272          * if there is delayed block allocation. But we still need
2273          * to journalling the i_disksize update if writes to the end
2274          * of file which has an already mapped buffer.
2275          */
2276         handle = ext4_journal_start(inode, 1);
2277         if (IS_ERR(handle)) {
2278                 ret = PTR_ERR(handle);
2279                 goto out;
2280         }
2281
2282         page = __grab_cache_page(mapping, index);
2283         if (!page)
2284                 return -ENOMEM;
2285         *pagep = page;
2286
2287         ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
2288                                                         ext4_da_get_block_prep);
2289         if (ret < 0) {
2290                 unlock_page(page);
2291                 ext4_journal_stop(handle);
2292                 page_cache_release(page);
2293         }
2294
2295         if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
2296                 goto retry;
2297 out:
2298         return ret;
2299 }
2300
2301 /*
2302  * Check if we should update i_disksize
2303  * when write to the end of file but not require block allocation
2304  */
2305 static int ext4_da_should_update_i_disksize(struct page *page,
2306                                          unsigned long offset)
2307 {
2308         struct buffer_head *bh;
2309         struct inode *inode = page->mapping->host;
2310         unsigned int idx;
2311         int i;
2312
2313         bh = page_buffers(page);
2314         idx = offset >> inode->i_blkbits;
2315
2316         for (i=0; i < idx; i++)
2317                 bh = bh->b_this_page;
2318
2319         if (!buffer_mapped(bh) || (buffer_delay(bh)))
2320                 return 0;
2321         return 1;
2322 }
2323
2324 static int ext4_da_write_end(struct file *file,
2325                                 struct address_space *mapping,
2326                                 loff_t pos, unsigned len, unsigned copied,
2327                                 struct page *page, void *fsdata)
2328 {
2329         struct inode *inode = mapping->host;
2330         int ret = 0, ret2;
2331         handle_t *handle = ext4_journal_current_handle();
2332         loff_t new_i_size;
2333         unsigned long start, end;
2334
2335         start = pos & (PAGE_CACHE_SIZE - 1);
2336         end = start + copied -1;
2337
2338         /*
2339          * generic_write_end() will run mark_inode_dirty() if i_size
2340          * changes.  So let's piggyback the i_disksize mark_inode_dirty
2341          * into that.
2342          */
2343
2344         new_i_size = pos + copied;
2345         if (new_i_size > EXT4_I(inode)->i_disksize) {
2346                 if (ext4_da_should_update_i_disksize(page, end)) {
2347                         down_write(&EXT4_I(inode)->i_data_sem);
2348                         if (new_i_size > EXT4_I(inode)->i_disksize) {
2349                                 /*
2350                                  * Updating i_disksize when extending file
2351                                  * without needing block allocation
2352                                  */
2353                                 if (ext4_should_order_data(inode))
2354                                         ret = ext4_jbd2_file_inode(handle,
2355                                                                    inode);
2356
2357                                 EXT4_I(inode)->i_disksize = new_i_size;
2358                         }
2359                         up_write(&EXT4_I(inode)->i_data_sem);
2360                 }
2361         }
2362         ret2 = generic_write_end(file, mapping, pos, len, copied,
2363                                                         page, fsdata);
2364         copied = ret2;
2365         if (ret2 < 0)
2366                 ret = ret2;
2367         ret2 = ext4_journal_stop(handle);
2368         if (!ret)
2369                 ret = ret2;
2370
2371         return ret ? ret : copied;
2372 }
2373
2374 static void ext4_da_invalidatepage(struct page *page, unsigned long offset)
2375 {
2376         /*
2377          * Drop reserved blocks
2378          */
2379         BUG_ON(!PageLocked(page));
2380         if (!page_has_buffers(page))
2381                 goto out;
2382
2383         ext4_da_page_release_reservation(page, offset);
2384
2385 out:
2386         ext4_invalidatepage(page, offset);
2387
2388         return;
2389 }
2390
2391
2392 /*
2393  * bmap() is special.  It gets used by applications such as lilo and by
2394  * the swapper to find the on-disk block of a specific piece of data.
2395  *
2396  * Naturally, this is dangerous if the block concerned is still in the
2397  * journal.  If somebody makes a swapfile on an ext4 data-journaling
2398  * filesystem and enables swap, then they may get a nasty shock when the
2399  * data getting swapped to that swapfile suddenly gets overwritten by
2400  * the original zero's written out previously to the journal and
2401  * awaiting writeback in the kernel's buffer cache.
2402  *
2403  * So, if we see any bmap calls here on a modified, data-journaled file,
2404  * take extra steps to flush any blocks which might be in the cache.
2405  */
2406 static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
2407 {
2408         struct inode *inode = mapping->host;
2409         journal_t *journal;
2410         int err;
2411
2412         if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) &&
2413                         test_opt(inode->i_sb, DELALLOC)) {
2414                 /*
2415                  * With delalloc we want to sync the file
2416                  * so that we can make sure we allocate
2417                  * blocks for file
2418                  */
2419                 filemap_write_and_wait(mapping);
2420         }
2421
2422         if (EXT4_I(inode)->i_state & EXT4_STATE_JDATA) {
2423                 /*
2424                  * This is a REALLY heavyweight approach, but the use of
2425                  * bmap on dirty files is expected to be extremely rare:
2426                  * only if we run lilo or swapon on a freshly made file
2427                  * do we expect this to happen.
2428                  *
2429                  * (bmap requires CAP_SYS_RAWIO so this does not
2430                  * represent an unprivileged user DOS attack --- we'd be
2431                  * in trouble if mortal users could trigger this path at
2432                  * will.)
2433                  *
2434                  * NB. EXT4_STATE_JDATA is not set on files other than
2435                  * regular files.  If somebody wants to bmap a directory
2436                  * or symlink and gets confused because the buffer
2437                  * hasn't yet been flushed to disk, they deserve
2438                  * everything they get.
2439                  */
2440
2441                 EXT4_I(inode)->i_state &= ~EXT4_STATE_JDATA;
2442                 journal = EXT4_JOURNAL(inode);
2443                 jbd2_journal_lock_updates(journal);
2444                 err = jbd2_journal_flush(journal);
2445                 jbd2_journal_unlock_updates(journal);
2446
2447                 if (err)
2448                         return 0;
2449         }
2450
2451         return generic_block_bmap(mapping,block,ext4_get_block);
2452 }
2453
2454 static int bget_one(handle_t *handle, struct buffer_head *bh)
2455 {
2456         get_bh(bh);
2457         return 0;
2458 }
2459
2460 static int bput_one(handle_t *handle, struct buffer_head *bh)
2461 {
2462         put_bh(bh);
2463         return 0;
2464 }
2465
2466 /*
2467  * Note that we don't need to start a transaction unless we're journaling data
2468  * because we should have holes filled from ext4_page_mkwrite(). We even don't
2469  * need to file the inode to the transaction's list in ordered mode because if
2470  * we are writing back data added by write(), the inode is already there and if
2471  * we are writing back data modified via mmap(), noone guarantees in which
2472  * transaction the data will hit the disk. In case we are journaling data, we
2473  * cannot start transaction directly because transaction start ranks above page
2474  * lock so we have to do some magic.
2475  *
2476  * In all journaling modes block_write_full_page() will start the I/O.
2477  *
2478  * Problem:
2479  *
2480  *      ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
2481  *              ext4_writepage()
2482  *
2483  * Similar for:
2484  *
2485  *      ext4_file_write() -> generic_file_write() -> __alloc_pages() -> ...
2486  *
2487  * Same applies to ext4_get_block().  We will deadlock on various things like
2488  * lock_journal and i_data_sem
2489  *
2490  * Setting PF_MEMALLOC here doesn't work - too many internal memory
2491  * allocations fail.
2492  *
2493  * 16May01: If we're reentered then journal_current_handle() will be
2494  *          non-zero. We simply *return*.
2495  *
2496  * 1 July 2001: @@@ FIXME:
2497  *   In journalled data mode, a data buffer may be metadata against the
2498  *   current transaction.  But the same file is part of a shared mapping
2499  *   and someone does a writepage() on it.
2500  *
2501  *   We will move the buffer onto the async_data list, but *after* it has
2502  *   been dirtied. So there's a small window where we have dirty data on
2503  *   BJ_Metadata.
2504  *
2505  *   Note that this only applies to the last partial page in the file.  The
2506  *   bit which block_write_full_page() uses prepare/commit for.  (That's
2507  *   broken code anyway: it's wrong for msync()).
2508  *
2509  *   It's a rare case: affects the final partial page, for journalled data
2510  *   where the file is subject to bith write() and writepage() in the same
2511  *   transction.  To fix it we'll need a custom block_write_full_page().
2512  *   We'll probably need that anyway for journalling writepage() output.
2513  *
2514  * We don't honour synchronous mounts for writepage().  That would be
2515  * disastrous.  Any write() or metadata operation will sync the fs for
2516  * us.
2517  *
2518  */
2519 static int __ext4_normal_writepage(struct page *page,
2520                                 struct writeback_control *wbc)
2521 {
2522         struct inode *inode = page->mapping->host;
2523
2524         if (test_opt(inode->i_sb, NOBH))
2525                 return nobh_writepage(page,
2526                                         ext4_normal_get_block_write, wbc);
2527         else
2528                 return block_write_full_page(page,
2529                                                 ext4_normal_get_block_write,
2530                                                 wbc);
2531 }
2532
2533 static int ext4_normal_writepage(struct page *page,
2534                                 struct writeback_control *wbc)
2535 {
2536         struct inode *inode = page->mapping->host;
2537         loff_t size = i_size_read(inode);
2538         loff_t len;
2539
2540         J_ASSERT(PageLocked(page));
2541         if (page->index == size >> PAGE_CACHE_SHIFT)
2542                 len = size & ~PAGE_CACHE_MASK;
2543         else
2544                 len = PAGE_CACHE_SIZE;
2545
2546         if (page_has_buffers(page)) {
2547                 /* if page has buffers it should all be mapped
2548                  * and allocated. If there are not buffers attached
2549                  * to the page we know the page is dirty but it lost
2550                  * buffers. That means that at some moment in time
2551                  * after write_begin() / write_end() has been called
2552                  * all buffers have been clean and thus they must have been
2553                  * written at least once. So they are all mapped and we can
2554                  * happily proceed with mapping them and writing the page.
2555                  */
2556                 BUG_ON(walk_page_buffers(NULL, page_buffers(page), 0, len, NULL,
2557                                         ext4_bh_unmapped_or_delay));
2558         }
2559
2560         if (!ext4_journal_current_handle())
2561                 return __ext4_normal_writepage(page, wbc);
2562
2563         redirty_page_for_writepage(wbc, page);
2564         unlock_page(page);
2565         return 0;
2566 }
2567
2568 static int __ext4_journalled_writepage(struct page *page,
2569                                 struct writeback_control *wbc)
2570 {
2571         struct address_space *mapping = page->mapping;
2572         struct inode *inode = mapping->host;
2573         struct buffer_head *page_bufs;
2574         handle_t *handle = NULL;
2575         int ret = 0;
2576         int err;
2577
2578         ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
2579                                         ext4_normal_get_block_write);
2580         if (ret != 0)
2581                 goto out_unlock;
2582
2583         page_bufs = page_buffers(page);
2584         walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE, NULL,
2585                                                                 bget_one);
2586         /* As soon as we unlock the page, it can go away, but we have
2587          * references to buffers so we are safe */
2588         unlock_page(page);
2589
2590         handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
2591         if (IS_ERR(handle)) {
2592                 ret = PTR_ERR(handle);
2593                 goto out;
2594         }
2595
2596         ret = walk_page_buffers(handle, page_bufs, 0,
2597                         PAGE_CACHE_SIZE, NULL, do_journal_get_write_access);
2598
2599         err = walk_page_buffers(handle, page_bufs, 0,
2600                                 PAGE_CACHE_SIZE, NULL, write_end_fn);
2601         if (ret == 0)
2602                 ret = err;
2603         err = ext4_journal_stop(handle);
2604         if (!ret)
2605                 ret = err;
2606
2607         walk_page_buffers(handle, page_bufs, 0,
2608                                 PAGE_CACHE_SIZE, NULL, bput_one);
2609         EXT4_I(inode)->i_state |= EXT4_STATE_JDATA;
2610         goto out;
2611
2612 out_unlock:
2613         unlock_page(page);
2614 out:
2615         return ret;
2616 }
2617
2618 static int ext4_journalled_writepage(struct page *page,
2619                                 struct writeback_control *wbc)
2620 {
2621         struct inode *inode = page->mapping->host;
2622         loff_t size = i_size_read(inode);
2623         loff_t len;
2624
2625         J_ASSERT(PageLocked(page));
2626         if (page->index == size >> PAGE_CACHE_SHIFT)
2627                 len = size & ~PAGE_CACHE_MASK;
2628         else
2629                 len = PAGE_CACHE_SIZE;
2630
2631         if (page_has_buffers(page)) {
2632                 /* if page has buffers it should all be mapped
2633                  * and allocated. If there are not buffers attached
2634                  * to the page we know the page is dirty but it lost
2635                  * buffers. That means that at some moment in time
2636                  * after write_begin() / write_end() has been called
2637                  * all buffers have been clean and thus they must have been
2638                  * written at least once. So they are all mapped and we can
2639                  * happily proceed with mapping them and writing the page.
2640                  */
2641                 BUG_ON(walk_page_buffers(NULL, page_buffers(page), 0, len, NULL,
2642                                         ext4_bh_unmapped_or_delay));
2643         }
2644
2645         if (ext4_journal_current_handle())
2646                 goto no_write;
2647
2648         if (PageChecked(page)) {
2649                 /*
2650                  * It's mmapped pagecache.  Add buffers and journal it.  There
2651                  * doesn't seem much point in redirtying the page here.
2652                  */
2653                 ClearPageChecked(page);
2654                 return __ext4_journalled_writepage(page, wbc);
2655         } else {
2656                 /*
2657                  * It may be a page full of checkpoint-mode buffers.  We don't
2658                  * really know unless we go poke around in the buffer_heads.
2659                  * But block_write_full_page will do the right thing.
2660                  */
2661                 return block_write_full_page(page,
2662                                                 ext4_normal_get_block_write,
2663                                                 wbc);
2664         }
2665 no_write:
2666         redirty_page_for_writepage(wbc, page);
2667         unlock_page(page);
2668         return 0;
2669 }
2670
2671 static int ext4_readpage(struct file *file, struct page *page)
2672 {
2673         return mpage_readpage(page, ext4_get_block);
2674 }
2675
2676 static int
2677 ext4_readpages(struct file *file, struct address_space *mapping,
2678                 struct list_head *pages, unsigned nr_pages)
2679 {
2680         return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
2681 }
2682
2683 static void ext4_invalidatepage(struct page *page, unsigned long offset)
2684 {
2685         journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2686
2687         /*
2688          * If it's a full truncate we just forget about the pending dirtying
2689          */
2690         if (offset == 0)
2691                 ClearPageChecked(page);
2692
2693         jbd2_journal_invalidatepage(journal, page, offset);
2694 }
2695
2696 static int ext4_releasepage(struct page *page, gfp_t wait)
2697 {
2698         journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2699
2700         WARN_ON(PageChecked(page));
2701         if (!page_has_buffers(page))
2702                 return 0;
2703         return jbd2_journal_try_to_free_buffers(journal, page, wait);
2704 }
2705
2706 /*
2707  * If the O_DIRECT write will extend the file then add this inode to the
2708  * orphan list.  So recovery will truncate it back to the original size
2709  * if the machine crashes during the write.
2710  *
2711  * If the O_DIRECT write is intantiating holes inside i_size and the machine
2712  * crashes then stale disk data _may_ be exposed inside the file. But current
2713  * VFS code falls back into buffered path in that case so we are safe.
2714  */
2715 static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
2716                         const struct iovec *iov, loff_t offset,
2717                         unsigned long nr_segs)
2718 {
2719         struct file *file = iocb->ki_filp;
2720         struct inode *inode = file->f_mapping->host;
2721         struct ext4_inode_info *ei = EXT4_I(inode);
2722         handle_t *handle;
2723         ssize_t ret;
2724         int orphan = 0;
2725         size_t count = iov_length(iov, nr_segs);
2726
2727         if (rw == WRITE) {
2728                 loff_t final_size = offset + count;
2729
2730                 if (final_size > inode->i_size) {
2731                         /* Credits for sb + inode write */
2732                         handle = ext4_journal_start(inode, 2);
2733                         if (IS_ERR(handle)) {
2734                                 ret = PTR_ERR(handle);
2735                                 goto out;
2736                         }
2737                         ret = ext4_orphan_add(handle, inode);
2738                         if (ret) {
2739                                 ext4_journal_stop(handle);
2740                                 goto out;
2741                         }
2742                         orphan = 1;
2743                         ei->i_disksize = inode->i_size;
2744                         ext4_journal_stop(handle);
2745                 }
2746         }
2747
2748         ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
2749                                  offset, nr_segs,
2750                                  ext4_get_block, NULL);
2751
2752         if (orphan) {
2753                 int err;
2754
2755                 /* Credits for sb + inode write */
2756                 handle = ext4_journal_start(inode, 2);
2757                 if (IS_ERR(handle)) {
2758                         /* This is really bad luck. We've written the data
2759                          * but cannot extend i_size. Bail out and pretend
2760                          * the write failed... */
2761                         ret = PTR_ERR(handle);
2762                         goto out;
2763                 }
2764                 if (inode->i_nlink)
2765                         ext4_orphan_del(handle, inode);
2766                 if (ret > 0) {
2767                         loff_t end = offset + ret;
2768                         if (end > inode->i_size) {
2769                                 ei->i_disksize = end;
2770                                 i_size_write(inode, end);
2771                                 /*
2772                                  * We're going to return a positive `ret'
2773                                  * here due to non-zero-length I/O, so there's
2774                                  * no way of reporting error returns from
2775                                  * ext4_mark_inode_dirty() to userspace.  So
2776                                  * ignore it.
2777                                  */
2778                                 ext4_mark_inode_dirty(handle, inode);
2779                         }
2780                 }
2781                 err = ext4_journal_stop(handle);
2782                 if (ret == 0)
2783                         ret = err;
2784         }
2785 out:
2786         return ret;
2787 }
2788
2789 /*
2790  * Pages can be marked dirty completely asynchronously from ext4's journalling
2791  * activity.  By filemap_sync_pte(), try_to_unmap_one(), etc.  We cannot do
2792  * much here because ->set_page_dirty is called under VFS locks.  The page is
2793  * not necessarily locked.
2794  *
2795  * We cannot just dirty the page and leave attached buffers clean, because the
2796  * buffers' dirty state is "definitive".  We cannot just set the buffers dirty
2797  * or jbddirty because all the journalling code will explode.
2798  *
2799  * So what we do is to mark the page "pending dirty" and next time writepage
2800  * is called, propagate that into the buffers appropriately.
2801  */
2802 static int ext4_journalled_set_page_dirty(struct page *page)
2803 {
2804         SetPageChecked(page);
2805         return __set_page_dirty_nobuffers(page);
2806 }
2807
2808 static const struct address_space_operations ext4_ordered_aops = {
2809         .readpage       = ext4_readpage,
2810         .readpages      = ext4_readpages,
2811         .writepage      = ext4_normal_writepage,
2812         .sync_page      = block_sync_page,
2813         .write_begin    = ext4_write_begin,
2814         .write_end      = ext4_ordered_write_end,
2815         .bmap           = ext4_bmap,
2816         .invalidatepage = ext4_invalidatepage,
2817         .releasepage    = ext4_releasepage,
2818         .direct_IO      = ext4_direct_IO,
2819         .migratepage    = buffer_migrate_page,
2820 };
2821
2822 static const struct address_space_operations ext4_writeback_aops = {
2823         .readpage       = ext4_readpage,
2824         .readpages      = ext4_readpages,
2825         .writepage      = ext4_normal_writepage,
2826         .sync_page      = block_sync_page,
2827         .write_begin    = ext4_write_begin,
2828         .write_end      = ext4_writeback_write_end,
2829         .bmap           = ext4_bmap,
2830         .invalidatepage = ext4_invalidatepage,
2831         .releasepage    = ext4_releasepage,
2832         .direct_IO      = ext4_direct_IO,
2833         .migratepage    = buffer_migrate_page,
2834 };
2835
2836 static const struct address_space_operations ext4_journalled_aops = {
2837         .readpage       = ext4_readpage,
2838         .readpages      = ext4_readpages,
2839         .writepage      = ext4_journalled_writepage,
2840         .sync_page      = block_sync_page,
2841         .write_begin    = ext4_write_begin,
2842         .write_end      = ext4_journalled_write_end,
2843         .set_page_dirty = ext4_journalled_set_page_dirty,
2844         .bmap           = ext4_bmap,
2845         .invalidatepage = ext4_invalidatepage,
2846         .releasepage    = ext4_releasepage,
2847 };
2848
2849 static const struct address_space_operations ext4_da_aops = {
2850         .readpage       = ext4_readpage,
2851         .readpages      = ext4_readpages,
2852         .writepage      = ext4_da_writepage,
2853         .writepages     = ext4_da_writepages,
2854         .sync_page      = block_sync_page,
2855         .write_begin    = ext4_da_write_begin,
2856         .write_end      = ext4_da_write_end,
2857         .bmap           = ext4_bmap,
2858         .invalidatepage = ext4_da_invalidatepage,
2859         .releasepage    = ext4_releasepage,
2860         .direct_IO      = ext4_direct_IO,
2861         .migratepage    = buffer_migrate_page,
2862 };
2863
2864 void ext4_set_aops(struct inode *inode)
2865 {
2866         if (ext4_should_order_data(inode) &&
2867                 test_opt(inode->i_sb, DELALLOC))
2868                 inode->i_mapping->a_ops = &ext4_da_aops;
2869         else if (ext4_should_order_data(inode))
2870                 inode->i_mapping->a_ops = &ext4_ordered_aops;
2871         else if (ext4_should_writeback_data(inode) &&
2872                  test_opt(inode->i_sb, DELALLOC))
2873                 inode->i_mapping->a_ops = &ext4_da_aops;
2874         else if (ext4_should_writeback_data(inode))
2875                 inode->i_mapping->a_ops = &ext4_writeback_aops;
2876         else
2877                 inode->i_mapping->a_ops = &ext4_journalled_aops;
2878 }
2879
2880 /*
2881  * ext4_block_truncate_page() zeroes out a mapping from file offset `from'
2882  * up to the end of the block which corresponds to `from'.
2883  * This required during truncate. We need to physically zero the tail end
2884  * of that block so it doesn't yield old data if the file is later grown.
2885  */
2886 int ext4_block_truncate_page(handle_t *handle,
2887                 struct address_space *mapping, loff_t from)
2888 {
2889         ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT;
2890         unsigned offset = from & (PAGE_CACHE_SIZE-1);
2891         unsigned blocksize, length, pos;
2892         ext4_lblk_t iblock;
2893         struct inode *inode = mapping->host;
2894         struct buffer_head *bh;
2895         struct page *page;
2896         int err = 0;
2897
2898         page = grab_cache_page(mapping, from >> PAGE_CACHE_SHIFT);
2899         if (!page)
2900                 return -EINVAL;
2901
2902         blocksize = inode->i_sb->s_blocksize;
2903         length = blocksize - (offset & (blocksize - 1));
2904         iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
2905
2906         /*
2907          * For "nobh" option,  we can only work if we don't need to
2908          * read-in the page - otherwise we create buffers to do the IO.
2909          */
2910         if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
2911              ext4_should_writeback_data(inode) && PageUptodate(page)) {
2912                 zero_user(page, offset, length);
2913                 set_page_dirty(page);
2914                 goto unlock;
2915         }
2916
2917         if (!page_has_buffers(page))
2918                 create_empty_buffers(page, blocksize, 0);
2919
2920         /* Find the buffer that contains "offset" */
2921         bh = page_buffers(page);
2922         pos = blocksize;
2923         while (offset >= pos) {
2924                 bh = bh->b_this_page;
2925                 iblock++;
2926                 pos += blocksize;
2927         }
2928
2929         err = 0;
2930         if (buffer_freed(bh)) {
2931                 BUFFER_TRACE(bh, "freed: skip");
2932                 goto unlock;
2933         }
2934
2935         if (!buffer_mapped(bh)) {
2936                 BUFFER_TRACE(bh, "unmapped");
2937                 ext4_get_block(inode, iblock, bh, 0);
2938                 /* unmapped? It's a hole - nothing to do */
2939                 if (!buffer_mapped(bh)) {
2940                         BUFFER_TRACE(bh, "still unmapped");
2941                         goto unlock;
2942                 }
2943         }
2944
2945         /* Ok, it's mapped. Make sure it's up-to-date */
2946         if (PageUptodate(page))
2947                 set_buffer_uptodate(bh);
2948
2949         if (!buffer_uptodate(bh)) {
2950                 err = -EIO;
2951                 ll_rw_block(READ, 1, &bh);
2952                 wait_on_buffer(bh);
2953                 /* Uhhuh. Read error. Complain and punt. */
2954                 if (!buffer_uptodate(bh))
2955                         goto unlock;
2956         }
2957
2958         if (ext4_should_journal_data(inode)) {
2959                 BUFFER_TRACE(bh, "get write access");
2960                 err = ext4_journal_get_write_access(handle, bh);
2961                 if (err)
2962                         goto unlock;
2963         }
2964
2965         zero_user(page, offset, length);
2966
2967         BUFFER_TRACE(bh, "zeroed end of block");
2968
2969         err = 0;
2970         if (ext4_should_journal_data(inode)) {
2971                 err = ext4_journal_dirty_metadata(handle, bh);
2972         } else {
2973                 if (ext4_should_order_data(inode))
2974                         err = ext4_jbd2_file_inode(handle, inode);
2975                 mark_buffer_dirty(bh);
2976         }
2977
2978 unlock:
2979         unlock_page(page);
2980         page_cache_release(page);
2981         return err;
2982 }
2983
2984 /*
2985  * Probably it should be a library function... search for first non-zero word
2986  * or memcmp with zero_page, whatever is better for particular architecture.
2987  * Linus?
2988  */
2989 static inline int all_zeroes(__le32 *p, __le32 *q)
2990 {
2991         while (p < q)
2992                 if (*p++)
2993                         return 0;
2994         return 1;
2995 }
2996
2997 /**
2998  *      ext4_find_shared - find the indirect blocks for partial truncation.
2999  *      @inode:   inode in question
3000  *      @depth:   depth of the affected branch
3001  *      @offsets: offsets of pointers in that branch (see ext4_block_to_path)
3002  *      @chain:   place to store the pointers to partial indirect blocks
3003  *      @top:     place to the (detached) top of branch
3004  *
3005  *      This is a helper function used by ext4_truncate().
3006  *
3007  *      When we do truncate() we may have to clean the ends of several
3008  *      indirect blocks but leave the blocks themselves alive. Block is
3009  *      partially truncated if some data below the new i_size is refered
3010  *      from it (and it is on the path to the first completely truncated
3011  *      data block, indeed).  We have to free the top of that path along
3012  *      with everything to the right of the path. Since no allocation
3013  *      past the truncation point is possible until ext4_truncate()
3014  *      finishes, we may safely do the latter, but top of branch may
3015  *      require special attention - pageout below the truncation point
3016  *      might try to populate it.
3017  *
3018  *      We atomically detach the top of branch from the tree, store the
3019  *      block number of its root in *@top, pointers to buffer_heads of
3020  *      partially truncated blocks - in @chain[].bh and pointers to
3021  *      their last elements that should not be removed - in
3022  *      @chain[].p. Return value is the pointer to last filled element
3023  *      of @chain.
3024  *
3025  *      The work left to caller to do the actual freeing of subtrees:
3026  *              a) free the subtree starting from *@top
3027  *              b) free the subtrees whose roots are stored in
3028  *                      (@chain[i].p+1 .. end of @chain[i].bh->b_data)
3029  *              c) free the subtrees growing from the inode past the @chain[0].
3030  *                      (no partially truncated stuff there).  */
3031
3032 static Indirect *ext4_find_shared(struct inode *inode, int depth,
3033                         ext4_lblk_t offsets[4], Indirect chain[4], __le32 *top)
3034 {
3035         Indirect *partial, *p;
3036         int k, err;
3037
3038         *top = 0;
3039         /* Make k index the deepest non-null offest + 1 */
3040         for (k = depth; k > 1 && !offsets[k-1]; k--)
3041                 ;
3042         partial = ext4_get_branch(inode, k, offsets, chain, &err);
3043         /* Writer: pointers */
3044         if (!partial)
3045                 partial = chain + k-1;
3046         /*
3047          * If the branch acquired continuation since we've looked at it -
3048          * fine, it should all survive and (new) top doesn't belong to us.
3049          */
3050         if (!partial->key && *partial->p)
3051                 /* Writer: end */
3052                 goto no_top;
3053         for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
3054                 ;
3055         /*
3056          * OK, we've found the last block that must survive. The rest of our
3057          * branch should be detached before unlocking. However, if that rest
3058          * of branch is all ours and does not grow immediately from the inode
3059          * it's easier to cheat and just decrement partial->p.
3060          */
3061         if (p == chain + k - 1 && p > chain) {
3062                 p->p--;
3063         } else {
3064                 *top = *p->p;
3065                 /* Nope, don't do this in ext4.  Must leave the tree intact */
3066 #if 0
3067                 *p->p = 0;
3068 #endif
3069         }
3070         /* Writer: end */
3071
3072         while(partial > p) {
3073                 brelse(partial->bh);
3074                 partial--;
3075         }
3076 no_top:
3077         return partial;
3078 }
3079
3080 /*
3081  * Zero a number of block pointers in either an inode or an indirect block.
3082  * If we restart the transaction we must again get write access to the
3083  * indirect block for further modification.
3084  *
3085  * We release `count' blocks on disk, but (last - first) may be greater
3086  * than `count' because there can be holes in there.
3087  */
3088 static void ext4_clear_blocks(handle_t *handle, struct inode *inode,
3089                 struct buffer_head *bh, ext4_fsblk_t block_to_free,
3090                 unsigned long count, __le32 *first, __le32 *last)
3091 {
3092         __le32 *p;
3093         if (try_to_extend_transaction(handle, inode)) {
3094                 if (bh) {
3095                         BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata");
3096                         ext4_journal_dirty_metadata(handle, bh);
3097                 }
3098                 ext4_mark_inode_dirty(handle, inode);
3099                 ext4_journal_test_restart(handle, inode);
3100                 if (bh) {
3101                         BUFFER_TRACE(bh, "retaking write access");
3102                         ext4_journal_get_write_access(handle, bh);
3103                 }
3104         }
3105
3106         /*
3107          * Any buffers which are on the journal will be in memory. We find
3108          * them on the hash table so jbd2_journal_revoke() will run jbd2_journal_forget()
3109          * on them.  We've already detached each block from the file, so
3110          * bforget() in jbd2_journal_forget() should be safe.
3111          *
3112          * AKPM: turn on bforget in jbd2_journal_forget()!!!
3113          */
3114         for (p = first; p < last; p++) {
3115                 u32 nr = le32_to_cpu(*p);
3116                 if (nr) {
3117                         struct buffer_head *tbh;
3118
3119                         *p = 0;
3120                         tbh = sb_find_get_block(inode->i_sb, nr);
3121                         ext4_forget(handle, 0, inode, tbh, nr);
3122                 }
3123         }
3124
3125         ext4_free_blocks(handle, inode, block_to_free, count, 0);
3126 }
3127
3128 /**
3129  * ext4_free_data - free a list of data blocks
3130  * @handle:     handle for this transaction
3131  * @inode:      inode we are dealing with
3132  * @this_bh:    indirect buffer_head which contains *@first and *@last
3133  * @first:      array of block numbers
3134  * @last:       points immediately past the end of array
3135  *
3136  * We are freeing all blocks refered from that array (numbers are stored as
3137  * little-endian 32-bit) and updating @inode->i_blocks appropriately.
3138  *
3139  * We accumulate contiguous runs of blocks to free.  Conveniently, if these
3140  * blocks are contiguous then releasing them at one time will only affect one
3141  * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
3142  * actually use a lot of journal space.
3143  *
3144  * @this_bh will be %NULL if @first and @last point into the inode's direct
3145  * block pointers.
3146  */
3147 static void ext4_free_data(handle_t *handle, struct inode *inode,
3148                            struct buffer_head *this_bh,
3149                            __le32 *first, __le32 *last)
3150 {
3151         ext4_fsblk_t block_to_free = 0;    /* Starting block # of a run */
3152         unsigned long count = 0;            /* Number of blocks in the run */
3153         __le32 *block_to_free_p = NULL;     /* Pointer into inode/ind
3154                                                corresponding to
3155                                                block_to_free */
3156         ext4_fsblk_t nr;                    /* Current block # */
3157         __le32 *p;                          /* Pointer into inode/ind
3158                                                for current block */
3159         int err;
3160
3161         if (this_bh) {                          /* For indirect block */
3162                 BUFFER_TRACE(this_bh, "get_write_access");
3163                 err = ext4_journal_get_write_access(handle, this_bh);
3164                 /* Important: if we can't update the indirect pointers
3165                  * to the blocks, we can't free them. */
3166                 if (err)
3167                         return;
3168         }
3169
3170         for (p = first; p < last; p++) {
3171                 nr = le32_to_cpu(*p);
3172                 if (nr) {
3173                         /* accumulate blocks to free if they're contiguous */
3174                         if (count == 0) {
3175                                 block_to_free = nr;
3176                                 block_to_free_p = p;
3177                                 count = 1;
3178                         } else if (nr == block_to_free + count) {
3179                                 count++;
3180                         } else {
3181                                 ext4_clear_blocks(handle, inode, this_bh,
3182                                                   block_to_free,
3183                                                   count, block_to_free_p, p);
3184                                 block_to_free = nr;
3185                                 block_to_free_p = p;
3186                                 count = 1;
3187                         }
3188                 }
3189         }
3190
3191         if (count > 0)
3192                 ext4_clear_blocks(handle, inode, this_bh, block_to_free,
3193                                   count, block_to_free_p, p);
3194
3195         if (this_bh) {
3196                 BUFFER_TRACE(this_bh, "call ext4_journal_dirty_metadata");
3197
3198                 /*
3199                  * The buffer head should have an attached journal head at this
3200                  * point. However, if the data is corrupted and an indirect
3201                  * block pointed to itself, it would have been detached when
3202                  * the block was cleared. Check for this instead of OOPSing.
3203                  */
3204                 if (bh2jh(this_bh))
3205                         ext4_journal_dirty_metadata(handle, this_bh);
3206                 else
3207                         ext4_error(inode->i_sb, __func__,
3208                                    "circular indirect block detected, "
3209                                    "inode=%lu, block=%llu",
3210                                    inode->i_ino,
3211                                    (unsigned long long) this_bh->b_blocknr);
3212         }
3213 }
3214
3215 /**
3216  *      ext4_free_branches - free an array of branches
3217  *      @handle: JBD handle for this transaction
3218  *      @inode: inode we are dealing with
3219  *      @parent_bh: the buffer_head which contains *@first and *@last
3220  *      @first: array of block numbers
3221  *      @last:  pointer immediately past the end of array
3222  *      @depth: depth of the branches to free
3223  *
3224  *      We are freeing all blocks refered from these branches (numbers are
3225  *      stored as little-endian 32-bit) and updating @inode->i_blocks
3226  *      appropriately.
3227  */
3228 static void ext4_free_branches(handle_t *handle, struct inode *inode,
3229                                struct buffer_head *parent_bh,
3230                                __le32 *first, __le32 *last, int depth)
3231 {
3232         ext4_fsblk_t nr;
3233         __le32 *p;
3234
3235         if (is_handle_aborted(handle))
3236                 return;
3237
3238         if (depth--) {
3239                 struct buffer_head *bh;
3240                 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb);
3241                 p = last;
3242                 while (--p >= first) {
3243                         nr = le32_to_cpu(*p);
3244                         if (!nr)
3245                                 continue;               /* A hole */
3246
3247                         /* Go read the buffer for the next level down */
3248                         bh = sb_bread(inode->i_sb, nr);
3249
3250                         /*
3251                          * A read failure? Report error and clear slot
3252                          * (should be rare).
3253                          */
3254                         if (!bh) {
3255                                 ext4_error(inode->i_sb, "ext4_free_branches",
3256                                            "Read failure, inode=%lu, block=%llu",
3257                                            inode->i_ino, nr);
3258                                 continue;
3259                         }
3260
3261                         /* This zaps the entire block.  Bottom up. */
3262                         BUFFER_TRACE(bh, "free child branches");
3263                         ext4_free_branches(handle, inode, bh,
3264                                            (__le32*)bh->b_data,
3265                                            (__le32*)bh->b_data + addr_per_block,
3266                                            depth);
3267
3268                         /*
3269                          * We've probably journalled the indirect block several
3270                          * times during the truncate.  But it's no longer
3271                          * needed and we now drop it from the transaction via
3272                          * jbd2_journal_revoke().
3273                          *
3274                          * That's easy if it's exclusively part of this
3275                          * transaction.  But if it's part of the committing
3276                          * transaction then jbd2_journal_forget() will simply
3277                          * brelse() it.  That means that if the underlying
3278                          * block is reallocated in ext4_get_block(),
3279                          * unmap_underlying_metadata() will find this block
3280                          * and will try to get rid of it.  damn, damn.
3281                          *
3282                          * If this block has already been committed to the
3283                          * journal, a revoke record will be written.  And
3284                          * revoke records must be emitted *before* clearing
3285                          * this block's bit in the bitmaps.
3286                          */
3287                         ext4_forget(handle, 1, inode, bh, bh->b_blocknr);
3288
3289                         /*
3290                          * Everything below this this pointer has been
3291                          * released.  Now let this top-of-subtree go.
3292                          *
3293                          * We want the freeing of this indirect block to be
3294                          * atomic in the journal with the updating of the
3295                          * bitmap block which owns it.  So make some room in
3296                          * the journal.
3297                          *
3298                          * We zero the parent pointer *after* freeing its
3299                          * pointee in the bitmaps, so if extend_transaction()
3300                          * for some reason fails to put the bitmap changes and
3301                          * the release into the same transaction, recovery
3302                          * will merely complain about releasing a free block,
3303                          * rather than leaking blocks.
3304                          */
3305                         if (is_handle_aborted(handle))
3306                                 return;
3307                         if (try_to_extend_transaction(handle, inode)) {
3308                                 ext4_mark_inode_dirty(handle, inode);
3309                                 ext4_journal_test_restart(handle, inode);
3310                         }
3311
3312                         ext4_free_blocks(handle, inode, nr, 1, 1);
3313
3314                         if (parent_bh) {
3315                                 /*
3316                                  * The block which we have just freed is
3317                                  * pointed to by an indirect block: journal it
3318                                  */
3319                                 BUFFER_TRACE(parent_bh, "get_write_access");
3320                                 if (!ext4_journal_get_write_access(handle,
3321                                                                    parent_bh)){
3322                                         *p = 0;
3323                                         BUFFER_TRACE(parent_bh,
3324                                         "call ext4_journal_dirty_metadata");
3325                                         ext4_journal_dirty_metadata(handle,
3326                                                                     parent_bh);
3327                                 }
3328                         }
3329                 }
3330         } else {
3331                 /* We have reached the bottom of the tree. */
3332                 BUFFER_TRACE(parent_bh, "free data blocks");
3333                 ext4_free_data(handle, inode, parent_bh, first, last);
3334         }
3335 }
3336
3337 int ext4_can_truncate(struct inode *inode)
3338 {
3339         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
3340                 return 0;
3341         if (S_ISREG(inode->i_mode))
3342                 return 1;
3343         if (S_ISDIR(inode->i_mode))
3344                 return 1;
3345         if (S_ISLNK(inode->i_mode))
3346                 return !ext4_inode_is_fast_symlink(inode);
3347         return 0;
3348 }
3349
3350 /*
3351  * ext4_truncate()
3352  *
3353  * We block out ext4_get_block() block instantiations across the entire
3354  * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3355  * simultaneously on behalf of the same inode.
3356  *
3357  * As we work through the truncate and commmit bits of it to the journal there
3358  * is one core, guiding principle: the file's tree must always be consistent on
3359  * disk.  We must be able to restart the truncate after a crash.
3360  *
3361  * The file's tree may be transiently inconsistent in memory (although it
3362  * probably isn't), but whenever we close off and commit a journal transaction,
3363  * the contents of (the filesystem + the journal) must be consistent and
3364  * restartable.  It's pretty simple, really: bottom up, right to left (although
3365  * left-to-right works OK too).
3366  *
3367  * Note that at recovery time, journal replay occurs *before* the restart of
3368  * truncate against the orphan inode list.
3369  *
3370  * The committed inode has the new, desired i_size (which is the same as
3371  * i_disksize in this case).  After a crash, ext4_orphan_cleanup() will see
3372  * that this inode's truncate did not complete and it will again call
3373  * ext4_truncate() to have another go.  So there will be instantiated blocks
3374  * to the right of the truncation point in a crashed ext4 filesystem.  But
3375  * that's fine - as long as they are linked from the inode, the post-crash
3376  * ext4_truncate() run will find them and release them.
3377  */
3378 void ext4_truncate(struct inode *inode)
3379 {
3380         handle_t *handle;
3381         struct ext4_inode_info *ei = EXT4_I(inode);
3382         __le32 *i_data = ei->i_data;
3383         int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb);
3384         struct address_space *mapping = inode->i_mapping;
3385         ext4_lblk_t offsets[4];
3386         Indirect chain[4];
3387         Indirect *partial;
3388         __le32 nr = 0;
3389         int n;
3390         ext4_lblk_t last_block;
3391         unsigned blocksize = inode->i_sb->s_blocksize;
3392
3393         if (!ext4_can_truncate(inode))
3394                 return;
3395
3396         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
3397                 ext4_ext_truncate(inode);
3398                 return;
3399         }
3400
3401         handle = start_transaction(inode);
3402         if (IS_ERR(handle))
3403                 return;         /* AKPM: return what? */
3404
3405         last_block = (inode->i_size + blocksize-1)
3406                                         >> EXT4_BLOCK_SIZE_BITS(inode->i_sb);
3407
3408         if (inode->i_size & (blocksize - 1))
3409                 if (ext4_block_truncate_page(handle, mapping, inode->i_size))
3410                         goto out_stop;
3411
3412         n = ext4_block_to_path(inode, last_block, offsets, NULL);
3413         if (n == 0)
3414                 goto out_stop;  /* error */
3415
3416         /*
3417          * OK.  This truncate is going to happen.  We add the inode to the
3418          * orphan list, so that if this truncate spans multiple transactions,
3419          * and we crash, we will resume the truncate when the filesystem
3420          * recovers.  It also marks the inode dirty, to catch the new size.
3421          *
3422          * Implication: the file must always be in a sane, consistent
3423          * truncatable state while each transaction commits.
3424          */
3425         if (ext4_orphan_add(handle, inode))
3426                 goto out_stop;
3427
3428         /*
3429          * From here we block out all ext4_get_block() callers who want to
3430          * modify the block allocation tree.
3431          */
3432         down_write(&ei->i_data_sem);
3433         /*
3434          * The orphan list entry will now protect us from any crash which
3435          * occurs before the truncate completes, so it is now safe to propagate
3436          * the new, shorter inode size (held for now in i_size) into the
3437          * on-disk inode. We do this via i_disksize, which is the value which
3438          * ext4 *really* writes onto the disk inode.
3439          */
3440         ei->i_disksize = inode->i_size;
3441
3442         if (n == 1) {           /* direct blocks */
3443                 ext4_free_data(handle, inode, NULL, i_data+offsets[0],
3444                                i_data + EXT4_NDIR_BLOCKS);
3445                 goto do_indirects;
3446         }
3447
3448         partial = ext4_find_shared(inode, n, offsets, chain, &nr);
3449         /* Kill the top of shared branch (not detached) */
3450         if (nr) {
3451                 if (partial == chain) {
3452                         /* Shared branch grows from the inode */
3453                         ext4_free_branches(handle, inode, NULL,
3454                                            &nr, &nr+1, (chain+n-1) - partial);
3455                         *partial->p = 0;
3456                         /*
3457                          * We mark the inode dirty prior to restart,
3458                          * and prior to stop.  No need for it here.
3459                          */
3460                 } else {
3461                         /* Shared branch grows from an indirect block */
3462                         BUFFER_TRACE(partial->bh, "get_write_access");
3463                         ext4_free_branches(handle, inode, partial->bh,
3464                                         partial->p,
3465                                         partial->p+1, (chain+n-1) - partial);
3466                 }
3467         }
3468         /* Clear the ends of indirect blocks on the shared branch */
3469         while (partial > chain) {
3470                 ext4_free_branches(handle, inode, partial->bh, partial->p + 1,
3471                                    (__le32*)partial->bh->b_data+addr_per_block,
3472                                    (chain+n-1) - partial);
3473                 BUFFER_TRACE(partial->bh, "call brelse");
3474                 brelse (partial->bh);
3475                 partial--;
3476         }
3477 do_indirects:
3478         /* Kill the remaining (whole) subtrees */
3479         switch (offsets[0]) {
3480         default:
3481                 nr = i_data[EXT4_IND_BLOCK];
3482                 if (nr) {
3483                         ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
3484                         i_data[EXT4_IND_BLOCK] = 0;
3485                 }
3486         case EXT4_IND_BLOCK:
3487                 nr = i_data[EXT4_DIND_BLOCK];
3488                 if (nr) {
3489                         ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
3490                         i_data[EXT4_DIND_BLOCK] = 0;
3491                 }
3492         case EXT4_DIND_BLOCK:
3493                 nr = i_data[EXT4_TIND_BLOCK];
3494                 if (nr) {
3495                         ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
3496                         i_data[EXT4_TIND_BLOCK] = 0;
3497                 }
3498         case EXT4_TIND_BLOCK:
3499                 ;
3500         }
3501
3502         ext4_discard_reservation(inode);
3503
3504         up_write(&ei->i_data_sem);
3505         inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
3506         ext4_mark_inode_dirty(handle, inode);
3507
3508         /*
3509          * In a multi-transaction truncate, we only make the final transaction
3510          * synchronous
3511          */
3512         if (IS_SYNC(inode))
3513                 handle->h_sync = 1;
3514 out_stop:
3515         /*
3516          * If this was a simple ftruncate(), and the file will remain alive
3517          * then we need to clear up the orphan record which we created above.
3518          * However, if this was a real unlink then we were called by
3519          * ext4_delete_inode(), and we allow that function to clean up the
3520          * orphan info for us.
3521          */
3522         if (inode->i_nlink)
3523                 ext4_orphan_del(handle, inode);
3524
3525         ext4_journal_stop(handle);
3526 }
3527
3528 static ext4_fsblk_t ext4_get_inode_block(struct super_block *sb,
3529                 unsigned long ino, struct ext4_iloc *iloc)
3530 {
3531         ext4_group_t block_group;
3532         unsigned long offset;
3533         ext4_fsblk_t block;
3534         struct ext4_group_desc *gdp;
3535
3536         if (!ext4_valid_inum(sb, ino)) {
3537                 /*
3538                  * This error is already checked for in namei.c unless we are
3539                  * looking at an NFS filehandle, in which case no error
3540                  * report is needed
3541                  */
3542                 return 0;
3543         }
3544
3545         block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
3546         gdp = ext4_get_group_desc(sb, block_group, NULL);
3547         if (!gdp)
3548                 return 0;
3549
3550         /*
3551          * Figure out the offset within the block group inode table
3552          */
3553         offset = ((ino - 1) % EXT4_INODES_PER_GROUP(sb)) *
3554                 EXT4_INODE_SIZE(sb);
3555         block = ext4_inode_table(sb, gdp) +
3556                 (offset >> EXT4_BLOCK_SIZE_BITS(sb));
3557
3558         iloc->block_group = block_group;
3559         iloc->offset = offset & (EXT4_BLOCK_SIZE(sb) - 1);
3560         return block;
3561 }
3562
3563 /*
3564  * ext4_get_inode_loc returns with an extra refcount against the inode's
3565  * underlying buffer_head on success. If 'in_mem' is true, we have all
3566  * data in memory that is needed to recreate the on-disk version of this
3567  * inode.
3568  */
3569 static int __ext4_get_inode_loc(struct inode *inode,
3570                                 struct ext4_iloc *iloc, int in_mem)
3571 {
3572         ext4_fsblk_t block;
3573         struct buffer_head *bh;
3574
3575         block = ext4_get_inode_block(inode->i_sb, inode->i_ino, iloc);
3576         if (!block)
3577                 return -EIO;
3578
3579         bh = sb_getblk(inode->i_sb, block);
3580         if (!bh) {
3581                 ext4_error (inode->i_sb, "ext4_get_inode_loc",
3582                                 "unable to read inode block - "
3583                                 "inode=%lu, block=%llu",
3584                                  inode->i_ino, block);
3585                 return -EIO;
3586         }
3587         if (!buffer_uptodate(bh)) {
3588                 lock_buffer(bh);
3589                 if (buffer_uptodate(bh)) {
3590                         /* someone brought it uptodate while we waited */
3591                         unlock_buffer(bh);
3592                         goto has_buffer;
3593                 }
3594
3595                 /*
3596                  * If we have all information of the inode in memory and this
3597                  * is the only valid inode in the block, we need not read the
3598                  * block.
3599                  */
3600                 if (in_mem) {
3601                         struct buffer_head *bitmap_bh;
3602                         struct ext4_group_desc *desc;
3603                         int inodes_per_buffer;
3604                         int inode_offset, i;
3605                         ext4_group_t block_group;
3606                         int start;
3607
3608                         block_group = (inode->i_ino - 1) /
3609                                         EXT4_INODES_PER_GROUP(inode->i_sb);
3610                         inodes_per_buffer = bh->b_size /
3611                                 EXT4_INODE_SIZE(inode->i_sb);
3612                         inode_offset = ((inode->i_ino - 1) %
3613                                         EXT4_INODES_PER_GROUP(inode->i_sb));
3614                         start = inode_offset & ~(inodes_per_buffer - 1);
3615
3616                         /* Is the inode bitmap in cache? */
3617                         desc = ext4_get_group_desc(inode->i_sb,
3618                                                 block_group, NULL);
3619                         if (!desc)
3620                                 goto make_io;
3621
3622                         bitmap_bh = sb_getblk(inode->i_sb,
3623                                 ext4_inode_bitmap(inode->i_sb, desc));
3624                         if (!bitmap_bh)
3625                                 goto make_io;
3626
3627                         /*
3628                          * If the inode bitmap isn't in cache then the
3629                          * optimisation may end up performing two reads instead
3630                          * of one, so skip it.
3631                          */
3632                         if (!buffer_uptodate(bitmap_bh)) {
3633                                 brelse(bitmap_bh);
3634                                 goto make_io;
3635                         }
3636                         for (i = start; i < start + inodes_per_buffer; i++) {
3637                                 if (i == inode_offset)
3638                                         continue;
3639                                 if (ext4_test_bit(i, bitmap_bh->b_data))
3640                                         break;
3641                         }
3642                         brelse(bitmap_bh);
3643                         if (i == start + inodes_per_buffer) {
3644                                 /* all other inodes are free, so skip I/O */
3645                                 memset(bh->b_data, 0, bh->b_size);
3646                                 set_buffer_uptodate(bh);
3647                                 unlock_buffer(bh);
3648                                 goto has_buffer;
3649                         }
3650                 }
3651
3652 make_io:
3653                 /*
3654                  * There are other valid inodes in the buffer, this inode
3655                  * has in-inode xattrs, or we don't have this inode in memory.
3656                  * Read the block from disk.
3657                  */
3658                 get_bh(bh);
3659                 bh->b_end_io = end_buffer_read_sync;
3660                 submit_bh(READ_META, bh);
3661                 wait_on_buffer(bh);
3662                 if (!buffer_uptodate(bh)) {
3663                         ext4_error(inode->i_sb, "ext4_get_inode_loc",
3664                                         "unable to read inode block - "
3665                                         "inode=%lu, block=%llu",
3666                                         inode->i_ino, block);
3667                         brelse(bh);
3668                         return -EIO;
3669                 }
3670         }
3671 has_buffer:
3672         iloc->bh = bh;
3673         return 0;
3674 }
3675
3676 int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
3677 {
3678         /* We have all inode data except xattrs in memory here. */
3679         return __ext4_get_inode_loc(inode, iloc,
3680                 !(EXT4_I(inode)->i_state & EXT4_STATE_XATTR));
3681 }
3682
3683 void ext4_set_inode_flags(struct inode *inode)
3684 {
3685         unsigned int flags = EXT4_I(inode)->i_flags;
3686
3687         inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
3688         if (flags & EXT4_SYNC_FL)
3689                 inode->i_flags |= S_SYNC;
3690         if (flags & EXT4_APPEND_FL)
3691                 inode->i_flags |= S_APPEND;
3692         if (flags & EXT4_IMMUTABLE_FL)
3693                 inode->i_flags |= S_IMMUTABLE;
3694         if (flags & EXT4_NOATIME_FL)
3695                 inode->i_flags |= S_NOATIME;
3696         if (flags & EXT4_DIRSYNC_FL)
3697                 inode->i_flags |= S_DIRSYNC;
3698 }
3699
3700 /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
3701 void ext4_get_inode_flags(struct ext4_inode_info *ei)
3702 {
3703         unsigned int flags = ei->vfs_inode.i_flags;
3704
3705         ei->i_flags &= ~(EXT4_SYNC_FL|EXT4_APPEND_FL|
3706                         EXT4_IMMUTABLE_FL|EXT4_NOATIME_FL|EXT4_DIRSYNC_FL);
3707         if (flags & S_SYNC)
3708                 ei->i_flags |= EXT4_SYNC_FL;
3709         if (flags & S_APPEND)
3710                 ei->i_flags |= EXT4_APPEND_FL;
3711         if (flags & S_IMMUTABLE)
3712                 ei->i_flags |= EXT4_IMMUTABLE_FL;
3713         if (flags & S_NOATIME)
3714                 ei->i_flags |= EXT4_NOATIME_FL;
3715         if (flags & S_DIRSYNC)
3716                 ei->i_flags |= EXT4_DIRSYNC_FL;
3717 }
3718 static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
3719                                         struct ext4_inode_info *ei)
3720 {
3721         blkcnt_t i_blocks ;
3722         struct inode *inode = &(ei->vfs_inode);
3723         struct super_block *sb = inode->i_sb;
3724
3725         if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
3726                                 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
3727                 /* we are using combined 48 bit field */
3728                 i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
3729                                         le32_to_cpu(raw_inode->i_blocks_lo);
3730                 if (ei->i_flags & EXT4_HUGE_FILE_FL) {
3731                         /* i_blocks represent file system block size */
3732                         return i_blocks  << (inode->i_blkbits - 9);
3733                 } else {
3734                         return i_blocks;
3735                 }
3736         } else {
3737                 return le32_to_cpu(raw_inode->i_blocks_lo);
3738         }
3739 }
3740
3741 struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
3742 {
3743         struct ext4_iloc iloc;
3744         struct ext4_inode *raw_inode;
3745         struct ext4_inode_info *ei;
3746         struct buffer_head *bh;
3747         struct inode *inode;
3748         long ret;
3749         int block;
3750
3751         inode = iget_locked(sb, ino);
3752         if (!inode)
3753                 return ERR_PTR(-ENOMEM);
3754         if (!(inode->i_state & I_NEW))
3755                 return inode;
3756
3757         ei = EXT4_I(inode);
3758 #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
3759         ei->i_acl = EXT4_ACL_NOT_CACHED;
3760         ei->i_default_acl = EXT4_ACL_NOT_CACHED;
3761 #endif
3762         ei->i_block_alloc_info = NULL;
3763
3764         ret = __ext4_get_inode_loc(inode, &iloc, 0);
3765         if (ret < 0)
3766                 goto bad_inode;
3767         bh = iloc.bh;
3768         raw_inode = ext4_raw_inode(&iloc);
3769         inode->i_mode = le16_to_cpu(raw_inode->i_mode);
3770         inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
3771         inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
3772         if(!(test_opt (inode->i_sb, NO_UID32))) {
3773                 inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
3774                 inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
3775         }
3776         inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
3777
3778         ei->i_state = 0;
3779         ei->i_dir_start_lookup = 0;
3780         ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
3781         /* We now have enough fields to check if the inode was active or not.
3782          * This is needed because nfsd might try to access dead inodes
3783          * the test is that same one that e2fsck uses
3784          * NeilBrown 1999oct15
3785          */
3786         if (inode->i_nlink == 0) {
3787                 if (inode->i_mode == 0 ||
3788                     !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
3789                         /* this inode is deleted */
3790                         brelse (bh);
3791                         ret = -ESTALE;
3792                         goto bad_inode;
3793                 }
3794                 /* The only unlinked inodes we let through here have
3795                  * valid i_mode and are being read by the orphan
3796                  * recovery code: that's fine, we're about to complete
3797                  * the process of deleting those. */
3798         }
3799         ei->i_flags = le32_to_cpu(raw_inode->i_flags);
3800         inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
3801         ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
3802         if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
3803             cpu_to_le32(EXT4_OS_HURD)) {
3804                 ei->i_file_acl |=
3805                         ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
3806         }
3807         inode->i_size = ext4_isize(raw_inode);
3808         ei->i_disksize = inode->i_size;
3809         inode->i_generation = le32_to_cpu(raw_inode->i_generation);
3810         ei->i_block_group = iloc.block_group;
3811         /*
3812          * NOTE! The in-memory inode i_data array is in little-endian order
3813          * even on big-endian machines: we do NOT byteswap the block numbers!
3814          */
3815         for (block = 0; block < EXT4_N_BLOCKS; block++)
3816                 ei->i_data[block] = raw_inode->i_block[block];
3817         INIT_LIST_HEAD(&ei->i_orphan);
3818
3819         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3820                 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
3821                 if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
3822                     EXT4_INODE_SIZE(inode->i_sb)) {
3823                         brelse (bh);
3824                         ret = -EIO;
3825                         goto bad_inode;
3826                 }
3827                 if (ei->i_extra_isize == 0) {
3828                         /* The extra space is currently unused. Use it. */
3829                         ei->i_extra_isize = sizeof(struct ext4_inode) -
3830                                             EXT4_GOOD_OLD_INODE_SIZE;
3831                 } else {
3832                         __le32 *magic = (void *)raw_inode +
3833                                         EXT4_GOOD_OLD_INODE_SIZE +
3834                                         ei->i_extra_isize;
3835                         if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC))
3836                                  ei->i_state |= EXT4_STATE_XATTR;
3837                 }
3838         } else
3839                 ei->i_extra_isize = 0;
3840
3841         EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode);
3842         EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode);
3843         EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
3844         EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
3845
3846         inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
3847         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3848                 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
3849                         inode->i_version |=
3850                         (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
3851         }
3852
3853         if (S_ISREG(inode->i_mode)) {
3854                 inode->i_op = &ext4_file_inode_operations;
3855                 inode->i_fop = &ext4_file_operations;
3856                 ext4_set_aops(inode);
3857         } else if (S_ISDIR(inode->i_mode)) {
3858                 inode->i_op = &ext4_dir_inode_operations;
3859                 inode->i_fop = &ext4_dir_operations;
3860         } else if (S_ISLNK(inode->i_mode)) {
3861                 if (ext4_inode_is_fast_symlink(inode))
3862                         inode->i_op = &ext4_fast_symlink_inode_operations;
3863                 else {
3864                         inode->i_op = &ext4_symlink_inode_operations;
3865                         ext4_set_aops(inode);
3866                 }
3867         } else {
3868                 inode->i_op = &ext4_special_inode_operations;
3869                 if (raw_inode->i_block[0])
3870                         init_special_inode(inode, inode->i_mode,
3871                            old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
3872                 else
3873                         init_special_inode(inode, inode->i_mode,
3874                            new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
3875         }
3876         brelse (iloc.bh);
3877         ext4_set_inode_flags(inode);
3878         unlock_new_inode(inode);
3879         return inode;
3880
3881 bad_inode:
3882         iget_failed(inode);
3883         return ERR_PTR(ret);
3884 }
3885
3886 static int ext4_inode_blocks_set(handle_t *handle,
3887                                 struct ext4_inode *raw_inode,
3888                                 struct ext4_inode_info *ei)
3889 {
3890         struct inode *inode = &(ei->vfs_inode);
3891         u64 i_blocks = inode->i_blocks;
3892         struct super_block *sb = inode->i_sb;
3893         int err = 0;
3894
3895         if (i_blocks <= ~0U) {
3896                 /*
3897                  * i_blocks can be represnted in a 32 bit variable
3898                  * as multiple of 512 bytes
3899                  */
3900                 raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
3901                 raw_inode->i_blocks_high = 0;
3902                 ei->i_flags &= ~EXT4_HUGE_FILE_FL;
3903         } else if (i_blocks <= 0xffffffffffffULL) {
3904                 /*
3905                  * i_blocks can be represented in a 48 bit variable
3906                  * as multiple of 512 bytes
3907                  */
3908                 err = ext4_update_rocompat_feature(handle, sb,
3909                                             EXT4_FEATURE_RO_COMPAT_HUGE_FILE);
3910                 if (err)
3911                         goto  err_out;
3912                 /* i_block is stored in the split  48 bit fields */
3913                 raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
3914                 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
3915                 ei->i_flags &= ~EXT4_HUGE_FILE_FL;
3916         } else {
3917                 /*
3918                  * i_blocks should be represented in a 48 bit variable
3919                  * as multiple of  file system block size
3920                  */
3921                 err = ext4_update_rocompat_feature(handle, sb,
3922                                             EXT4_FEATURE_RO_COMPAT_HUGE_FILE);
3923                 if (err)
3924                         goto  err_out;
3925                 ei->i_flags |= EXT4_HUGE_FILE_FL;
3926                 /* i_block is stored in file system block size */
3927                 i_blocks = i_blocks >> (inode->i_blkbits - 9);
3928                 raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
3929                 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
3930         }
3931 err_out:
3932         return err;
3933 }
3934
3935 /*
3936  * Post the struct inode info into an on-disk inode location in the
3937  * buffer-cache.  This gobbles the caller's reference to the
3938  * buffer_head in the inode location struct.
3939  *
3940  * The caller must have write access to iloc->bh.
3941  */
3942 static int ext4_do_update_inode(handle_t *handle,
3943                                 struct inode *inode,
3944                                 struct ext4_iloc *iloc)
3945 {
3946         struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
3947         struct ext4_inode_info *ei = EXT4_I(inode);
3948         struct buffer_head *bh = iloc->bh;
3949         int err = 0, rc, block;
3950
3951         /* For fields not not tracking in the in-memory inode,
3952          * initialise them to zero for new inodes. */
3953         if (ei->i_state & EXT4_STATE_NEW)
3954                 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
3955
3956         ext4_get_inode_flags(ei);
3957         raw_inode->i_mode = cpu_to_le16(inode->i_mode);
3958         if(!(test_opt(inode->i_sb, NO_UID32))) {
3959                 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
3960                 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
3961 /*
3962  * Fix up interoperability with old kernels. Otherwise, old inodes get
3963  * re-used with the upper 16 bits of the uid/gid intact
3964  */
3965                 if(!ei->i_dtime) {
3966                         raw_inode->i_uid_high =
3967                                 cpu_to_le16(high_16_bits(inode->i_uid));
3968                         raw_inode->i_gid_high =
3969                                 cpu_to_le16(high_16_bits(inode->i_gid));
3970                 } else {
3971                         raw_inode->i_uid_high = 0;
3972                         raw_inode->i_gid_high = 0;
3973                 }
3974         } else {
3975                 raw_inode->i_uid_low =
3976                         cpu_to_le16(fs_high2lowuid(inode->i_uid));
3977                 raw_inode->i_gid_low =
3978                         cpu_to_le16(fs_high2lowgid(inode->i_gid));
3979                 raw_inode->i_uid_high = 0;
3980                 raw_inode->i_gid_high = 0;
3981         }
3982         raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
3983
3984         EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
3985         EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
3986         EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
3987         EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
3988
3989         if (ext4_inode_blocks_set(handle, raw_inode, ei))
3990                 goto out_brelse;
3991         raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
3992         /* clear the migrate flag in the raw_inode */
3993         raw_inode->i_flags = cpu_to_le32(ei->i_flags & ~EXT4_EXT_MIGRATE);
3994         if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
3995             cpu_to_le32(EXT4_OS_HURD))
3996                 raw_inode->i_file_acl_high =
3997                         cpu_to_le16(ei->i_file_acl >> 32);
3998         raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
3999         ext4_isize_set(raw_inode, ei->i_disksize);
4000         if (ei->i_disksize > 0x7fffffffULL) {
4001                 struct super_block *sb = inode->i_sb;
4002                 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
4003                                 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
4004                                 EXT4_SB(sb)->s_es->s_rev_level ==
4005                                 cpu_to_le32(EXT4_GOOD_OLD_REV)) {
4006                         /* If this is the first large file
4007                          * created, add a flag to the superblock.
4008                          */
4009                         err = ext4_journal_get_write_access(handle,
4010                                         EXT4_SB(sb)->s_sbh);
4011                         if (err)
4012                                 goto out_brelse;
4013                         ext4_update_dynamic_rev(sb);
4014                         EXT4_SET_RO_COMPAT_FEATURE(sb,
4015                                         EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4016                         sb->s_dirt = 1;
4017                         handle->h_sync = 1;
4018                         err = ext4_journal_dirty_metadata(handle,
4019                                         EXT4_SB(sb)->s_sbh);
4020                 }
4021         }
4022         raw_inode->i_generation = cpu_to_le32(inode->i_generation);
4023         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
4024                 if (old_valid_dev(inode->i_rdev)) {
4025                         raw_inode->i_block[0] =
4026                                 cpu_to_le32(old_encode_dev(inode->i_rdev));
4027                         raw_inode->i_block[1] = 0;
4028                 } else {
4029                         raw_inode->i_block[0] = 0;
4030                         raw_inode->i_block[1] =
4031                                 cpu_to_le32(new_encode_dev(inode->i_rdev));
4032                         raw_inode->i_block[2] = 0;
4033                 }
4034         } else for (block = 0; block < EXT4_N_BLOCKS; block++)
4035                 raw_inode->i_block[block] = ei->i_data[block];
4036
4037         raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
4038         if (ei->i_extra_isize) {
4039                 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
4040                         raw_inode->i_version_hi =
4041                         cpu_to_le32(inode->i_version >> 32);
4042                 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
4043         }
4044
4045
4046         BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata");
4047         rc = ext4_journal_dirty_metadata(handle, bh);
4048         if (!err)
4049                 err = rc;
4050         ei->i_state &= ~EXT4_STATE_NEW;
4051
4052 out_brelse:
4053         brelse (bh);
4054         ext4_std_error(inode->i_sb, err);
4055         return err;
4056 }
4057
4058 /*
4059  * ext4_write_inode()
4060  *
4061  * We are called from a few places:
4062  *
4063  * - Within generic_file_write() for O_SYNC files.
4064  *   Here, there will be no transaction running. We wait for any running
4065  *   trasnaction to commit.
4066  *
4067  * - Within sys_sync(), kupdate and such.
4068  *   We wait on commit, if tol to.
4069  *
4070  * - Within prune_icache() (PF_MEMALLOC == true)
4071  *   Here we simply return.  We can't afford to block kswapd on the
4072  *   journal commit.
4073  *
4074  * In all cases it is actually safe for us to return without doing anything,
4075  * because the inode has been copied into a raw inode buffer in
4076  * ext4_mark_inode_dirty().  This is a correctness thing for O_SYNC and for
4077  * knfsd.
4078  *
4079  * Note that we are absolutely dependent upon all inode dirtiers doing the
4080  * right thing: they *must* call mark_inode_dirty() after dirtying info in
4081  * which we are interested.
4082  *
4083  * It would be a bug for them to not do this.  The code:
4084  *
4085  *      mark_inode_dirty(inode)
4086  *      stuff();
4087  *      inode->i_size = expr;
4088  *
4089  * is in error because a kswapd-driven write_inode() could occur while
4090  * `stuff()' is running, and the new i_size will be lost.  Plus the inode
4091  * will no longer be on the superblock's dirty inode list.
4092  */
4093 int ext4_write_inode(struct inode *inode, int wait)
4094 {
4095         if (current->flags & PF_MEMALLOC)
4096                 return 0;
4097
4098         if (ext4_journal_current_handle()) {
4099                 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
4100                 dump_stack();
4101                 return -EIO;
4102         }
4103
4104         if (!wait)
4105                 return 0;
4106
4107         return ext4_force_commit(inode->i_sb);
4108 }
4109
4110 /*
4111  * ext4_setattr()
4112  *
4113  * Called from notify_change.
4114  *
4115  * We want to trap VFS attempts to truncate the file as soon as
4116  * possible.  In particular, we want to make sure that when the VFS
4117  * shrinks i_size, we put the inode on the orphan list and modify
4118  * i_disksize immediately, so that during the subsequent flushing of
4119  * dirty pages and freeing of disk blocks, we can guarantee that any
4120  * commit will leave the blocks being flushed in an unused state on
4121  * disk.  (On recovery, the inode will get truncated and the blocks will
4122  * be freed, so we have a strong guarantee that no future commit will
4123  * leave these blocks visible to the user.)
4124  *
4125  * Another thing we have to assure is that if we are in ordered mode
4126  * and inode is still attached to the committing transaction, we must
4127  * we start writeout of all the dirty pages which are being truncated.
4128  * This way we are sure that all the data written in the previous
4129  * transaction are already on disk (truncate waits for pages under
4130  * writeback).
4131  *
4132  * Called with inode->i_mutex down.
4133  */
4134 int ext4_setattr(struct dentry *dentry, struct iattr *attr)
4135 {
4136         struct inode *inode = dentry->d_inode;
4137         int error, rc = 0;
4138         const unsigned int ia_valid = attr->ia_valid;
4139
4140         error = inode_change_ok(inode, attr);
4141         if (error)
4142                 return error;
4143
4144         if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
4145                 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
4146                 handle_t *handle;
4147
4148                 /* (user+group)*(old+new) structure, inode write (sb,
4149                  * inode block, ? - but truncate inode update has it) */
4150                 handle = ext4_journal_start(inode, 2*(EXT4_QUOTA_INIT_BLOCKS(inode->i_sb)+
4151                                         EXT4_QUOTA_DEL_BLOCKS(inode->i_sb))+3);
4152                 if (IS_ERR(handle)) {
4153                         error = PTR_ERR(handle);
4154                         goto err_out;
4155                 }
4156                 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
4157                 if (error) {
4158                         ext4_journal_stop(handle);
4159                         return error;
4160                 }
4161                 /* Update corresponding info in inode so that everything is in
4162                  * one transaction */
4163                 if (attr->ia_valid & ATTR_UID)
4164                         inode->i_uid = attr->ia_uid;
4165                 if (attr->ia_valid & ATTR_GID)
4166                         inode->i_gid = attr->ia_gid;
4167                 error = ext4_mark_inode_dirty(handle, inode);
4168                 ext4_journal_stop(handle);
4169         }
4170
4171         if (attr->ia_valid & ATTR_SIZE) {
4172                 if (!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)) {
4173                         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4174
4175                         if (attr->ia_size > sbi->s_bitmap_maxbytes) {
4176                                 error = -EFBIG;
4177                                 goto err_out;
4178                         }
4179                 }
4180         }
4181
4182         if (S_ISREG(inode->i_mode) &&
4183             attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
4184                 handle_t *handle;
4185
4186                 handle = ext4_journal_start(inode, 3);
4187                 if (IS_ERR(handle)) {
4188                         error = PTR_ERR(handle);
4189                         goto err_out;
4190                 }
4191
4192                 error = ext4_orphan_add(handle, inode);
4193                 EXT4_I(inode)->i_disksize = attr->ia_size;
4194                 rc = ext4_mark_inode_dirty(handle, inode);
4195                 if (!error)
4196                         error = rc;
4197                 ext4_journal_stop(handle);
4198
4199                 if (ext4_should_order_data(inode)) {
4200                         error = ext4_begin_ordered_truncate(inode,
4201                                                             attr->ia_size);
4202                         if (error) {
4203                                 /* Do as much error cleanup as possible */
4204                                 handle = ext4_journal_start(inode, 3);
4205                                 if (IS_ERR(handle)) {
4206                                         ext4_orphan_del(NULL, inode);
4207                                         goto err_out;
4208                                 }
4209                                 ext4_orphan_del(handle, inode);
4210                                 ext4_journal_stop(handle);
4211                                 goto err_out;
4212                         }
4213                 }
4214         }
4215
4216         rc = inode_setattr(inode, attr);
4217
4218         /* If inode_setattr's call to ext4_truncate failed to get a
4219          * transaction handle at all, we need to clean up the in-core
4220          * orphan list manually. */
4221         if (inode->i_nlink)
4222                 ext4_orphan_del(NULL, inode);
4223
4224         if (!rc && (ia_valid & ATTR_MODE))
4225                 rc = ext4_acl_chmod(inode);
4226
4227 err_out:
4228         ext4_std_error(inode->i_sb, error);
4229         if (!error)
4230                 error = rc;
4231         return error;
4232 }
4233
4234 int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
4235                  struct kstat *stat)
4236 {
4237         struct inode *inode;
4238         unsigned long delalloc_blocks;
4239
4240         inode = dentry->d_inode;
4241         generic_fillattr(inode, stat);
4242
4243         /*
4244          * We can't update i_blocks if the block allocation is delayed
4245          * otherwise in the case of system crash before the real block
4246          * allocation is done, we will have i_blocks inconsistent with
4247          * on-disk file blocks.
4248          * We always keep i_blocks updated together with real
4249          * allocation. But to not confuse with user, stat
4250          * will return the blocks that include the delayed allocation
4251          * blocks for this file.
4252          */
4253         spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
4254         delalloc_blocks = EXT4_I(inode)->i_reserved_data_blocks;
4255         spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
4256
4257         stat->blocks += (delalloc_blocks << inode->i_sb->s_blocksize_bits)>>9;
4258         return 0;
4259 }
4260
4261 /*
4262  * How many blocks doth make a writepage()?
4263  *
4264  * With N blocks per page, it may be:
4265  * N data blocks
4266  * 2 indirect block
4267  * 2 dindirect
4268  * 1 tindirect
4269  * N+5 bitmap blocks (from the above)
4270  * N+5 group descriptor summary blocks
4271  * 1 inode block
4272  * 1 superblock.
4273  * 2 * EXT4_SINGLEDATA_TRANS_BLOCKS for the quote files
4274  *
4275  * 3 * (N + 5) + 2 + 2 * EXT4_SINGLEDATA_TRANS_BLOCKS
4276  *
4277  * With ordered or writeback data it's the same, less the N data blocks.
4278  *
4279  * If the inode's direct blocks can hold an integral number of pages then a
4280  * page cannot straddle two indirect blocks, and we can only touch one indirect
4281  * and dindirect block, and the "5" above becomes "3".
4282  *
4283  * This still overestimates under most circumstances.  If we were to pass the
4284  * start and end offsets in here as well we could do block_to_path() on each
4285  * block and work out the exact number of indirects which are touched.  Pah.
4286  */
4287
4288 int ext4_writepage_trans_blocks(struct inode *inode)
4289 {
4290         int bpp = ext4_journal_blocks_per_page(inode);
4291         int indirects = (EXT4_NDIR_BLOCKS % bpp) ? 5 : 3;
4292         int ret;
4293
4294         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)
4295                 return ext4_ext_writepage_trans_blocks(inode, bpp);
4296
4297         if (ext4_should_journal_data(inode))
4298                 ret = 3 * (bpp + indirects) + 2;
4299         else
4300                 ret = 2 * (bpp + indirects) + 2;
4301
4302 #ifdef CONFIG_QUOTA
4303         /* We know that structure was already allocated during DQUOT_INIT so
4304          * we will be updating only the data blocks + inodes */
4305         ret += 2*EXT4_QUOTA_TRANS_BLOCKS(inode->i_sb);
4306 #endif
4307
4308         return ret;
4309 }
4310
4311 /*
4312  * The caller must have previously called ext4_reserve_inode_write().
4313  * Give this, we know that the caller already has write access to iloc->bh.
4314  */
4315 int ext4_mark_iloc_dirty(handle_t *handle,
4316                 struct inode *inode, struct ext4_iloc *iloc)
4317 {
4318         int err = 0;
4319
4320         if (test_opt(inode->i_sb, I_VERSION))
4321                 inode_inc_iversion(inode);
4322
4323         /* the do_update_inode consumes one bh->b_count */
4324         get_bh(iloc->bh);
4325
4326         /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4327         err = ext4_do_update_inode(handle, inode, iloc);
4328         put_bh(iloc->bh);
4329         return err;
4330 }
4331
4332 /*
4333  * On success, We end up with an outstanding reference count against
4334  * iloc->bh.  This _must_ be cleaned up later.
4335  */
4336
4337 int
4338 ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
4339                          struct ext4_iloc *iloc)
4340 {
4341         int err = 0;
4342         if (handle) {
4343                 err = ext4_get_inode_loc(inode, iloc);
4344                 if (!err) {
4345                         BUFFER_TRACE(iloc->bh, "get_write_access");
4346                         err = ext4_journal_get_write_access(handle, iloc->bh);
4347                         if (err) {
4348                                 brelse(iloc->bh);
4349                                 iloc->bh = NULL;
4350                         }
4351                 }
4352         }
4353         ext4_std_error(inode->i_sb, err);
4354         return err;
4355 }
4356
4357 /*
4358  * Expand an inode by new_extra_isize bytes.
4359  * Returns 0 on success or negative error number on failure.
4360  */
4361 static int ext4_expand_extra_isize(struct inode *inode,
4362                                    unsigned int new_extra_isize,
4363                                    struct ext4_iloc iloc,
4364                                    handle_t *handle)
4365 {
4366         struct ext4_inode *raw_inode;
4367         struct ext4_xattr_ibody_header *header;
4368         struct ext4_xattr_entry *entry;
4369
4370         if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
4371                 return 0;
4372
4373         raw_inode = ext4_raw_inode(&iloc);
4374
4375         header = IHDR(inode, raw_inode);
4376         entry = IFIRST(header);
4377
4378         /* No extended attributes present */
4379         if (!(EXT4_I(inode)->i_state & EXT4_STATE_XATTR) ||
4380                 header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
4381                 memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0,
4382                         new_extra_isize);
4383                 EXT4_I(inode)->i_extra_isize = new_extra_isize;
4384                 return 0;
4385         }
4386
4387         /* try to expand with EAs present */
4388         return ext4_expand_extra_isize_ea(inode, new_extra_isize,
4389                                           raw_inode, handle);
4390 }
4391
4392 /*
4393  * What we do here is to mark the in-core inode as clean with respect to inode
4394  * dirtiness (it may still be data-dirty).
4395  * This means that the in-core inode may be reaped by prune_icache
4396  * without having to perform any I/O.  This is a very good thing,
4397  * because *any* task may call prune_icache - even ones which
4398  * have a transaction open against a different journal.
4399  *
4400  * Is this cheating?  Not really.  Sure, we haven't written the
4401  * inode out, but prune_icache isn't a user-visible syncing function.
4402  * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
4403  * we start and wait on commits.
4404  *
4405  * Is this efficient/effective?  Well, we're being nice to the system
4406  * by cleaning up our inodes proactively so they can be reaped
4407  * without I/O.  But we are potentially leaving up to five seconds'
4408  * worth of inodes floating about which prune_icache wants us to
4409  * write out.  One way to fix that would be to get prune_icache()
4410  * to do a write_super() to free up some memory.  It has the desired
4411  * effect.
4412  */
4413 int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
4414 {
4415         struct ext4_iloc iloc;
4416         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4417         static unsigned int mnt_count;
4418         int err, ret;
4419
4420         might_sleep();
4421         err = ext4_reserve_inode_write(handle, inode, &iloc);
4422         if (EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize &&
4423             !(EXT4_I(inode)->i_state & EXT4_STATE_NO_EXPAND)) {
4424                 /*
4425                  * We need extra buffer credits since we may write into EA block
4426                  * with this same handle. If journal_extend fails, then it will
4427                  * only result in a minor loss of functionality for that inode.
4428                  * If this is felt to be critical, then e2fsck should be run to
4429                  * force a large enough s_min_extra_isize.
4430                  */
4431                 if ((jbd2_journal_extend(handle,
4432                              EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
4433                         ret = ext4_expand_extra_isize(inode,
4434                                                       sbi->s_want_extra_isize,
4435                                                       iloc, handle);
4436                         if (ret) {
4437                                 EXT4_I(inode)->i_state |= EXT4_STATE_NO_EXPAND;
4438                                 if (mnt_count !=
4439                                         le16_to_cpu(sbi->s_es->s_mnt_count)) {
4440                                         ext4_warning(inode->i_sb, __func__,
4441                                         "Unable to expand inode %lu. Delete"
4442                                         " some EAs or run e2fsck.",
4443                                         inode->i_ino);
4444                                         mnt_count =
4445                                           le16_to_cpu(sbi->s_es->s_mnt_count);
4446                                 }
4447                         }
4448                 }
4449         }
4450         if (!err)
4451                 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
4452         return err;
4453 }
4454
4455 /*
4456  * ext4_dirty_inode() is called from __mark_inode_dirty()
4457  *
4458  * We're really interested in the case where a file is being extended.
4459  * i_size has been changed by generic_commit_write() and we thus need
4460  * to include the updated inode in the current transaction.
4461  *
4462  * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks
4463  * are allocated to the file.
4464  *
4465  * If the inode is marked synchronous, we don't honour that here - doing
4466  * so would cause a commit on atime updates, which we don't bother doing.
4467  * We handle synchronous inodes at the highest possible level.
4468  */
4469 void ext4_dirty_inode(struct inode *inode)
4470 {
4471         handle_t *current_handle = ext4_journal_current_handle();
4472         handle_t *handle;
4473
4474         handle = ext4_journal_start(inode, 2);
4475         if (IS_ERR(handle))
4476                 goto out;
4477         if (current_handle &&
4478                 current_handle->h_transaction != handle->h_transaction) {
4479                 /* This task has a transaction open against a different fs */
4480                 printk(KERN_EMERG "%s: transactions do not match!\n",
4481                        __func__);
4482         } else {
4483                 jbd_debug(5, "marking dirty.  outer handle=%p\n",
4484                                 current_handle);
4485                 ext4_mark_inode_dirty(handle, inode);
4486         }
4487         ext4_journal_stop(handle);
4488 out:
4489         return;
4490 }
4491
4492 #if 0
4493 /*
4494  * Bind an inode's backing buffer_head into this transaction, to prevent
4495  * it from being flushed to disk early.  Unlike
4496  * ext4_reserve_inode_write, this leaves behind no bh reference and
4497  * returns no iloc structure, so the caller needs to repeat the iloc
4498  * lookup to mark the inode dirty later.
4499  */
4500 static int ext4_pin_inode(handle_t *handle, struct inode *inode)
4501 {
4502         struct ext4_iloc iloc;
4503
4504         int err = 0;
4505         if (handle) {
4506                 err = ext4_get_inode_loc(inode, &iloc);
4507                 if (!err) {
4508                         BUFFER_TRACE(iloc.bh, "get_write_access");
4509                         err = jbd2_journal_get_write_access(handle, iloc.bh);
4510                         if (!err)
4511                                 err = ext4_journal_dirty_metadata(handle,
4512                                                                   iloc.bh);
4513                         brelse(iloc.bh);
4514                 }
4515         }
4516         ext4_std_error(inode->i_sb, err);
4517         return err;
4518 }
4519 #endif
4520
4521 int ext4_change_inode_journal_flag(struct inode *inode, int val)
4522 {
4523         journal_t *journal;
4524         handle_t *handle;
4525         int err;
4526
4527         /*
4528          * We have to be very careful here: changing a data block's
4529          * journaling status dynamically is dangerous.  If we write a
4530          * data block to the journal, change the status and then delete
4531          * that block, we risk forgetting to revoke the old log record
4532          * from the journal and so a subsequent replay can corrupt data.
4533          * So, first we make sure that the journal is empty and that
4534          * nobody is changing anything.
4535          */
4536
4537         journal = EXT4_JOURNAL(inode);
4538         if (is_journal_aborted(journal))
4539                 return -EROFS;
4540
4541         jbd2_journal_lock_updates(journal);
4542         jbd2_journal_flush(journal);
4543
4544         /*
4545          * OK, there are no updates running now, and all cached data is
4546          * synced to disk.  We are now in a completely consistent state
4547          * which doesn't have anything in the journal, and we know that
4548          * no filesystem updates are running, so it is safe to modify
4549          * the inode's in-core data-journaling state flag now.
4550          */
4551
4552         if (val)
4553                 EXT4_I(inode)->i_flags |= EXT4_JOURNAL_DATA_FL;
4554         else
4555                 EXT4_I(inode)->i_flags &= ~EXT4_JOURNAL_DATA_FL;
4556         ext4_set_aops(inode);
4557
4558         jbd2_journal_unlock_updates(journal);
4559
4560         /* Finally we can mark the inode as dirty. */
4561
4562         handle = ext4_journal_start(inode, 1);
4563         if (IS_ERR(handle))
4564                 return PTR_ERR(handle);
4565
4566         err = ext4_mark_inode_dirty(handle, inode);
4567         handle->h_sync = 1;
4568         ext4_journal_stop(handle);
4569         ext4_std_error(inode->i_sb, err);
4570
4571         return err;
4572 }
4573
4574 static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh)
4575 {
4576         return !buffer_mapped(bh);
4577 }
4578
4579 int ext4_page_mkwrite(struct vm_area_struct *vma, struct page *page)
4580 {
4581         loff_t size;
4582         unsigned long len;
4583         int ret = -EINVAL;
4584         struct file *file = vma->vm_file;
4585         struct inode *inode = file->f_path.dentry->d_inode;
4586         struct address_space *mapping = inode->i_mapping;
4587
4588         /*
4589          * Get i_alloc_sem to stop truncates messing with the inode. We cannot
4590          * get i_mutex because we are already holding mmap_sem.
4591          */
4592         down_read(&inode->i_alloc_sem);
4593         size = i_size_read(inode);
4594         if (page->mapping != mapping || size <= page_offset(page)
4595             || !PageUptodate(page)) {
4596                 /* page got truncated from under us? */
4597                 goto out_unlock;
4598         }
4599         ret = 0;
4600         if (PageMappedToDisk(page))
4601                 goto out_unlock;
4602
4603         if (page->index == size >> PAGE_CACHE_SHIFT)
4604                 len = size & ~PAGE_CACHE_MASK;
4605         else
4606                 len = PAGE_CACHE_SIZE;
4607
4608         if (page_has_buffers(page)) {
4609                 /* return if we have all the buffers mapped */
4610                 if (!walk_page_buffers(NULL, page_buffers(page), 0, len, NULL,
4611                                        ext4_bh_unmapped))
4612                         goto out_unlock;
4613         }
4614         /*
4615          * OK, we need to fill the hole... Do write_begin write_end
4616          * to do block allocation/reservation.We are not holding
4617          * inode.i__mutex here. That allow * parallel write_begin,
4618          * write_end call. lock_page prevent this from happening
4619          * on the same page though
4620          */
4621         ret = mapping->a_ops->write_begin(file, mapping, page_offset(page),
4622                         len, AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
4623         if (ret < 0)
4624                 goto out_unlock;
4625         ret = mapping->a_ops->write_end(file, mapping, page_offset(page),
4626                         len, len, page, NULL);
4627         if (ret < 0)
4628                 goto out_unlock;
4629         ret = 0;
4630 out_unlock:
4631         up_read(&inode->i_alloc_sem);
4632         return ret;
4633 }