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