vfs: pagecache usage optimization for pagesize!=blocksize
[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         .is_partially_uptodate  = block_is_partially_uptodate,
2821 };
2822
2823 static const struct address_space_operations ext4_writeback_aops = {
2824         .readpage               = ext4_readpage,
2825         .readpages              = ext4_readpages,
2826         .writepage              = ext4_normal_writepage,
2827         .sync_page              = block_sync_page,
2828         .write_begin            = ext4_write_begin,
2829         .write_end              = ext4_writeback_write_end,
2830         .bmap                   = ext4_bmap,
2831         .invalidatepage         = ext4_invalidatepage,
2832         .releasepage            = ext4_releasepage,
2833         .direct_IO              = ext4_direct_IO,
2834         .migratepage            = buffer_migrate_page,
2835         .is_partially_uptodate  = block_is_partially_uptodate,
2836 };
2837
2838 static const struct address_space_operations ext4_journalled_aops = {
2839         .readpage               = ext4_readpage,
2840         .readpages              = ext4_readpages,
2841         .writepage              = ext4_journalled_writepage,
2842         .sync_page              = block_sync_page,
2843         .write_begin            = ext4_write_begin,
2844         .write_end              = ext4_journalled_write_end,
2845         .set_page_dirty         = ext4_journalled_set_page_dirty,
2846         .bmap                   = ext4_bmap,
2847         .invalidatepage         = ext4_invalidatepage,
2848         .releasepage            = ext4_releasepage,
2849         .is_partially_uptodate  = block_is_partially_uptodate,
2850 };
2851
2852 static const struct address_space_operations ext4_da_aops = {
2853         .readpage               = ext4_readpage,
2854         .readpages              = ext4_readpages,
2855         .writepage              = ext4_da_writepage,
2856         .writepages             = ext4_da_writepages,
2857         .sync_page              = block_sync_page,
2858         .write_begin            = ext4_da_write_begin,
2859         .write_end              = ext4_da_write_end,
2860         .bmap                   = ext4_bmap,
2861         .invalidatepage         = ext4_da_invalidatepage,
2862         .releasepage            = ext4_releasepage,
2863         .direct_IO              = ext4_direct_IO,
2864         .migratepage            = buffer_migrate_page,
2865         .is_partially_uptodate  = block_is_partially_uptodate,
2866 };
2867
2868 void ext4_set_aops(struct inode *inode)
2869 {
2870         if (ext4_should_order_data(inode) &&
2871                 test_opt(inode->i_sb, DELALLOC))
2872                 inode->i_mapping->a_ops = &ext4_da_aops;
2873         else if (ext4_should_order_data(inode))
2874                 inode->i_mapping->a_ops = &ext4_ordered_aops;
2875         else if (ext4_should_writeback_data(inode) &&
2876                  test_opt(inode->i_sb, DELALLOC))
2877                 inode->i_mapping->a_ops = &ext4_da_aops;
2878         else if (ext4_should_writeback_data(inode))
2879                 inode->i_mapping->a_ops = &ext4_writeback_aops;
2880         else
2881                 inode->i_mapping->a_ops = &ext4_journalled_aops;
2882 }
2883
2884 /*
2885  * ext4_block_truncate_page() zeroes out a mapping from file offset `from'
2886  * up to the end of the block which corresponds to `from'.
2887  * This required during truncate. We need to physically zero the tail end
2888  * of that block so it doesn't yield old data if the file is later grown.
2889  */
2890 int ext4_block_truncate_page(handle_t *handle,
2891                 struct address_space *mapping, loff_t from)
2892 {
2893         ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT;
2894         unsigned offset = from & (PAGE_CACHE_SIZE-1);
2895         unsigned blocksize, length, pos;
2896         ext4_lblk_t iblock;
2897         struct inode *inode = mapping->host;
2898         struct buffer_head *bh;
2899         struct page *page;
2900         int err = 0;
2901
2902         page = grab_cache_page(mapping, from >> PAGE_CACHE_SHIFT);
2903         if (!page)
2904                 return -EINVAL;
2905
2906         blocksize = inode->i_sb->s_blocksize;
2907         length = blocksize - (offset & (blocksize - 1));
2908         iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
2909
2910         /*
2911          * For "nobh" option,  we can only work if we don't need to
2912          * read-in the page - otherwise we create buffers to do the IO.
2913          */
2914         if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
2915              ext4_should_writeback_data(inode) && PageUptodate(page)) {
2916                 zero_user(page, offset, length);
2917                 set_page_dirty(page);
2918                 goto unlock;
2919         }
2920
2921         if (!page_has_buffers(page))
2922                 create_empty_buffers(page, blocksize, 0);
2923
2924         /* Find the buffer that contains "offset" */
2925         bh = page_buffers(page);
2926         pos = blocksize;
2927         while (offset >= pos) {
2928                 bh = bh->b_this_page;
2929                 iblock++;
2930                 pos += blocksize;
2931         }
2932
2933         err = 0;
2934         if (buffer_freed(bh)) {
2935                 BUFFER_TRACE(bh, "freed: skip");
2936                 goto unlock;
2937         }
2938
2939         if (!buffer_mapped(bh)) {
2940                 BUFFER_TRACE(bh, "unmapped");
2941                 ext4_get_block(inode, iblock, bh, 0);
2942                 /* unmapped? It's a hole - nothing to do */
2943                 if (!buffer_mapped(bh)) {
2944                         BUFFER_TRACE(bh, "still unmapped");
2945                         goto unlock;
2946                 }
2947         }
2948
2949         /* Ok, it's mapped. Make sure it's up-to-date */
2950         if (PageUptodate(page))
2951                 set_buffer_uptodate(bh);
2952
2953         if (!buffer_uptodate(bh)) {
2954                 err = -EIO;
2955                 ll_rw_block(READ, 1, &bh);
2956                 wait_on_buffer(bh);
2957                 /* Uhhuh. Read error. Complain and punt. */
2958                 if (!buffer_uptodate(bh))
2959                         goto unlock;
2960         }
2961
2962         if (ext4_should_journal_data(inode)) {
2963                 BUFFER_TRACE(bh, "get write access");
2964                 err = ext4_journal_get_write_access(handle, bh);
2965                 if (err)
2966                         goto unlock;
2967         }
2968
2969         zero_user(page, offset, length);
2970
2971         BUFFER_TRACE(bh, "zeroed end of block");
2972
2973         err = 0;
2974         if (ext4_should_journal_data(inode)) {
2975                 err = ext4_journal_dirty_metadata(handle, bh);
2976         } else {
2977                 if (ext4_should_order_data(inode))
2978                         err = ext4_jbd2_file_inode(handle, inode);
2979                 mark_buffer_dirty(bh);
2980         }
2981
2982 unlock:
2983         unlock_page(page);
2984         page_cache_release(page);
2985         return err;
2986 }
2987
2988 /*
2989  * Probably it should be a library function... search for first non-zero word
2990  * or memcmp with zero_page, whatever is better for particular architecture.
2991  * Linus?
2992  */
2993 static inline int all_zeroes(__le32 *p, __le32 *q)
2994 {
2995         while (p < q)
2996                 if (*p++)
2997                         return 0;
2998         return 1;
2999 }
3000
3001 /**
3002  *      ext4_find_shared - find the indirect blocks for partial truncation.
3003  *      @inode:   inode in question
3004  *      @depth:   depth of the affected branch
3005  *      @offsets: offsets of pointers in that branch (see ext4_block_to_path)
3006  *      @chain:   place to store the pointers to partial indirect blocks
3007  *      @top:     place to the (detached) top of branch
3008  *
3009  *      This is a helper function used by ext4_truncate().
3010  *
3011  *      When we do truncate() we may have to clean the ends of several
3012  *      indirect blocks but leave the blocks themselves alive. Block is
3013  *      partially truncated if some data below the new i_size is refered
3014  *      from it (and it is on the path to the first completely truncated
3015  *      data block, indeed).  We have to free the top of that path along
3016  *      with everything to the right of the path. Since no allocation
3017  *      past the truncation point is possible until ext4_truncate()
3018  *      finishes, we may safely do the latter, but top of branch may
3019  *      require special attention - pageout below the truncation point
3020  *      might try to populate it.
3021  *
3022  *      We atomically detach the top of branch from the tree, store the
3023  *      block number of its root in *@top, pointers to buffer_heads of
3024  *      partially truncated blocks - in @chain[].bh and pointers to
3025  *      their last elements that should not be removed - in
3026  *      @chain[].p. Return value is the pointer to last filled element
3027  *      of @chain.
3028  *
3029  *      The work left to caller to do the actual freeing of subtrees:
3030  *              a) free the subtree starting from *@top
3031  *              b) free the subtrees whose roots are stored in
3032  *                      (@chain[i].p+1 .. end of @chain[i].bh->b_data)
3033  *              c) free the subtrees growing from the inode past the @chain[0].
3034  *                      (no partially truncated stuff there).  */
3035
3036 static Indirect *ext4_find_shared(struct inode *inode, int depth,
3037                         ext4_lblk_t offsets[4], Indirect chain[4], __le32 *top)
3038 {
3039         Indirect *partial, *p;
3040         int k, err;
3041
3042         *top = 0;
3043         /* Make k index the deepest non-null offest + 1 */
3044         for (k = depth; k > 1 && !offsets[k-1]; k--)
3045                 ;
3046         partial = ext4_get_branch(inode, k, offsets, chain, &err);
3047         /* Writer: pointers */
3048         if (!partial)
3049                 partial = chain + k-1;
3050         /*
3051          * If the branch acquired continuation since we've looked at it -
3052          * fine, it should all survive and (new) top doesn't belong to us.
3053          */
3054         if (!partial->key && *partial->p)
3055                 /* Writer: end */
3056                 goto no_top;
3057         for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
3058                 ;
3059         /*
3060          * OK, we've found the last block that must survive. The rest of our
3061          * branch should be detached before unlocking. However, if that rest
3062          * of branch is all ours and does not grow immediately from the inode
3063          * it's easier to cheat and just decrement partial->p.
3064          */
3065         if (p == chain + k - 1 && p > chain) {
3066                 p->p--;
3067         } else {
3068                 *top = *p->p;
3069                 /* Nope, don't do this in ext4.  Must leave the tree intact */
3070 #if 0
3071                 *p->p = 0;
3072 #endif
3073         }
3074         /* Writer: end */
3075
3076         while(partial > p) {
3077                 brelse(partial->bh);
3078                 partial--;
3079         }
3080 no_top:
3081         return partial;
3082 }
3083
3084 /*
3085  * Zero a number of block pointers in either an inode or an indirect block.
3086  * If we restart the transaction we must again get write access to the
3087  * indirect block for further modification.
3088  *
3089  * We release `count' blocks on disk, but (last - first) may be greater
3090  * than `count' because there can be holes in there.
3091  */
3092 static void ext4_clear_blocks(handle_t *handle, struct inode *inode,
3093                 struct buffer_head *bh, ext4_fsblk_t block_to_free,
3094                 unsigned long count, __le32 *first, __le32 *last)
3095 {
3096         __le32 *p;
3097         if (try_to_extend_transaction(handle, inode)) {
3098                 if (bh) {
3099                         BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata");
3100                         ext4_journal_dirty_metadata(handle, bh);
3101                 }
3102                 ext4_mark_inode_dirty(handle, inode);
3103                 ext4_journal_test_restart(handle, inode);
3104                 if (bh) {
3105                         BUFFER_TRACE(bh, "retaking write access");
3106                         ext4_journal_get_write_access(handle, bh);
3107                 }
3108         }
3109
3110         /*
3111          * Any buffers which are on the journal will be in memory. We find
3112          * them on the hash table so jbd2_journal_revoke() will run jbd2_journal_forget()
3113          * on them.  We've already detached each block from the file, so
3114          * bforget() in jbd2_journal_forget() should be safe.
3115          *
3116          * AKPM: turn on bforget in jbd2_journal_forget()!!!
3117          */
3118         for (p = first; p < last; p++) {
3119                 u32 nr = le32_to_cpu(*p);
3120                 if (nr) {
3121                         struct buffer_head *tbh;
3122
3123                         *p = 0;
3124                         tbh = sb_find_get_block(inode->i_sb, nr);
3125                         ext4_forget(handle, 0, inode, tbh, nr);
3126                 }
3127         }
3128
3129         ext4_free_blocks(handle, inode, block_to_free, count, 0);
3130 }
3131
3132 /**
3133  * ext4_free_data - free a list of data blocks
3134  * @handle:     handle for this transaction
3135  * @inode:      inode we are dealing with
3136  * @this_bh:    indirect buffer_head which contains *@first and *@last
3137  * @first:      array of block numbers
3138  * @last:       points immediately past the end of array
3139  *
3140  * We are freeing all blocks refered from that array (numbers are stored as
3141  * little-endian 32-bit) and updating @inode->i_blocks appropriately.
3142  *
3143  * We accumulate contiguous runs of blocks to free.  Conveniently, if these
3144  * blocks are contiguous then releasing them at one time will only affect one
3145  * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
3146  * actually use a lot of journal space.
3147  *
3148  * @this_bh will be %NULL if @first and @last point into the inode's direct
3149  * block pointers.
3150  */
3151 static void ext4_free_data(handle_t *handle, struct inode *inode,
3152                            struct buffer_head *this_bh,
3153                            __le32 *first, __le32 *last)
3154 {
3155         ext4_fsblk_t block_to_free = 0;    /* Starting block # of a run */
3156         unsigned long count = 0;            /* Number of blocks in the run */
3157         __le32 *block_to_free_p = NULL;     /* Pointer into inode/ind
3158                                                corresponding to
3159                                                block_to_free */
3160         ext4_fsblk_t nr;                    /* Current block # */
3161         __le32 *p;                          /* Pointer into inode/ind
3162                                                for current block */
3163         int err;
3164
3165         if (this_bh) {                          /* For indirect block */
3166                 BUFFER_TRACE(this_bh, "get_write_access");
3167                 err = ext4_journal_get_write_access(handle, this_bh);
3168                 /* Important: if we can't update the indirect pointers
3169                  * to the blocks, we can't free them. */
3170                 if (err)
3171                         return;
3172         }
3173
3174         for (p = first; p < last; p++) {
3175                 nr = le32_to_cpu(*p);
3176                 if (nr) {
3177                         /* accumulate blocks to free if they're contiguous */
3178                         if (count == 0) {
3179                                 block_to_free = nr;
3180                                 block_to_free_p = p;
3181                                 count = 1;
3182                         } else if (nr == block_to_free + count) {
3183                                 count++;
3184                         } else {
3185                                 ext4_clear_blocks(handle, inode, this_bh,
3186                                                   block_to_free,
3187                                                   count, block_to_free_p, p);
3188                                 block_to_free = nr;
3189                                 block_to_free_p = p;
3190                                 count = 1;
3191                         }
3192                 }
3193         }
3194
3195         if (count > 0)
3196                 ext4_clear_blocks(handle, inode, this_bh, block_to_free,
3197                                   count, block_to_free_p, p);
3198
3199         if (this_bh) {
3200                 BUFFER_TRACE(this_bh, "call ext4_journal_dirty_metadata");
3201
3202                 /*
3203                  * The buffer head should have an attached journal head at this
3204                  * point. However, if the data is corrupted and an indirect
3205                  * block pointed to itself, it would have been detached when
3206                  * the block was cleared. Check for this instead of OOPSing.
3207                  */
3208                 if (bh2jh(this_bh))
3209                         ext4_journal_dirty_metadata(handle, this_bh);
3210                 else
3211                         ext4_error(inode->i_sb, __func__,
3212                                    "circular indirect block detected, "
3213                                    "inode=%lu, block=%llu",
3214                                    inode->i_ino,
3215                                    (unsigned long long) this_bh->b_blocknr);
3216         }
3217 }
3218
3219 /**
3220  *      ext4_free_branches - free an array of branches
3221  *      @handle: JBD handle for this transaction
3222  *      @inode: inode we are dealing with
3223  *      @parent_bh: the buffer_head which contains *@first and *@last
3224  *      @first: array of block numbers
3225  *      @last:  pointer immediately past the end of array
3226  *      @depth: depth of the branches to free
3227  *
3228  *      We are freeing all blocks refered from these branches (numbers are
3229  *      stored as little-endian 32-bit) and updating @inode->i_blocks
3230  *      appropriately.
3231  */
3232 static void ext4_free_branches(handle_t *handle, struct inode *inode,
3233                                struct buffer_head *parent_bh,
3234                                __le32 *first, __le32 *last, int depth)
3235 {
3236         ext4_fsblk_t nr;
3237         __le32 *p;
3238
3239         if (is_handle_aborted(handle))
3240                 return;
3241
3242         if (depth--) {
3243                 struct buffer_head *bh;
3244                 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb);
3245                 p = last;
3246                 while (--p >= first) {
3247                         nr = le32_to_cpu(*p);
3248                         if (!nr)
3249                                 continue;               /* A hole */
3250
3251                         /* Go read the buffer for the next level down */
3252                         bh = sb_bread(inode->i_sb, nr);
3253
3254                         /*
3255                          * A read failure? Report error and clear slot
3256                          * (should be rare).
3257                          */
3258                         if (!bh) {
3259                                 ext4_error(inode->i_sb, "ext4_free_branches",
3260                                            "Read failure, inode=%lu, block=%llu",
3261                                            inode->i_ino, nr);
3262                                 continue;
3263                         }
3264
3265                         /* This zaps the entire block.  Bottom up. */
3266                         BUFFER_TRACE(bh, "free child branches");
3267                         ext4_free_branches(handle, inode, bh,
3268                                            (__le32*)bh->b_data,
3269                                            (__le32*)bh->b_data + addr_per_block,
3270                                            depth);
3271
3272                         /*
3273                          * We've probably journalled the indirect block several
3274                          * times during the truncate.  But it's no longer
3275                          * needed and we now drop it from the transaction via
3276                          * jbd2_journal_revoke().
3277                          *
3278                          * That's easy if it's exclusively part of this
3279                          * transaction.  But if it's part of the committing
3280                          * transaction then jbd2_journal_forget() will simply
3281                          * brelse() it.  That means that if the underlying
3282                          * block is reallocated in ext4_get_block(),
3283                          * unmap_underlying_metadata() will find this block
3284                          * and will try to get rid of it.  damn, damn.
3285                          *
3286                          * If this block has already been committed to the
3287                          * journal, a revoke record will be written.  And
3288                          * revoke records must be emitted *before* clearing
3289                          * this block's bit in the bitmaps.
3290                          */
3291                         ext4_forget(handle, 1, inode, bh, bh->b_blocknr);
3292
3293                         /*
3294                          * Everything below this this pointer has been
3295                          * released.  Now let this top-of-subtree go.
3296                          *
3297                          * We want the freeing of this indirect block to be
3298                          * atomic in the journal with the updating of the
3299                          * bitmap block which owns it.  So make some room in
3300                          * the journal.
3301                          *
3302                          * We zero the parent pointer *after* freeing its
3303                          * pointee in the bitmaps, so if extend_transaction()
3304                          * for some reason fails to put the bitmap changes and
3305                          * the release into the same transaction, recovery
3306                          * will merely complain about releasing a free block,
3307                          * rather than leaking blocks.
3308                          */
3309                         if (is_handle_aborted(handle))
3310                                 return;
3311                         if (try_to_extend_transaction(handle, inode)) {
3312                                 ext4_mark_inode_dirty(handle, inode);
3313                                 ext4_journal_test_restart(handle, inode);
3314                         }
3315
3316                         ext4_free_blocks(handle, inode, nr, 1, 1);
3317
3318                         if (parent_bh) {
3319                                 /*
3320                                  * The block which we have just freed is
3321                                  * pointed to by an indirect block: journal it
3322                                  */
3323                                 BUFFER_TRACE(parent_bh, "get_write_access");
3324                                 if (!ext4_journal_get_write_access(handle,
3325                                                                    parent_bh)){
3326                                         *p = 0;
3327                                         BUFFER_TRACE(parent_bh,
3328                                         "call ext4_journal_dirty_metadata");
3329                                         ext4_journal_dirty_metadata(handle,
3330                                                                     parent_bh);
3331                                 }
3332                         }
3333                 }
3334         } else {
3335                 /* We have reached the bottom of the tree. */
3336                 BUFFER_TRACE(parent_bh, "free data blocks");
3337                 ext4_free_data(handle, inode, parent_bh, first, last);
3338         }
3339 }
3340
3341 int ext4_can_truncate(struct inode *inode)
3342 {
3343         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
3344                 return 0;
3345         if (S_ISREG(inode->i_mode))
3346                 return 1;
3347         if (S_ISDIR(inode->i_mode))
3348                 return 1;
3349         if (S_ISLNK(inode->i_mode))
3350                 return !ext4_inode_is_fast_symlink(inode);
3351         return 0;
3352 }
3353
3354 /*
3355  * ext4_truncate()
3356  *
3357  * We block out ext4_get_block() block instantiations across the entire
3358  * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3359  * simultaneously on behalf of the same inode.
3360  *
3361  * As we work through the truncate and commmit bits of it to the journal there
3362  * is one core, guiding principle: the file's tree must always be consistent on
3363  * disk.  We must be able to restart the truncate after a crash.
3364  *
3365  * The file's tree may be transiently inconsistent in memory (although it
3366  * probably isn't), but whenever we close off and commit a journal transaction,
3367  * the contents of (the filesystem + the journal) must be consistent and
3368  * restartable.  It's pretty simple, really: bottom up, right to left (although
3369  * left-to-right works OK too).
3370  *
3371  * Note that at recovery time, journal replay occurs *before* the restart of
3372  * truncate against the orphan inode list.
3373  *
3374  * The committed inode has the new, desired i_size (which is the same as
3375  * i_disksize in this case).  After a crash, ext4_orphan_cleanup() will see
3376  * that this inode's truncate did not complete and it will again call
3377  * ext4_truncate() to have another go.  So there will be instantiated blocks
3378  * to the right of the truncation point in a crashed ext4 filesystem.  But
3379  * that's fine - as long as they are linked from the inode, the post-crash
3380  * ext4_truncate() run will find them and release them.
3381  */
3382 void ext4_truncate(struct inode *inode)
3383 {
3384         handle_t *handle;
3385         struct ext4_inode_info *ei = EXT4_I(inode);
3386         __le32 *i_data = ei->i_data;
3387         int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb);
3388         struct address_space *mapping = inode->i_mapping;
3389         ext4_lblk_t offsets[4];
3390         Indirect chain[4];
3391         Indirect *partial;
3392         __le32 nr = 0;
3393         int n;
3394         ext4_lblk_t last_block;
3395         unsigned blocksize = inode->i_sb->s_blocksize;
3396
3397         if (!ext4_can_truncate(inode))
3398                 return;
3399
3400         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
3401                 ext4_ext_truncate(inode);
3402                 return;
3403         }
3404
3405         handle = start_transaction(inode);
3406         if (IS_ERR(handle))
3407                 return;         /* AKPM: return what? */
3408
3409         last_block = (inode->i_size + blocksize-1)
3410                                         >> EXT4_BLOCK_SIZE_BITS(inode->i_sb);
3411
3412         if (inode->i_size & (blocksize - 1))
3413                 if (ext4_block_truncate_page(handle, mapping, inode->i_size))
3414                         goto out_stop;
3415
3416         n = ext4_block_to_path(inode, last_block, offsets, NULL);
3417         if (n == 0)
3418                 goto out_stop;  /* error */
3419
3420         /*
3421          * OK.  This truncate is going to happen.  We add the inode to the
3422          * orphan list, so that if this truncate spans multiple transactions,
3423          * and we crash, we will resume the truncate when the filesystem
3424          * recovers.  It also marks the inode dirty, to catch the new size.
3425          *
3426          * Implication: the file must always be in a sane, consistent
3427          * truncatable state while each transaction commits.
3428          */
3429         if (ext4_orphan_add(handle, inode))
3430                 goto out_stop;
3431
3432         /*
3433          * From here we block out all ext4_get_block() callers who want to
3434          * modify the block allocation tree.
3435          */
3436         down_write(&ei->i_data_sem);
3437         /*
3438          * The orphan list entry will now protect us from any crash which
3439          * occurs before the truncate completes, so it is now safe to propagate
3440          * the new, shorter inode size (held for now in i_size) into the
3441          * on-disk inode. We do this via i_disksize, which is the value which
3442          * ext4 *really* writes onto the disk inode.
3443          */
3444         ei->i_disksize = inode->i_size;
3445
3446         if (n == 1) {           /* direct blocks */
3447                 ext4_free_data(handle, inode, NULL, i_data+offsets[0],
3448                                i_data + EXT4_NDIR_BLOCKS);
3449                 goto do_indirects;
3450         }
3451
3452         partial = ext4_find_shared(inode, n, offsets, chain, &nr);
3453         /* Kill the top of shared branch (not detached) */
3454         if (nr) {
3455                 if (partial == chain) {
3456                         /* Shared branch grows from the inode */
3457                         ext4_free_branches(handle, inode, NULL,
3458                                            &nr, &nr+1, (chain+n-1) - partial);
3459                         *partial->p = 0;
3460                         /*
3461                          * We mark the inode dirty prior to restart,
3462                          * and prior to stop.  No need for it here.
3463                          */
3464                 } else {
3465                         /* Shared branch grows from an indirect block */
3466                         BUFFER_TRACE(partial->bh, "get_write_access");
3467                         ext4_free_branches(handle, inode, partial->bh,
3468                                         partial->p,
3469                                         partial->p+1, (chain+n-1) - partial);
3470                 }
3471         }
3472         /* Clear the ends of indirect blocks on the shared branch */
3473         while (partial > chain) {
3474                 ext4_free_branches(handle, inode, partial->bh, partial->p + 1,
3475                                    (__le32*)partial->bh->b_data+addr_per_block,
3476                                    (chain+n-1) - partial);
3477                 BUFFER_TRACE(partial->bh, "call brelse");
3478                 brelse (partial->bh);
3479                 partial--;
3480         }
3481 do_indirects:
3482         /* Kill the remaining (whole) subtrees */
3483         switch (offsets[0]) {
3484         default:
3485                 nr = i_data[EXT4_IND_BLOCK];
3486                 if (nr) {
3487                         ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
3488                         i_data[EXT4_IND_BLOCK] = 0;
3489                 }
3490         case EXT4_IND_BLOCK:
3491                 nr = i_data[EXT4_DIND_BLOCK];
3492                 if (nr) {
3493                         ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
3494                         i_data[EXT4_DIND_BLOCK] = 0;
3495                 }
3496         case EXT4_DIND_BLOCK:
3497                 nr = i_data[EXT4_TIND_BLOCK];
3498                 if (nr) {
3499                         ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
3500                         i_data[EXT4_TIND_BLOCK] = 0;
3501                 }
3502         case EXT4_TIND_BLOCK:
3503                 ;
3504         }
3505
3506         ext4_discard_reservation(inode);
3507
3508         up_write(&ei->i_data_sem);
3509         inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
3510         ext4_mark_inode_dirty(handle, inode);
3511
3512         /*
3513          * In a multi-transaction truncate, we only make the final transaction
3514          * synchronous
3515          */
3516         if (IS_SYNC(inode))
3517                 handle->h_sync = 1;
3518 out_stop:
3519         /*
3520          * If this was a simple ftruncate(), and the file will remain alive
3521          * then we need to clear up the orphan record which we created above.
3522          * However, if this was a real unlink then we were called by
3523          * ext4_delete_inode(), and we allow that function to clean up the
3524          * orphan info for us.
3525          */
3526         if (inode->i_nlink)
3527                 ext4_orphan_del(handle, inode);
3528
3529         ext4_journal_stop(handle);
3530 }
3531
3532 static ext4_fsblk_t ext4_get_inode_block(struct super_block *sb,
3533                 unsigned long ino, struct ext4_iloc *iloc)
3534 {
3535         ext4_group_t block_group;
3536         unsigned long offset;
3537         ext4_fsblk_t block;
3538         struct ext4_group_desc *gdp;
3539
3540         if (!ext4_valid_inum(sb, ino)) {
3541                 /*
3542                  * This error is already checked for in namei.c unless we are
3543                  * looking at an NFS filehandle, in which case no error
3544                  * report is needed
3545                  */
3546                 return 0;
3547         }
3548
3549         block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
3550         gdp = ext4_get_group_desc(sb, block_group, NULL);
3551         if (!gdp)
3552                 return 0;
3553
3554         /*
3555          * Figure out the offset within the block group inode table
3556          */
3557         offset = ((ino - 1) % EXT4_INODES_PER_GROUP(sb)) *
3558                 EXT4_INODE_SIZE(sb);
3559         block = ext4_inode_table(sb, gdp) +
3560                 (offset >> EXT4_BLOCK_SIZE_BITS(sb));
3561
3562         iloc->block_group = block_group;
3563         iloc->offset = offset & (EXT4_BLOCK_SIZE(sb) - 1);
3564         return block;
3565 }
3566
3567 /*
3568  * ext4_get_inode_loc returns with an extra refcount against the inode's
3569  * underlying buffer_head on success. If 'in_mem' is true, we have all
3570  * data in memory that is needed to recreate the on-disk version of this
3571  * inode.
3572  */
3573 static int __ext4_get_inode_loc(struct inode *inode,
3574                                 struct ext4_iloc *iloc, int in_mem)
3575 {
3576         ext4_fsblk_t block;
3577         struct buffer_head *bh;
3578
3579         block = ext4_get_inode_block(inode->i_sb, inode->i_ino, iloc);
3580         if (!block)
3581                 return -EIO;
3582
3583         bh = sb_getblk(inode->i_sb, block);
3584         if (!bh) {
3585                 ext4_error (inode->i_sb, "ext4_get_inode_loc",
3586                                 "unable to read inode block - "
3587                                 "inode=%lu, block=%llu",
3588                                  inode->i_ino, block);
3589                 return -EIO;
3590         }
3591         if (!buffer_uptodate(bh)) {
3592                 lock_buffer(bh);
3593                 if (buffer_uptodate(bh)) {
3594                         /* someone brought it uptodate while we waited */
3595                         unlock_buffer(bh);
3596                         goto has_buffer;
3597                 }
3598
3599                 /*
3600                  * If we have all information of the inode in memory and this
3601                  * is the only valid inode in the block, we need not read the
3602                  * block.
3603                  */
3604                 if (in_mem) {
3605                         struct buffer_head *bitmap_bh;
3606                         struct ext4_group_desc *desc;
3607                         int inodes_per_buffer;
3608                         int inode_offset, i;
3609                         ext4_group_t block_group;
3610                         int start;
3611
3612                         block_group = (inode->i_ino - 1) /
3613                                         EXT4_INODES_PER_GROUP(inode->i_sb);
3614                         inodes_per_buffer = bh->b_size /
3615                                 EXT4_INODE_SIZE(inode->i_sb);
3616                         inode_offset = ((inode->i_ino - 1) %
3617                                         EXT4_INODES_PER_GROUP(inode->i_sb));
3618                         start = inode_offset & ~(inodes_per_buffer - 1);
3619
3620                         /* Is the inode bitmap in cache? */
3621                         desc = ext4_get_group_desc(inode->i_sb,
3622                                                 block_group, NULL);
3623                         if (!desc)
3624                                 goto make_io;
3625
3626                         bitmap_bh = sb_getblk(inode->i_sb,
3627                                 ext4_inode_bitmap(inode->i_sb, desc));
3628                         if (!bitmap_bh)
3629                                 goto make_io;
3630
3631                         /*
3632                          * If the inode bitmap isn't in cache then the
3633                          * optimisation may end up performing two reads instead
3634                          * of one, so skip it.
3635                          */
3636                         if (!buffer_uptodate(bitmap_bh)) {
3637                                 brelse(bitmap_bh);
3638                                 goto make_io;
3639                         }
3640                         for (i = start; i < start + inodes_per_buffer; i++) {
3641                                 if (i == inode_offset)
3642                                         continue;
3643                                 if (ext4_test_bit(i, bitmap_bh->b_data))
3644                                         break;
3645                         }
3646                         brelse(bitmap_bh);
3647                         if (i == start + inodes_per_buffer) {
3648                                 /* all other inodes are free, so skip I/O */
3649                                 memset(bh->b_data, 0, bh->b_size);
3650                                 set_buffer_uptodate(bh);
3651                                 unlock_buffer(bh);
3652                                 goto has_buffer;
3653                         }
3654                 }
3655
3656 make_io:
3657                 /*
3658                  * There are other valid inodes in the buffer, this inode
3659                  * has in-inode xattrs, or we don't have this inode in memory.
3660                  * Read the block from disk.
3661                  */
3662                 get_bh(bh);
3663                 bh->b_end_io = end_buffer_read_sync;
3664                 submit_bh(READ_META, bh);
3665                 wait_on_buffer(bh);
3666                 if (!buffer_uptodate(bh)) {
3667                         ext4_error(inode->i_sb, "ext4_get_inode_loc",
3668                                         "unable to read inode block - "
3669                                         "inode=%lu, block=%llu",
3670                                         inode->i_ino, block);
3671                         brelse(bh);
3672                         return -EIO;
3673                 }
3674         }
3675 has_buffer:
3676         iloc->bh = bh;
3677         return 0;
3678 }
3679
3680 int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
3681 {
3682         /* We have all inode data except xattrs in memory here. */
3683         return __ext4_get_inode_loc(inode, iloc,
3684                 !(EXT4_I(inode)->i_state & EXT4_STATE_XATTR));
3685 }
3686
3687 void ext4_set_inode_flags(struct inode *inode)
3688 {
3689         unsigned int flags = EXT4_I(inode)->i_flags;
3690
3691         inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
3692         if (flags & EXT4_SYNC_FL)
3693                 inode->i_flags |= S_SYNC;
3694         if (flags & EXT4_APPEND_FL)
3695                 inode->i_flags |= S_APPEND;
3696         if (flags & EXT4_IMMUTABLE_FL)
3697                 inode->i_flags |= S_IMMUTABLE;
3698         if (flags & EXT4_NOATIME_FL)
3699                 inode->i_flags |= S_NOATIME;
3700         if (flags & EXT4_DIRSYNC_FL)
3701                 inode->i_flags |= S_DIRSYNC;
3702 }
3703
3704 /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
3705 void ext4_get_inode_flags(struct ext4_inode_info *ei)
3706 {
3707         unsigned int flags = ei->vfs_inode.i_flags;
3708
3709         ei->i_flags &= ~(EXT4_SYNC_FL|EXT4_APPEND_FL|
3710                         EXT4_IMMUTABLE_FL|EXT4_NOATIME_FL|EXT4_DIRSYNC_FL);
3711         if (flags & S_SYNC)
3712                 ei->i_flags |= EXT4_SYNC_FL;
3713         if (flags & S_APPEND)
3714                 ei->i_flags |= EXT4_APPEND_FL;
3715         if (flags & S_IMMUTABLE)
3716                 ei->i_flags |= EXT4_IMMUTABLE_FL;
3717         if (flags & S_NOATIME)
3718                 ei->i_flags |= EXT4_NOATIME_FL;
3719         if (flags & S_DIRSYNC)
3720                 ei->i_flags |= EXT4_DIRSYNC_FL;
3721 }
3722 static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
3723                                         struct ext4_inode_info *ei)
3724 {
3725         blkcnt_t i_blocks ;
3726         struct inode *inode = &(ei->vfs_inode);
3727         struct super_block *sb = inode->i_sb;
3728
3729         if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
3730                                 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
3731                 /* we are using combined 48 bit field */
3732                 i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
3733                                         le32_to_cpu(raw_inode->i_blocks_lo);
3734                 if (ei->i_flags & EXT4_HUGE_FILE_FL) {
3735                         /* i_blocks represent file system block size */
3736                         return i_blocks  << (inode->i_blkbits - 9);
3737                 } else {
3738                         return i_blocks;
3739                 }
3740         } else {
3741                 return le32_to_cpu(raw_inode->i_blocks_lo);
3742         }
3743 }
3744
3745 struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
3746 {
3747         struct ext4_iloc iloc;
3748         struct ext4_inode *raw_inode;
3749         struct ext4_inode_info *ei;
3750         struct buffer_head *bh;
3751         struct inode *inode;
3752         long ret;
3753         int block;
3754
3755         inode = iget_locked(sb, ino);
3756         if (!inode)
3757                 return ERR_PTR(-ENOMEM);
3758         if (!(inode->i_state & I_NEW))
3759                 return inode;
3760
3761         ei = EXT4_I(inode);
3762 #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
3763         ei->i_acl = EXT4_ACL_NOT_CACHED;
3764         ei->i_default_acl = EXT4_ACL_NOT_CACHED;
3765 #endif
3766         ei->i_block_alloc_info = NULL;
3767
3768         ret = __ext4_get_inode_loc(inode, &iloc, 0);
3769         if (ret < 0)
3770                 goto bad_inode;
3771         bh = iloc.bh;
3772         raw_inode = ext4_raw_inode(&iloc);
3773         inode->i_mode = le16_to_cpu(raw_inode->i_mode);
3774         inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
3775         inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
3776         if(!(test_opt (inode->i_sb, NO_UID32))) {
3777                 inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
3778                 inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
3779         }
3780         inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
3781
3782         ei->i_state = 0;
3783         ei->i_dir_start_lookup = 0;
3784         ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
3785         /* We now have enough fields to check if the inode was active or not.
3786          * This is needed because nfsd might try to access dead inodes
3787          * the test is that same one that e2fsck uses
3788          * NeilBrown 1999oct15
3789          */
3790         if (inode->i_nlink == 0) {
3791                 if (inode->i_mode == 0 ||
3792                     !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
3793                         /* this inode is deleted */
3794                         brelse (bh);
3795                         ret = -ESTALE;
3796                         goto bad_inode;
3797                 }
3798                 /* The only unlinked inodes we let through here have
3799                  * valid i_mode and are being read by the orphan
3800                  * recovery code: that's fine, we're about to complete
3801                  * the process of deleting those. */
3802         }
3803         ei->i_flags = le32_to_cpu(raw_inode->i_flags);
3804         inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
3805         ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
3806         if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
3807             cpu_to_le32(EXT4_OS_HURD)) {
3808                 ei->i_file_acl |=
3809                         ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
3810         }
3811         inode->i_size = ext4_isize(raw_inode);
3812         ei->i_disksize = inode->i_size;
3813         inode->i_generation = le32_to_cpu(raw_inode->i_generation);
3814         ei->i_block_group = iloc.block_group;
3815         /*
3816          * NOTE! The in-memory inode i_data array is in little-endian order
3817          * even on big-endian machines: we do NOT byteswap the block numbers!
3818          */
3819         for (block = 0; block < EXT4_N_BLOCKS; block++)
3820                 ei->i_data[block] = raw_inode->i_block[block];
3821         INIT_LIST_HEAD(&ei->i_orphan);
3822
3823         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3824                 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
3825                 if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
3826                     EXT4_INODE_SIZE(inode->i_sb)) {
3827                         brelse (bh);
3828                         ret = -EIO;
3829                         goto bad_inode;
3830                 }
3831                 if (ei->i_extra_isize == 0) {
3832                         /* The extra space is currently unused. Use it. */
3833                         ei->i_extra_isize = sizeof(struct ext4_inode) -
3834                                             EXT4_GOOD_OLD_INODE_SIZE;
3835                 } else {
3836                         __le32 *magic = (void *)raw_inode +
3837                                         EXT4_GOOD_OLD_INODE_SIZE +
3838                                         ei->i_extra_isize;
3839                         if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC))
3840                                  ei->i_state |= EXT4_STATE_XATTR;
3841                 }
3842         } else
3843                 ei->i_extra_isize = 0;
3844
3845         EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode);
3846         EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode);
3847         EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
3848         EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
3849
3850         inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
3851         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3852                 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
3853                         inode->i_version |=
3854                         (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
3855         }
3856
3857         if (S_ISREG(inode->i_mode)) {
3858                 inode->i_op = &ext4_file_inode_operations;
3859                 inode->i_fop = &ext4_file_operations;
3860                 ext4_set_aops(inode);
3861         } else if (S_ISDIR(inode->i_mode)) {
3862                 inode->i_op = &ext4_dir_inode_operations;
3863                 inode->i_fop = &ext4_dir_operations;
3864         } else if (S_ISLNK(inode->i_mode)) {
3865                 if (ext4_inode_is_fast_symlink(inode))
3866                         inode->i_op = &ext4_fast_symlink_inode_operations;
3867                 else {
3868                         inode->i_op = &ext4_symlink_inode_operations;
3869                         ext4_set_aops(inode);
3870                 }
3871         } else {
3872                 inode->i_op = &ext4_special_inode_operations;
3873                 if (raw_inode->i_block[0])
3874                         init_special_inode(inode, inode->i_mode,
3875                            old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
3876                 else
3877                         init_special_inode(inode, inode->i_mode,
3878                            new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
3879         }
3880         brelse (iloc.bh);
3881         ext4_set_inode_flags(inode);
3882         unlock_new_inode(inode);
3883         return inode;
3884
3885 bad_inode:
3886         iget_failed(inode);
3887         return ERR_PTR(ret);
3888 }
3889
3890 static int ext4_inode_blocks_set(handle_t *handle,
3891                                 struct ext4_inode *raw_inode,
3892                                 struct ext4_inode_info *ei)
3893 {
3894         struct inode *inode = &(ei->vfs_inode);
3895         u64 i_blocks = inode->i_blocks;
3896         struct super_block *sb = inode->i_sb;
3897         int err = 0;
3898
3899         if (i_blocks <= ~0U) {
3900                 /*
3901                  * i_blocks can be represnted in a 32 bit variable
3902                  * as multiple of 512 bytes
3903                  */
3904                 raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
3905                 raw_inode->i_blocks_high = 0;
3906                 ei->i_flags &= ~EXT4_HUGE_FILE_FL;
3907         } else if (i_blocks <= 0xffffffffffffULL) {
3908                 /*
3909                  * i_blocks can be represented in a 48 bit variable
3910                  * as multiple of 512 bytes
3911                  */
3912                 err = ext4_update_rocompat_feature(handle, sb,
3913                                             EXT4_FEATURE_RO_COMPAT_HUGE_FILE);
3914                 if (err)
3915                         goto  err_out;
3916                 /* i_block is stored in the split  48 bit fields */
3917                 raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
3918                 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
3919                 ei->i_flags &= ~EXT4_HUGE_FILE_FL;
3920         } else {
3921                 /*
3922                  * i_blocks should be represented in a 48 bit variable
3923                  * as multiple of  file system block size
3924                  */
3925                 err = ext4_update_rocompat_feature(handle, sb,
3926                                             EXT4_FEATURE_RO_COMPAT_HUGE_FILE);
3927                 if (err)
3928                         goto  err_out;
3929                 ei->i_flags |= EXT4_HUGE_FILE_FL;
3930                 /* i_block is stored in file system block size */
3931                 i_blocks = i_blocks >> (inode->i_blkbits - 9);
3932                 raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
3933                 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
3934         }
3935 err_out:
3936         return err;
3937 }
3938
3939 /*
3940  * Post the struct inode info into an on-disk inode location in the
3941  * buffer-cache.  This gobbles the caller's reference to the
3942  * buffer_head in the inode location struct.
3943  *
3944  * The caller must have write access to iloc->bh.
3945  */
3946 static int ext4_do_update_inode(handle_t *handle,
3947                                 struct inode *inode,
3948                                 struct ext4_iloc *iloc)
3949 {
3950         struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
3951         struct ext4_inode_info *ei = EXT4_I(inode);
3952         struct buffer_head *bh = iloc->bh;
3953         int err = 0, rc, block;
3954
3955         /* For fields not not tracking in the in-memory inode,
3956          * initialise them to zero for new inodes. */
3957         if (ei->i_state & EXT4_STATE_NEW)
3958                 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
3959
3960         ext4_get_inode_flags(ei);
3961         raw_inode->i_mode = cpu_to_le16(inode->i_mode);
3962         if(!(test_opt(inode->i_sb, NO_UID32))) {
3963                 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
3964                 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
3965 /*
3966  * Fix up interoperability with old kernels. Otherwise, old inodes get
3967  * re-used with the upper 16 bits of the uid/gid intact
3968  */
3969                 if(!ei->i_dtime) {
3970                         raw_inode->i_uid_high =
3971                                 cpu_to_le16(high_16_bits(inode->i_uid));
3972                         raw_inode->i_gid_high =
3973                                 cpu_to_le16(high_16_bits(inode->i_gid));
3974                 } else {
3975                         raw_inode->i_uid_high = 0;
3976                         raw_inode->i_gid_high = 0;
3977                 }
3978         } else {
3979                 raw_inode->i_uid_low =
3980                         cpu_to_le16(fs_high2lowuid(inode->i_uid));
3981                 raw_inode->i_gid_low =
3982                         cpu_to_le16(fs_high2lowgid(inode->i_gid));
3983                 raw_inode->i_uid_high = 0;
3984                 raw_inode->i_gid_high = 0;
3985         }
3986         raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
3987
3988         EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
3989         EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
3990         EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
3991         EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
3992
3993         if (ext4_inode_blocks_set(handle, raw_inode, ei))
3994                 goto out_brelse;
3995         raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
3996         /* clear the migrate flag in the raw_inode */
3997         raw_inode->i_flags = cpu_to_le32(ei->i_flags & ~EXT4_EXT_MIGRATE);
3998         if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
3999             cpu_to_le32(EXT4_OS_HURD))
4000                 raw_inode->i_file_acl_high =
4001                         cpu_to_le16(ei->i_file_acl >> 32);
4002         raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
4003         ext4_isize_set(raw_inode, ei->i_disksize);
4004         if (ei->i_disksize > 0x7fffffffULL) {
4005                 struct super_block *sb = inode->i_sb;
4006                 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
4007                                 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
4008                                 EXT4_SB(sb)->s_es->s_rev_level ==
4009                                 cpu_to_le32(EXT4_GOOD_OLD_REV)) {
4010                         /* If this is the first large file
4011                          * created, add a flag to the superblock.
4012                          */
4013                         err = ext4_journal_get_write_access(handle,
4014                                         EXT4_SB(sb)->s_sbh);
4015                         if (err)
4016                                 goto out_brelse;
4017                         ext4_update_dynamic_rev(sb);
4018                         EXT4_SET_RO_COMPAT_FEATURE(sb,
4019                                         EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4020                         sb->s_dirt = 1;
4021                         handle->h_sync = 1;
4022                         err = ext4_journal_dirty_metadata(handle,
4023                                         EXT4_SB(sb)->s_sbh);
4024                 }
4025         }
4026         raw_inode->i_generation = cpu_to_le32(inode->i_generation);
4027         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
4028                 if (old_valid_dev(inode->i_rdev)) {
4029                         raw_inode->i_block[0] =
4030                                 cpu_to_le32(old_encode_dev(inode->i_rdev));
4031                         raw_inode->i_block[1] = 0;
4032                 } else {
4033                         raw_inode->i_block[0] = 0;
4034                         raw_inode->i_block[1] =
4035                                 cpu_to_le32(new_encode_dev(inode->i_rdev));
4036                         raw_inode->i_block[2] = 0;
4037                 }
4038         } else for (block = 0; block < EXT4_N_BLOCKS; block++)
4039                 raw_inode->i_block[block] = ei->i_data[block];
4040
4041         raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
4042         if (ei->i_extra_isize) {
4043                 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
4044                         raw_inode->i_version_hi =
4045                         cpu_to_le32(inode->i_version >> 32);
4046                 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
4047         }
4048
4049
4050         BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata");
4051         rc = ext4_journal_dirty_metadata(handle, bh);
4052         if (!err)
4053                 err = rc;
4054         ei->i_state &= ~EXT4_STATE_NEW;
4055
4056 out_brelse:
4057         brelse (bh);
4058         ext4_std_error(inode->i_sb, err);
4059         return err;
4060 }
4061
4062 /*
4063  * ext4_write_inode()
4064  *
4065  * We are called from a few places:
4066  *
4067  * - Within generic_file_write() for O_SYNC files.
4068  *   Here, there will be no transaction running. We wait for any running
4069  *   trasnaction to commit.
4070  *
4071  * - Within sys_sync(), kupdate and such.
4072  *   We wait on commit, if tol to.
4073  *
4074  * - Within prune_icache() (PF_MEMALLOC == true)
4075  *   Here we simply return.  We can't afford to block kswapd on the
4076  *   journal commit.
4077  *
4078  * In all cases it is actually safe for us to return without doing anything,
4079  * because the inode has been copied into a raw inode buffer in
4080  * ext4_mark_inode_dirty().  This is a correctness thing for O_SYNC and for
4081  * knfsd.
4082  *
4083  * Note that we are absolutely dependent upon all inode dirtiers doing the
4084  * right thing: they *must* call mark_inode_dirty() after dirtying info in
4085  * which we are interested.
4086  *
4087  * It would be a bug for them to not do this.  The code:
4088  *
4089  *      mark_inode_dirty(inode)
4090  *      stuff();
4091  *      inode->i_size = expr;
4092  *
4093  * is in error because a kswapd-driven write_inode() could occur while
4094  * `stuff()' is running, and the new i_size will be lost.  Plus the inode
4095  * will no longer be on the superblock's dirty inode list.
4096  */
4097 int ext4_write_inode(struct inode *inode, int wait)
4098 {
4099         if (current->flags & PF_MEMALLOC)
4100                 return 0;
4101
4102         if (ext4_journal_current_handle()) {
4103                 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
4104                 dump_stack();
4105                 return -EIO;
4106         }
4107
4108         if (!wait)
4109                 return 0;
4110
4111         return ext4_force_commit(inode->i_sb);
4112 }
4113
4114 /*
4115  * ext4_setattr()
4116  *
4117  * Called from notify_change.
4118  *
4119  * We want to trap VFS attempts to truncate the file as soon as
4120  * possible.  In particular, we want to make sure that when the VFS
4121  * shrinks i_size, we put the inode on the orphan list and modify
4122  * i_disksize immediately, so that during the subsequent flushing of
4123  * dirty pages and freeing of disk blocks, we can guarantee that any
4124  * commit will leave the blocks being flushed in an unused state on
4125  * disk.  (On recovery, the inode will get truncated and the blocks will
4126  * be freed, so we have a strong guarantee that no future commit will
4127  * leave these blocks visible to the user.)
4128  *
4129  * Another thing we have to assure is that if we are in ordered mode
4130  * and inode is still attached to the committing transaction, we must
4131  * we start writeout of all the dirty pages which are being truncated.
4132  * This way we are sure that all the data written in the previous
4133  * transaction are already on disk (truncate waits for pages under
4134  * writeback).
4135  *
4136  * Called with inode->i_mutex down.
4137  */
4138 int ext4_setattr(struct dentry *dentry, struct iattr *attr)
4139 {
4140         struct inode *inode = dentry->d_inode;
4141         int error, rc = 0;
4142         const unsigned int ia_valid = attr->ia_valid;
4143
4144         error = inode_change_ok(inode, attr);
4145         if (error)
4146                 return error;
4147
4148         if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
4149                 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
4150                 handle_t *handle;
4151
4152                 /* (user+group)*(old+new) structure, inode write (sb,
4153                  * inode block, ? - but truncate inode update has it) */
4154                 handle = ext4_journal_start(inode, 2*(EXT4_QUOTA_INIT_BLOCKS(inode->i_sb)+
4155                                         EXT4_QUOTA_DEL_BLOCKS(inode->i_sb))+3);
4156                 if (IS_ERR(handle)) {
4157                         error = PTR_ERR(handle);
4158                         goto err_out;
4159                 }
4160                 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
4161                 if (error) {
4162                         ext4_journal_stop(handle);
4163                         return error;
4164                 }
4165                 /* Update corresponding info in inode so that everything is in
4166                  * one transaction */
4167                 if (attr->ia_valid & ATTR_UID)
4168                         inode->i_uid = attr->ia_uid;
4169                 if (attr->ia_valid & ATTR_GID)
4170                         inode->i_gid = attr->ia_gid;
4171                 error = ext4_mark_inode_dirty(handle, inode);
4172                 ext4_journal_stop(handle);
4173         }
4174
4175         if (attr->ia_valid & ATTR_SIZE) {
4176                 if (!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)) {
4177                         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4178
4179                         if (attr->ia_size > sbi->s_bitmap_maxbytes) {
4180                                 error = -EFBIG;
4181                                 goto err_out;
4182                         }
4183                 }
4184         }
4185
4186         if (S_ISREG(inode->i_mode) &&
4187             attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
4188                 handle_t *handle;
4189
4190                 handle = ext4_journal_start(inode, 3);
4191                 if (IS_ERR(handle)) {
4192                         error = PTR_ERR(handle);
4193                         goto err_out;
4194                 }
4195
4196                 error = ext4_orphan_add(handle, inode);
4197                 EXT4_I(inode)->i_disksize = attr->ia_size;
4198                 rc = ext4_mark_inode_dirty(handle, inode);
4199                 if (!error)
4200                         error = rc;
4201                 ext4_journal_stop(handle);
4202
4203                 if (ext4_should_order_data(inode)) {
4204                         error = ext4_begin_ordered_truncate(inode,
4205                                                             attr->ia_size);
4206                         if (error) {
4207                                 /* Do as much error cleanup as possible */
4208                                 handle = ext4_journal_start(inode, 3);
4209                                 if (IS_ERR(handle)) {
4210                                         ext4_orphan_del(NULL, inode);
4211                                         goto err_out;
4212                                 }
4213                                 ext4_orphan_del(handle, inode);
4214                                 ext4_journal_stop(handle);
4215                                 goto err_out;
4216                         }
4217                 }
4218         }
4219
4220         rc = inode_setattr(inode, attr);
4221
4222         /* If inode_setattr's call to ext4_truncate failed to get a
4223          * transaction handle at all, we need to clean up the in-core
4224          * orphan list manually. */
4225         if (inode->i_nlink)
4226                 ext4_orphan_del(NULL, inode);
4227
4228         if (!rc && (ia_valid & ATTR_MODE))
4229                 rc = ext4_acl_chmod(inode);
4230
4231 err_out:
4232         ext4_std_error(inode->i_sb, error);
4233         if (!error)
4234                 error = rc;
4235         return error;
4236 }
4237
4238 int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
4239                  struct kstat *stat)
4240 {
4241         struct inode *inode;
4242         unsigned long delalloc_blocks;
4243
4244         inode = dentry->d_inode;
4245         generic_fillattr(inode, stat);
4246
4247         /*
4248          * We can't update i_blocks if the block allocation is delayed
4249          * otherwise in the case of system crash before the real block
4250          * allocation is done, we will have i_blocks inconsistent with
4251          * on-disk file blocks.
4252          * We always keep i_blocks updated together with real
4253          * allocation. But to not confuse with user, stat
4254          * will return the blocks that include the delayed allocation
4255          * blocks for this file.
4256          */
4257         spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
4258         delalloc_blocks = EXT4_I(inode)->i_reserved_data_blocks;
4259         spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
4260
4261         stat->blocks += (delalloc_blocks << inode->i_sb->s_blocksize_bits)>>9;
4262         return 0;
4263 }
4264
4265 /*
4266  * How many blocks doth make a writepage()?
4267  *
4268  * With N blocks per page, it may be:
4269  * N data blocks
4270  * 2 indirect block
4271  * 2 dindirect
4272  * 1 tindirect
4273  * N+5 bitmap blocks (from the above)
4274  * N+5 group descriptor summary blocks
4275  * 1 inode block
4276  * 1 superblock.
4277  * 2 * EXT4_SINGLEDATA_TRANS_BLOCKS for the quote files
4278  *
4279  * 3 * (N + 5) + 2 + 2 * EXT4_SINGLEDATA_TRANS_BLOCKS
4280  *
4281  * With ordered or writeback data it's the same, less the N data blocks.
4282  *
4283  * If the inode's direct blocks can hold an integral number of pages then a
4284  * page cannot straddle two indirect blocks, and we can only touch one indirect
4285  * and dindirect block, and the "5" above becomes "3".
4286  *
4287  * This still overestimates under most circumstances.  If we were to pass the
4288  * start and end offsets in here as well we could do block_to_path() on each
4289  * block and work out the exact number of indirects which are touched.  Pah.
4290  */
4291
4292 int ext4_writepage_trans_blocks(struct inode *inode)
4293 {
4294         int bpp = ext4_journal_blocks_per_page(inode);
4295         int indirects = (EXT4_NDIR_BLOCKS % bpp) ? 5 : 3;
4296         int ret;
4297
4298         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)
4299                 return ext4_ext_writepage_trans_blocks(inode, bpp);
4300
4301         if (ext4_should_journal_data(inode))
4302                 ret = 3 * (bpp + indirects) + 2;
4303         else
4304                 ret = 2 * (bpp + indirects) + 2;
4305
4306 #ifdef CONFIG_QUOTA
4307         /* We know that structure was already allocated during DQUOT_INIT so
4308          * we will be updating only the data blocks + inodes */
4309         ret += 2*EXT4_QUOTA_TRANS_BLOCKS(inode->i_sb);
4310 #endif
4311
4312         return ret;
4313 }
4314
4315 /*
4316  * The caller must have previously called ext4_reserve_inode_write().
4317  * Give this, we know that the caller already has write access to iloc->bh.
4318  */
4319 int ext4_mark_iloc_dirty(handle_t *handle,
4320                 struct inode *inode, struct ext4_iloc *iloc)
4321 {
4322         int err = 0;
4323
4324         if (test_opt(inode->i_sb, I_VERSION))
4325                 inode_inc_iversion(inode);
4326
4327         /* the do_update_inode consumes one bh->b_count */
4328         get_bh(iloc->bh);
4329
4330         /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4331         err = ext4_do_update_inode(handle, inode, iloc);
4332         put_bh(iloc->bh);
4333         return err;
4334 }
4335
4336 /*
4337  * On success, We end up with an outstanding reference count against
4338  * iloc->bh.  This _must_ be cleaned up later.
4339  */
4340
4341 int
4342 ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
4343                          struct ext4_iloc *iloc)
4344 {
4345         int err = 0;
4346         if (handle) {
4347                 err = ext4_get_inode_loc(inode, iloc);
4348                 if (!err) {
4349                         BUFFER_TRACE(iloc->bh, "get_write_access");
4350                         err = ext4_journal_get_write_access(handle, iloc->bh);
4351                         if (err) {
4352                                 brelse(iloc->bh);
4353                                 iloc->bh = NULL;
4354                         }
4355                 }
4356         }
4357         ext4_std_error(inode->i_sb, err);
4358         return err;
4359 }
4360
4361 /*
4362  * Expand an inode by new_extra_isize bytes.
4363  * Returns 0 on success or negative error number on failure.
4364  */
4365 static int ext4_expand_extra_isize(struct inode *inode,
4366                                    unsigned int new_extra_isize,
4367                                    struct ext4_iloc iloc,
4368                                    handle_t *handle)
4369 {
4370         struct ext4_inode *raw_inode;
4371         struct ext4_xattr_ibody_header *header;
4372         struct ext4_xattr_entry *entry;
4373
4374         if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
4375                 return 0;
4376
4377         raw_inode = ext4_raw_inode(&iloc);
4378
4379         header = IHDR(inode, raw_inode);
4380         entry = IFIRST(header);
4381
4382         /* No extended attributes present */
4383         if (!(EXT4_I(inode)->i_state & EXT4_STATE_XATTR) ||
4384                 header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
4385                 memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0,
4386                         new_extra_isize);
4387                 EXT4_I(inode)->i_extra_isize = new_extra_isize;
4388                 return 0;
4389         }
4390
4391         /* try to expand with EAs present */
4392         return ext4_expand_extra_isize_ea(inode, new_extra_isize,
4393                                           raw_inode, handle);
4394 }
4395
4396 /*
4397  * What we do here is to mark the in-core inode as clean with respect to inode
4398  * dirtiness (it may still be data-dirty).
4399  * This means that the in-core inode may be reaped by prune_icache
4400  * without having to perform any I/O.  This is a very good thing,
4401  * because *any* task may call prune_icache - even ones which
4402  * have a transaction open against a different journal.
4403  *
4404  * Is this cheating?  Not really.  Sure, we haven't written the
4405  * inode out, but prune_icache isn't a user-visible syncing function.
4406  * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
4407  * we start and wait on commits.
4408  *
4409  * Is this efficient/effective?  Well, we're being nice to the system
4410  * by cleaning up our inodes proactively so they can be reaped
4411  * without I/O.  But we are potentially leaving up to five seconds'
4412  * worth of inodes floating about which prune_icache wants us to
4413  * write out.  One way to fix that would be to get prune_icache()
4414  * to do a write_super() to free up some memory.  It has the desired
4415  * effect.
4416  */
4417 int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
4418 {
4419         struct ext4_iloc iloc;
4420         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4421         static unsigned int mnt_count;
4422         int err, ret;
4423
4424         might_sleep();
4425         err = ext4_reserve_inode_write(handle, inode, &iloc);
4426         if (EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize &&
4427             !(EXT4_I(inode)->i_state & EXT4_STATE_NO_EXPAND)) {
4428                 /*
4429                  * We need extra buffer credits since we may write into EA block
4430                  * with this same handle. If journal_extend fails, then it will
4431                  * only result in a minor loss of functionality for that inode.
4432                  * If this is felt to be critical, then e2fsck should be run to
4433                  * force a large enough s_min_extra_isize.
4434                  */
4435                 if ((jbd2_journal_extend(handle,
4436                              EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
4437                         ret = ext4_expand_extra_isize(inode,
4438                                                       sbi->s_want_extra_isize,
4439                                                       iloc, handle);
4440                         if (ret) {
4441                                 EXT4_I(inode)->i_state |= EXT4_STATE_NO_EXPAND;
4442                                 if (mnt_count !=
4443                                         le16_to_cpu(sbi->s_es->s_mnt_count)) {
4444                                         ext4_warning(inode->i_sb, __func__,
4445                                         "Unable to expand inode %lu. Delete"
4446                                         " some EAs or run e2fsck.",
4447                                         inode->i_ino);
4448                                         mnt_count =
4449                                           le16_to_cpu(sbi->s_es->s_mnt_count);
4450                                 }
4451                         }
4452                 }
4453         }
4454         if (!err)
4455                 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
4456         return err;
4457 }
4458
4459 /*
4460  * ext4_dirty_inode() is called from __mark_inode_dirty()
4461  *
4462  * We're really interested in the case where a file is being extended.
4463  * i_size has been changed by generic_commit_write() and we thus need
4464  * to include the updated inode in the current transaction.
4465  *
4466  * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks
4467  * are allocated to the file.
4468  *
4469  * If the inode is marked synchronous, we don't honour that here - doing
4470  * so would cause a commit on atime updates, which we don't bother doing.
4471  * We handle synchronous inodes at the highest possible level.
4472  */
4473 void ext4_dirty_inode(struct inode *inode)
4474 {
4475         handle_t *current_handle = ext4_journal_current_handle();
4476         handle_t *handle;
4477
4478         handle = ext4_journal_start(inode, 2);
4479         if (IS_ERR(handle))
4480                 goto out;
4481         if (current_handle &&
4482                 current_handle->h_transaction != handle->h_transaction) {
4483                 /* This task has a transaction open against a different fs */
4484                 printk(KERN_EMERG "%s: transactions do not match!\n",
4485                        __func__);
4486         } else {
4487                 jbd_debug(5, "marking dirty.  outer handle=%p\n",
4488                                 current_handle);
4489                 ext4_mark_inode_dirty(handle, inode);
4490         }
4491         ext4_journal_stop(handle);
4492 out:
4493         return;
4494 }
4495
4496 #if 0
4497 /*
4498  * Bind an inode's backing buffer_head into this transaction, to prevent
4499  * it from being flushed to disk early.  Unlike
4500  * ext4_reserve_inode_write, this leaves behind no bh reference and
4501  * returns no iloc structure, so the caller needs to repeat the iloc
4502  * lookup to mark the inode dirty later.
4503  */
4504 static int ext4_pin_inode(handle_t *handle, struct inode *inode)
4505 {
4506         struct ext4_iloc iloc;
4507
4508         int err = 0;
4509         if (handle) {
4510                 err = ext4_get_inode_loc(inode, &iloc);
4511                 if (!err) {
4512                         BUFFER_TRACE(iloc.bh, "get_write_access");
4513                         err = jbd2_journal_get_write_access(handle, iloc.bh);
4514                         if (!err)
4515                                 err = ext4_journal_dirty_metadata(handle,
4516                                                                   iloc.bh);
4517                         brelse(iloc.bh);
4518                 }
4519         }
4520         ext4_std_error(inode->i_sb, err);
4521         return err;
4522 }
4523 #endif
4524
4525 int ext4_change_inode_journal_flag(struct inode *inode, int val)
4526 {
4527         journal_t *journal;
4528         handle_t *handle;
4529         int err;
4530
4531         /*
4532          * We have to be very careful here: changing a data block's
4533          * journaling status dynamically is dangerous.  If we write a
4534          * data block to the journal, change the status and then delete
4535          * that block, we risk forgetting to revoke the old log record
4536          * from the journal and so a subsequent replay can corrupt data.
4537          * So, first we make sure that the journal is empty and that
4538          * nobody is changing anything.
4539          */
4540
4541         journal = EXT4_JOURNAL(inode);
4542         if (is_journal_aborted(journal))
4543                 return -EROFS;
4544
4545         jbd2_journal_lock_updates(journal);
4546         jbd2_journal_flush(journal);
4547
4548         /*
4549          * OK, there are no updates running now, and all cached data is
4550          * synced to disk.  We are now in a completely consistent state
4551          * which doesn't have anything in the journal, and we know that
4552          * no filesystem updates are running, so it is safe to modify
4553          * the inode's in-core data-journaling state flag now.
4554          */
4555
4556         if (val)
4557                 EXT4_I(inode)->i_flags |= EXT4_JOURNAL_DATA_FL;
4558         else
4559                 EXT4_I(inode)->i_flags &= ~EXT4_JOURNAL_DATA_FL;
4560         ext4_set_aops(inode);
4561
4562         jbd2_journal_unlock_updates(journal);
4563
4564         /* Finally we can mark the inode as dirty. */
4565
4566         handle = ext4_journal_start(inode, 1);
4567         if (IS_ERR(handle))
4568                 return PTR_ERR(handle);
4569
4570         err = ext4_mark_inode_dirty(handle, inode);
4571         handle->h_sync = 1;
4572         ext4_journal_stop(handle);
4573         ext4_std_error(inode->i_sb, err);
4574
4575         return err;
4576 }
4577
4578 static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh)
4579 {
4580         return !buffer_mapped(bh);
4581 }
4582
4583 int ext4_page_mkwrite(struct vm_area_struct *vma, struct page *page)
4584 {
4585         loff_t size;
4586         unsigned long len;
4587         int ret = -EINVAL;
4588         struct file *file = vma->vm_file;
4589         struct inode *inode = file->f_path.dentry->d_inode;
4590         struct address_space *mapping = inode->i_mapping;
4591
4592         /*
4593          * Get i_alloc_sem to stop truncates messing with the inode. We cannot
4594          * get i_mutex because we are already holding mmap_sem.
4595          */
4596         down_read(&inode->i_alloc_sem);
4597         size = i_size_read(inode);
4598         if (page->mapping != mapping || size <= page_offset(page)
4599             || !PageUptodate(page)) {
4600                 /* page got truncated from under us? */
4601                 goto out_unlock;
4602         }
4603         ret = 0;
4604         if (PageMappedToDisk(page))
4605                 goto out_unlock;
4606
4607         if (page->index == size >> PAGE_CACHE_SHIFT)
4608                 len = size & ~PAGE_CACHE_MASK;
4609         else
4610                 len = PAGE_CACHE_SIZE;
4611
4612         if (page_has_buffers(page)) {
4613                 /* return if we have all the buffers mapped */
4614                 if (!walk_page_buffers(NULL, page_buffers(page), 0, len, NULL,
4615                                        ext4_bh_unmapped))
4616                         goto out_unlock;
4617         }
4618         /*
4619          * OK, we need to fill the hole... Do write_begin write_end
4620          * to do block allocation/reservation.We are not holding
4621          * inode.i__mutex here. That allow * parallel write_begin,
4622          * write_end call. lock_page prevent this from happening
4623          * on the same page though
4624          */
4625         ret = mapping->a_ops->write_begin(file, mapping, page_offset(page),
4626                         len, AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
4627         if (ret < 0)
4628                 goto out_unlock;
4629         ret = mapping->a_ops->write_end(file, mapping, page_offset(page),
4630                         len, len, page, NULL);
4631         if (ret < 0)
4632                 goto out_unlock;
4633         ret = 0;
4634 out_unlock:
4635         up_read(&inode->i_alloc_sem);
4636         return ret;
4637 }