5352db1a3086a075f777652b1ac496a1f2c84aaa
[sfrench/cifs-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/namei.h>
38 #include <linux/uio.h>
39 #include <linux/bio.h>
40 #include <linux/workqueue.h>
41
42 #include "ext4_jbd2.h"
43 #include "xattr.h"
44 #include "acl.h"
45 #include "ext4_extents.h"
46
47 #include <trace/events/ext4.h>
48
49 #define MPAGE_DA_EXTENT_TAIL 0x01
50
51 static inline int ext4_begin_ordered_truncate(struct inode *inode,
52                                               loff_t new_size)
53 {
54         return jbd2_journal_begin_ordered_truncate(
55                                         EXT4_SB(inode->i_sb)->s_journal,
56                                         &EXT4_I(inode)->jinode,
57                                         new_size);
58 }
59
60 static void ext4_invalidatepage(struct page *page, unsigned long offset);
61
62 /*
63  * Test whether an inode is a fast symlink.
64  */
65 static int ext4_inode_is_fast_symlink(struct inode *inode)
66 {
67         int ea_blocks = EXT4_I(inode)->i_file_acl ?
68                 (inode->i_sb->s_blocksize >> 9) : 0;
69
70         return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
71 }
72
73 /*
74  * Work out how many blocks we need to proceed with the next chunk of a
75  * truncate transaction.
76  */
77 static unsigned long blocks_for_truncate(struct inode *inode)
78 {
79         ext4_lblk_t needed;
80
81         needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
82
83         /* Give ourselves just enough room to cope with inodes in which
84          * i_blocks is corrupt: we've seen disk corruptions in the past
85          * which resulted in random data in an inode which looked enough
86          * like a regular file for ext4 to try to delete it.  Things
87          * will go a bit crazy if that happens, but at least we should
88          * try not to panic the whole kernel. */
89         if (needed < 2)
90                 needed = 2;
91
92         /* But we need to bound the transaction so we don't overflow the
93          * journal. */
94         if (needed > EXT4_MAX_TRANS_DATA)
95                 needed = EXT4_MAX_TRANS_DATA;
96
97         return EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
98 }
99
100 /*
101  * Truncate transactions can be complex and absolutely huge.  So we need to
102  * be able to restart the transaction at a conventient checkpoint to make
103  * sure we don't overflow the journal.
104  *
105  * start_transaction gets us a new handle for a truncate transaction,
106  * and extend_transaction tries to extend the existing one a bit.  If
107  * extend fails, we need to propagate the failure up and restart the
108  * transaction in the top-level truncate loop. --sct
109  */
110 static handle_t *start_transaction(struct inode *inode)
111 {
112         handle_t *result;
113
114         result = ext4_journal_start(inode, blocks_for_truncate(inode));
115         if (!IS_ERR(result))
116                 return result;
117
118         ext4_std_error(inode->i_sb, PTR_ERR(result));
119         return result;
120 }
121
122 /*
123  * Try to extend this transaction for the purposes of truncation.
124  *
125  * Returns 0 if we managed to create more room.  If we can't create more
126  * room, and the transaction must be restarted we return 1.
127  */
128 static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
129 {
130         if (!ext4_handle_valid(handle))
131                 return 0;
132         if (ext4_handle_has_enough_credits(handle, EXT4_RESERVE_TRANS_BLOCKS+1))
133                 return 0;
134         if (!ext4_journal_extend(handle, blocks_for_truncate(inode)))
135                 return 0;
136         return 1;
137 }
138
139 /*
140  * Restart the transaction associated with *handle.  This does a commit,
141  * so before we call here everything must be consistently dirtied against
142  * this transaction.
143  */
144 int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode,
145                                  int nblocks)
146 {
147         int ret;
148
149         /*
150          * Drop i_data_sem to avoid deadlock with ext4_get_blocks At this
151          * moment, get_block can be called only for blocks inside i_size since
152          * page cache has been already dropped and writes are blocked by
153          * i_mutex. So we can safely drop the i_data_sem here.
154          */
155         BUG_ON(EXT4_JOURNAL(inode) == NULL);
156         jbd_debug(2, "restarting handle %p\n", handle);
157         up_write(&EXT4_I(inode)->i_data_sem);
158         ret = ext4_journal_restart(handle, blocks_for_truncate(inode));
159         down_write(&EXT4_I(inode)->i_data_sem);
160         ext4_discard_preallocations(inode);
161
162         return ret;
163 }
164
165 /*
166  * Called at the last iput() if i_nlink is zero.
167  */
168 void ext4_delete_inode(struct inode *inode)
169 {
170         handle_t *handle;
171         int err;
172
173         if (ext4_should_order_data(inode))
174                 ext4_begin_ordered_truncate(inode, 0);
175         truncate_inode_pages(&inode->i_data, 0);
176
177         if (is_bad_inode(inode))
178                 goto no_delete;
179
180         handle = ext4_journal_start(inode, blocks_for_truncate(inode)+3);
181         if (IS_ERR(handle)) {
182                 ext4_std_error(inode->i_sb, PTR_ERR(handle));
183                 /*
184                  * If we're going to skip the normal cleanup, we still need to
185                  * make sure that the in-core orphan linked list is properly
186                  * cleaned up.
187                  */
188                 ext4_orphan_del(NULL, inode);
189                 goto no_delete;
190         }
191
192         if (IS_SYNC(inode))
193                 ext4_handle_sync(handle);
194         inode->i_size = 0;
195         err = ext4_mark_inode_dirty(handle, inode);
196         if (err) {
197                 ext4_warning(inode->i_sb, __func__,
198                              "couldn't mark inode dirty (err %d)", err);
199                 goto stop_handle;
200         }
201         if (inode->i_blocks)
202                 ext4_truncate(inode);
203
204         /*
205          * ext4_ext_truncate() doesn't reserve any slop when it
206          * restarts journal transactions; therefore there may not be
207          * enough credits left in the handle to remove the inode from
208          * the orphan list and set the dtime field.
209          */
210         if (!ext4_handle_has_enough_credits(handle, 3)) {
211                 err = ext4_journal_extend(handle, 3);
212                 if (err > 0)
213                         err = ext4_journal_restart(handle, 3);
214                 if (err != 0) {
215                         ext4_warning(inode->i_sb, __func__,
216                                      "couldn't extend journal (err %d)", err);
217                 stop_handle:
218                         ext4_journal_stop(handle);
219                         goto no_delete;
220                 }
221         }
222
223         /*
224          * Kill off the orphan record which ext4_truncate created.
225          * AKPM: I think this can be inside the above `if'.
226          * Note that ext4_orphan_del() has to be able to cope with the
227          * deletion of a non-existent orphan - this is because we don't
228          * know if ext4_truncate() actually created an orphan record.
229          * (Well, we could do this if we need to, but heck - it works)
230          */
231         ext4_orphan_del(handle, inode);
232         EXT4_I(inode)->i_dtime  = get_seconds();
233
234         /*
235          * One subtle ordering requirement: if anything has gone wrong
236          * (transaction abort, IO errors, whatever), then we can still
237          * do these next steps (the fs will already have been marked as
238          * having errors), but we can't free the inode if the mark_dirty
239          * fails.
240          */
241         if (ext4_mark_inode_dirty(handle, inode))
242                 /* If that failed, just do the required in-core inode clear. */
243                 clear_inode(inode);
244         else
245                 ext4_free_inode(handle, inode);
246         ext4_journal_stop(handle);
247         return;
248 no_delete:
249         clear_inode(inode);     /* We must guarantee clearing of inode... */
250 }
251
252 typedef struct {
253         __le32  *p;
254         __le32  key;
255         struct buffer_head *bh;
256 } Indirect;
257
258 static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
259 {
260         p->key = *(p->p = v);
261         p->bh = bh;
262 }
263
264 /**
265  *      ext4_block_to_path - parse the block number into array of offsets
266  *      @inode: inode in question (we are only interested in its superblock)
267  *      @i_block: block number to be parsed
268  *      @offsets: array to store the offsets in
269  *      @boundary: set this non-zero if the referred-to block is likely to be
270  *             followed (on disk) by an indirect block.
271  *
272  *      To store the locations of file's data ext4 uses a data structure common
273  *      for UNIX filesystems - tree of pointers anchored in the inode, with
274  *      data blocks at leaves and indirect blocks in intermediate nodes.
275  *      This function translates the block number into path in that tree -
276  *      return value is the path length and @offsets[n] is the offset of
277  *      pointer to (n+1)th node in the nth one. If @block is out of range
278  *      (negative or too large) warning is printed and zero returned.
279  *
280  *      Note: function doesn't find node addresses, so no IO is needed. All
281  *      we need to know is the capacity of indirect blocks (taken from the
282  *      inode->i_sb).
283  */
284
285 /*
286  * Portability note: the last comparison (check that we fit into triple
287  * indirect block) is spelled differently, because otherwise on an
288  * architecture with 32-bit longs and 8Kb pages we might get into trouble
289  * if our filesystem had 8Kb blocks. We might use long long, but that would
290  * kill us on x86. Oh, well, at least the sign propagation does not matter -
291  * i_block would have to be negative in the very beginning, so we would not
292  * get there at all.
293  */
294
295 static int ext4_block_to_path(struct inode *inode,
296                               ext4_lblk_t i_block,
297                               ext4_lblk_t offsets[4], int *boundary)
298 {
299         int ptrs = EXT4_ADDR_PER_BLOCK(inode->i_sb);
300         int ptrs_bits = EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb);
301         const long direct_blocks = EXT4_NDIR_BLOCKS,
302                 indirect_blocks = ptrs,
303                 double_blocks = (1 << (ptrs_bits * 2));
304         int n = 0;
305         int final = 0;
306
307         if (i_block < direct_blocks) {
308                 offsets[n++] = i_block;
309                 final = direct_blocks;
310         } else if ((i_block -= direct_blocks) < indirect_blocks) {
311                 offsets[n++] = EXT4_IND_BLOCK;
312                 offsets[n++] = i_block;
313                 final = ptrs;
314         } else if ((i_block -= indirect_blocks) < double_blocks) {
315                 offsets[n++] = EXT4_DIND_BLOCK;
316                 offsets[n++] = i_block >> ptrs_bits;
317                 offsets[n++] = i_block & (ptrs - 1);
318                 final = ptrs;
319         } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
320                 offsets[n++] = EXT4_TIND_BLOCK;
321                 offsets[n++] = i_block >> (ptrs_bits * 2);
322                 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
323                 offsets[n++] = i_block & (ptrs - 1);
324                 final = ptrs;
325         } else {
326                 ext4_warning(inode->i_sb, "ext4_block_to_path",
327                              "block %lu > max in inode %lu",
328                              i_block + direct_blocks +
329                              indirect_blocks + double_blocks, inode->i_ino);
330         }
331         if (boundary)
332                 *boundary = final - 1 - (i_block & (ptrs - 1));
333         return n;
334 }
335
336 static int __ext4_check_blockref(const char *function, struct inode *inode,
337                                  __le32 *p, unsigned int max)
338 {
339         __le32 *bref = p;
340         unsigned int blk;
341
342         while (bref < p+max) {
343                 blk = le32_to_cpu(*bref++);
344                 if (blk &&
345                     unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
346                                                     blk, 1))) {
347                         ext4_error(inode->i_sb, function,
348                                    "invalid block reference %u "
349                                    "in inode #%lu", blk, inode->i_ino);
350                         return -EIO;
351                 }
352         }
353         return 0;
354 }
355
356
357 #define ext4_check_indirect_blockref(inode, bh)                         \
358         __ext4_check_blockref(__func__, inode, (__le32 *)(bh)->b_data,  \
359                               EXT4_ADDR_PER_BLOCK((inode)->i_sb))
360
361 #define ext4_check_inode_blockref(inode)                                \
362         __ext4_check_blockref(__func__, inode, EXT4_I(inode)->i_data,   \
363                               EXT4_NDIR_BLOCKS)
364
365 /**
366  *      ext4_get_branch - read the chain of indirect blocks leading to data
367  *      @inode: inode in question
368  *      @depth: depth of the chain (1 - direct pointer, etc.)
369  *      @offsets: offsets of pointers in inode/indirect blocks
370  *      @chain: place to store the result
371  *      @err: here we store the error value
372  *
373  *      Function fills the array of triples <key, p, bh> and returns %NULL
374  *      if everything went OK or the pointer to the last filled triple
375  *      (incomplete one) otherwise. Upon the return chain[i].key contains
376  *      the number of (i+1)-th block in the chain (as it is stored in memory,
377  *      i.e. little-endian 32-bit), chain[i].p contains the address of that
378  *      number (it points into struct inode for i==0 and into the bh->b_data
379  *      for i>0) and chain[i].bh points to the buffer_head of i-th indirect
380  *      block for i>0 and NULL for i==0. In other words, it holds the block
381  *      numbers of the chain, addresses they were taken from (and where we can
382  *      verify that chain did not change) and buffer_heads hosting these
383  *      numbers.
384  *
385  *      Function stops when it stumbles upon zero pointer (absent block)
386  *              (pointer to last triple returned, *@err == 0)
387  *      or when it gets an IO error reading an indirect block
388  *              (ditto, *@err == -EIO)
389  *      or when it reads all @depth-1 indirect blocks successfully and finds
390  *      the whole chain, all way to the data (returns %NULL, *err == 0).
391  *
392  *      Need to be called with
393  *      down_read(&EXT4_I(inode)->i_data_sem)
394  */
395 static Indirect *ext4_get_branch(struct inode *inode, int depth,
396                                  ext4_lblk_t  *offsets,
397                                  Indirect chain[4], int *err)
398 {
399         struct super_block *sb = inode->i_sb;
400         Indirect *p = chain;
401         struct buffer_head *bh;
402
403         *err = 0;
404         /* i_data is not going away, no lock needed */
405         add_chain(chain, NULL, EXT4_I(inode)->i_data + *offsets);
406         if (!p->key)
407                 goto no_block;
408         while (--depth) {
409                 bh = sb_getblk(sb, le32_to_cpu(p->key));
410                 if (unlikely(!bh))
411                         goto failure;
412
413                 if (!bh_uptodate_or_lock(bh)) {
414                         if (bh_submit_read(bh) < 0) {
415                                 put_bh(bh);
416                                 goto failure;
417                         }
418                         /* validate block references */
419                         if (ext4_check_indirect_blockref(inode, bh)) {
420                                 put_bh(bh);
421                                 goto failure;
422                         }
423                 }
424
425                 add_chain(++p, bh, (__le32 *)bh->b_data + *++offsets);
426                 /* Reader: end */
427                 if (!p->key)
428                         goto no_block;
429         }
430         return NULL;
431
432 failure:
433         *err = -EIO;
434 no_block:
435         return p;
436 }
437
438 /**
439  *      ext4_find_near - find a place for allocation with sufficient locality
440  *      @inode: owner
441  *      @ind: descriptor of indirect block.
442  *
443  *      This function returns the preferred place for block allocation.
444  *      It is used when heuristic for sequential allocation fails.
445  *      Rules are:
446  *        + if there is a block to the left of our position - allocate near it.
447  *        + if pointer will live in indirect block - allocate near that block.
448  *        + if pointer will live in inode - allocate in the same
449  *          cylinder group.
450  *
451  * In the latter case we colour the starting block by the callers PID to
452  * prevent it from clashing with concurrent allocations for a different inode
453  * in the same block group.   The PID is used here so that functionally related
454  * files will be close-by on-disk.
455  *
456  *      Caller must make sure that @ind is valid and will stay that way.
457  */
458 static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind)
459 {
460         struct ext4_inode_info *ei = EXT4_I(inode);
461         __le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data;
462         __le32 *p;
463         ext4_fsblk_t bg_start;
464         ext4_fsblk_t last_block;
465         ext4_grpblk_t colour;
466         ext4_group_t block_group;
467         int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb));
468
469         /* Try to find previous block */
470         for (p = ind->p - 1; p >= start; p--) {
471                 if (*p)
472                         return le32_to_cpu(*p);
473         }
474
475         /* No such thing, so let's try location of indirect block */
476         if (ind->bh)
477                 return ind->bh->b_blocknr;
478
479         /*
480          * It is going to be referred to from the inode itself? OK, just put it
481          * into the same cylinder group then.
482          */
483         block_group = ei->i_block_group;
484         if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) {
485                 block_group &= ~(flex_size-1);
486                 if (S_ISREG(inode->i_mode))
487                         block_group++;
488         }
489         bg_start = ext4_group_first_block_no(inode->i_sb, block_group);
490         last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
491
492         /*
493          * If we are doing delayed allocation, we don't need take
494          * colour into account.
495          */
496         if (test_opt(inode->i_sb, DELALLOC))
497                 return bg_start;
498
499         if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
500                 colour = (current->pid % 16) *
501                         (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
502         else
503                 colour = (current->pid % 16) * ((last_block - bg_start) / 16);
504         return bg_start + colour;
505 }
506
507 /**
508  *      ext4_find_goal - find a preferred place for allocation.
509  *      @inode: owner
510  *      @block:  block we want
511  *      @partial: pointer to the last triple within a chain
512  *
513  *      Normally this function find the preferred place for block allocation,
514  *      returns it.
515  *      Because this is only used for non-extent files, we limit the block nr
516  *      to 32 bits.
517  */
518 static ext4_fsblk_t ext4_find_goal(struct inode *inode, ext4_lblk_t block,
519                                    Indirect *partial)
520 {
521         ext4_fsblk_t goal;
522
523         /*
524          * XXX need to get goal block from mballoc's data structures
525          */
526
527         goal = ext4_find_near(inode, partial);
528         goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
529         return goal;
530 }
531
532 /**
533  *      ext4_blks_to_allocate: Look up the block map and count the number
534  *      of direct blocks need to be allocated for the given branch.
535  *
536  *      @branch: chain of indirect blocks
537  *      @k: number of blocks need for indirect blocks
538  *      @blks: number of data blocks to be mapped.
539  *      @blocks_to_boundary:  the offset in the indirect block
540  *
541  *      return the total number of blocks to be allocate, including the
542  *      direct and indirect blocks.
543  */
544 static int ext4_blks_to_allocate(Indirect *branch, int k, unsigned int blks,
545                                  int blocks_to_boundary)
546 {
547         unsigned int count = 0;
548
549         /*
550          * Simple case, [t,d]Indirect block(s) has not allocated yet
551          * then it's clear blocks on that path have not allocated
552          */
553         if (k > 0) {
554                 /* right now we don't handle cross boundary allocation */
555                 if (blks < blocks_to_boundary + 1)
556                         count += blks;
557                 else
558                         count += blocks_to_boundary + 1;
559                 return count;
560         }
561
562         count++;
563         while (count < blks && count <= blocks_to_boundary &&
564                 le32_to_cpu(*(branch[0].p + count)) == 0) {
565                 count++;
566         }
567         return count;
568 }
569
570 /**
571  *      ext4_alloc_blocks: multiple allocate blocks needed for a branch
572  *      @indirect_blks: the number of blocks need to allocate for indirect
573  *                      blocks
574  *
575  *      @new_blocks: on return it will store the new block numbers for
576  *      the indirect blocks(if needed) and the first direct block,
577  *      @blks:  on return it will store the total number of allocated
578  *              direct blocks
579  */
580 static int ext4_alloc_blocks(handle_t *handle, struct inode *inode,
581                              ext4_lblk_t iblock, ext4_fsblk_t goal,
582                              int indirect_blks, int blks,
583                              ext4_fsblk_t new_blocks[4], int *err)
584 {
585         struct ext4_allocation_request ar;
586         int target, i;
587         unsigned long count = 0, blk_allocated = 0;
588         int index = 0;
589         ext4_fsblk_t current_block = 0;
590         int ret = 0;
591
592         /*
593          * Here we try to allocate the requested multiple blocks at once,
594          * on a best-effort basis.
595          * To build a branch, we should allocate blocks for
596          * the indirect blocks(if not allocated yet), and at least
597          * the first direct block of this branch.  That's the
598          * minimum number of blocks need to allocate(required)
599          */
600         /* first we try to allocate the indirect blocks */
601         target = indirect_blks;
602         while (target > 0) {
603                 count = target;
604                 /* allocating blocks for indirect blocks and direct blocks */
605                 current_block = ext4_new_meta_blocks(handle, inode,
606                                                         goal, &count, err);
607                 if (*err)
608                         goto failed_out;
609
610                 BUG_ON(current_block + count > EXT4_MAX_BLOCK_FILE_PHYS);
611
612                 target -= count;
613                 /* allocate blocks for indirect blocks */
614                 while (index < indirect_blks && count) {
615                         new_blocks[index++] = current_block++;
616                         count--;
617                 }
618                 if (count > 0) {
619                         /*
620                          * save the new block number
621                          * for the first direct block
622                          */
623                         new_blocks[index] = current_block;
624                         printk(KERN_INFO "%s returned more blocks than "
625                                                 "requested\n", __func__);
626                         WARN_ON(1);
627                         break;
628                 }
629         }
630
631         target = blks - count ;
632         blk_allocated = count;
633         if (!target)
634                 goto allocated;
635         /* Now allocate data blocks */
636         memset(&ar, 0, sizeof(ar));
637         ar.inode = inode;
638         ar.goal = goal;
639         ar.len = target;
640         ar.logical = iblock;
641         if (S_ISREG(inode->i_mode))
642                 /* enable in-core preallocation only for regular files */
643                 ar.flags = EXT4_MB_HINT_DATA;
644
645         current_block = ext4_mb_new_blocks(handle, &ar, err);
646         BUG_ON(current_block + ar.len > EXT4_MAX_BLOCK_FILE_PHYS);
647
648         if (*err && (target == blks)) {
649                 /*
650                  * if the allocation failed and we didn't allocate
651                  * any blocks before
652                  */
653                 goto failed_out;
654         }
655         if (!*err) {
656                 if (target == blks) {
657                         /*
658                          * save the new block number
659                          * for the first direct block
660                          */
661                         new_blocks[index] = current_block;
662                 }
663                 blk_allocated += ar.len;
664         }
665 allocated:
666         /* total number of blocks allocated for direct blocks */
667         ret = blk_allocated;
668         *err = 0;
669         return ret;
670 failed_out:
671         for (i = 0; i < index; i++)
672                 ext4_free_blocks(handle, inode, 0, new_blocks[i], 1, 0);
673         return ret;
674 }
675
676 /**
677  *      ext4_alloc_branch - allocate and set up a chain of blocks.
678  *      @inode: owner
679  *      @indirect_blks: number of allocated indirect blocks
680  *      @blks: number of allocated direct blocks
681  *      @offsets: offsets (in the blocks) to store the pointers to next.
682  *      @branch: place to store the chain in.
683  *
684  *      This function allocates blocks, zeroes out all but the last one,
685  *      links them into chain and (if we are synchronous) writes them to disk.
686  *      In other words, it prepares a branch that can be spliced onto the
687  *      inode. It stores the information about that chain in the branch[], in
688  *      the same format as ext4_get_branch() would do. We are calling it after
689  *      we had read the existing part of chain and partial points to the last
690  *      triple of that (one with zero ->key). Upon the exit we have the same
691  *      picture as after the successful ext4_get_block(), except that in one
692  *      place chain is disconnected - *branch->p is still zero (we did not
693  *      set the last link), but branch->key contains the number that should
694  *      be placed into *branch->p to fill that gap.
695  *
696  *      If allocation fails we free all blocks we've allocated (and forget
697  *      their buffer_heads) and return the error value the from failed
698  *      ext4_alloc_block() (normally -ENOSPC). Otherwise we set the chain
699  *      as described above and return 0.
700  */
701 static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
702                              ext4_lblk_t iblock, int indirect_blks,
703                              int *blks, ext4_fsblk_t goal,
704                              ext4_lblk_t *offsets, Indirect *branch)
705 {
706         int blocksize = inode->i_sb->s_blocksize;
707         int i, n = 0;
708         int err = 0;
709         struct buffer_head *bh;
710         int num;
711         ext4_fsblk_t new_blocks[4];
712         ext4_fsblk_t current_block;
713
714         num = ext4_alloc_blocks(handle, inode, iblock, goal, indirect_blks,
715                                 *blks, new_blocks, &err);
716         if (err)
717                 return err;
718
719         branch[0].key = cpu_to_le32(new_blocks[0]);
720         /*
721          * metadata blocks and data blocks are allocated.
722          */
723         for (n = 1; n <= indirect_blks;  n++) {
724                 /*
725                  * Get buffer_head for parent block, zero it out
726                  * and set the pointer to new one, then send
727                  * parent to disk.
728                  */
729                 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
730                 branch[n].bh = bh;
731                 lock_buffer(bh);
732                 BUFFER_TRACE(bh, "call get_create_access");
733                 err = ext4_journal_get_create_access(handle, bh);
734                 if (err) {
735                         /* Don't brelse(bh) here; it's done in
736                          * ext4_journal_forget() below */
737                         unlock_buffer(bh);
738                         goto failed;
739                 }
740
741                 memset(bh->b_data, 0, blocksize);
742                 branch[n].p = (__le32 *) bh->b_data + offsets[n];
743                 branch[n].key = cpu_to_le32(new_blocks[n]);
744                 *branch[n].p = branch[n].key;
745                 if (n == indirect_blks) {
746                         current_block = new_blocks[n];
747                         /*
748                          * End of chain, update the last new metablock of
749                          * the chain to point to the new allocated
750                          * data blocks numbers
751                          */
752                         for (i = 1; i < num; i++)
753                                 *(branch[n].p + i) = cpu_to_le32(++current_block);
754                 }
755                 BUFFER_TRACE(bh, "marking uptodate");
756                 set_buffer_uptodate(bh);
757                 unlock_buffer(bh);
758
759                 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
760                 err = ext4_handle_dirty_metadata(handle, inode, bh);
761                 if (err)
762                         goto failed;
763         }
764         *blks = num;
765         return err;
766 failed:
767         /* Allocation failed, free what we already allocated */
768         ext4_free_blocks(handle, inode, 0, new_blocks[0], 1, 0);
769         for (i = 1; i <= n ; i++) {
770                 /* 
771                  * branch[i].bh is newly allocated, so there is no
772                  * need to revoke the block, which is why we don't
773                  * need to set EXT4_FREE_BLOCKS_METADATA.
774                  */
775                 ext4_free_blocks(handle, inode, 0, new_blocks[i], 1,
776                                  EXT4_FREE_BLOCKS_FORGET);
777         }
778         for (i = n+1; i < indirect_blks; i++)
779                 ext4_free_blocks(handle, inode, 0, new_blocks[i], 1, 0);
780
781         ext4_free_blocks(handle, inode, 0, new_blocks[i], num, 0);
782
783         return err;
784 }
785
786 /**
787  * ext4_splice_branch - splice the allocated branch onto inode.
788  * @inode: owner
789  * @block: (logical) number of block we are adding
790  * @chain: chain of indirect blocks (with a missing link - see
791  *      ext4_alloc_branch)
792  * @where: location of missing link
793  * @num:   number of indirect blocks we are adding
794  * @blks:  number of direct blocks we are adding
795  *
796  * This function fills the missing link and does all housekeeping needed in
797  * inode (->i_blocks, etc.). In case of success we end up with the full
798  * chain to new block and return 0.
799  */
800 static int ext4_splice_branch(handle_t *handle, struct inode *inode,
801                               ext4_lblk_t block, Indirect *where, int num,
802                               int blks)
803 {
804         int i;
805         int err = 0;
806         ext4_fsblk_t current_block;
807
808         /*
809          * If we're splicing into a [td]indirect block (as opposed to the
810          * inode) then we need to get write access to the [td]indirect block
811          * before the splice.
812          */
813         if (where->bh) {
814                 BUFFER_TRACE(where->bh, "get_write_access");
815                 err = ext4_journal_get_write_access(handle, where->bh);
816                 if (err)
817                         goto err_out;
818         }
819         /* That's it */
820
821         *where->p = where->key;
822
823         /*
824          * Update the host buffer_head or inode to point to more just allocated
825          * direct blocks blocks
826          */
827         if (num == 0 && blks > 1) {
828                 current_block = le32_to_cpu(where->key) + 1;
829                 for (i = 1; i < blks; i++)
830                         *(where->p + i) = cpu_to_le32(current_block++);
831         }
832
833         /* We are done with atomic stuff, now do the rest of housekeeping */
834         /* had we spliced it onto indirect block? */
835         if (where->bh) {
836                 /*
837                  * If we spliced it onto an indirect block, we haven't
838                  * altered the inode.  Note however that if it is being spliced
839                  * onto an indirect block at the very end of the file (the
840                  * file is growing) then we *will* alter the inode to reflect
841                  * the new i_size.  But that is not done here - it is done in
842                  * generic_commit_write->__mark_inode_dirty->ext4_dirty_inode.
843                  */
844                 jbd_debug(5, "splicing indirect only\n");
845                 BUFFER_TRACE(where->bh, "call ext4_handle_dirty_metadata");
846                 err = ext4_handle_dirty_metadata(handle, inode, where->bh);
847                 if (err)
848                         goto err_out;
849         } else {
850                 /*
851                  * OK, we spliced it into the inode itself on a direct block.
852                  */
853                 ext4_mark_inode_dirty(handle, inode);
854                 jbd_debug(5, "splicing direct\n");
855         }
856         return err;
857
858 err_out:
859         for (i = 1; i <= num; i++) {
860                 /* 
861                  * branch[i].bh is newly allocated, so there is no
862                  * need to revoke the block, which is why we don't
863                  * need to set EXT4_FREE_BLOCKS_METADATA.
864                  */
865                 ext4_free_blocks(handle, inode, where[i].bh, 0, 1,
866                                  EXT4_FREE_BLOCKS_FORGET);
867         }
868         ext4_free_blocks(handle, inode, 0, le32_to_cpu(where[num].key),
869                          blks, 0);
870
871         return err;
872 }
873
874 /*
875  * The ext4_ind_get_blocks() function handles non-extents inodes
876  * (i.e., using the traditional indirect/double-indirect i_blocks
877  * scheme) for ext4_get_blocks().
878  *
879  * Allocation strategy is simple: if we have to allocate something, we will
880  * have to go the whole way to leaf. So let's do it before attaching anything
881  * to tree, set linkage between the newborn blocks, write them if sync is
882  * required, recheck the path, free and repeat if check fails, otherwise
883  * set the last missing link (that will protect us from any truncate-generated
884  * removals - all blocks on the path are immune now) and possibly force the
885  * write on the parent block.
886  * That has a nice additional property: no special recovery from the failed
887  * allocations is needed - we simply release blocks and do not touch anything
888  * reachable from inode.
889  *
890  * `handle' can be NULL if create == 0.
891  *
892  * return > 0, # of blocks mapped or allocated.
893  * return = 0, if plain lookup failed.
894  * return < 0, error case.
895  *
896  * The ext4_ind_get_blocks() function should be called with
897  * down_write(&EXT4_I(inode)->i_data_sem) if allocating filesystem
898  * blocks (i.e., flags has EXT4_GET_BLOCKS_CREATE set) or
899  * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system
900  * blocks.
901  */
902 static int ext4_ind_get_blocks(handle_t *handle, struct inode *inode,
903                                ext4_lblk_t iblock, unsigned int maxblocks,
904                                struct buffer_head *bh_result,
905                                int flags)
906 {
907         int err = -EIO;
908         ext4_lblk_t offsets[4];
909         Indirect chain[4];
910         Indirect *partial;
911         ext4_fsblk_t goal;
912         int indirect_blks;
913         int blocks_to_boundary = 0;
914         int depth;
915         int count = 0;
916         ext4_fsblk_t first_block = 0;
917
918         J_ASSERT(!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL));
919         J_ASSERT(handle != NULL || (flags & EXT4_GET_BLOCKS_CREATE) == 0);
920         depth = ext4_block_to_path(inode, iblock, offsets,
921                                    &blocks_to_boundary);
922
923         if (depth == 0)
924                 goto out;
925
926         partial = ext4_get_branch(inode, depth, offsets, chain, &err);
927
928         /* Simplest case - block found, no allocation needed */
929         if (!partial) {
930                 first_block = le32_to_cpu(chain[depth - 1].key);
931                 clear_buffer_new(bh_result);
932                 count++;
933                 /*map more blocks*/
934                 while (count < maxblocks && count <= blocks_to_boundary) {
935                         ext4_fsblk_t blk;
936
937                         blk = le32_to_cpu(*(chain[depth-1].p + count));
938
939                         if (blk == first_block + count)
940                                 count++;
941                         else
942                                 break;
943                 }
944                 goto got_it;
945         }
946
947         /* Next simple case - plain lookup or failed read of indirect block */
948         if ((flags & EXT4_GET_BLOCKS_CREATE) == 0 || err == -EIO)
949                 goto cleanup;
950
951         /*
952          * Okay, we need to do block allocation.
953         */
954         goal = ext4_find_goal(inode, iblock, partial);
955
956         /* the number of blocks need to allocate for [d,t]indirect blocks */
957         indirect_blks = (chain + depth) - partial - 1;
958
959         /*
960          * Next look up the indirect map to count the totoal number of
961          * direct blocks to allocate for this branch.
962          */
963         count = ext4_blks_to_allocate(partial, indirect_blks,
964                                         maxblocks, blocks_to_boundary);
965         /*
966          * Block out ext4_truncate while we alter the tree
967          */
968         err = ext4_alloc_branch(handle, inode, iblock, indirect_blks,
969                                 &count, goal,
970                                 offsets + (partial - chain), partial);
971
972         /*
973          * The ext4_splice_branch call will free and forget any buffers
974          * on the new chain if there is a failure, but that risks using
975          * up transaction credits, especially for bitmaps where the
976          * credits cannot be returned.  Can we handle this somehow?  We
977          * may need to return -EAGAIN upwards in the worst case.  --sct
978          */
979         if (!err)
980                 err = ext4_splice_branch(handle, inode, iblock,
981                                          partial, indirect_blks, count);
982         if (err)
983                 goto cleanup;
984
985         set_buffer_new(bh_result);
986
987         ext4_update_inode_fsync_trans(handle, inode, 1);
988 got_it:
989         map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
990         if (count > blocks_to_boundary)
991                 set_buffer_boundary(bh_result);
992         err = count;
993         /* Clean up and exit */
994         partial = chain + depth - 1;    /* the whole chain */
995 cleanup:
996         while (partial > chain) {
997                 BUFFER_TRACE(partial->bh, "call brelse");
998                 brelse(partial->bh);
999                 partial--;
1000         }
1001         BUFFER_TRACE(bh_result, "returned");
1002 out:
1003         return err;
1004 }
1005
1006 qsize_t ext4_get_reserved_space(struct inode *inode)
1007 {
1008         unsigned long long total;
1009
1010         spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1011         total = EXT4_I(inode)->i_reserved_data_blocks +
1012                 EXT4_I(inode)->i_reserved_meta_blocks;
1013         spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1014
1015         return (total << inode->i_blkbits);
1016 }
1017 /*
1018  * Calculate the number of metadata blocks need to reserve
1019  * to allocate @blocks for non extent file based file
1020  */
1021 static int ext4_indirect_calc_metadata_amount(struct inode *inode, int blocks)
1022 {
1023         int icap = EXT4_ADDR_PER_BLOCK(inode->i_sb);
1024         int ind_blks, dind_blks, tind_blks;
1025
1026         /* number of new indirect blocks needed */
1027         ind_blks = (blocks + icap - 1) / icap;
1028
1029         dind_blks = (ind_blks + icap - 1) / icap;
1030
1031         tind_blks = 1;
1032
1033         return ind_blks + dind_blks + tind_blks;
1034 }
1035
1036 /*
1037  * Calculate the number of metadata blocks need to reserve
1038  * to allocate given number of blocks
1039  */
1040 static int ext4_calc_metadata_amount(struct inode *inode, int blocks)
1041 {
1042         if (!blocks)
1043                 return 0;
1044
1045         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)
1046                 return ext4_ext_calc_metadata_amount(inode, blocks);
1047
1048         return ext4_indirect_calc_metadata_amount(inode, blocks);
1049 }
1050
1051 static void ext4_da_update_reserve_space(struct inode *inode, int used)
1052 {
1053         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1054         int total, mdb, mdb_free;
1055
1056         spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1057         /* recalculate the number of metablocks still need to be reserved */
1058         total = EXT4_I(inode)->i_reserved_data_blocks - used;
1059         mdb = ext4_calc_metadata_amount(inode, total);
1060
1061         /* figure out how many metablocks to release */
1062         BUG_ON(mdb > EXT4_I(inode)->i_reserved_meta_blocks);
1063         mdb_free = EXT4_I(inode)->i_reserved_meta_blocks - mdb;
1064
1065         if (mdb_free) {
1066                 /* Account for allocated meta_blocks */
1067                 mdb_free -= EXT4_I(inode)->i_allocated_meta_blocks;
1068
1069                 /* update fs dirty blocks counter */
1070                 percpu_counter_sub(&sbi->s_dirtyblocks_counter, mdb_free);
1071                 EXT4_I(inode)->i_allocated_meta_blocks = 0;
1072                 EXT4_I(inode)->i_reserved_meta_blocks = mdb;
1073         }
1074
1075         /* update per-inode reservations */
1076         BUG_ON(used  > EXT4_I(inode)->i_reserved_data_blocks);
1077         EXT4_I(inode)->i_reserved_data_blocks -= used;
1078         spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1079
1080         /*
1081          * free those over-booking quota for metadata blocks
1082          */
1083         if (mdb_free)
1084                 vfs_dq_release_reservation_block(inode, mdb_free);
1085
1086         /*
1087          * If we have done all the pending block allocations and if
1088          * there aren't any writers on the inode, we can discard the
1089          * inode's preallocations.
1090          */
1091         if (!total && (atomic_read(&inode->i_writecount) == 0))
1092                 ext4_discard_preallocations(inode);
1093 }
1094
1095 static int check_block_validity(struct inode *inode, const char *msg,
1096                                 sector_t logical, sector_t phys, int len)
1097 {
1098         if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), phys, len)) {
1099                 ext4_error(inode->i_sb, msg,
1100                            "inode #%lu logical block %llu mapped to %llu "
1101                            "(size %d)", inode->i_ino,
1102                            (unsigned long long) logical,
1103                            (unsigned long long) phys, len);
1104                 return -EIO;
1105         }
1106         return 0;
1107 }
1108
1109 /*
1110  * Return the number of contiguous dirty pages in a given inode
1111  * starting at page frame idx.
1112  */
1113 static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx,
1114                                     unsigned int max_pages)
1115 {
1116         struct address_space *mapping = inode->i_mapping;
1117         pgoff_t index;
1118         struct pagevec pvec;
1119         pgoff_t num = 0;
1120         int i, nr_pages, done = 0;
1121
1122         if (max_pages == 0)
1123                 return 0;
1124         pagevec_init(&pvec, 0);
1125         while (!done) {
1126                 index = idx;
1127                 nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1128                                               PAGECACHE_TAG_DIRTY,
1129                                               (pgoff_t)PAGEVEC_SIZE);
1130                 if (nr_pages == 0)
1131                         break;
1132                 for (i = 0; i < nr_pages; i++) {
1133                         struct page *page = pvec.pages[i];
1134                         struct buffer_head *bh, *head;
1135
1136                         lock_page(page);
1137                         if (unlikely(page->mapping != mapping) ||
1138                             !PageDirty(page) ||
1139                             PageWriteback(page) ||
1140                             page->index != idx) {
1141                                 done = 1;
1142                                 unlock_page(page);
1143                                 break;
1144                         }
1145                         if (page_has_buffers(page)) {
1146                                 bh = head = page_buffers(page);
1147                                 do {
1148                                         if (!buffer_delay(bh) &&
1149                                             !buffer_unwritten(bh))
1150                                                 done = 1;
1151                                         bh = bh->b_this_page;
1152                                 } while (!done && (bh != head));
1153                         }
1154                         unlock_page(page);
1155                         if (done)
1156                                 break;
1157                         idx++;
1158                         num++;
1159                         if (num >= max_pages)
1160                                 break;
1161                 }
1162                 pagevec_release(&pvec);
1163         }
1164         return num;
1165 }
1166
1167 /*
1168  * The ext4_get_blocks() function tries to look up the requested blocks,
1169  * and returns if the blocks are already mapped.
1170  *
1171  * Otherwise it takes the write lock of the i_data_sem and allocate blocks
1172  * and store the allocated blocks in the result buffer head and mark it
1173  * mapped.
1174  *
1175  * If file type is extents based, it will call ext4_ext_get_blocks(),
1176  * Otherwise, call with ext4_ind_get_blocks() to handle indirect mapping
1177  * based files
1178  *
1179  * On success, it returns the number of blocks being mapped or allocate.
1180  * if create==0 and the blocks are pre-allocated and uninitialized block,
1181  * the result buffer head is unmapped. If the create ==1, it will make sure
1182  * the buffer head is mapped.
1183  *
1184  * It returns 0 if plain look up failed (blocks have not been allocated), in
1185  * that casem, buffer head is unmapped
1186  *
1187  * It returns the error in case of allocation failure.
1188  */
1189 int ext4_get_blocks(handle_t *handle, struct inode *inode, sector_t block,
1190                     unsigned int max_blocks, struct buffer_head *bh,
1191                     int flags)
1192 {
1193         int retval;
1194
1195         clear_buffer_mapped(bh);
1196         clear_buffer_unwritten(bh);
1197
1198         ext_debug("ext4_get_blocks(): inode %lu, flag %d, max_blocks %u,"
1199                   "logical block %lu\n", inode->i_ino, flags, max_blocks,
1200                   (unsigned long)block);
1201         /*
1202          * Try to see if we can get the block without requesting a new
1203          * file system block.
1204          */
1205         down_read((&EXT4_I(inode)->i_data_sem));
1206         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
1207                 retval =  ext4_ext_get_blocks(handle, inode, block, max_blocks,
1208                                 bh, 0);
1209         } else {
1210                 retval = ext4_ind_get_blocks(handle, inode, block, max_blocks,
1211                                              bh, 0);
1212         }
1213         up_read((&EXT4_I(inode)->i_data_sem));
1214
1215         if (retval > 0 && buffer_mapped(bh)) {
1216                 int ret = check_block_validity(inode, "file system corruption",
1217                                                block, bh->b_blocknr, retval);
1218                 if (ret != 0)
1219                         return ret;
1220         }
1221
1222         /* If it is only a block(s) look up */
1223         if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
1224                 return retval;
1225
1226         /*
1227          * Returns if the blocks have already allocated
1228          *
1229          * Note that if blocks have been preallocated
1230          * ext4_ext_get_block() returns th create = 0
1231          * with buffer head unmapped.
1232          */
1233         if (retval > 0 && buffer_mapped(bh))
1234                 return retval;
1235
1236         /*
1237          * When we call get_blocks without the create flag, the
1238          * BH_Unwritten flag could have gotten set if the blocks
1239          * requested were part of a uninitialized extent.  We need to
1240          * clear this flag now that we are committed to convert all or
1241          * part of the uninitialized extent to be an initialized
1242          * extent.  This is because we need to avoid the combination
1243          * of BH_Unwritten and BH_Mapped flags being simultaneously
1244          * set on the buffer_head.
1245          */
1246         clear_buffer_unwritten(bh);
1247
1248         /*
1249          * New blocks allocate and/or writing to uninitialized extent
1250          * will possibly result in updating i_data, so we take
1251          * the write lock of i_data_sem, and call get_blocks()
1252          * with create == 1 flag.
1253          */
1254         down_write((&EXT4_I(inode)->i_data_sem));
1255
1256         /*
1257          * if the caller is from delayed allocation writeout path
1258          * we have already reserved fs blocks for allocation
1259          * let the underlying get_block() function know to
1260          * avoid double accounting
1261          */
1262         if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
1263                 EXT4_I(inode)->i_delalloc_reserved_flag = 1;
1264         /*
1265          * We need to check for EXT4 here because migrate
1266          * could have changed the inode type in between
1267          */
1268         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
1269                 retval =  ext4_ext_get_blocks(handle, inode, block, max_blocks,
1270                                               bh, flags);
1271         } else {
1272                 retval = ext4_ind_get_blocks(handle, inode, block,
1273                                              max_blocks, bh, flags);
1274
1275                 if (retval > 0 && buffer_new(bh)) {
1276                         /*
1277                          * We allocated new blocks which will result in
1278                          * i_data's format changing.  Force the migrate
1279                          * to fail by clearing migrate flags
1280                          */
1281                         EXT4_I(inode)->i_state &= ~EXT4_STATE_EXT_MIGRATE;
1282                 }
1283         }
1284
1285         if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
1286                 EXT4_I(inode)->i_delalloc_reserved_flag = 0;
1287
1288         /*
1289          * Update reserved blocks/metadata blocks after successful
1290          * block allocation which had been deferred till now.
1291          */
1292         if ((retval > 0) && (flags & EXT4_GET_BLOCKS_UPDATE_RESERVE_SPACE))
1293                 ext4_da_update_reserve_space(inode, retval);
1294
1295         up_write((&EXT4_I(inode)->i_data_sem));
1296         if (retval > 0 && buffer_mapped(bh)) {
1297                 int ret = check_block_validity(inode, "file system "
1298                                                "corruption after allocation",
1299                                                block, bh->b_blocknr, retval);
1300                 if (ret != 0)
1301                         return ret;
1302         }
1303         return retval;
1304 }
1305
1306 /* Maximum number of blocks we map for direct IO at once. */
1307 #define DIO_MAX_BLOCKS 4096
1308
1309 int ext4_get_block(struct inode *inode, sector_t iblock,
1310                    struct buffer_head *bh_result, int create)
1311 {
1312         handle_t *handle = ext4_journal_current_handle();
1313         int ret = 0, started = 0;
1314         unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
1315         int dio_credits;
1316
1317         if (create && !handle) {
1318                 /* Direct IO write... */
1319                 if (max_blocks > DIO_MAX_BLOCKS)
1320                         max_blocks = DIO_MAX_BLOCKS;
1321                 dio_credits = ext4_chunk_trans_blocks(inode, max_blocks);
1322                 handle = ext4_journal_start(inode, dio_credits);
1323                 if (IS_ERR(handle)) {
1324                         ret = PTR_ERR(handle);
1325                         goto out;
1326                 }
1327                 started = 1;
1328         }
1329
1330         ret = ext4_get_blocks(handle, inode, iblock, max_blocks, bh_result,
1331                               create ? EXT4_GET_BLOCKS_CREATE : 0);
1332         if (ret > 0) {
1333                 bh_result->b_size = (ret << inode->i_blkbits);
1334                 ret = 0;
1335         }
1336         if (started)
1337                 ext4_journal_stop(handle);
1338 out:
1339         return ret;
1340 }
1341
1342 /*
1343  * `handle' can be NULL if create is zero
1344  */
1345 struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
1346                                 ext4_lblk_t block, int create, int *errp)
1347 {
1348         struct buffer_head dummy;
1349         int fatal = 0, err;
1350         int flags = 0;
1351
1352         J_ASSERT(handle != NULL || create == 0);
1353
1354         dummy.b_state = 0;
1355         dummy.b_blocknr = -1000;
1356         buffer_trace_init(&dummy.b_history);
1357         if (create)
1358                 flags |= EXT4_GET_BLOCKS_CREATE;
1359         err = ext4_get_blocks(handle, inode, block, 1, &dummy, flags);
1360         /*
1361          * ext4_get_blocks() returns number of blocks mapped. 0 in
1362          * case of a HOLE.
1363          */
1364         if (err > 0) {
1365                 if (err > 1)
1366                         WARN_ON(1);
1367                 err = 0;
1368         }
1369         *errp = err;
1370         if (!err && buffer_mapped(&dummy)) {
1371                 struct buffer_head *bh;
1372                 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
1373                 if (!bh) {
1374                         *errp = -EIO;
1375                         goto err;
1376                 }
1377                 if (buffer_new(&dummy)) {
1378                         J_ASSERT(create != 0);
1379                         J_ASSERT(handle != NULL);
1380
1381                         /*
1382                          * Now that we do not always journal data, we should
1383                          * keep in mind whether this should always journal the
1384                          * new buffer as metadata.  For now, regular file
1385                          * writes use ext4_get_block instead, so it's not a
1386                          * problem.
1387                          */
1388                         lock_buffer(bh);
1389                         BUFFER_TRACE(bh, "call get_create_access");
1390                         fatal = ext4_journal_get_create_access(handle, bh);
1391                         if (!fatal && !buffer_uptodate(bh)) {
1392                                 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
1393                                 set_buffer_uptodate(bh);
1394                         }
1395                         unlock_buffer(bh);
1396                         BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
1397                         err = ext4_handle_dirty_metadata(handle, inode, bh);
1398                         if (!fatal)
1399                                 fatal = err;
1400                 } else {
1401                         BUFFER_TRACE(bh, "not a new buffer");
1402                 }
1403                 if (fatal) {
1404                         *errp = fatal;
1405                         brelse(bh);
1406                         bh = NULL;
1407                 }
1408                 return bh;
1409         }
1410 err:
1411         return NULL;
1412 }
1413
1414 struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
1415                                ext4_lblk_t block, int create, int *err)
1416 {
1417         struct buffer_head *bh;
1418
1419         bh = ext4_getblk(handle, inode, block, create, err);
1420         if (!bh)
1421                 return bh;
1422         if (buffer_uptodate(bh))
1423                 return bh;
1424         ll_rw_block(READ_META, 1, &bh);
1425         wait_on_buffer(bh);
1426         if (buffer_uptodate(bh))
1427                 return bh;
1428         put_bh(bh);
1429         *err = -EIO;
1430         return NULL;
1431 }
1432
1433 static int walk_page_buffers(handle_t *handle,
1434                              struct buffer_head *head,
1435                              unsigned from,
1436                              unsigned to,
1437                              int *partial,
1438                              int (*fn)(handle_t *handle,
1439                                        struct buffer_head *bh))
1440 {
1441         struct buffer_head *bh;
1442         unsigned block_start, block_end;
1443         unsigned blocksize = head->b_size;
1444         int err, ret = 0;
1445         struct buffer_head *next;
1446
1447         for (bh = head, block_start = 0;
1448              ret == 0 && (bh != head || !block_start);
1449              block_start = block_end, bh = next) {
1450                 next = bh->b_this_page;
1451                 block_end = block_start + blocksize;
1452                 if (block_end <= from || block_start >= to) {
1453                         if (partial && !buffer_uptodate(bh))
1454                                 *partial = 1;
1455                         continue;
1456                 }
1457                 err = (*fn)(handle, bh);
1458                 if (!ret)
1459                         ret = err;
1460         }
1461         return ret;
1462 }
1463
1464 /*
1465  * To preserve ordering, it is essential that the hole instantiation and
1466  * the data write be encapsulated in a single transaction.  We cannot
1467  * close off a transaction and start a new one between the ext4_get_block()
1468  * and the commit_write().  So doing the jbd2_journal_start at the start of
1469  * prepare_write() is the right place.
1470  *
1471  * Also, this function can nest inside ext4_writepage() ->
1472  * block_write_full_page(). In that case, we *know* that ext4_writepage()
1473  * has generated enough buffer credits to do the whole page.  So we won't
1474  * block on the journal in that case, which is good, because the caller may
1475  * be PF_MEMALLOC.
1476  *
1477  * By accident, ext4 can be reentered when a transaction is open via
1478  * quota file writes.  If we were to commit the transaction while thus
1479  * reentered, there can be a deadlock - we would be holding a quota
1480  * lock, and the commit would never complete if another thread had a
1481  * transaction open and was blocking on the quota lock - a ranking
1482  * violation.
1483  *
1484  * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
1485  * will _not_ run commit under these circumstances because handle->h_ref
1486  * is elevated.  We'll still have enough credits for the tiny quotafile
1487  * write.
1488  */
1489 static int do_journal_get_write_access(handle_t *handle,
1490                                        struct buffer_head *bh)
1491 {
1492         if (!buffer_mapped(bh) || buffer_freed(bh))
1493                 return 0;
1494         return ext4_journal_get_write_access(handle, bh);
1495 }
1496
1497 /*
1498  * Truncate blocks that were not used by write. We have to truncate the
1499  * pagecache as well so that corresponding buffers get properly unmapped.
1500  */
1501 static void ext4_truncate_failed_write(struct inode *inode)
1502 {
1503         truncate_inode_pages(inode->i_mapping, inode->i_size);
1504         ext4_truncate(inode);
1505 }
1506
1507 static int ext4_write_begin(struct file *file, struct address_space *mapping,
1508                             loff_t pos, unsigned len, unsigned flags,
1509                             struct page **pagep, void **fsdata)
1510 {
1511         struct inode *inode = mapping->host;
1512         int ret, needed_blocks;
1513         handle_t *handle;
1514         int retries = 0;
1515         struct page *page;
1516         pgoff_t index;
1517         unsigned from, to;
1518
1519         trace_ext4_write_begin(inode, pos, len, flags);
1520         /*
1521          * Reserve one block more for addition to orphan list in case
1522          * we allocate blocks but write fails for some reason
1523          */
1524         needed_blocks = ext4_writepage_trans_blocks(inode) + 1;
1525         index = pos >> PAGE_CACHE_SHIFT;
1526         from = pos & (PAGE_CACHE_SIZE - 1);
1527         to = from + len;
1528
1529 retry:
1530         handle = ext4_journal_start(inode, needed_blocks);
1531         if (IS_ERR(handle)) {
1532                 ret = PTR_ERR(handle);
1533                 goto out;
1534         }
1535
1536         /* We cannot recurse into the filesystem as the transaction is already
1537          * started */
1538         flags |= AOP_FLAG_NOFS;
1539
1540         page = grab_cache_page_write_begin(mapping, index, flags);
1541         if (!page) {
1542                 ext4_journal_stop(handle);
1543                 ret = -ENOMEM;
1544                 goto out;
1545         }
1546         *pagep = page;
1547
1548         ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
1549                                 ext4_get_block);
1550
1551         if (!ret && ext4_should_journal_data(inode)) {
1552                 ret = walk_page_buffers(handle, page_buffers(page),
1553                                 from, to, NULL, do_journal_get_write_access);
1554         }
1555
1556         if (ret) {
1557                 unlock_page(page);
1558                 page_cache_release(page);
1559                 /*
1560                  * block_write_begin may have instantiated a few blocks
1561                  * outside i_size.  Trim these off again. Don't need
1562                  * i_size_read because we hold i_mutex.
1563                  *
1564                  * Add inode to orphan list in case we crash before
1565                  * truncate finishes
1566                  */
1567                 if (pos + len > inode->i_size && ext4_can_truncate(inode))
1568                         ext4_orphan_add(handle, inode);
1569
1570                 ext4_journal_stop(handle);
1571                 if (pos + len > inode->i_size) {
1572                         ext4_truncate_failed_write(inode);
1573                         /*
1574                          * If truncate failed early the inode might
1575                          * still be on the orphan list; we need to
1576                          * make sure the inode is removed from the
1577                          * orphan list in that case.
1578                          */
1579                         if (inode->i_nlink)
1580                                 ext4_orphan_del(NULL, inode);
1581                 }
1582         }
1583
1584         if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
1585                 goto retry;
1586 out:
1587         return ret;
1588 }
1589
1590 /* For write_end() in data=journal mode */
1591 static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1592 {
1593         if (!buffer_mapped(bh) || buffer_freed(bh))
1594                 return 0;
1595         set_buffer_uptodate(bh);
1596         return ext4_handle_dirty_metadata(handle, NULL, bh);
1597 }
1598
1599 static int ext4_generic_write_end(struct file *file,
1600                                   struct address_space *mapping,
1601                                   loff_t pos, unsigned len, unsigned copied,
1602                                   struct page *page, void *fsdata)
1603 {
1604         int i_size_changed = 0;
1605         struct inode *inode = mapping->host;
1606         handle_t *handle = ext4_journal_current_handle();
1607
1608         copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1609
1610         /*
1611          * No need to use i_size_read() here, the i_size
1612          * cannot change under us because we hold i_mutex.
1613          *
1614          * But it's important to update i_size while still holding page lock:
1615          * page writeout could otherwise come in and zero beyond i_size.
1616          */
1617         if (pos + copied > inode->i_size) {
1618                 i_size_write(inode, pos + copied);
1619                 i_size_changed = 1;
1620         }
1621
1622         if (pos + copied >  EXT4_I(inode)->i_disksize) {
1623                 /* We need to mark inode dirty even if
1624                  * new_i_size is less that inode->i_size
1625                  * bu greater than i_disksize.(hint delalloc)
1626                  */
1627                 ext4_update_i_disksize(inode, (pos + copied));
1628                 i_size_changed = 1;
1629         }
1630         unlock_page(page);
1631         page_cache_release(page);
1632
1633         /*
1634          * Don't mark the inode dirty under page lock. First, it unnecessarily
1635          * makes the holding time of page lock longer. Second, it forces lock
1636          * ordering of page lock and transaction start for journaling
1637          * filesystems.
1638          */
1639         if (i_size_changed)
1640                 ext4_mark_inode_dirty(handle, inode);
1641
1642         return copied;
1643 }
1644
1645 /*
1646  * We need to pick up the new inode size which generic_commit_write gave us
1647  * `file' can be NULL - eg, when called from page_symlink().
1648  *
1649  * ext4 never places buffers on inode->i_mapping->private_list.  metadata
1650  * buffers are managed internally.
1651  */
1652 static int ext4_ordered_write_end(struct file *file,
1653                                   struct address_space *mapping,
1654                                   loff_t pos, unsigned len, unsigned copied,
1655                                   struct page *page, void *fsdata)
1656 {
1657         handle_t *handle = ext4_journal_current_handle();
1658         struct inode *inode = mapping->host;
1659         int ret = 0, ret2;
1660
1661         trace_ext4_ordered_write_end(inode, pos, len, copied);
1662         ret = ext4_jbd2_file_inode(handle, inode);
1663
1664         if (ret == 0) {
1665                 ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
1666                                                         page, fsdata);
1667                 copied = ret2;
1668                 if (pos + len > inode->i_size && ext4_can_truncate(inode))
1669                         /* if we have allocated more blocks and copied
1670                          * less. We will have blocks allocated outside
1671                          * inode->i_size. So truncate them
1672                          */
1673                         ext4_orphan_add(handle, inode);
1674                 if (ret2 < 0)
1675                         ret = ret2;
1676         }
1677         ret2 = ext4_journal_stop(handle);
1678         if (!ret)
1679                 ret = ret2;
1680
1681         if (pos + len > inode->i_size) {
1682                 ext4_truncate_failed_write(inode);
1683                 /*
1684                  * If truncate failed early the inode might still be
1685                  * on the orphan list; we need to make sure the inode
1686                  * is removed from the orphan list in that case.
1687                  */
1688                 if (inode->i_nlink)
1689                         ext4_orphan_del(NULL, inode);
1690         }
1691
1692
1693         return ret ? ret : copied;
1694 }
1695
1696 static int ext4_writeback_write_end(struct file *file,
1697                                     struct address_space *mapping,
1698                                     loff_t pos, unsigned len, unsigned copied,
1699                                     struct page *page, void *fsdata)
1700 {
1701         handle_t *handle = ext4_journal_current_handle();
1702         struct inode *inode = mapping->host;
1703         int ret = 0, ret2;
1704
1705         trace_ext4_writeback_write_end(inode, pos, len, copied);
1706         ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
1707                                                         page, fsdata);
1708         copied = ret2;
1709         if (pos + len > inode->i_size && ext4_can_truncate(inode))
1710                 /* if we have allocated more blocks and copied
1711                  * less. We will have blocks allocated outside
1712                  * inode->i_size. So truncate them
1713                  */
1714                 ext4_orphan_add(handle, inode);
1715
1716         if (ret2 < 0)
1717                 ret = ret2;
1718
1719         ret2 = ext4_journal_stop(handle);
1720         if (!ret)
1721                 ret = ret2;
1722
1723         if (pos + len > inode->i_size) {
1724                 ext4_truncate_failed_write(inode);
1725                 /*
1726                  * If truncate failed early the inode might still be
1727                  * on the orphan list; we need to make sure the inode
1728                  * is removed from the orphan list in that case.
1729                  */
1730                 if (inode->i_nlink)
1731                         ext4_orphan_del(NULL, inode);
1732         }
1733
1734         return ret ? ret : copied;
1735 }
1736
1737 static int ext4_journalled_write_end(struct file *file,
1738                                      struct address_space *mapping,
1739                                      loff_t pos, unsigned len, unsigned copied,
1740                                      struct page *page, void *fsdata)
1741 {
1742         handle_t *handle = ext4_journal_current_handle();
1743         struct inode *inode = mapping->host;
1744         int ret = 0, ret2;
1745         int partial = 0;
1746         unsigned from, to;
1747         loff_t new_i_size;
1748
1749         trace_ext4_journalled_write_end(inode, pos, len, copied);
1750         from = pos & (PAGE_CACHE_SIZE - 1);
1751         to = from + len;
1752
1753         if (copied < len) {
1754                 if (!PageUptodate(page))
1755                         copied = 0;
1756                 page_zero_new_buffers(page, from+copied, to);
1757         }
1758
1759         ret = walk_page_buffers(handle, page_buffers(page), from,
1760                                 to, &partial, write_end_fn);
1761         if (!partial)
1762                 SetPageUptodate(page);
1763         new_i_size = pos + copied;
1764         if (new_i_size > inode->i_size)
1765                 i_size_write(inode, pos+copied);
1766         EXT4_I(inode)->i_state |= EXT4_STATE_JDATA;
1767         if (new_i_size > EXT4_I(inode)->i_disksize) {
1768                 ext4_update_i_disksize(inode, new_i_size);
1769                 ret2 = ext4_mark_inode_dirty(handle, inode);
1770                 if (!ret)
1771                         ret = ret2;
1772         }
1773
1774         unlock_page(page);
1775         page_cache_release(page);
1776         if (pos + len > inode->i_size && ext4_can_truncate(inode))
1777                 /* if we have allocated more blocks and copied
1778                  * less. We will have blocks allocated outside
1779                  * inode->i_size. So truncate them
1780                  */
1781                 ext4_orphan_add(handle, inode);
1782
1783         ret2 = ext4_journal_stop(handle);
1784         if (!ret)
1785                 ret = ret2;
1786         if (pos + len > inode->i_size) {
1787                 ext4_truncate_failed_write(inode);
1788                 /*
1789                  * If truncate failed early the inode might still be
1790                  * on the orphan list; we need to make sure the inode
1791                  * is removed from the orphan list in that case.
1792                  */
1793                 if (inode->i_nlink)
1794                         ext4_orphan_del(NULL, inode);
1795         }
1796
1797         return ret ? ret : copied;
1798 }
1799
1800 static int ext4_da_reserve_space(struct inode *inode, int nrblocks)
1801 {
1802         int retries = 0;
1803         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1804         unsigned long md_needed, mdblocks, total = 0;
1805
1806         /*
1807          * recalculate the amount of metadata blocks to reserve
1808          * in order to allocate nrblocks
1809          * worse case is one extent per block
1810          */
1811 repeat:
1812         spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1813         total = EXT4_I(inode)->i_reserved_data_blocks + nrblocks;
1814         mdblocks = ext4_calc_metadata_amount(inode, total);
1815         BUG_ON(mdblocks < EXT4_I(inode)->i_reserved_meta_blocks);
1816
1817         md_needed = mdblocks - EXT4_I(inode)->i_reserved_meta_blocks;
1818         total = md_needed + nrblocks;
1819
1820         /*
1821          * Make quota reservation here to prevent quota overflow
1822          * later. Real quota accounting is done at pages writeout
1823          * time.
1824          */
1825         if (vfs_dq_reserve_block(inode, total)) {
1826                 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1827                 return -EDQUOT;
1828         }
1829
1830         if (ext4_claim_free_blocks(sbi, total)) {
1831                 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1832                 vfs_dq_release_reservation_block(inode, total);
1833                 if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
1834                         yield();
1835                         goto repeat;
1836                 }
1837                 return -ENOSPC;
1838         }
1839         EXT4_I(inode)->i_reserved_data_blocks += nrblocks;
1840         EXT4_I(inode)->i_reserved_meta_blocks = mdblocks;
1841
1842         spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1843         return 0;       /* success */
1844 }
1845
1846 static void ext4_da_release_space(struct inode *inode, int to_free)
1847 {
1848         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1849         int total, mdb, mdb_free, release;
1850
1851         if (!to_free)
1852                 return;         /* Nothing to release, exit */
1853
1854         spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1855
1856         if (!EXT4_I(inode)->i_reserved_data_blocks) {
1857                 /*
1858                  * if there is no reserved blocks, but we try to free some
1859                  * then the counter is messed up somewhere.
1860                  * but since this function is called from invalidate
1861                  * page, it's harmless to return without any action
1862                  */
1863                 printk(KERN_INFO "ext4 delalloc try to release %d reserved "
1864                             "blocks for inode %lu, but there is no reserved "
1865                             "data blocks\n", to_free, inode->i_ino);
1866                 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1867                 return;
1868         }
1869
1870         /* recalculate the number of metablocks still need to be reserved */
1871         total = EXT4_I(inode)->i_reserved_data_blocks - to_free;
1872         mdb = ext4_calc_metadata_amount(inode, total);
1873
1874         /* figure out how many metablocks to release */
1875         BUG_ON(mdb > EXT4_I(inode)->i_reserved_meta_blocks);
1876         mdb_free = EXT4_I(inode)->i_reserved_meta_blocks - mdb;
1877
1878         release = to_free + mdb_free;
1879
1880         /* update fs dirty blocks counter for truncate case */
1881         percpu_counter_sub(&sbi->s_dirtyblocks_counter, release);
1882
1883         /* update per-inode reservations */
1884         BUG_ON(to_free > EXT4_I(inode)->i_reserved_data_blocks);
1885         EXT4_I(inode)->i_reserved_data_blocks -= to_free;
1886
1887         BUG_ON(mdb > EXT4_I(inode)->i_reserved_meta_blocks);
1888         EXT4_I(inode)->i_reserved_meta_blocks = mdb;
1889         spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1890
1891         vfs_dq_release_reservation_block(inode, release);
1892 }
1893
1894 static void ext4_da_page_release_reservation(struct page *page,
1895                                              unsigned long offset)
1896 {
1897         int to_release = 0;
1898         struct buffer_head *head, *bh;
1899         unsigned int curr_off = 0;
1900
1901         head = page_buffers(page);
1902         bh = head;
1903         do {
1904                 unsigned int next_off = curr_off + bh->b_size;
1905
1906                 if ((offset <= curr_off) && (buffer_delay(bh))) {
1907                         to_release++;
1908                         clear_buffer_delay(bh);
1909                 }
1910                 curr_off = next_off;
1911         } while ((bh = bh->b_this_page) != head);
1912         ext4_da_release_space(page->mapping->host, to_release);
1913 }
1914
1915 /*
1916  * Delayed allocation stuff
1917  */
1918
1919 /*
1920  * mpage_da_submit_io - walks through extent of pages and try to write
1921  * them with writepage() call back
1922  *
1923  * @mpd->inode: inode
1924  * @mpd->first_page: first page of the extent
1925  * @mpd->next_page: page after the last page of the extent
1926  *
1927  * By the time mpage_da_submit_io() is called we expect all blocks
1928  * to be allocated. this may be wrong if allocation failed.
1929  *
1930  * As pages are already locked by write_cache_pages(), we can't use it
1931  */
1932 static int mpage_da_submit_io(struct mpage_da_data *mpd)
1933 {
1934         long pages_skipped;
1935         struct pagevec pvec;
1936         unsigned long index, end;
1937         int ret = 0, err, nr_pages, i;
1938         struct inode *inode = mpd->inode;
1939         struct address_space *mapping = inode->i_mapping;
1940
1941         BUG_ON(mpd->next_page <= mpd->first_page);
1942         /*
1943          * We need to start from the first_page to the next_page - 1
1944          * to make sure we also write the mapped dirty buffer_heads.
1945          * If we look at mpd->b_blocknr we would only be looking
1946          * at the currently mapped buffer_heads.
1947          */
1948         index = mpd->first_page;
1949         end = mpd->next_page - 1;
1950
1951         pagevec_init(&pvec, 0);
1952         while (index <= end) {
1953                 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1954                 if (nr_pages == 0)
1955                         break;
1956                 for (i = 0; i < nr_pages; i++) {
1957                         struct page *page = pvec.pages[i];
1958
1959                         index = page->index;
1960                         if (index > end)
1961                                 break;
1962                         index++;
1963
1964                         BUG_ON(!PageLocked(page));
1965                         BUG_ON(PageWriteback(page));
1966
1967                         pages_skipped = mpd->wbc->pages_skipped;
1968                         err = mapping->a_ops->writepage(page, mpd->wbc);
1969                         if (!err && (pages_skipped == mpd->wbc->pages_skipped))
1970                                 /*
1971                                  * have successfully written the page
1972                                  * without skipping the same
1973                                  */
1974                                 mpd->pages_written++;
1975                         /*
1976                          * In error case, we have to continue because
1977                          * remaining pages are still locked
1978                          * XXX: unlock and re-dirty them?
1979                          */
1980                         if (ret == 0)
1981                                 ret = err;
1982                 }
1983                 pagevec_release(&pvec);
1984         }
1985         return ret;
1986 }
1987
1988 /*
1989  * mpage_put_bnr_to_bhs - walk blocks and assign them actual numbers
1990  *
1991  * @mpd->inode - inode to walk through
1992  * @exbh->b_blocknr - first block on a disk
1993  * @exbh->b_size - amount of space in bytes
1994  * @logical - first logical block to start assignment with
1995  *
1996  * the function goes through all passed space and put actual disk
1997  * block numbers into buffer heads, dropping BH_Delay and BH_Unwritten
1998  */
1999 static void mpage_put_bnr_to_bhs(struct mpage_da_data *mpd, sector_t logical,
2000                                  struct buffer_head *exbh)
2001 {
2002         struct inode *inode = mpd->inode;
2003         struct address_space *mapping = inode->i_mapping;
2004         int blocks = exbh->b_size >> inode->i_blkbits;
2005         sector_t pblock = exbh->b_blocknr, cur_logical;
2006         struct buffer_head *head, *bh;
2007         pgoff_t index, end;
2008         struct pagevec pvec;
2009         int nr_pages, i;
2010
2011         index = logical >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
2012         end = (logical + blocks - 1) >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
2013         cur_logical = index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
2014
2015         pagevec_init(&pvec, 0);
2016
2017         while (index <= end) {
2018                 /* XXX: optimize tail */
2019                 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
2020                 if (nr_pages == 0)
2021                         break;
2022                 for (i = 0; i < nr_pages; i++) {
2023                         struct page *page = pvec.pages[i];
2024
2025                         index = page->index;
2026                         if (index > end)
2027                                 break;
2028                         index++;
2029
2030                         BUG_ON(!PageLocked(page));
2031                         BUG_ON(PageWriteback(page));
2032                         BUG_ON(!page_has_buffers(page));
2033
2034                         bh = page_buffers(page);
2035                         head = bh;
2036
2037                         /* skip blocks out of the range */
2038                         do {
2039                                 if (cur_logical >= logical)
2040                                         break;
2041                                 cur_logical++;
2042                         } while ((bh = bh->b_this_page) != head);
2043
2044                         do {
2045                                 if (cur_logical >= logical + blocks)
2046                                         break;
2047
2048                                 if (buffer_delay(bh) ||
2049                                                 buffer_unwritten(bh)) {
2050
2051                                         BUG_ON(bh->b_bdev != inode->i_sb->s_bdev);
2052
2053                                         if (buffer_delay(bh)) {
2054                                                 clear_buffer_delay(bh);
2055                                                 bh->b_blocknr = pblock;
2056                                         } else {
2057                                                 /*
2058                                                  * unwritten already should have
2059                                                  * blocknr assigned. Verify that
2060                                                  */
2061                                                 clear_buffer_unwritten(bh);
2062                                                 BUG_ON(bh->b_blocknr != pblock);
2063                                         }
2064
2065                                 } else if (buffer_mapped(bh))
2066                                         BUG_ON(bh->b_blocknr != pblock);
2067
2068                                 cur_logical++;
2069                                 pblock++;
2070                         } while ((bh = bh->b_this_page) != head);
2071                 }
2072                 pagevec_release(&pvec);
2073         }
2074 }
2075
2076
2077 /*
2078  * __unmap_underlying_blocks - just a helper function to unmap
2079  * set of blocks described by @bh
2080  */
2081 static inline void __unmap_underlying_blocks(struct inode *inode,
2082                                              struct buffer_head *bh)
2083 {
2084         struct block_device *bdev = inode->i_sb->s_bdev;
2085         int blocks, i;
2086
2087         blocks = bh->b_size >> inode->i_blkbits;
2088         for (i = 0; i < blocks; i++)
2089                 unmap_underlying_metadata(bdev, bh->b_blocknr + i);
2090 }
2091
2092 static void ext4_da_block_invalidatepages(struct mpage_da_data *mpd,
2093                                         sector_t logical, long blk_cnt)
2094 {
2095         int nr_pages, i;
2096         pgoff_t index, end;
2097         struct pagevec pvec;
2098         struct inode *inode = mpd->inode;
2099         struct address_space *mapping = inode->i_mapping;
2100
2101         index = logical >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
2102         end   = (logical + blk_cnt - 1) >>
2103                                 (PAGE_CACHE_SHIFT - inode->i_blkbits);
2104         while (index <= end) {
2105                 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
2106                 if (nr_pages == 0)
2107                         break;
2108                 for (i = 0; i < nr_pages; i++) {
2109                         struct page *page = pvec.pages[i];
2110                         index = page->index;
2111                         if (index > end)
2112                                 break;
2113                         index++;
2114
2115                         BUG_ON(!PageLocked(page));
2116                         BUG_ON(PageWriteback(page));
2117                         block_invalidatepage(page, 0);
2118                         ClearPageUptodate(page);
2119                         unlock_page(page);
2120                 }
2121         }
2122         return;
2123 }
2124
2125 static void ext4_print_free_blocks(struct inode *inode)
2126 {
2127         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2128         printk(KERN_CRIT "Total free blocks count %lld\n",
2129                ext4_count_free_blocks(inode->i_sb));
2130         printk(KERN_CRIT "Free/Dirty block details\n");
2131         printk(KERN_CRIT "free_blocks=%lld\n",
2132                (long long) percpu_counter_sum(&sbi->s_freeblocks_counter));
2133         printk(KERN_CRIT "dirty_blocks=%lld\n",
2134                (long long) percpu_counter_sum(&sbi->s_dirtyblocks_counter));
2135         printk(KERN_CRIT "Block reservation details\n");
2136         printk(KERN_CRIT "i_reserved_data_blocks=%u\n",
2137                EXT4_I(inode)->i_reserved_data_blocks);
2138         printk(KERN_CRIT "i_reserved_meta_blocks=%u\n",
2139                EXT4_I(inode)->i_reserved_meta_blocks);
2140         return;
2141 }
2142
2143 /*
2144  * mpage_da_map_blocks - go through given space
2145  *
2146  * @mpd - bh describing space
2147  *
2148  * The function skips space we know is already mapped to disk blocks.
2149  *
2150  */
2151 static int mpage_da_map_blocks(struct mpage_da_data *mpd)
2152 {
2153         int err, blks, get_blocks_flags;
2154         struct buffer_head new;
2155         sector_t next = mpd->b_blocknr;
2156         unsigned max_blocks = mpd->b_size >> mpd->inode->i_blkbits;
2157         loff_t disksize = EXT4_I(mpd->inode)->i_disksize;
2158         handle_t *handle = NULL;
2159
2160         /*
2161          * We consider only non-mapped and non-allocated blocks
2162          */
2163         if ((mpd->b_state  & (1 << BH_Mapped)) &&
2164                 !(mpd->b_state & (1 << BH_Delay)) &&
2165                 !(mpd->b_state & (1 << BH_Unwritten)))
2166                 return 0;
2167
2168         /*
2169          * If we didn't accumulate anything to write simply return
2170          */
2171         if (!mpd->b_size)
2172                 return 0;
2173
2174         handle = ext4_journal_current_handle();
2175         BUG_ON(!handle);
2176
2177         /*
2178          * Call ext4_get_blocks() to allocate any delayed allocation
2179          * blocks, or to convert an uninitialized extent to be
2180          * initialized (in the case where we have written into
2181          * one or more preallocated blocks).
2182          *
2183          * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE to
2184          * indicate that we are on the delayed allocation path.  This
2185          * affects functions in many different parts of the allocation
2186          * call path.  This flag exists primarily because we don't
2187          * want to change *many* call functions, so ext4_get_blocks()
2188          * will set the magic i_delalloc_reserved_flag once the
2189          * inode's allocation semaphore is taken.
2190          *
2191          * If the blocks in questions were delalloc blocks, set
2192          * EXT4_GET_BLOCKS_DELALLOC_RESERVE so the delalloc accounting
2193          * variables are updated after the blocks have been allocated.
2194          */
2195         new.b_state = 0;
2196         get_blocks_flags = (EXT4_GET_BLOCKS_CREATE |
2197                             EXT4_GET_BLOCKS_DELALLOC_RESERVE);
2198         if (mpd->b_state & (1 << BH_Delay))
2199                 get_blocks_flags |= EXT4_GET_BLOCKS_UPDATE_RESERVE_SPACE;
2200         blks = ext4_get_blocks(handle, mpd->inode, next, max_blocks,
2201                                &new, get_blocks_flags);
2202         if (blks < 0) {
2203                 err = blks;
2204                 /*
2205                  * If get block returns with error we simply
2206                  * return. Later writepage will redirty the page and
2207                  * writepages will find the dirty page again
2208                  */
2209                 if (err == -EAGAIN)
2210                         return 0;
2211
2212                 if (err == -ENOSPC &&
2213                     ext4_count_free_blocks(mpd->inode->i_sb)) {
2214                         mpd->retval = err;
2215                         return 0;
2216                 }
2217
2218                 /*
2219                  * get block failure will cause us to loop in
2220                  * writepages, because a_ops->writepage won't be able
2221                  * to make progress. The page will be redirtied by
2222                  * writepage and writepages will again try to write
2223                  * the same.
2224                  */
2225                 ext4_msg(mpd->inode->i_sb, KERN_CRIT,
2226                          "delayed block allocation failed for inode %lu at "
2227                          "logical offset %llu with max blocks %zd with "
2228                          "error %d\n", mpd->inode->i_ino,
2229                          (unsigned long long) next,
2230                          mpd->b_size >> mpd->inode->i_blkbits, err);
2231                 printk(KERN_CRIT "This should not happen!!  "
2232                        "Data will be lost\n");
2233                 if (err == -ENOSPC) {
2234                         ext4_print_free_blocks(mpd->inode);
2235                 }
2236                 /* invalidate all the pages */
2237                 ext4_da_block_invalidatepages(mpd, next,
2238                                 mpd->b_size >> mpd->inode->i_blkbits);
2239                 return err;
2240         }
2241         BUG_ON(blks == 0);
2242
2243         new.b_size = (blks << mpd->inode->i_blkbits);
2244
2245         if (buffer_new(&new))
2246                 __unmap_underlying_blocks(mpd->inode, &new);
2247
2248         /*
2249          * If blocks are delayed marked, we need to
2250          * put actual blocknr and drop delayed bit
2251          */
2252         if ((mpd->b_state & (1 << BH_Delay)) ||
2253             (mpd->b_state & (1 << BH_Unwritten)))
2254                 mpage_put_bnr_to_bhs(mpd, next, &new);
2255
2256         if (ext4_should_order_data(mpd->inode)) {
2257                 err = ext4_jbd2_file_inode(handle, mpd->inode);
2258                 if (err)
2259                         return err;
2260         }
2261
2262         /*
2263          * Update on-disk size along with block allocation.
2264          */
2265         disksize = ((loff_t) next + blks) << mpd->inode->i_blkbits;
2266         if (disksize > i_size_read(mpd->inode))
2267                 disksize = i_size_read(mpd->inode);
2268         if (disksize > EXT4_I(mpd->inode)->i_disksize) {
2269                 ext4_update_i_disksize(mpd->inode, disksize);
2270                 return ext4_mark_inode_dirty(handle, mpd->inode);
2271         }
2272
2273         return 0;
2274 }
2275
2276 #define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | \
2277                 (1 << BH_Delay) | (1 << BH_Unwritten))
2278
2279 /*
2280  * mpage_add_bh_to_extent - try to add one more block to extent of blocks
2281  *
2282  * @mpd->lbh - extent of blocks
2283  * @logical - logical number of the block in the file
2284  * @bh - bh of the block (used to access block's state)
2285  *
2286  * the function is used to collect contig. blocks in same state
2287  */
2288 static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
2289                                    sector_t logical, size_t b_size,
2290                                    unsigned long b_state)
2291 {
2292         sector_t next;
2293         int nrblocks = mpd->b_size >> mpd->inode->i_blkbits;
2294
2295         /* check if thereserved journal credits might overflow */
2296         if (!(EXT4_I(mpd->inode)->i_flags & EXT4_EXTENTS_FL)) {
2297                 if (nrblocks >= EXT4_MAX_TRANS_DATA) {
2298                         /*
2299                          * With non-extent format we are limited by the journal
2300                          * credit available.  Total credit needed to insert
2301                          * nrblocks contiguous blocks is dependent on the
2302                          * nrblocks.  So limit nrblocks.
2303                          */
2304                         goto flush_it;
2305                 } else if ((nrblocks + (b_size >> mpd->inode->i_blkbits)) >
2306                                 EXT4_MAX_TRANS_DATA) {
2307                         /*
2308                          * Adding the new buffer_head would make it cross the
2309                          * allowed limit for which we have journal credit
2310                          * reserved. So limit the new bh->b_size
2311                          */
2312                         b_size = (EXT4_MAX_TRANS_DATA - nrblocks) <<
2313                                                 mpd->inode->i_blkbits;
2314                         /* we will do mpage_da_submit_io in the next loop */
2315                 }
2316         }
2317         /*
2318          * First block in the extent
2319          */
2320         if (mpd->b_size == 0) {
2321                 mpd->b_blocknr = logical;
2322                 mpd->b_size = b_size;
2323                 mpd->b_state = b_state & BH_FLAGS;
2324                 return;
2325         }
2326
2327         next = mpd->b_blocknr + nrblocks;
2328         /*
2329          * Can we merge the block to our big extent?
2330          */
2331         if (logical == next && (b_state & BH_FLAGS) == mpd->b_state) {
2332                 mpd->b_size += b_size;
2333                 return;
2334         }
2335
2336 flush_it:
2337         /*
2338          * We couldn't merge the block to our extent, so we
2339          * need to flush current  extent and start new one
2340          */
2341         if (mpage_da_map_blocks(mpd) == 0)
2342                 mpage_da_submit_io(mpd);
2343         mpd->io_done = 1;
2344         return;
2345 }
2346
2347 static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
2348 {
2349         return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
2350 }
2351
2352 /*
2353  * __mpage_da_writepage - finds extent of pages and blocks
2354  *
2355  * @page: page to consider
2356  * @wbc: not used, we just follow rules
2357  * @data: context
2358  *
2359  * The function finds extents of pages and scan them for all blocks.
2360  */
2361 static int __mpage_da_writepage(struct page *page,
2362                                 struct writeback_control *wbc, void *data)
2363 {
2364         struct mpage_da_data *mpd = data;
2365         struct inode *inode = mpd->inode;
2366         struct buffer_head *bh, *head;
2367         sector_t logical;
2368
2369         if (mpd->io_done) {
2370                 /*
2371                  * Rest of the page in the page_vec
2372                  * redirty then and skip then. We will
2373                  * try to write them again after
2374                  * starting a new transaction
2375                  */
2376                 redirty_page_for_writepage(wbc, page);
2377                 unlock_page(page);
2378                 return MPAGE_DA_EXTENT_TAIL;
2379         }
2380         /*
2381          * Can we merge this page to current extent?
2382          */
2383         if (mpd->next_page != page->index) {
2384                 /*
2385                  * Nope, we can't. So, we map non-allocated blocks
2386                  * and start IO on them using writepage()
2387                  */
2388                 if (mpd->next_page != mpd->first_page) {
2389                         if (mpage_da_map_blocks(mpd) == 0)
2390                                 mpage_da_submit_io(mpd);
2391                         /*
2392                          * skip rest of the page in the page_vec
2393                          */
2394                         mpd->io_done = 1;
2395                         redirty_page_for_writepage(wbc, page);
2396                         unlock_page(page);
2397                         return MPAGE_DA_EXTENT_TAIL;
2398                 }
2399
2400                 /*
2401                  * Start next extent of pages ...
2402                  */
2403                 mpd->first_page = page->index;
2404
2405                 /*
2406                  * ... and blocks
2407                  */
2408                 mpd->b_size = 0;
2409                 mpd->b_state = 0;
2410                 mpd->b_blocknr = 0;
2411         }
2412
2413         mpd->next_page = page->index + 1;
2414         logical = (sector_t) page->index <<
2415                   (PAGE_CACHE_SHIFT - inode->i_blkbits);
2416
2417         if (!page_has_buffers(page)) {
2418                 mpage_add_bh_to_extent(mpd, logical, PAGE_CACHE_SIZE,
2419                                        (1 << BH_Dirty) | (1 << BH_Uptodate));
2420                 if (mpd->io_done)
2421                         return MPAGE_DA_EXTENT_TAIL;
2422         } else {
2423                 /*
2424                  * Page with regular buffer heads, just add all dirty ones
2425                  */
2426                 head = page_buffers(page);
2427                 bh = head;
2428                 do {
2429                         BUG_ON(buffer_locked(bh));
2430                         /*
2431                          * We need to try to allocate
2432                          * unmapped blocks in the same page.
2433                          * Otherwise we won't make progress
2434                          * with the page in ext4_writepage
2435                          */
2436                         if (ext4_bh_delay_or_unwritten(NULL, bh)) {
2437                                 mpage_add_bh_to_extent(mpd, logical,
2438                                                        bh->b_size,
2439                                                        bh->b_state);
2440                                 if (mpd->io_done)
2441                                         return MPAGE_DA_EXTENT_TAIL;
2442                         } else if (buffer_dirty(bh) && (buffer_mapped(bh))) {
2443                                 /*
2444                                  * mapped dirty buffer. We need to update
2445                                  * the b_state because we look at
2446                                  * b_state in mpage_da_map_blocks. We don't
2447                                  * update b_size because if we find an
2448                                  * unmapped buffer_head later we need to
2449                                  * use the b_state flag of that buffer_head.
2450                                  */
2451                                 if (mpd->b_size == 0)
2452                                         mpd->b_state = bh->b_state & BH_FLAGS;
2453                         }
2454                         logical++;
2455                 } while ((bh = bh->b_this_page) != head);
2456         }
2457
2458         return 0;
2459 }
2460
2461 /*
2462  * This is a special get_blocks_t callback which is used by
2463  * ext4_da_write_begin().  It will either return mapped block or
2464  * reserve space for a single block.
2465  *
2466  * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
2467  * We also have b_blocknr = -1 and b_bdev initialized properly
2468  *
2469  * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
2470  * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
2471  * initialized properly.
2472  */
2473 static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
2474                                   struct buffer_head *bh_result, int create)
2475 {
2476         int ret = 0;
2477         sector_t invalid_block = ~((sector_t) 0xffff);
2478
2479         if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
2480                 invalid_block = ~0;
2481
2482         BUG_ON(create == 0);
2483         BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
2484
2485         /*
2486          * first, we need to know whether the block is allocated already
2487          * preallocated blocks are unmapped but should treated
2488          * the same as allocated blocks.
2489          */
2490         ret = ext4_get_blocks(NULL, inode, iblock, 1,  bh_result, 0);
2491         if ((ret == 0) && !buffer_delay(bh_result)) {
2492                 /* the block isn't (pre)allocated yet, let's reserve space */
2493                 /*
2494                  * XXX: __block_prepare_write() unmaps passed block,
2495                  * is it OK?
2496                  */
2497                 ret = ext4_da_reserve_space(inode, 1);
2498                 if (ret)
2499                         /* not enough space to reserve */
2500                         return ret;
2501
2502                 map_bh(bh_result, inode->i_sb, invalid_block);
2503                 set_buffer_new(bh_result);
2504                 set_buffer_delay(bh_result);
2505         } else if (ret > 0) {
2506                 bh_result->b_size = (ret << inode->i_blkbits);
2507                 if (buffer_unwritten(bh_result)) {
2508                         /* A delayed write to unwritten bh should
2509                          * be marked new and mapped.  Mapped ensures
2510                          * that we don't do get_block multiple times
2511                          * when we write to the same offset and new
2512                          * ensures that we do proper zero out for
2513                          * partial write.
2514                          */
2515                         set_buffer_new(bh_result);
2516                         set_buffer_mapped(bh_result);
2517                 }
2518                 ret = 0;
2519         }
2520
2521         return ret;
2522 }
2523
2524 /*
2525  * This function is used as a standard get_block_t calback function
2526  * when there is no desire to allocate any blocks.  It is used as a
2527  * callback function for block_prepare_write(), nobh_writepage(), and
2528  * block_write_full_page().  These functions should only try to map a
2529  * single block at a time.
2530  *
2531  * Since this function doesn't do block allocations even if the caller
2532  * requests it by passing in create=1, it is critically important that
2533  * any caller checks to make sure that any buffer heads are returned
2534  * by this function are either all already mapped or marked for
2535  * delayed allocation before calling nobh_writepage() or
2536  * block_write_full_page().  Otherwise, b_blocknr could be left
2537  * unitialized, and the page write functions will be taken by
2538  * surprise.
2539  */
2540 static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
2541                                    struct buffer_head *bh_result, int create)
2542 {
2543         int ret = 0;
2544         unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
2545
2546         BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
2547
2548         /*
2549          * we don't want to do block allocation in writepage
2550          * so call get_block_wrap with create = 0
2551          */
2552         ret = ext4_get_blocks(NULL, inode, iblock, max_blocks, bh_result, 0);
2553         if (ret > 0) {
2554                 bh_result->b_size = (ret << inode->i_blkbits);
2555                 ret = 0;
2556         }
2557         return ret;
2558 }
2559
2560 static int bget_one(handle_t *handle, struct buffer_head *bh)
2561 {
2562         get_bh(bh);
2563         return 0;
2564 }
2565
2566 static int bput_one(handle_t *handle, struct buffer_head *bh)
2567 {
2568         put_bh(bh);
2569         return 0;
2570 }
2571
2572 static int __ext4_journalled_writepage(struct page *page,
2573                                        unsigned int len)
2574 {
2575         struct address_space *mapping = page->mapping;
2576         struct inode *inode = mapping->host;
2577         struct buffer_head *page_bufs;
2578         handle_t *handle = NULL;
2579         int ret = 0;
2580         int err;
2581
2582         page_bufs = page_buffers(page);
2583         BUG_ON(!page_bufs);
2584         walk_page_buffers(handle, page_bufs, 0, len, NULL, bget_one);
2585         /* As soon as we unlock the page, it can go away, but we have
2586          * references to buffers so we are safe */
2587         unlock_page(page);
2588
2589         handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
2590         if (IS_ERR(handle)) {
2591                 ret = PTR_ERR(handle);
2592                 goto out;
2593         }
2594
2595         ret = walk_page_buffers(handle, page_bufs, 0, len, NULL,
2596                                 do_journal_get_write_access);
2597
2598         err = walk_page_buffers(handle, page_bufs, 0, len, NULL,
2599                                 write_end_fn);
2600         if (ret == 0)
2601                 ret = err;
2602         err = ext4_journal_stop(handle);
2603         if (!ret)
2604                 ret = err;
2605
2606         walk_page_buffers(handle, page_bufs, 0, len, NULL, bput_one);
2607         EXT4_I(inode)->i_state |= EXT4_STATE_JDATA;
2608 out:
2609         return ret;
2610 }
2611
2612 /*
2613  * Note that we don't need to start a transaction unless we're journaling data
2614  * because we should have holes filled from ext4_page_mkwrite(). We even don't
2615  * need to file the inode to the transaction's list in ordered mode because if
2616  * we are writing back data added by write(), the inode is already there and if
2617  * we are writing back data modified via mmap(), noone guarantees in which
2618  * transaction the data will hit the disk. In case we are journaling data, we
2619  * cannot start transaction directly because transaction start ranks above page
2620  * lock so we have to do some magic.
2621  *
2622  * This function can get called via...
2623  *   - ext4_da_writepages after taking page lock (have journal handle)
2624  *   - journal_submit_inode_data_buffers (no journal handle)
2625  *   - shrink_page_list via pdflush (no journal handle)
2626  *   - grab_page_cache when doing write_begin (have journal handle)
2627  *
2628  * We don't do any block allocation in this function. If we have page with
2629  * multiple blocks we need to write those buffer_heads that are mapped. This
2630  * is important for mmaped based write. So if we do with blocksize 1K
2631  * truncate(f, 1024);
2632  * a = mmap(f, 0, 4096);
2633  * a[0] = 'a';
2634  * truncate(f, 4096);
2635  * we have in the page first buffer_head mapped via page_mkwrite call back
2636  * but other bufer_heads would be unmapped but dirty(dirty done via the
2637  * do_wp_page). So writepage should write the first block. If we modify
2638  * the mmap area beyond 1024 we will again get a page_fault and the
2639  * page_mkwrite callback will do the block allocation and mark the
2640  * buffer_heads mapped.
2641  *
2642  * We redirty the page if we have any buffer_heads that is either delay or
2643  * unwritten in the page.
2644  *
2645  * We can get recursively called as show below.
2646  *
2647  *      ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
2648  *              ext4_writepage()
2649  *
2650  * But since we don't do any block allocation we should not deadlock.
2651  * Page also have the dirty flag cleared so we don't get recurive page_lock.
2652  */
2653 static int ext4_writepage(struct page *page,
2654                           struct writeback_control *wbc)
2655 {
2656         int ret = 0;
2657         loff_t size;
2658         unsigned int len;
2659         struct buffer_head *page_bufs;
2660         struct inode *inode = page->mapping->host;
2661
2662         trace_ext4_writepage(inode, page);
2663         size = i_size_read(inode);
2664         if (page->index == size >> PAGE_CACHE_SHIFT)
2665                 len = size & ~PAGE_CACHE_MASK;
2666         else
2667                 len = PAGE_CACHE_SIZE;
2668
2669         if (page_has_buffers(page)) {
2670                 page_bufs = page_buffers(page);
2671                 if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
2672                                         ext4_bh_delay_or_unwritten)) {
2673                         /*
2674                          * We don't want to do  block allocation
2675                          * So redirty the page and return
2676                          * We may reach here when we do a journal commit
2677                          * via journal_submit_inode_data_buffers.
2678                          * If we don't have mapping block we just ignore
2679                          * them. We can also reach here via shrink_page_list
2680                          */
2681                         redirty_page_for_writepage(wbc, page);
2682                         unlock_page(page);
2683                         return 0;
2684                 }
2685         } else {
2686                 /*
2687                  * The test for page_has_buffers() is subtle:
2688                  * We know the page is dirty but it lost buffers. That means
2689                  * that at some moment in time after write_begin()/write_end()
2690                  * has been called all buffers have been clean and thus they
2691                  * must have been written at least once. So they are all
2692                  * mapped and we can happily proceed with mapping them
2693                  * and writing the page.
2694                  *
2695                  * Try to initialize the buffer_heads and check whether
2696                  * all are mapped and non delay. We don't want to
2697                  * do block allocation here.
2698                  */
2699                 ret = block_prepare_write(page, 0, len,
2700                                           noalloc_get_block_write);
2701                 if (!ret) {
2702                         page_bufs = page_buffers(page);
2703                         /* check whether all are mapped and non delay */
2704                         if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
2705                                                 ext4_bh_delay_or_unwritten)) {
2706                                 redirty_page_for_writepage(wbc, page);
2707                                 unlock_page(page);
2708                                 return 0;
2709                         }
2710                 } else {
2711                         /*
2712                          * We can't do block allocation here
2713                          * so just redity the page and unlock
2714                          * and return
2715                          */
2716                         redirty_page_for_writepage(wbc, page);
2717                         unlock_page(page);
2718                         return 0;
2719                 }
2720                 /* now mark the buffer_heads as dirty and uptodate */
2721                 block_commit_write(page, 0, len);
2722         }
2723
2724         if (PageChecked(page) && ext4_should_journal_data(inode)) {
2725                 /*
2726                  * It's mmapped pagecache.  Add buffers and journal it.  There
2727                  * doesn't seem much point in redirtying the page here.
2728                  */
2729                 ClearPageChecked(page);
2730                 return __ext4_journalled_writepage(page, len);
2731         }
2732
2733         if (test_opt(inode->i_sb, NOBH) && ext4_should_writeback_data(inode))
2734                 ret = nobh_writepage(page, noalloc_get_block_write, wbc);
2735         else
2736                 ret = block_write_full_page(page, noalloc_get_block_write,
2737                                             wbc);
2738
2739         return ret;
2740 }
2741
2742 /*
2743  * This is called via ext4_da_writepages() to
2744  * calulate the total number of credits to reserve to fit
2745  * a single extent allocation into a single transaction,
2746  * ext4_da_writpeages() will loop calling this before
2747  * the block allocation.
2748  */
2749
2750 static int ext4_da_writepages_trans_blocks(struct inode *inode)
2751 {
2752         int max_blocks = EXT4_I(inode)->i_reserved_data_blocks;
2753
2754         /*
2755          * With non-extent format the journal credit needed to
2756          * insert nrblocks contiguous block is dependent on
2757          * number of contiguous block. So we will limit
2758          * number of contiguous block to a sane value
2759          */
2760         if (!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) &&
2761             (max_blocks > EXT4_MAX_TRANS_DATA))
2762                 max_blocks = EXT4_MAX_TRANS_DATA;
2763
2764         return ext4_chunk_trans_blocks(inode, max_blocks);
2765 }
2766
2767 static int ext4_da_writepages(struct address_space *mapping,
2768                               struct writeback_control *wbc)
2769 {
2770         pgoff_t index;
2771         int range_whole = 0;
2772         handle_t *handle = NULL;
2773         struct mpage_da_data mpd;
2774         struct inode *inode = mapping->host;
2775         int no_nrwrite_index_update;
2776         int pages_written = 0;
2777         long pages_skipped;
2778         unsigned int max_pages;
2779         int range_cyclic, cycled = 1, io_done = 0;
2780         int needed_blocks, ret = 0;
2781         long desired_nr_to_write, nr_to_writebump = 0;
2782         loff_t range_start = wbc->range_start;
2783         struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
2784
2785         trace_ext4_da_writepages(inode, wbc);
2786
2787         /*
2788          * No pages to write? This is mainly a kludge to avoid starting
2789          * a transaction for special inodes like journal inode on last iput()
2790          * because that could violate lock ordering on umount
2791          */
2792         if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2793                 return 0;
2794
2795         /*
2796          * If the filesystem has aborted, it is read-only, so return
2797          * right away instead of dumping stack traces later on that
2798          * will obscure the real source of the problem.  We test
2799          * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2800          * the latter could be true if the filesystem is mounted
2801          * read-only, and in that case, ext4_da_writepages should
2802          * *never* be called, so if that ever happens, we would want
2803          * the stack trace.
2804          */
2805         if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED))
2806                 return -EROFS;
2807
2808         if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2809                 range_whole = 1;
2810
2811         range_cyclic = wbc->range_cyclic;
2812         if (wbc->range_cyclic) {
2813                 index = mapping->writeback_index;
2814                 if (index)
2815                         cycled = 0;
2816                 wbc->range_start = index << PAGE_CACHE_SHIFT;
2817                 wbc->range_end  = LLONG_MAX;
2818                 wbc->range_cyclic = 0;
2819         } else
2820                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
2821
2822         /*
2823          * This works around two forms of stupidity.  The first is in
2824          * the writeback code, which caps the maximum number of pages
2825          * written to be 1024 pages.  This is wrong on multiple
2826          * levels; different architectues have a different page size,
2827          * which changes the maximum amount of data which gets
2828          * written.  Secondly, 4 megabytes is way too small.  XFS
2829          * forces this value to be 16 megabytes by multiplying
2830          * nr_to_write parameter by four, and then relies on its
2831          * allocator to allocate larger extents to make them
2832          * contiguous.  Unfortunately this brings us to the second
2833          * stupidity, which is that ext4's mballoc code only allocates
2834          * at most 2048 blocks.  So we force contiguous writes up to
2835          * the number of dirty blocks in the inode, or
2836          * sbi->max_writeback_mb_bump whichever is smaller.
2837          */
2838         max_pages = sbi->s_max_writeback_mb_bump << (20 - PAGE_CACHE_SHIFT);
2839         if (!range_cyclic && range_whole)
2840                 desired_nr_to_write = wbc->nr_to_write * 8;
2841         else
2842                 desired_nr_to_write = ext4_num_dirty_pages(inode, index,
2843                                                            max_pages);
2844         if (desired_nr_to_write > max_pages)
2845                 desired_nr_to_write = max_pages;
2846
2847         if (wbc->nr_to_write < desired_nr_to_write) {
2848                 nr_to_writebump = desired_nr_to_write - wbc->nr_to_write;
2849                 wbc->nr_to_write = desired_nr_to_write;
2850         }
2851
2852         mpd.wbc = wbc;
2853         mpd.inode = mapping->host;
2854
2855         /*
2856          * we don't want write_cache_pages to update
2857          * nr_to_write and writeback_index
2858          */
2859         no_nrwrite_index_update = wbc->no_nrwrite_index_update;
2860         wbc->no_nrwrite_index_update = 1;
2861         pages_skipped = wbc->pages_skipped;
2862
2863 retry:
2864         while (!ret && wbc->nr_to_write > 0) {
2865
2866                 /*
2867                  * we  insert one extent at a time. So we need
2868                  * credit needed for single extent allocation.
2869                  * journalled mode is currently not supported
2870                  * by delalloc
2871                  */
2872                 BUG_ON(ext4_should_journal_data(inode));
2873                 needed_blocks = ext4_da_writepages_trans_blocks(inode);
2874
2875                 /* start a new transaction*/
2876                 handle = ext4_journal_start(inode, needed_blocks);
2877                 if (IS_ERR(handle)) {
2878                         ret = PTR_ERR(handle);
2879                         ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2880                                "%ld pages, ino %lu; err %d\n", __func__,
2881                                 wbc->nr_to_write, inode->i_ino, ret);
2882                         goto out_writepages;
2883                 }
2884
2885                 /*
2886                  * Now call __mpage_da_writepage to find the next
2887                  * contiguous region of logical blocks that need
2888                  * blocks to be allocated by ext4.  We don't actually
2889                  * submit the blocks for I/O here, even though
2890                  * write_cache_pages thinks it will, and will set the
2891                  * pages as clean for write before calling
2892                  * __mpage_da_writepage().
2893                  */
2894                 mpd.b_size = 0;
2895                 mpd.b_state = 0;
2896                 mpd.b_blocknr = 0;
2897                 mpd.first_page = 0;
2898                 mpd.next_page = 0;
2899                 mpd.io_done = 0;
2900                 mpd.pages_written = 0;
2901                 mpd.retval = 0;
2902                 ret = write_cache_pages(mapping, wbc, __mpage_da_writepage,
2903                                         &mpd);
2904                 /*
2905                  * If we have a contiguous extent of pages and we
2906                  * haven't done the I/O yet, map the blocks and submit
2907                  * them for I/O.
2908                  */
2909                 if (!mpd.io_done && mpd.next_page != mpd.first_page) {
2910                         if (mpage_da_map_blocks(&mpd) == 0)
2911                                 mpage_da_submit_io(&mpd);
2912                         mpd.io_done = 1;
2913                         ret = MPAGE_DA_EXTENT_TAIL;
2914                 }
2915                 trace_ext4_da_write_pages(inode, &mpd);
2916                 wbc->nr_to_write -= mpd.pages_written;
2917
2918                 ext4_journal_stop(handle);
2919
2920                 if ((mpd.retval == -ENOSPC) && sbi->s_journal) {
2921                         /* commit the transaction which would
2922                          * free blocks released in the transaction
2923                          * and try again
2924                          */
2925                         jbd2_journal_force_commit_nested(sbi->s_journal);
2926                         wbc->pages_skipped = pages_skipped;
2927                         ret = 0;
2928                 } else if (ret == MPAGE_DA_EXTENT_TAIL) {
2929                         /*
2930                          * got one extent now try with
2931                          * rest of the pages
2932                          */
2933                         pages_written += mpd.pages_written;
2934                         wbc->pages_skipped = pages_skipped;
2935                         ret = 0;
2936                         io_done = 1;
2937                 } else if (wbc->nr_to_write)
2938                         /*
2939                          * There is no more writeout needed
2940                          * or we requested for a noblocking writeout
2941                          * and we found the device congested
2942                          */
2943                         break;
2944         }
2945         if (!io_done && !cycled) {
2946                 cycled = 1;
2947                 index = 0;
2948                 wbc->range_start = index << PAGE_CACHE_SHIFT;
2949                 wbc->range_end  = mapping->writeback_index - 1;
2950                 goto retry;
2951         }
2952         if (pages_skipped != wbc->pages_skipped)
2953                 ext4_msg(inode->i_sb, KERN_CRIT,
2954                          "This should not happen leaving %s "
2955                          "with nr_to_write = %ld ret = %d\n",
2956                          __func__, wbc->nr_to_write, ret);
2957
2958         /* Update index */
2959         index += pages_written;
2960         wbc->range_cyclic = range_cyclic;
2961         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2962                 /*
2963                  * set the writeback_index so that range_cyclic
2964                  * mode will write it back later
2965                  */
2966                 mapping->writeback_index = index;
2967
2968 out_writepages:
2969         if (!no_nrwrite_index_update)
2970                 wbc->no_nrwrite_index_update = 0;
2971         if (wbc->nr_to_write > nr_to_writebump)
2972                 wbc->nr_to_write -= nr_to_writebump;
2973         wbc->range_start = range_start;
2974         trace_ext4_da_writepages_result(inode, wbc, ret, pages_written);
2975         return ret;
2976 }
2977
2978 #define FALL_BACK_TO_NONDELALLOC 1
2979 static int ext4_nonda_switch(struct super_block *sb)
2980 {
2981         s64 free_blocks, dirty_blocks;
2982         struct ext4_sb_info *sbi = EXT4_SB(sb);
2983
2984         /*
2985          * switch to non delalloc mode if we are running low
2986          * on free block. The free block accounting via percpu
2987          * counters can get slightly wrong with percpu_counter_batch getting
2988          * accumulated on each CPU without updating global counters
2989          * Delalloc need an accurate free block accounting. So switch
2990          * to non delalloc when we are near to error range.
2991          */
2992         free_blocks  = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
2993         dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyblocks_counter);
2994         if (2 * free_blocks < 3 * dirty_blocks ||
2995                 free_blocks < (dirty_blocks + EXT4_FREEBLOCKS_WATERMARK)) {
2996                 /*
2997                  * free block count is less that 150% of dirty blocks
2998                  * or free blocks is less that watermark
2999                  */
3000                 return 1;
3001         }
3002         return 0;
3003 }
3004
3005 static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
3006                                loff_t pos, unsigned len, unsigned flags,
3007                                struct page **pagep, void **fsdata)
3008 {
3009         int ret, retries = 0;
3010         struct page *page;
3011         pgoff_t index;
3012         unsigned from, to;
3013         struct inode *inode = mapping->host;
3014         handle_t *handle;
3015
3016         index = pos >> PAGE_CACHE_SHIFT;
3017         from = pos & (PAGE_CACHE_SIZE - 1);
3018         to = from + len;
3019
3020         if (ext4_nonda_switch(inode->i_sb)) {
3021                 *fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
3022                 return ext4_write_begin(file, mapping, pos,
3023                                         len, flags, pagep, fsdata);
3024         }
3025         *fsdata = (void *)0;
3026         trace_ext4_da_write_begin(inode, pos, len, flags);
3027 retry:
3028         /*
3029          * With delayed allocation, we don't log the i_disksize update
3030          * if there is delayed block allocation. But we still need
3031          * to journalling the i_disksize update if writes to the end
3032          * of file which has an already mapped buffer.
3033          */
3034         handle = ext4_journal_start(inode, 1);
3035         if (IS_ERR(handle)) {
3036                 ret = PTR_ERR(handle);
3037                 goto out;
3038         }
3039         /* We cannot recurse into the filesystem as the transaction is already
3040          * started */
3041         flags |= AOP_FLAG_NOFS;
3042
3043         page = grab_cache_page_write_begin(mapping, index, flags);
3044         if (!page) {
3045                 ext4_journal_stop(handle);
3046                 ret = -ENOMEM;
3047                 goto out;
3048         }
3049         *pagep = page;
3050
3051         ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
3052                                 ext4_da_get_block_prep);
3053         if (ret < 0) {
3054                 unlock_page(page);
3055                 ext4_journal_stop(handle);
3056                 page_cache_release(page);
3057                 /*
3058                  * block_write_begin may have instantiated a few blocks
3059                  * outside i_size.  Trim these off again. Don't need
3060                  * i_size_read because we hold i_mutex.
3061                  */
3062                 if (pos + len > inode->i_size)
3063                         ext4_truncate_failed_write(inode);
3064         }
3065
3066         if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
3067                 goto retry;
3068 out:
3069         return ret;
3070 }
3071
3072 /*
3073  * Check if we should update i_disksize
3074  * when write to the end of file but not require block allocation
3075  */
3076 static int ext4_da_should_update_i_disksize(struct page *page,
3077                                             unsigned long offset)
3078 {
3079         struct buffer_head *bh;
3080         struct inode *inode = page->mapping->host;
3081         unsigned int idx;
3082         int i;
3083
3084         bh = page_buffers(page);
3085         idx = offset >> inode->i_blkbits;
3086
3087         for (i = 0; i < idx; i++)
3088                 bh = bh->b_this_page;
3089
3090         if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
3091                 return 0;
3092         return 1;
3093 }
3094
3095 static int ext4_da_write_end(struct file *file,
3096                              struct address_space *mapping,
3097                              loff_t pos, unsigned len, unsigned copied,
3098                              struct page *page, void *fsdata)
3099 {
3100         struct inode *inode = mapping->host;
3101         int ret = 0, ret2;
3102         handle_t *handle = ext4_journal_current_handle();
3103         loff_t new_i_size;
3104         unsigned long start, end;
3105         int write_mode = (int)(unsigned long)fsdata;
3106
3107         if (write_mode == FALL_BACK_TO_NONDELALLOC) {
3108                 if (ext4_should_order_data(inode)) {
3109                         return ext4_ordered_write_end(file, mapping, pos,
3110                                         len, copied, page, fsdata);
3111                 } else if (ext4_should_writeback_data(inode)) {
3112                         return ext4_writeback_write_end(file, mapping, pos,
3113                                         len, copied, page, fsdata);
3114                 } else {
3115                         BUG();
3116                 }
3117         }
3118
3119         trace_ext4_da_write_end(inode, pos, len, copied);
3120         start = pos & (PAGE_CACHE_SIZE - 1);
3121         end = start + copied - 1;
3122
3123         /*
3124          * generic_write_end() will run mark_inode_dirty() if i_size
3125          * changes.  So let's piggyback the i_disksize mark_inode_dirty
3126          * into that.
3127          */
3128
3129         new_i_size = pos + copied;
3130         if (new_i_size > EXT4_I(inode)->i_disksize) {
3131                 if (ext4_da_should_update_i_disksize(page, end)) {
3132                         down_write(&EXT4_I(inode)->i_data_sem);
3133                         if (new_i_size > EXT4_I(inode)->i_disksize) {
3134                                 /*
3135                                  * Updating i_disksize when extending file
3136                                  * without needing block allocation
3137                                  */
3138                                 if (ext4_should_order_data(inode))
3139                                         ret = ext4_jbd2_file_inode(handle,
3140                                                                    inode);
3141
3142                                 EXT4_I(inode)->i_disksize = new_i_size;
3143                         }
3144                         up_write(&EXT4_I(inode)->i_data_sem);
3145                         /* We need to mark inode dirty even if
3146                          * new_i_size is less that inode->i_size
3147                          * bu greater than i_disksize.(hint delalloc)
3148                          */
3149                         ext4_mark_inode_dirty(handle, inode);
3150                 }
3151         }
3152         ret2 = generic_write_end(file, mapping, pos, len, copied,
3153                                                         page, fsdata);
3154         copied = ret2;
3155         if (ret2 < 0)
3156                 ret = ret2;
3157         ret2 = ext4_journal_stop(handle);
3158         if (!ret)
3159                 ret = ret2;
3160
3161         return ret ? ret : copied;
3162 }
3163
3164 static void ext4_da_invalidatepage(struct page *page, unsigned long offset)
3165 {
3166         /*
3167          * Drop reserved blocks
3168          */
3169         BUG_ON(!PageLocked(page));