]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - fs/ext4/inode.c
ext4: remove page_skipped hackery in ext4_da_writepages()
[mirror_ubuntu-artful-kernel.git] / fs / ext4 / inode.c
CommitLineData
ac27a0ec 1/*
617ba13b 2 * linux/fs/ext4/inode.c
ac27a0ec
DK
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 *
617ba13b 22 * Assorted race fixes, rewrite of ext4_get_block() by Al Viro, 2000
ac27a0ec
DK
23 */
24
25#include <linux/module.h>
26#include <linux/fs.h>
27#include <linux/time.h>
dab291af 28#include <linux/jbd2.h>
ac27a0ec
DK
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>
64769240 35#include <linux/pagevec.h>
ac27a0ec 36#include <linux/mpage.h>
e83c1397 37#include <linux/namei.h>
ac27a0ec
DK
38#include <linux/uio.h>
39#include <linux/bio.h>
4c0425ff 40#include <linux/workqueue.h>
744692dc 41#include <linux/kernel.h>
6db26ffc 42#include <linux/printk.h>
5a0e3ad6 43#include <linux/slab.h>
a8901d34 44#include <linux/ratelimit.h>
9bffad1e 45
3dcf5451 46#include "ext4_jbd2.h"
ac27a0ec
DK
47#include "xattr.h"
48#include "acl.h"
d2a17637 49#include "ext4_extents.h"
ac27a0ec 50
9bffad1e
TT
51#include <trace/events/ext4.h>
52
a1d6cc56
AK
53#define MPAGE_DA_EXTENT_TAIL 0x01
54
678aaf48
JK
55static inline int ext4_begin_ordered_truncate(struct inode *inode,
56 loff_t new_size)
57{
7ff9c073 58 trace_ext4_begin_ordered_truncate(inode, new_size);
8aefcd55
TT
59 /*
60 * If jinode is zero, then we never opened the file for
61 * writing, so there's no need to call
62 * jbd2_journal_begin_ordered_truncate() since there's no
63 * outstanding writes we need to flush.
64 */
65 if (!EXT4_I(inode)->jinode)
66 return 0;
67 return jbd2_journal_begin_ordered_truncate(EXT4_JOURNAL(inode),
68 EXT4_I(inode)->jinode,
69 new_size);
678aaf48
JK
70}
71
64769240 72static void ext4_invalidatepage(struct page *page, unsigned long offset);
cb20d518
TT
73static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
74 struct buffer_head *bh_result, int create);
75static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode);
76static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate);
77static int __ext4_journalled_writepage(struct page *page, unsigned int len);
78static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh);
64769240 79
ac27a0ec
DK
80/*
81 * Test whether an inode is a fast symlink.
82 */
617ba13b 83static int ext4_inode_is_fast_symlink(struct inode *inode)
ac27a0ec 84{
617ba13b 85 int ea_blocks = EXT4_I(inode)->i_file_acl ?
ac27a0ec
DK
86 (inode->i_sb->s_blocksize >> 9) : 0;
87
88 return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
89}
90
ac27a0ec
DK
91/*
92 * Work out how many blocks we need to proceed with the next chunk of a
93 * truncate transaction.
94 */
95static unsigned long blocks_for_truncate(struct inode *inode)
96{
725d26d3 97 ext4_lblk_t needed;
ac27a0ec
DK
98
99 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
100
101 /* Give ourselves just enough room to cope with inodes in which
102 * i_blocks is corrupt: we've seen disk corruptions in the past
103 * which resulted in random data in an inode which looked enough
617ba13b 104 * like a regular file for ext4 to try to delete it. Things
ac27a0ec
DK
105 * will go a bit crazy if that happens, but at least we should
106 * try not to panic the whole kernel. */
107 if (needed < 2)
108 needed = 2;
109
110 /* But we need to bound the transaction so we don't overflow the
111 * journal. */
617ba13b
MC
112 if (needed > EXT4_MAX_TRANS_DATA)
113 needed = EXT4_MAX_TRANS_DATA;
ac27a0ec 114
617ba13b 115 return EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
ac27a0ec
DK
116}
117
118/*
119 * Truncate transactions can be complex and absolutely huge. So we need to
120 * be able to restart the transaction at a conventient checkpoint to make
121 * sure we don't overflow the journal.
122 *
123 * start_transaction gets us a new handle for a truncate transaction,
124 * and extend_transaction tries to extend the existing one a bit. If
125 * extend fails, we need to propagate the failure up and restart the
126 * transaction in the top-level truncate loop. --sct
127 */
128static handle_t *start_transaction(struct inode *inode)
129{
130 handle_t *result;
131
617ba13b 132 result = ext4_journal_start(inode, blocks_for_truncate(inode));
ac27a0ec
DK
133 if (!IS_ERR(result))
134 return result;
135
617ba13b 136 ext4_std_error(inode->i_sb, PTR_ERR(result));
ac27a0ec
DK
137 return result;
138}
139
140/*
141 * Try to extend this transaction for the purposes of truncation.
142 *
143 * Returns 0 if we managed to create more room. If we can't create more
144 * room, and the transaction must be restarted we return 1.
145 */
146static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
147{
0390131b
FM
148 if (!ext4_handle_valid(handle))
149 return 0;
150 if (ext4_handle_has_enough_credits(handle, EXT4_RESERVE_TRANS_BLOCKS+1))
ac27a0ec 151 return 0;
617ba13b 152 if (!ext4_journal_extend(handle, blocks_for_truncate(inode)))
ac27a0ec
DK
153 return 0;
154 return 1;
155}
156
157/*
158 * Restart the transaction associated with *handle. This does a commit,
159 * so before we call here everything must be consistently dirtied against
160 * this transaction.
161 */
fa5d1113 162int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode,
487caeef 163 int nblocks)
ac27a0ec 164{
487caeef
JK
165 int ret;
166
167 /*
e35fd660 168 * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
487caeef
JK
169 * moment, get_block can be called only for blocks inside i_size since
170 * page cache has been already dropped and writes are blocked by
171 * i_mutex. So we can safely drop the i_data_sem here.
172 */
0390131b 173 BUG_ON(EXT4_JOURNAL(inode) == NULL);
ac27a0ec 174 jbd_debug(2, "restarting handle %p\n", handle);
487caeef
JK
175 up_write(&EXT4_I(inode)->i_data_sem);
176 ret = ext4_journal_restart(handle, blocks_for_truncate(inode));
177 down_write(&EXT4_I(inode)->i_data_sem);
fa5d1113 178 ext4_discard_preallocations(inode);
487caeef
JK
179
180 return ret;
ac27a0ec
DK
181}
182
183/*
184 * Called at the last iput() if i_nlink is zero.
185 */
0930fcc1 186void ext4_evict_inode(struct inode *inode)
ac27a0ec
DK
187{
188 handle_t *handle;
bc965ab3 189 int err;
ac27a0ec 190
7ff9c073 191 trace_ext4_evict_inode(inode);
0930fcc1
AV
192 if (inode->i_nlink) {
193 truncate_inode_pages(&inode->i_data, 0);
194 goto no_delete;
195 }
196
907f4554 197 if (!is_bad_inode(inode))
871a2931 198 dquot_initialize(inode);
907f4554 199
678aaf48
JK
200 if (ext4_should_order_data(inode))
201 ext4_begin_ordered_truncate(inode, 0);
ac27a0ec
DK
202 truncate_inode_pages(&inode->i_data, 0);
203
204 if (is_bad_inode(inode))
205 goto no_delete;
206
bc965ab3 207 handle = ext4_journal_start(inode, blocks_for_truncate(inode)+3);
ac27a0ec 208 if (IS_ERR(handle)) {
bc965ab3 209 ext4_std_error(inode->i_sb, PTR_ERR(handle));
ac27a0ec
DK
210 /*
211 * If we're going to skip the normal cleanup, we still need to
212 * make sure that the in-core orphan linked list is properly
213 * cleaned up.
214 */
617ba13b 215 ext4_orphan_del(NULL, inode);
ac27a0ec
DK
216 goto no_delete;
217 }
218
219 if (IS_SYNC(inode))
0390131b 220 ext4_handle_sync(handle);
ac27a0ec 221 inode->i_size = 0;
bc965ab3
TT
222 err = ext4_mark_inode_dirty(handle, inode);
223 if (err) {
12062ddd 224 ext4_warning(inode->i_sb,
bc965ab3
TT
225 "couldn't mark inode dirty (err %d)", err);
226 goto stop_handle;
227 }
ac27a0ec 228 if (inode->i_blocks)
617ba13b 229 ext4_truncate(inode);
bc965ab3
TT
230
231 /*
232 * ext4_ext_truncate() doesn't reserve any slop when it
233 * restarts journal transactions; therefore there may not be
234 * enough credits left in the handle to remove the inode from
235 * the orphan list and set the dtime field.
236 */
0390131b 237 if (!ext4_handle_has_enough_credits(handle, 3)) {
bc965ab3
TT
238 err = ext4_journal_extend(handle, 3);
239 if (err > 0)
240 err = ext4_journal_restart(handle, 3);
241 if (err != 0) {
12062ddd 242 ext4_warning(inode->i_sb,
bc965ab3
TT
243 "couldn't extend journal (err %d)", err);
244 stop_handle:
245 ext4_journal_stop(handle);
45388219 246 ext4_orphan_del(NULL, inode);
bc965ab3
TT
247 goto no_delete;
248 }
249 }
250
ac27a0ec 251 /*
617ba13b 252 * Kill off the orphan record which ext4_truncate created.
ac27a0ec 253 * AKPM: I think this can be inside the above `if'.
617ba13b 254 * Note that ext4_orphan_del() has to be able to cope with the
ac27a0ec 255 * deletion of a non-existent orphan - this is because we don't
617ba13b 256 * know if ext4_truncate() actually created an orphan record.
ac27a0ec
DK
257 * (Well, we could do this if we need to, but heck - it works)
258 */
617ba13b
MC
259 ext4_orphan_del(handle, inode);
260 EXT4_I(inode)->i_dtime = get_seconds();
ac27a0ec
DK
261
262 /*
263 * One subtle ordering requirement: if anything has gone wrong
264 * (transaction abort, IO errors, whatever), then we can still
265 * do these next steps (the fs will already have been marked as
266 * having errors), but we can't free the inode if the mark_dirty
267 * fails.
268 */
617ba13b 269 if (ext4_mark_inode_dirty(handle, inode))
ac27a0ec 270 /* If that failed, just do the required in-core inode clear. */
0930fcc1 271 ext4_clear_inode(inode);
ac27a0ec 272 else
617ba13b
MC
273 ext4_free_inode(handle, inode);
274 ext4_journal_stop(handle);
ac27a0ec
DK
275 return;
276no_delete:
0930fcc1 277 ext4_clear_inode(inode); /* We must guarantee clearing of inode... */
ac27a0ec
DK
278}
279
280typedef struct {
281 __le32 *p;
282 __le32 key;
283 struct buffer_head *bh;
284} Indirect;
285
286static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
287{
288 p->key = *(p->p = v);
289 p->bh = bh;
290}
291
ac27a0ec 292/**
617ba13b 293 * ext4_block_to_path - parse the block number into array of offsets
ac27a0ec
DK
294 * @inode: inode in question (we are only interested in its superblock)
295 * @i_block: block number to be parsed
296 * @offsets: array to store the offsets in
8c55e204
DK
297 * @boundary: set this non-zero if the referred-to block is likely to be
298 * followed (on disk) by an indirect block.
ac27a0ec 299 *
617ba13b 300 * To store the locations of file's data ext4 uses a data structure common
ac27a0ec
DK
301 * for UNIX filesystems - tree of pointers anchored in the inode, with
302 * data blocks at leaves and indirect blocks in intermediate nodes.
303 * This function translates the block number into path in that tree -
304 * return value is the path length and @offsets[n] is the offset of
305 * pointer to (n+1)th node in the nth one. If @block is out of range
306 * (negative or too large) warning is printed and zero returned.
307 *
308 * Note: function doesn't find node addresses, so no IO is needed. All
309 * we need to know is the capacity of indirect blocks (taken from the
310 * inode->i_sb).
311 */
312
313/*
314 * Portability note: the last comparison (check that we fit into triple
315 * indirect block) is spelled differently, because otherwise on an
316 * architecture with 32-bit longs and 8Kb pages we might get into trouble
317 * if our filesystem had 8Kb blocks. We might use long long, but that would
318 * kill us on x86. Oh, well, at least the sign propagation does not matter -
319 * i_block would have to be negative in the very beginning, so we would not
320 * get there at all.
321 */
322
617ba13b 323static int ext4_block_to_path(struct inode *inode,
de9a55b8
TT
324 ext4_lblk_t i_block,
325 ext4_lblk_t offsets[4], int *boundary)
ac27a0ec 326{
617ba13b
MC
327 int ptrs = EXT4_ADDR_PER_BLOCK(inode->i_sb);
328 int ptrs_bits = EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb);
329 const long direct_blocks = EXT4_NDIR_BLOCKS,
ac27a0ec
DK
330 indirect_blocks = ptrs,
331 double_blocks = (1 << (ptrs_bits * 2));
332 int n = 0;
333 int final = 0;
334
c333e073 335 if (i_block < direct_blocks) {
ac27a0ec
DK
336 offsets[n++] = i_block;
337 final = direct_blocks;
af5bc92d 338 } else if ((i_block -= direct_blocks) < indirect_blocks) {
617ba13b 339 offsets[n++] = EXT4_IND_BLOCK;
ac27a0ec
DK
340 offsets[n++] = i_block;
341 final = ptrs;
342 } else if ((i_block -= indirect_blocks) < double_blocks) {
617ba13b 343 offsets[n++] = EXT4_DIND_BLOCK;
ac27a0ec
DK
344 offsets[n++] = i_block >> ptrs_bits;
345 offsets[n++] = i_block & (ptrs - 1);
346 final = ptrs;
347 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
617ba13b 348 offsets[n++] = EXT4_TIND_BLOCK;
ac27a0ec
DK
349 offsets[n++] = i_block >> (ptrs_bits * 2);
350 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
351 offsets[n++] = i_block & (ptrs - 1);
352 final = ptrs;
353 } else {
12062ddd 354 ext4_warning(inode->i_sb, "block %lu > max in inode %lu",
de9a55b8
TT
355 i_block + direct_blocks +
356 indirect_blocks + double_blocks, inode->i_ino);
ac27a0ec
DK
357 }
358 if (boundary)
359 *boundary = final - 1 - (i_block & (ptrs - 1));
360 return n;
361}
362
c398eda0
TT
363static int __ext4_check_blockref(const char *function, unsigned int line,
364 struct inode *inode,
6fd058f7
TT
365 __le32 *p, unsigned int max)
366{
1c13d5c0 367 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
f73953c0 368 __le32 *bref = p;
6fd058f7
TT
369 unsigned int blk;
370
fe2c8191 371 while (bref < p+max) {
6fd058f7 372 blk = le32_to_cpu(*bref++);
de9a55b8
TT
373 if (blk &&
374 unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
6fd058f7 375 blk, 1))) {
1c13d5c0 376 es->s_last_error_block = cpu_to_le64(blk);
c398eda0
TT
377 ext4_error_inode(inode, function, line, blk,
378 "invalid block");
de9a55b8
TT
379 return -EIO;
380 }
381 }
382 return 0;
fe2c8191
TN
383}
384
385
386#define ext4_check_indirect_blockref(inode, bh) \
c398eda0
TT
387 __ext4_check_blockref(__func__, __LINE__, inode, \
388 (__le32 *)(bh)->b_data, \
fe2c8191
TN
389 EXT4_ADDR_PER_BLOCK((inode)->i_sb))
390
391#define ext4_check_inode_blockref(inode) \
c398eda0
TT
392 __ext4_check_blockref(__func__, __LINE__, inode, \
393 EXT4_I(inode)->i_data, \
fe2c8191
TN
394 EXT4_NDIR_BLOCKS)
395
ac27a0ec 396/**
617ba13b 397 * ext4_get_branch - read the chain of indirect blocks leading to data
ac27a0ec
DK
398 * @inode: inode in question
399 * @depth: depth of the chain (1 - direct pointer, etc.)
400 * @offsets: offsets of pointers in inode/indirect blocks
401 * @chain: place to store the result
402 * @err: here we store the error value
403 *
404 * Function fills the array of triples <key, p, bh> and returns %NULL
405 * if everything went OK or the pointer to the last filled triple
406 * (incomplete one) otherwise. Upon the return chain[i].key contains
407 * the number of (i+1)-th block in the chain (as it is stored in memory,
408 * i.e. little-endian 32-bit), chain[i].p contains the address of that
409 * number (it points into struct inode for i==0 and into the bh->b_data
410 * for i>0) and chain[i].bh points to the buffer_head of i-th indirect
411 * block for i>0 and NULL for i==0. In other words, it holds the block
412 * numbers of the chain, addresses they were taken from (and where we can
413 * verify that chain did not change) and buffer_heads hosting these
414 * numbers.
415 *
416 * Function stops when it stumbles upon zero pointer (absent block)
417 * (pointer to last triple returned, *@err == 0)
418 * or when it gets an IO error reading an indirect block
419 * (ditto, *@err == -EIO)
ac27a0ec
DK
420 * or when it reads all @depth-1 indirect blocks successfully and finds
421 * the whole chain, all way to the data (returns %NULL, *err == 0).
c278bfec
AK
422 *
423 * Need to be called with
0e855ac8 424 * down_read(&EXT4_I(inode)->i_data_sem)
ac27a0ec 425 */
725d26d3
AK
426static Indirect *ext4_get_branch(struct inode *inode, int depth,
427 ext4_lblk_t *offsets,
ac27a0ec
DK
428 Indirect chain[4], int *err)
429{
430 struct super_block *sb = inode->i_sb;
431 Indirect *p = chain;
432 struct buffer_head *bh;
433
434 *err = 0;
435 /* i_data is not going away, no lock needed */
af5bc92d 436 add_chain(chain, NULL, EXT4_I(inode)->i_data + *offsets);
ac27a0ec
DK
437 if (!p->key)
438 goto no_block;
439 while (--depth) {
fe2c8191
TN
440 bh = sb_getblk(sb, le32_to_cpu(p->key));
441 if (unlikely(!bh))
ac27a0ec 442 goto failure;
de9a55b8 443
fe2c8191
TN
444 if (!bh_uptodate_or_lock(bh)) {
445 if (bh_submit_read(bh) < 0) {
446 put_bh(bh);
447 goto failure;
448 }
449 /* validate block references */
450 if (ext4_check_indirect_blockref(inode, bh)) {
451 put_bh(bh);
452 goto failure;
453 }
454 }
de9a55b8 455
af5bc92d 456 add_chain(++p, bh, (__le32 *)bh->b_data + *++offsets);
ac27a0ec
DK
457 /* Reader: end */
458 if (!p->key)
459 goto no_block;
460 }
461 return NULL;
462
ac27a0ec
DK
463failure:
464 *err = -EIO;
465no_block:
466 return p;
467}
468
469/**
617ba13b 470 * ext4_find_near - find a place for allocation with sufficient locality
ac27a0ec
DK
471 * @inode: owner
472 * @ind: descriptor of indirect block.
473 *
1cc8dcf5 474 * This function returns the preferred place for block allocation.
ac27a0ec
DK
475 * It is used when heuristic for sequential allocation fails.
476 * Rules are:
477 * + if there is a block to the left of our position - allocate near it.
478 * + if pointer will live in indirect block - allocate near that block.
479 * + if pointer will live in inode - allocate in the same
480 * cylinder group.
481 *
482 * In the latter case we colour the starting block by the callers PID to
483 * prevent it from clashing with concurrent allocations for a different inode
484 * in the same block group. The PID is used here so that functionally related
485 * files will be close-by on-disk.
486 *
487 * Caller must make sure that @ind is valid and will stay that way.
488 */
617ba13b 489static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind)
ac27a0ec 490{
617ba13b 491 struct ext4_inode_info *ei = EXT4_I(inode);
af5bc92d 492 __le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data;
ac27a0ec 493 __le32 *p;
617ba13b 494 ext4_fsblk_t bg_start;
74d3487f 495 ext4_fsblk_t last_block;
617ba13b 496 ext4_grpblk_t colour;
a4912123
TT
497 ext4_group_t block_group;
498 int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb));
ac27a0ec
DK
499
500 /* Try to find previous block */
501 for (p = ind->p - 1; p >= start; p--) {
502 if (*p)
503 return le32_to_cpu(*p);
504 }
505
506 /* No such thing, so let's try location of indirect block */
507 if (ind->bh)
508 return ind->bh->b_blocknr;
509
510 /*
511 * It is going to be referred to from the inode itself? OK, just put it
512 * into the same cylinder group then.
513 */
a4912123
TT
514 block_group = ei->i_block_group;
515 if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) {
516 block_group &= ~(flex_size-1);
517 if (S_ISREG(inode->i_mode))
518 block_group++;
519 }
520 bg_start = ext4_group_first_block_no(inode->i_sb, block_group);
74d3487f
VC
521 last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
522
a4912123
TT
523 /*
524 * If we are doing delayed allocation, we don't need take
525 * colour into account.
526 */
527 if (test_opt(inode->i_sb, DELALLOC))
528 return bg_start;
529
74d3487f
VC
530 if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
531 colour = (current->pid % 16) *
617ba13b 532 (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
74d3487f
VC
533 else
534 colour = (current->pid % 16) * ((last_block - bg_start) / 16);
ac27a0ec
DK
535 return bg_start + colour;
536}
537
538/**
1cc8dcf5 539 * ext4_find_goal - find a preferred place for allocation.
ac27a0ec
DK
540 * @inode: owner
541 * @block: block we want
ac27a0ec 542 * @partial: pointer to the last triple within a chain
ac27a0ec 543 *
1cc8dcf5 544 * Normally this function find the preferred place for block allocation,
fb01bfda 545 * returns it.
fb0a387d
ES
546 * Because this is only used for non-extent files, we limit the block nr
547 * to 32 bits.
ac27a0ec 548 */
725d26d3 549static ext4_fsblk_t ext4_find_goal(struct inode *inode, ext4_lblk_t block,
de9a55b8 550 Indirect *partial)
ac27a0ec 551{
fb0a387d
ES
552 ext4_fsblk_t goal;
553
ac27a0ec 554 /*
c2ea3fde 555 * XXX need to get goal block from mballoc's data structures
ac27a0ec 556 */
ac27a0ec 557
fb0a387d
ES
558 goal = ext4_find_near(inode, partial);
559 goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
560 return goal;
ac27a0ec
DK
561}
562
563/**
225db7d3 564 * ext4_blks_to_allocate - Look up the block map and count the number
ac27a0ec
DK
565 * of direct blocks need to be allocated for the given branch.
566 *
567 * @branch: chain of indirect blocks
568 * @k: number of blocks need for indirect blocks
569 * @blks: number of data blocks to be mapped.
570 * @blocks_to_boundary: the offset in the indirect block
571 *
572 * return the total number of blocks to be allocate, including the
573 * direct and indirect blocks.
574 */
498e5f24 575static int ext4_blks_to_allocate(Indirect *branch, int k, unsigned int blks,
de9a55b8 576 int blocks_to_boundary)
ac27a0ec 577{
498e5f24 578 unsigned int count = 0;
ac27a0ec
DK
579
580 /*
581 * Simple case, [t,d]Indirect block(s) has not allocated yet
582 * then it's clear blocks on that path have not allocated
583 */
584 if (k > 0) {
585 /* right now we don't handle cross boundary allocation */
586 if (blks < blocks_to_boundary + 1)
587 count += blks;
588 else
589 count += blocks_to_boundary + 1;
590 return count;
591 }
592
593 count++;
594 while (count < blks && count <= blocks_to_boundary &&
595 le32_to_cpu(*(branch[0].p + count)) == 0) {
596 count++;
597 }
598 return count;
599}
600
601/**
617ba13b 602 * ext4_alloc_blocks: multiple allocate blocks needed for a branch
225db7d3
TT
603 * @handle: handle for this transaction
604 * @inode: inode which needs allocated blocks
605 * @iblock: the logical block to start allocated at
606 * @goal: preferred physical block of allocation
ac27a0ec
DK
607 * @indirect_blks: the number of blocks need to allocate for indirect
608 * blocks
225db7d3 609 * @blks: number of desired blocks
ac27a0ec
DK
610 * @new_blocks: on return it will store the new block numbers for
611 * the indirect blocks(if needed) and the first direct block,
225db7d3
TT
612 * @err: on return it will store the error code
613 *
614 * This function will return the number of blocks allocated as
615 * requested by the passed-in parameters.
ac27a0ec 616 */
617ba13b 617static int ext4_alloc_blocks(handle_t *handle, struct inode *inode,
de9a55b8
TT
618 ext4_lblk_t iblock, ext4_fsblk_t goal,
619 int indirect_blks, int blks,
620 ext4_fsblk_t new_blocks[4], int *err)
ac27a0ec 621{
815a1130 622 struct ext4_allocation_request ar;
ac27a0ec 623 int target, i;
7061eba7 624 unsigned long count = 0, blk_allocated = 0;
ac27a0ec 625 int index = 0;
617ba13b 626 ext4_fsblk_t current_block = 0;
ac27a0ec
DK
627 int ret = 0;
628
629 /*
630 * Here we try to allocate the requested multiple blocks at once,
631 * on a best-effort basis.
632 * To build a branch, we should allocate blocks for
633 * the indirect blocks(if not allocated yet), and at least
634 * the first direct block of this branch. That's the
635 * minimum number of blocks need to allocate(required)
636 */
7061eba7
AK
637 /* first we try to allocate the indirect blocks */
638 target = indirect_blks;
639 while (target > 0) {
ac27a0ec
DK
640 count = target;
641 /* allocating blocks for indirect blocks and direct blocks */
7061eba7
AK
642 current_block = ext4_new_meta_blocks(handle, inode,
643 goal, &count, err);
ac27a0ec
DK
644 if (*err)
645 goto failed_out;
646
273df556
FM
647 if (unlikely(current_block + count > EXT4_MAX_BLOCK_FILE_PHYS)) {
648 EXT4_ERROR_INODE(inode,
649 "current_block %llu + count %lu > %d!",
650 current_block, count,
651 EXT4_MAX_BLOCK_FILE_PHYS);
652 *err = -EIO;
653 goto failed_out;
654 }
fb0a387d 655
ac27a0ec
DK
656 target -= count;
657 /* allocate blocks for indirect blocks */
658 while (index < indirect_blks && count) {
659 new_blocks[index++] = current_block++;
660 count--;
661 }
7061eba7
AK
662 if (count > 0) {
663 /*
664 * save the new block number
665 * for the first direct block
666 */
667 new_blocks[index] = current_block;
668 printk(KERN_INFO "%s returned more blocks than "
669 "requested\n", __func__);
670 WARN_ON(1);
ac27a0ec 671 break;
7061eba7 672 }
ac27a0ec
DK
673 }
674
7061eba7
AK
675 target = blks - count ;
676 blk_allocated = count;
677 if (!target)
678 goto allocated;
679 /* Now allocate data blocks */
815a1130
TT
680 memset(&ar, 0, sizeof(ar));
681 ar.inode = inode;
682 ar.goal = goal;
683 ar.len = target;
684 ar.logical = iblock;
685 if (S_ISREG(inode->i_mode))
686 /* enable in-core preallocation only for regular files */
687 ar.flags = EXT4_MB_HINT_DATA;
688
689 current_block = ext4_mb_new_blocks(handle, &ar, err);
273df556
FM
690 if (unlikely(current_block + ar.len > EXT4_MAX_BLOCK_FILE_PHYS)) {
691 EXT4_ERROR_INODE(inode,
692 "current_block %llu + ar.len %d > %d!",
693 current_block, ar.len,
694 EXT4_MAX_BLOCK_FILE_PHYS);
695 *err = -EIO;
696 goto failed_out;
697 }
815a1130 698
7061eba7
AK
699 if (*err && (target == blks)) {
700 /*
701 * if the allocation failed and we didn't allocate
702 * any blocks before
703 */
704 goto failed_out;
705 }
706 if (!*err) {
707 if (target == blks) {
de9a55b8
TT
708 /*
709 * save the new block number
710 * for the first direct block
711 */
7061eba7
AK
712 new_blocks[index] = current_block;
713 }
815a1130 714 blk_allocated += ar.len;
7061eba7
AK
715 }
716allocated:
ac27a0ec 717 /* total number of blocks allocated for direct blocks */
7061eba7 718 ret = blk_allocated;
ac27a0ec
DK
719 *err = 0;
720 return ret;
721failed_out:
af5bc92d 722 for (i = 0; i < index; i++)
7dc57615 723 ext4_free_blocks(handle, inode, NULL, new_blocks[i], 1, 0);
ac27a0ec
DK
724 return ret;
725}
726
727/**
617ba13b 728 * ext4_alloc_branch - allocate and set up a chain of blocks.
225db7d3 729 * @handle: handle for this transaction
ac27a0ec
DK
730 * @inode: owner
731 * @indirect_blks: number of allocated indirect blocks
732 * @blks: number of allocated direct blocks
225db7d3 733 * @goal: preferred place for allocation
ac27a0ec
DK
734 * @offsets: offsets (in the blocks) to store the pointers to next.
735 * @branch: place to store the chain in.
736 *
737 * This function allocates blocks, zeroes out all but the last one,
738 * links them into chain and (if we are synchronous) writes them to disk.
739 * In other words, it prepares a branch that can be spliced onto the
740 * inode. It stores the information about that chain in the branch[], in
617ba13b 741 * the same format as ext4_get_branch() would do. We are calling it after
ac27a0ec
DK
742 * we had read the existing part of chain and partial points to the last
743 * triple of that (one with zero ->key). Upon the exit we have the same
617ba13b 744 * picture as after the successful ext4_get_block(), except that in one
ac27a0ec
DK
745 * place chain is disconnected - *branch->p is still zero (we did not
746 * set the last link), but branch->key contains the number that should
747 * be placed into *branch->p to fill that gap.
748 *
749 * If allocation fails we free all blocks we've allocated (and forget
750 * their buffer_heads) and return the error value the from failed
617ba13b 751 * ext4_alloc_block() (normally -ENOSPC). Otherwise we set the chain
ac27a0ec
DK
752 * as described above and return 0.
753 */
617ba13b 754static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
de9a55b8
TT
755 ext4_lblk_t iblock, int indirect_blks,
756 int *blks, ext4_fsblk_t goal,
757 ext4_lblk_t *offsets, Indirect *branch)
ac27a0ec
DK
758{
759 int blocksize = inode->i_sb->s_blocksize;
760 int i, n = 0;
761 int err = 0;
762 struct buffer_head *bh;
763 int num;
617ba13b
MC
764 ext4_fsblk_t new_blocks[4];
765 ext4_fsblk_t current_block;
ac27a0ec 766
7061eba7 767 num = ext4_alloc_blocks(handle, inode, iblock, goal, indirect_blks,
ac27a0ec
DK
768 *blks, new_blocks, &err);
769 if (err)
770 return err;
771
772 branch[0].key = cpu_to_le32(new_blocks[0]);
773 /*
774 * metadata blocks and data blocks are allocated.
775 */
776 for (n = 1; n <= indirect_blks; n++) {
777 /*
778 * Get buffer_head for parent block, zero it out
779 * and set the pointer to new one, then send
780 * parent to disk.
781 */
782 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
87783690
NK
783 if (unlikely(!bh)) {
784 err = -EIO;
785 goto failed;
786 }
787
ac27a0ec
DK
788 branch[n].bh = bh;
789 lock_buffer(bh);
790 BUFFER_TRACE(bh, "call get_create_access");
617ba13b 791 err = ext4_journal_get_create_access(handle, bh);
ac27a0ec 792 if (err) {
6487a9d3
CW
793 /* Don't brelse(bh) here; it's done in
794 * ext4_journal_forget() below */
ac27a0ec 795 unlock_buffer(bh);
ac27a0ec
DK
796 goto failed;
797 }
798
799 memset(bh->b_data, 0, blocksize);
800 branch[n].p = (__le32 *) bh->b_data + offsets[n];
801 branch[n].key = cpu_to_le32(new_blocks[n]);
802 *branch[n].p = branch[n].key;
af5bc92d 803 if (n == indirect_blks) {
ac27a0ec
DK
804 current_block = new_blocks[n];
805 /*
806 * End of chain, update the last new metablock of
807 * the chain to point to the new allocated
808 * data blocks numbers
809 */
de9a55b8 810 for (i = 1; i < num; i++)
ac27a0ec
DK
811 *(branch[n].p + i) = cpu_to_le32(++current_block);
812 }
813 BUFFER_TRACE(bh, "marking uptodate");
814 set_buffer_uptodate(bh);
815 unlock_buffer(bh);
816
0390131b
FM
817 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
818 err = ext4_handle_dirty_metadata(handle, inode, bh);
ac27a0ec
DK
819 if (err)
820 goto failed;
821 }
822 *blks = num;
823 return err;
824failed:
825 /* Allocation failed, free what we already allocated */
7dc57615 826 ext4_free_blocks(handle, inode, NULL, new_blocks[0], 1, 0);
ac27a0ec 827 for (i = 1; i <= n ; i++) {
60e6679e 828 /*
e6362609
TT
829 * branch[i].bh is newly allocated, so there is no
830 * need to revoke the block, which is why we don't
831 * need to set EXT4_FREE_BLOCKS_METADATA.
b7e57e7c 832 */
7dc57615 833 ext4_free_blocks(handle, inode, NULL, new_blocks[i], 1,
e6362609 834 EXT4_FREE_BLOCKS_FORGET);
ac27a0ec 835 }
e6362609 836 for (i = n+1; i < indirect_blks; i++)
7dc57615 837 ext4_free_blocks(handle, inode, NULL, new_blocks[i], 1, 0);
ac27a0ec 838
7dc57615 839 ext4_free_blocks(handle, inode, NULL, new_blocks[i], num, 0);
ac27a0ec
DK
840
841 return err;
842}
843
844/**
617ba13b 845 * ext4_splice_branch - splice the allocated branch onto inode.
225db7d3 846 * @handle: handle for this transaction
ac27a0ec
DK
847 * @inode: owner
848 * @block: (logical) number of block we are adding
849 * @chain: chain of indirect blocks (with a missing link - see
617ba13b 850 * ext4_alloc_branch)
ac27a0ec
DK
851 * @where: location of missing link
852 * @num: number of indirect blocks we are adding
853 * @blks: number of direct blocks we are adding
854 *
855 * This function fills the missing link and does all housekeeping needed in
856 * inode (->i_blocks, etc.). In case of success we end up with the full
857 * chain to new block and return 0.
858 */
617ba13b 859static int ext4_splice_branch(handle_t *handle, struct inode *inode,
de9a55b8
TT
860 ext4_lblk_t block, Indirect *where, int num,
861 int blks)
ac27a0ec
DK
862{
863 int i;
864 int err = 0;
617ba13b 865 ext4_fsblk_t current_block;
ac27a0ec 866
ac27a0ec
DK
867 /*
868 * If we're splicing into a [td]indirect block (as opposed to the
869 * inode) then we need to get write access to the [td]indirect block
870 * before the splice.
871 */
872 if (where->bh) {
873 BUFFER_TRACE(where->bh, "get_write_access");
617ba13b 874 err = ext4_journal_get_write_access(handle, where->bh);
ac27a0ec
DK
875 if (err)
876 goto err_out;
877 }
878 /* That's it */
879
880 *where->p = where->key;
881
882 /*
883 * Update the host buffer_head or inode to point to more just allocated
884 * direct blocks blocks
885 */
886 if (num == 0 && blks > 1) {
887 current_block = le32_to_cpu(where->key) + 1;
888 for (i = 1; i < blks; i++)
af5bc92d 889 *(where->p + i) = cpu_to_le32(current_block++);
ac27a0ec
DK
890 }
891
ac27a0ec 892 /* We are done with atomic stuff, now do the rest of housekeeping */
ac27a0ec
DK
893 /* had we spliced it onto indirect block? */
894 if (where->bh) {
895 /*
896 * If we spliced it onto an indirect block, we haven't
897 * altered the inode. Note however that if it is being spliced
898 * onto an indirect block at the very end of the file (the
899 * file is growing) then we *will* alter the inode to reflect
900 * the new i_size. But that is not done here - it is done in
617ba13b 901 * generic_commit_write->__mark_inode_dirty->ext4_dirty_inode.
ac27a0ec
DK
902 */
903 jbd_debug(5, "splicing indirect only\n");
0390131b
FM
904 BUFFER_TRACE(where->bh, "call ext4_handle_dirty_metadata");
905 err = ext4_handle_dirty_metadata(handle, inode, where->bh);
ac27a0ec
DK
906 if (err)
907 goto err_out;
908 } else {
909 /*
910 * OK, we spliced it into the inode itself on a direct block.
ac27a0ec 911 */
41591750 912 ext4_mark_inode_dirty(handle, inode);
ac27a0ec
DK
913 jbd_debug(5, "splicing direct\n");
914 }
915 return err;
916
917err_out:
918 for (i = 1; i <= num; i++) {
60e6679e 919 /*
e6362609
TT
920 * branch[i].bh is newly allocated, so there is no
921 * need to revoke the block, which is why we don't
922 * need to set EXT4_FREE_BLOCKS_METADATA.
b7e57e7c 923 */
e6362609
TT
924 ext4_free_blocks(handle, inode, where[i].bh, 0, 1,
925 EXT4_FREE_BLOCKS_FORGET);
ac27a0ec 926 }
7dc57615 927 ext4_free_blocks(handle, inode, NULL, le32_to_cpu(where[num].key),
e6362609 928 blks, 0);
ac27a0ec
DK
929
930 return err;
931}
932
933/*
e35fd660 934 * The ext4_ind_map_blocks() function handles non-extents inodes
b920c755 935 * (i.e., using the traditional indirect/double-indirect i_blocks
e35fd660 936 * scheme) for ext4_map_blocks().
b920c755 937 *
ac27a0ec
DK
938 * Allocation strategy is simple: if we have to allocate something, we will
939 * have to go the whole way to leaf. So let's do it before attaching anything
940 * to tree, set linkage between the newborn blocks, write them if sync is
941 * required, recheck the path, free and repeat if check fails, otherwise
942 * set the last missing link (that will protect us from any truncate-generated
943 * removals - all blocks on the path are immune now) and possibly force the
944 * write on the parent block.
945 * That has a nice additional property: no special recovery from the failed
946 * allocations is needed - we simply release blocks and do not touch anything
947 * reachable from inode.
948 *
949 * `handle' can be NULL if create == 0.
950 *
ac27a0ec
DK
951 * return > 0, # of blocks mapped or allocated.
952 * return = 0, if plain lookup failed.
953 * return < 0, error case.
c278bfec 954 *
b920c755
TT
955 * The ext4_ind_get_blocks() function should be called with
956 * down_write(&EXT4_I(inode)->i_data_sem) if allocating filesystem
957 * blocks (i.e., flags has EXT4_GET_BLOCKS_CREATE set) or
958 * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system
959 * blocks.
ac27a0ec 960 */
e35fd660
TT
961static int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
962 struct ext4_map_blocks *map,
de9a55b8 963 int flags)
ac27a0ec
DK
964{
965 int err = -EIO;
725d26d3 966 ext4_lblk_t offsets[4];
ac27a0ec
DK
967 Indirect chain[4];
968 Indirect *partial;
617ba13b 969 ext4_fsblk_t goal;
ac27a0ec
DK
970 int indirect_blks;
971 int blocks_to_boundary = 0;
972 int depth;
ac27a0ec 973 int count = 0;
617ba13b 974 ext4_fsblk_t first_block = 0;
ac27a0ec 975
12e9b892 976 J_ASSERT(!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)));
c2177057 977 J_ASSERT(handle != NULL || (flags & EXT4_GET_BLOCKS_CREATE) == 0);
e35fd660 978 depth = ext4_block_to_path(inode, map->m_lblk, offsets,
de9a55b8 979 &blocks_to_boundary);
ac27a0ec
DK
980
981 if (depth == 0)
982 goto out;
983
617ba13b 984 partial = ext4_get_branch(inode, depth, offsets, chain, &err);
ac27a0ec
DK
985
986 /* Simplest case - block found, no allocation needed */
987 if (!partial) {
988 first_block = le32_to_cpu(chain[depth - 1].key);
ac27a0ec
DK
989 count++;
990 /*map more blocks*/
e35fd660 991 while (count < map->m_len && count <= blocks_to_boundary) {
617ba13b 992 ext4_fsblk_t blk;
ac27a0ec 993
ac27a0ec
DK
994 blk = le32_to_cpu(*(chain[depth-1].p + count));
995
996 if (blk == first_block + count)
997 count++;
998 else
999 break;
1000 }
c278bfec 1001 goto got_it;
ac27a0ec
DK
1002 }
1003
1004 /* Next simple case - plain lookup or failed read of indirect block */
c2177057 1005 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0 || err == -EIO)
ac27a0ec
DK
1006 goto cleanup;
1007
ac27a0ec 1008 /*
c2ea3fde 1009 * Okay, we need to do block allocation.
ac27a0ec 1010 */
e35fd660 1011 goal = ext4_find_goal(inode, map->m_lblk, partial);
ac27a0ec
DK
1012
1013 /* the number of blocks need to allocate for [d,t]indirect blocks */
1014 indirect_blks = (chain + depth) - partial - 1;
1015
1016 /*
1017 * Next look up the indirect map to count the totoal number of
1018 * direct blocks to allocate for this branch.
1019 */
617ba13b 1020 count = ext4_blks_to_allocate(partial, indirect_blks,
e35fd660 1021 map->m_len, blocks_to_boundary);
ac27a0ec 1022 /*
617ba13b 1023 * Block out ext4_truncate while we alter the tree
ac27a0ec 1024 */
e35fd660 1025 err = ext4_alloc_branch(handle, inode, map->m_lblk, indirect_blks,
de9a55b8
TT
1026 &count, goal,
1027 offsets + (partial - chain), partial);
ac27a0ec
DK
1028
1029 /*
617ba13b 1030 * The ext4_splice_branch call will free and forget any buffers
ac27a0ec
DK
1031 * on the new chain if there is a failure, but that risks using
1032 * up transaction credits, especially for bitmaps where the
1033 * credits cannot be returned. Can we handle this somehow? We
1034 * may need to return -EAGAIN upwards in the worst case. --sct
1035 */
1036 if (!err)
e35fd660 1037 err = ext4_splice_branch(handle, inode, map->m_lblk,
de9a55b8 1038 partial, indirect_blks, count);
2bba702d 1039 if (err)
ac27a0ec
DK
1040 goto cleanup;
1041
e35fd660 1042 map->m_flags |= EXT4_MAP_NEW;
b436b9be
JK
1043
1044 ext4_update_inode_fsync_trans(handle, inode, 1);
ac27a0ec 1045got_it:
e35fd660
TT
1046 map->m_flags |= EXT4_MAP_MAPPED;
1047 map->m_pblk = le32_to_cpu(chain[depth-1].key);
1048 map->m_len = count;
ac27a0ec 1049 if (count > blocks_to_boundary)
e35fd660 1050 map->m_flags |= EXT4_MAP_BOUNDARY;
ac27a0ec
DK
1051 err = count;
1052 /* Clean up and exit */
1053 partial = chain + depth - 1; /* the whole chain */
1054cleanup:
1055 while (partial > chain) {
1056 BUFFER_TRACE(partial->bh, "call brelse");
1057 brelse(partial->bh);
1058 partial--;
1059 }
ac27a0ec
DK
1060out:
1061 return err;
1062}
1063
a9e7f447
DM
1064#ifdef CONFIG_QUOTA
1065qsize_t *ext4_get_reserved_space(struct inode *inode)
60e58e0f 1066{
a9e7f447 1067 return &EXT4_I(inode)->i_reserved_quota;
60e58e0f 1068}
a9e7f447 1069#endif
9d0be502 1070
12219aea
AK
1071/*
1072 * Calculate the number of metadata blocks need to reserve
9d0be502 1073 * to allocate a new block at @lblocks for non extent file based file
12219aea 1074 */
9d0be502
TT
1075static int ext4_indirect_calc_metadata_amount(struct inode *inode,
1076 sector_t lblock)
12219aea 1077{
9d0be502 1078 struct ext4_inode_info *ei = EXT4_I(inode);
d330a5be 1079 sector_t dind_mask = ~((sector_t)EXT4_ADDR_PER_BLOCK(inode->i_sb) - 1);
9d0be502 1080 int blk_bits;
12219aea 1081
9d0be502
TT
1082 if (lblock < EXT4_NDIR_BLOCKS)
1083 return 0;
12219aea 1084
9d0be502 1085 lblock -= EXT4_NDIR_BLOCKS;
12219aea 1086
9d0be502
TT
1087 if (ei->i_da_metadata_calc_len &&
1088 (lblock & dind_mask) == ei->i_da_metadata_calc_last_lblock) {
1089 ei->i_da_metadata_calc_len++;
1090 return 0;
1091 }
1092 ei->i_da_metadata_calc_last_lblock = lblock & dind_mask;
1093 ei->i_da_metadata_calc_len = 1;
d330a5be 1094 blk_bits = order_base_2(lblock);
9d0be502 1095 return (blk_bits / EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb)) + 1;
12219aea
AK
1096}
1097
1098/*
1099 * Calculate the number of metadata blocks need to reserve
9d0be502 1100 * to allocate a block located at @lblock
12219aea 1101 */
01f49d0b 1102static int ext4_calc_metadata_amount(struct inode *inode, ext4_lblk_t lblock)
12219aea 1103{
12e9b892 1104 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
9d0be502 1105 return ext4_ext_calc_metadata_amount(inode, lblock);
12219aea 1106
9d0be502 1107 return ext4_indirect_calc_metadata_amount(inode, lblock);
12219aea
AK
1108}
1109
0637c6f4
TT
1110/*
1111 * Called with i_data_sem down, which is important since we can call
1112 * ext4_discard_preallocations() from here.
1113 */
5f634d06
AK
1114void ext4_da_update_reserve_space(struct inode *inode,
1115 int used, int quota_claim)
12219aea
AK
1116{
1117 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
0637c6f4 1118 struct ext4_inode_info *ei = EXT4_I(inode);
0637c6f4
TT
1119
1120 spin_lock(&ei->i_block_reservation_lock);
f8ec9d68 1121 trace_ext4_da_update_reserve_space(inode, used);
0637c6f4
TT
1122 if (unlikely(used > ei->i_reserved_data_blocks)) {
1123 ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, used %d "
1124 "with only %d reserved data blocks\n",
1125 __func__, inode->i_ino, used,
1126 ei->i_reserved_data_blocks);
1127 WARN_ON(1);
1128 used = ei->i_reserved_data_blocks;
1129 }
12219aea 1130
0637c6f4
TT
1131 /* Update per-inode reservations */
1132 ei->i_reserved_data_blocks -= used;
0637c6f4 1133 ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks;
72b8ab9d
ES
1134 percpu_counter_sub(&sbi->s_dirtyblocks_counter,
1135 used + ei->i_allocated_meta_blocks);
0637c6f4 1136 ei->i_allocated_meta_blocks = 0;
6bc6e63f 1137
0637c6f4
TT
1138 if (ei->i_reserved_data_blocks == 0) {
1139 /*
1140 * We can release all of the reserved metadata blocks
1141 * only when we have written all of the delayed
1142 * allocation blocks.
1143 */
72b8ab9d
ES
1144 percpu_counter_sub(&sbi->s_dirtyblocks_counter,
1145 ei->i_reserved_meta_blocks);
ee5f4d9c 1146 ei->i_reserved_meta_blocks = 0;
9d0be502 1147 ei->i_da_metadata_calc_len = 0;
6bc6e63f 1148 }
12219aea 1149 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
60e58e0f 1150
72b8ab9d
ES
1151 /* Update quota subsystem for data blocks */
1152 if (quota_claim)
5dd4056d 1153 dquot_claim_block(inode, used);
72b8ab9d 1154 else {
5f634d06
AK
1155 /*
1156 * We did fallocate with an offset that is already delayed
1157 * allocated. So on delayed allocated writeback we should
72b8ab9d 1158 * not re-claim the quota for fallocated blocks.
5f634d06 1159 */
72b8ab9d 1160 dquot_release_reservation_block(inode, used);
5f634d06 1161 }
d6014301
AK
1162
1163 /*
1164 * If we have done all the pending block allocations and if
1165 * there aren't any writers on the inode, we can discard the
1166 * inode's preallocations.
1167 */
0637c6f4
TT
1168 if ((ei->i_reserved_data_blocks == 0) &&
1169 (atomic_read(&inode->i_writecount) == 0))
d6014301 1170 ext4_discard_preallocations(inode);
12219aea
AK
1171}
1172
e29136f8 1173static int __check_block_validity(struct inode *inode, const char *func,
c398eda0
TT
1174 unsigned int line,
1175 struct ext4_map_blocks *map)
6fd058f7 1176{
24676da4
TT
1177 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk,
1178 map->m_len)) {
c398eda0
TT
1179 ext4_error_inode(inode, func, line, map->m_pblk,
1180 "lblock %lu mapped to illegal pblock "
1181 "(length %d)", (unsigned long) map->m_lblk,
1182 map->m_len);
6fd058f7
TT
1183 return -EIO;
1184 }
1185 return 0;
1186}
1187
e29136f8 1188#define check_block_validity(inode, map) \
c398eda0 1189 __check_block_validity((inode), __func__, __LINE__, (map))
e29136f8 1190
55138e0b 1191/*
1f94533d
TT
1192 * Return the number of contiguous dirty pages in a given inode
1193 * starting at page frame idx.
55138e0b
TT
1194 */
1195static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx,
1196 unsigned int max_pages)
1197{
1198 struct address_space *mapping = inode->i_mapping;
1199 pgoff_t index;
1200 struct pagevec pvec;
1201 pgoff_t num = 0;
1202 int i, nr_pages, done = 0;
1203
1204 if (max_pages == 0)
1205 return 0;
1206 pagevec_init(&pvec, 0);
1207 while (!done) {
1208 index = idx;
1209 nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1210 PAGECACHE_TAG_DIRTY,
1211 (pgoff_t)PAGEVEC_SIZE);
1212 if (nr_pages == 0)
1213 break;
1214 for (i = 0; i < nr_pages; i++) {
1215 struct page *page = pvec.pages[i];
1216 struct buffer_head *bh, *head;
1217
1218 lock_page(page);
1219 if (unlikely(page->mapping != mapping) ||
1220 !PageDirty(page) ||
1221 PageWriteback(page) ||
1222 page->index != idx) {
1223 done = 1;
1224 unlock_page(page);
1225 break;
1226 }
1f94533d
TT
1227 if (page_has_buffers(page)) {
1228 bh = head = page_buffers(page);
1229 do {
1230 if (!buffer_delay(bh) &&
1231 !buffer_unwritten(bh))
1232 done = 1;
1233 bh = bh->b_this_page;
1234 } while (!done && (bh != head));
1235 }
55138e0b
TT
1236 unlock_page(page);
1237 if (done)
1238 break;
1239 idx++;
1240 num++;
659c6009
ES
1241 if (num >= max_pages) {
1242 done = 1;
55138e0b 1243 break;
659c6009 1244 }
55138e0b
TT
1245 }
1246 pagevec_release(&pvec);
1247 }
1248 return num;
1249}
1250
f5ab0d1f 1251/*
e35fd660 1252 * The ext4_map_blocks() function tries to look up the requested blocks,
2b2d6d01 1253 * and returns if the blocks are already mapped.
f5ab0d1f 1254 *
f5ab0d1f
MC
1255 * Otherwise it takes the write lock of the i_data_sem and allocate blocks
1256 * and store the allocated blocks in the result buffer head and mark it
1257 * mapped.
1258 *
e35fd660
TT
1259 * If file type is extents based, it will call ext4_ext_map_blocks(),
1260 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
f5ab0d1f
MC
1261 * based files
1262 *
1263 * On success, it returns the number of blocks being mapped or allocate.
1264 * if create==0 and the blocks are pre-allocated and uninitialized block,
1265 * the result buffer head is unmapped. If the create ==1, it will make sure
1266 * the buffer head is mapped.
1267 *
1268 * It returns 0 if plain look up failed (blocks have not been allocated), in
1269 * that casem, buffer head is unmapped
1270 *
1271 * It returns the error in case of allocation failure.
1272 */
e35fd660
TT
1273int ext4_map_blocks(handle_t *handle, struct inode *inode,
1274 struct ext4_map_blocks *map, int flags)
0e855ac8
AK
1275{
1276 int retval;
f5ab0d1f 1277
e35fd660
TT
1278 map->m_flags = 0;
1279 ext_debug("ext4_map_blocks(): inode %lu, flag %d, max_blocks %u,"
1280 "logical block %lu\n", inode->i_ino, flags, map->m_len,
1281 (unsigned long) map->m_lblk);
4df3d265 1282 /*
b920c755
TT
1283 * Try to see if we can get the block without requesting a new
1284 * file system block.
4df3d265
AK
1285 */
1286 down_read((&EXT4_I(inode)->i_data_sem));
12e9b892 1287 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
e35fd660 1288 retval = ext4_ext_map_blocks(handle, inode, map, 0);
0e855ac8 1289 } else {
e35fd660 1290 retval = ext4_ind_map_blocks(handle, inode, map, 0);
0e855ac8 1291 }
4df3d265 1292 up_read((&EXT4_I(inode)->i_data_sem));
f5ab0d1f 1293
e35fd660 1294 if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
e29136f8 1295 int ret = check_block_validity(inode, map);
6fd058f7
TT
1296 if (ret != 0)
1297 return ret;
1298 }
1299
f5ab0d1f 1300 /* If it is only a block(s) look up */
c2177057 1301 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
f5ab0d1f
MC
1302 return retval;
1303
1304 /*
1305 * Returns if the blocks have already allocated
1306 *
1307 * Note that if blocks have been preallocated
1308 * ext4_ext_get_block() returns th create = 0
1309 * with buffer head unmapped.
1310 */
e35fd660 1311 if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
4df3d265
AK
1312 return retval;
1313
2a8964d6
AK
1314 /*
1315 * When we call get_blocks without the create flag, the
1316 * BH_Unwritten flag could have gotten set if the blocks
1317 * requested were part of a uninitialized extent. We need to
1318 * clear this flag now that we are committed to convert all or
1319 * part of the uninitialized extent to be an initialized
1320 * extent. This is because we need to avoid the combination
1321 * of BH_Unwritten and BH_Mapped flags being simultaneously
1322 * set on the buffer_head.
1323 */
e35fd660 1324 map->m_flags &= ~EXT4_MAP_UNWRITTEN;
2a8964d6 1325
4df3d265 1326 /*
f5ab0d1f
MC
1327 * New blocks allocate and/or writing to uninitialized extent
1328 * will possibly result in updating i_data, so we take
1329 * the write lock of i_data_sem, and call get_blocks()
1330 * with create == 1 flag.
4df3d265
AK
1331 */
1332 down_write((&EXT4_I(inode)->i_data_sem));
d2a17637
MC
1333
1334 /*
1335 * if the caller is from delayed allocation writeout path
1336 * we have already reserved fs blocks for allocation
1337 * let the underlying get_block() function know to
1338 * avoid double accounting
1339 */
c2177057 1340 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
f2321097 1341 ext4_set_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
4df3d265
AK
1342 /*
1343 * We need to check for EXT4 here because migrate
1344 * could have changed the inode type in between
1345 */
12e9b892 1346 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
e35fd660 1347 retval = ext4_ext_map_blocks(handle, inode, map, flags);
0e855ac8 1348 } else {
e35fd660 1349 retval = ext4_ind_map_blocks(handle, inode, map, flags);
267e4db9 1350
e35fd660 1351 if (retval > 0 && map->m_flags & EXT4_MAP_NEW) {
267e4db9
AK
1352 /*
1353 * We allocated new blocks which will result in
1354 * i_data's format changing. Force the migrate
1355 * to fail by clearing migrate flags
1356 */
19f5fb7a 1357 ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
267e4db9 1358 }
d2a17637 1359
5f634d06
AK
1360 /*
1361 * Update reserved blocks/metadata blocks after successful
1362 * block allocation which had been deferred till now. We don't
1363 * support fallocate for non extent files. So we can update
1364 * reserve space here.
1365 */
1366 if ((retval > 0) &&
1296cc85 1367 (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE))
5f634d06
AK
1368 ext4_da_update_reserve_space(inode, retval, 1);
1369 }
2ac3b6e0 1370 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
f2321097 1371 ext4_clear_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
2ac3b6e0 1372
4df3d265 1373 up_write((&EXT4_I(inode)->i_data_sem));
e35fd660 1374 if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
e29136f8 1375 int ret = check_block_validity(inode, map);
6fd058f7
TT
1376 if (ret != 0)
1377 return ret;
1378 }
0e855ac8
AK
1379 return retval;
1380}
1381
f3bd1f3f
MC
1382/* Maximum number of blocks we map for direct IO at once. */
1383#define DIO_MAX_BLOCKS 4096
1384
2ed88685
TT
1385static int _ext4_get_block(struct inode *inode, sector_t iblock,
1386 struct buffer_head *bh, int flags)
ac27a0ec 1387{
3e4fdaf8 1388 handle_t *handle = ext4_journal_current_handle();
2ed88685 1389 struct ext4_map_blocks map;
7fb5409d 1390 int ret = 0, started = 0;
f3bd1f3f 1391 int dio_credits;
ac27a0ec 1392
2ed88685
TT
1393 map.m_lblk = iblock;
1394 map.m_len = bh->b_size >> inode->i_blkbits;
1395
1396 if (flags && !handle) {
7fb5409d 1397 /* Direct IO write... */
2ed88685
TT
1398 if (map.m_len > DIO_MAX_BLOCKS)
1399 map.m_len = DIO_MAX_BLOCKS;
1400 dio_credits = ext4_chunk_trans_blocks(inode, map.m_len);
f3bd1f3f 1401 handle = ext4_journal_start(inode, dio_credits);
7fb5409d 1402 if (IS_ERR(handle)) {
ac27a0ec 1403 ret = PTR_ERR(handle);
2ed88685 1404 return ret;
ac27a0ec 1405 }
7fb5409d 1406 started = 1;
ac27a0ec
DK
1407 }
1408
2ed88685 1409 ret = ext4_map_blocks(handle, inode, &map, flags);
7fb5409d 1410 if (ret > 0) {
2ed88685
TT
1411 map_bh(bh, inode->i_sb, map.m_pblk);
1412 bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
1413 bh->b_size = inode->i_sb->s_blocksize * map.m_len;
7fb5409d 1414 ret = 0;
ac27a0ec 1415 }
7fb5409d
JK
1416 if (started)
1417 ext4_journal_stop(handle);
ac27a0ec
DK
1418 return ret;
1419}
1420
2ed88685
TT
1421int ext4_get_block(struct inode *inode, sector_t iblock,
1422 struct buffer_head *bh, int create)
1423{
1424 return _ext4_get_block(inode, iblock, bh,
1425 create ? EXT4_GET_BLOCKS_CREATE : 0);
1426}
1427
ac27a0ec
DK
1428/*
1429 * `handle' can be NULL if create is zero
1430 */
617ba13b 1431struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
725d26d3 1432 ext4_lblk_t block, int create, int *errp)
ac27a0ec 1433{
2ed88685
TT
1434 struct ext4_map_blocks map;
1435 struct buffer_head *bh;
ac27a0ec
DK
1436 int fatal = 0, err;
1437
1438 J_ASSERT(handle != NULL || create == 0);
1439
2ed88685
TT
1440 map.m_lblk = block;
1441 map.m_len = 1;
1442 err = ext4_map_blocks(handle, inode, &map,
1443 create ? EXT4_GET_BLOCKS_CREATE : 0);
ac27a0ec 1444
2ed88685
TT
1445 if (err < 0)
1446 *errp = err;
1447 if (err <= 0)
1448 return NULL;
1449 *errp = 0;
1450
1451 bh = sb_getblk(inode->i_sb, map.m_pblk);
1452 if (!bh) {
1453 *errp = -EIO;
1454 return NULL;
ac27a0ec 1455 }
2ed88685
TT
1456 if (map.m_flags & EXT4_MAP_NEW) {
1457 J_ASSERT(create != 0);
1458 J_ASSERT(handle != NULL);
ac27a0ec 1459
2ed88685
TT
1460 /*
1461 * Now that we do not always journal data, we should
1462 * keep in mind whether this should always journal the
1463 * new buffer as metadata. For now, regular file
1464 * writes use ext4_get_block instead, so it's not a
1465 * problem.
1466 */
1467 lock_buffer(bh);
1468 BUFFER_TRACE(bh, "call get_create_access");
1469 fatal = ext4_journal_get_create_access(handle, bh);
1470 if (!fatal && !buffer_uptodate(bh)) {
1471 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
1472 set_buffer_uptodate(bh);
ac27a0ec 1473 }
2ed88685
TT
1474 unlock_buffer(bh);
1475 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
1476 err = ext4_handle_dirty_metadata(handle, inode, bh);
1477 if (!fatal)
1478 fatal = err;
1479 } else {
1480 BUFFER_TRACE(bh, "not a new buffer");
ac27a0ec 1481 }
2ed88685
TT
1482 if (fatal) {
1483 *errp = fatal;
1484 brelse(bh);
1485 bh = NULL;
1486 }
1487 return bh;
ac27a0ec
DK
1488}
1489
617ba13b 1490struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
725d26d3 1491 ext4_lblk_t block, int create, int *err)
ac27a0ec 1492{
af5bc92d 1493 struct buffer_head *bh;
ac27a0ec 1494
617ba13b 1495 bh = ext4_getblk(handle, inode, block, create, err);
ac27a0ec
DK
1496 if (!bh)
1497 return bh;
1498 if (buffer_uptodate(bh))
1499 return bh;
1500 ll_rw_block(READ_META, 1, &bh);
1501 wait_on_buffer(bh);
1502 if (buffer_uptodate(bh))
1503 return bh;
1504 put_bh(bh);
1505 *err = -EIO;
1506 return NULL;
1507}
1508
af5bc92d
TT
1509static int walk_page_buffers(handle_t *handle,
1510 struct buffer_head *head,
1511 unsigned from,
1512 unsigned to,
1513 int *partial,
1514 int (*fn)(handle_t *handle,
1515 struct buffer_head *bh))
ac27a0ec
DK
1516{
1517 struct buffer_head *bh;
1518 unsigned block_start, block_end;
1519 unsigned blocksize = head->b_size;
1520 int err, ret = 0;
1521 struct buffer_head *next;
1522
af5bc92d
TT
1523 for (bh = head, block_start = 0;
1524 ret == 0 && (bh != head || !block_start);
de9a55b8 1525 block_start = block_end, bh = next) {
ac27a0ec
DK
1526 next = bh->b_this_page;
1527 block_end = block_start + blocksize;
1528 if (block_end <= from || block_start >= to) {
1529 if (partial && !buffer_uptodate(bh))
1530 *partial = 1;
1531 continue;
1532 }
1533 err = (*fn)(handle, bh);
1534 if (!ret)
1535 ret = err;
1536 }
1537 return ret;
1538}
1539
1540/*
1541 * To preserve ordering, it is essential that the hole instantiation and
1542 * the data write be encapsulated in a single transaction. We cannot
617ba13b 1543 * close off a transaction and start a new one between the ext4_get_block()
dab291af 1544 * and the commit_write(). So doing the jbd2_journal_start at the start of
ac27a0ec
DK
1545 * prepare_write() is the right place.
1546 *
617ba13b
MC
1547 * Also, this function can nest inside ext4_writepage() ->
1548 * block_write_full_page(). In that case, we *know* that ext4_writepage()
ac27a0ec
DK
1549 * has generated enough buffer credits to do the whole page. So we won't
1550 * block on the journal in that case, which is good, because the caller may
1551 * be PF_MEMALLOC.
1552 *
617ba13b 1553 * By accident, ext4 can be reentered when a transaction is open via
ac27a0ec
DK
1554 * quota file writes. If we were to commit the transaction while thus
1555 * reentered, there can be a deadlock - we would be holding a quota
1556 * lock, and the commit would never complete if another thread had a
1557 * transaction open and was blocking on the quota lock - a ranking
1558 * violation.
1559 *
dab291af 1560 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
ac27a0ec
DK
1561 * will _not_ run commit under these circumstances because handle->h_ref
1562 * is elevated. We'll still have enough credits for the tiny quotafile
1563 * write.
1564 */
1565static int do_journal_get_write_access(handle_t *handle,
de9a55b8 1566 struct buffer_head *bh)
ac27a0ec 1567{
56d35a4c
JK
1568 int dirty = buffer_dirty(bh);
1569 int ret;
1570
ac27a0ec
DK
1571 if (!buffer_mapped(bh) || buffer_freed(bh))
1572 return 0;
56d35a4c 1573 /*
ebdec241 1574 * __block_write_begin() could have dirtied some buffers. Clean
56d35a4c
JK
1575 * the dirty bit as jbd2_journal_get_write_access() could complain
1576 * otherwise about fs integrity issues. Setting of the dirty bit
ebdec241 1577 * by __block_write_begin() isn't a real problem here as we clear
56d35a4c
JK
1578 * the bit before releasing a page lock and thus writeback cannot
1579 * ever write the buffer.
1580 */
1581 if (dirty)
1582 clear_buffer_dirty(bh);
1583 ret = ext4_journal_get_write_access(handle, bh);
1584 if (!ret && dirty)
1585 ret = ext4_handle_dirty_metadata(handle, NULL, bh);
1586 return ret;
ac27a0ec
DK
1587}
1588
b9a4207d
JK
1589/*
1590 * Truncate blocks that were not used by write. We have to truncate the
1591 * pagecache as well so that corresponding buffers get properly unmapped.
1592 */
1593static void ext4_truncate_failed_write(struct inode *inode)
1594{
1595 truncate_inode_pages(inode->i_mapping, inode->i_size);
1596 ext4_truncate(inode);
1597}
1598
744692dc
JZ
1599static int ext4_get_block_write(struct inode *inode, sector_t iblock,
1600 struct buffer_head *bh_result, int create);
bfc1af65 1601static int ext4_write_begin(struct file *file, struct address_space *mapping,
de9a55b8
TT
1602 loff_t pos, unsigned len, unsigned flags,
1603 struct page **pagep, void **fsdata)
ac27a0ec 1604{
af5bc92d 1605 struct inode *inode = mapping->host;
1938a150 1606 int ret, needed_blocks;
ac27a0ec
DK
1607 handle_t *handle;
1608 int retries = 0;
af5bc92d 1609 struct page *page;
de9a55b8 1610 pgoff_t index;
af5bc92d 1611 unsigned from, to;
bfc1af65 1612
9bffad1e 1613 trace_ext4_write_begin(inode, pos, len, flags);
1938a150
AK
1614 /*
1615 * Reserve one block more for addition to orphan list in case
1616 * we allocate blocks but write fails for some reason
1617 */
1618 needed_blocks = ext4_writepage_trans_blocks(inode) + 1;
de9a55b8 1619 index = pos >> PAGE_CACHE_SHIFT;
af5bc92d
TT
1620 from = pos & (PAGE_CACHE_SIZE - 1);
1621 to = from + len;
ac27a0ec
DK
1622
1623retry:
af5bc92d
TT
1624 handle = ext4_journal_start(inode, needed_blocks);
1625 if (IS_ERR(handle)) {
1626 ret = PTR_ERR(handle);
1627 goto out;
7479d2b9 1628 }
ac27a0ec 1629
ebd3610b
JK
1630 /* We cannot recurse into the filesystem as the transaction is already
1631 * started */
1632 flags |= AOP_FLAG_NOFS;
1633
54566b2c 1634 page = grab_cache_page_write_begin(mapping, index, flags);
cf108bca
JK
1635 if (!page) {
1636 ext4_journal_stop(handle);
1637 ret = -ENOMEM;
1638 goto out;
1639 }
1640 *pagep = page;
1641
744692dc 1642 if (ext4_should_dioread_nolock(inode))
6e1db88d 1643 ret = __block_write_begin(page, pos, len, ext4_get_block_write);
744692dc 1644 else
6e1db88d 1645 ret = __block_write_begin(page, pos, len, ext4_get_block);
bfc1af65
NP
1646
1647 if (!ret && ext4_should_journal_data(inode)) {
ac27a0ec
DK
1648 ret = walk_page_buffers(handle, page_buffers(page),
1649 from, to, NULL, do_journal_get_write_access);
1650 }
bfc1af65
NP
1651
1652 if (ret) {
af5bc92d 1653 unlock_page(page);
af5bc92d 1654 page_cache_release(page);
ae4d5372 1655 /*
6e1db88d 1656 * __block_write_begin may have instantiated a few blocks
ae4d5372
AK
1657 * outside i_size. Trim these off again. Don't need
1658 * i_size_read because we hold i_mutex.
1938a150
AK
1659 *
1660 * Add inode to orphan list in case we crash before
1661 * truncate finishes
ae4d5372 1662 */
ffacfa7a 1663 if (pos + len > inode->i_size && ext4_can_truncate(inode))
1938a150
AK
1664 ext4_orphan_add(handle, inode);
1665
1666 ext4_journal_stop(handle);
1667 if (pos + len > inode->i_size) {
b9a4207d 1668 ext4_truncate_failed_write(inode);
de9a55b8 1669 /*
ffacfa7a 1670 * If truncate failed early the inode might
1938a150
AK
1671 * still be on the orphan list; we need to
1672 * make sure the inode is removed from the
1673 * orphan list in that case.
1674 */
1675 if (inode->i_nlink)
1676 ext4_orphan_del(NULL, inode);
1677 }
bfc1af65
NP
1678 }
1679
617ba13b 1680 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
ac27a0ec 1681 goto retry;
7479d2b9 1682out:
ac27a0ec
DK
1683 return ret;
1684}
1685
bfc1af65
NP
1686/* For write_end() in data=journal mode */
1687static int write_end_fn(handle_t *handle, struct buffer_head *bh)
ac27a0ec
DK
1688{
1689 if (!buffer_mapped(bh) || buffer_freed(bh))
1690 return 0;
1691 set_buffer_uptodate(bh);
0390131b 1692 return ext4_handle_dirty_metadata(handle, NULL, bh);
ac27a0ec
DK
1693}
1694
f8514083 1695static int ext4_generic_write_end(struct file *file,
de9a55b8
TT
1696 struct address_space *mapping,
1697 loff_t pos, unsigned len, unsigned copied,
1698 struct page *page, void *fsdata)
f8514083
AK
1699{
1700 int i_size_changed = 0;
1701 struct inode *inode = mapping->host;
1702 handle_t *handle = ext4_journal_current_handle();
1703
1704 copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1705
1706 /*
1707 * No need to use i_size_read() here, the i_size
1708 * cannot change under us because we hold i_mutex.
1709 *
1710 * But it's important to update i_size while still holding page lock:
1711 * page writeout could otherwise come in and zero beyond i_size.
1712 */
1713 if (pos + copied > inode->i_size) {
1714 i_size_write(inode, pos + copied);
1715 i_size_changed = 1;
1716 }
1717
1718 if (pos + copied > EXT4_I(inode)->i_disksize) {
1719 /* We need to mark inode dirty even if
1720 * new_i_size is less that inode->i_size
1721 * bu greater than i_disksize.(hint delalloc)
1722 */
1723 ext4_update_i_disksize(inode, (pos + copied));
1724 i_size_changed = 1;
1725 }
1726 unlock_page(page);
1727 page_cache_release(page);
1728
1729 /*
1730 * Don't mark the inode dirty under page lock. First, it unnecessarily
1731 * makes the holding time of page lock longer. Second, it forces lock
1732 * ordering of page lock and transaction start for journaling
1733 * filesystems.
1734 */
1735 if (i_size_changed)
1736 ext4_mark_inode_dirty(handle, inode);
1737
1738 return copied;
1739}
1740
ac27a0ec
DK
1741/*
1742 * We need to pick up the new inode size which generic_commit_write gave us
1743 * `file' can be NULL - eg, when called from page_symlink().
1744 *
617ba13b 1745 * ext4 never places buffers on inode->i_mapping->private_list. metadata
ac27a0ec
DK
1746 * buffers are managed internally.
1747 */
bfc1af65 1748static int ext4_ordered_write_end(struct file *file,
de9a55b8
TT
1749 struct address_space *mapping,
1750 loff_t pos, unsigned len, unsigned copied,
1751 struct page *page, void *fsdata)
ac27a0ec 1752{
617ba13b 1753 handle_t *handle = ext4_journal_current_handle();
cf108bca 1754 struct inode *inode = mapping->host;
ac27a0ec
DK
1755 int ret = 0, ret2;
1756
9bffad1e 1757 trace_ext4_ordered_write_end(inode, pos, len, copied);
678aaf48 1758 ret = ext4_jbd2_file_inode(handle, inode);
ac27a0ec
DK
1759
1760 if (ret == 0) {
f8514083 1761 ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
bfc1af65 1762 page, fsdata);
f8a87d89 1763 copied = ret2;
ffacfa7a 1764 if (pos + len > inode->i_size && ext4_can_truncate(inode))
f8514083
AK
1765 /* if we have allocated more blocks and copied
1766 * less. We will have blocks allocated outside
1767 * inode->i_size. So truncate them
1768 */
1769 ext4_orphan_add(handle, inode);
f8a87d89
RK
1770 if (ret2 < 0)
1771 ret = ret2;
ac27a0ec 1772 }
617ba13b 1773 ret2 = ext4_journal_stop(handle);
ac27a0ec
DK
1774 if (!ret)
1775 ret = ret2;
bfc1af65 1776
f8514083 1777 if (pos + len > inode->i_size) {
b9a4207d 1778 ext4_truncate_failed_write(inode);
de9a55b8 1779 /*
ffacfa7a 1780 * If truncate failed early the inode might still be
f8514083
AK
1781 * on the orphan list; we need to make sure the inode
1782 * is removed from the orphan list in that case.
1783 */
1784 if (inode->i_nlink)
1785 ext4_orphan_del(NULL, inode);
1786 }
1787
1788
bfc1af65 1789 return ret ? ret : copied;
ac27a0ec
DK
1790}
1791
bfc1af65 1792static int ext4_writeback_write_end(struct file *file,
de9a55b8
TT
1793 struct address_space *mapping,
1794 loff_t pos, unsigned len, unsigned copied,
1795 struct page *page, void *fsdata)
ac27a0ec 1796{
617ba13b 1797 handle_t *handle = ext4_journal_current_handle();
cf108bca 1798 struct inode *inode = mapping->host;
ac27a0ec 1799 int ret = 0, ret2;
ac27a0ec 1800
9bffad1e 1801 trace_ext4_writeback_write_end(inode, pos, len, copied);
f8514083 1802 ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
bfc1af65 1803 page, fsdata);
f8a87d89 1804 copied = ret2;
ffacfa7a 1805 if (pos + len > inode->i_size && ext4_can_truncate(inode))
f8514083
AK
1806 /* if we have allocated more blocks and copied
1807 * less. We will have blocks allocated outside
1808 * inode->i_size. So truncate them
1809 */
1810 ext4_orphan_add(handle, inode);
1811
f8a87d89
RK
1812 if (ret2 < 0)
1813 ret = ret2;
ac27a0ec 1814
617ba13b 1815 ret2 = ext4_journal_stop(handle);
ac27a0ec
DK
1816 if (!ret)
1817 ret = ret2;
bfc1af65 1818
f8514083 1819 if (pos + len > inode->i_size) {
b9a4207d 1820 ext4_truncate_failed_write(inode);
de9a55b8 1821 /*
ffacfa7a 1822 * If truncate failed early the inode might still be
f8514083
AK
1823 * on the orphan list; we need to make sure the inode
1824 * is removed from the orphan list in that case.
1825 */
1826 if (inode->i_nlink)
1827 ext4_orphan_del(NULL, inode);
1828 }
1829
bfc1af65 1830 return ret ? ret : copied;
ac27a0ec
DK
1831}
1832
bfc1af65 1833static int ext4_journalled_write_end(struct file *file,
de9a55b8
TT
1834 struct address_space *mapping,
1835 loff_t pos, unsigned len, unsigned copied,
1836 struct page *page, void *fsdata)
ac27a0ec 1837{
617ba13b 1838 handle_t *handle = ext4_journal_current_handle();
bfc1af65 1839 struct inode *inode = mapping->host;
ac27a0ec
DK
1840 int ret = 0, ret2;
1841 int partial = 0;
bfc1af65 1842 unsigned from, to;
cf17fea6 1843 loff_t new_i_size;
ac27a0ec 1844
9bffad1e 1845 trace_ext4_journalled_write_end(inode, pos, len, copied);
bfc1af65
NP
1846 from = pos & (PAGE_CACHE_SIZE - 1);
1847 to = from + len;
1848
1849 if (copied < len) {
1850 if (!PageUptodate(page))
1851 copied = 0;
1852 page_zero_new_buffers(page, from+copied, to);
1853 }
ac27a0ec
DK
1854
1855 ret = walk_page_buffers(handle, page_buffers(page), from,
bfc1af65 1856 to, &partial, write_end_fn);
ac27a0ec
DK
1857 if (!partial)
1858 SetPageUptodate(page);
cf17fea6
AK
1859 new_i_size = pos + copied;
1860 if (new_i_size > inode->i_size)
bfc1af65 1861 i_size_write(inode, pos+copied);
19f5fb7a 1862 ext4_set_inode_state(inode, EXT4_STATE_JDATA);
cf17fea6
AK
1863 if (new_i_size > EXT4_I(inode)->i_disksize) {
1864 ext4_update_i_disksize(inode, new_i_size);
617ba13b 1865 ret2 = ext4_mark_inode_dirty(handle, inode);
ac27a0ec
DK
1866 if (!ret)
1867 ret = ret2;
1868 }
bfc1af65 1869
cf108bca 1870 unlock_page(page);
f8514083 1871 page_cache_release(page);
ffacfa7a 1872 if (pos + len > inode->i_size && ext4_can_truncate(inode))
f8514083
AK
1873 /* if we have allocated more blocks and copied
1874 * less. We will have blocks allocated outside
1875 * inode->i_size. So truncate them
1876 */
1877 ext4_orphan_add(handle, inode);
1878
617ba13b 1879 ret2 = ext4_journal_stop(handle);
ac27a0ec
DK
1880 if (!ret)
1881 ret = ret2;
f8514083 1882 if (pos + len > inode->i_size) {
b9a4207d 1883 ext4_truncate_failed_write(inode);
de9a55b8 1884 /*
ffacfa7a 1885 * If truncate failed early the inode might still be
f8514083
AK
1886 * on the orphan list; we need to make sure the inode
1887 * is removed from the orphan list in that case.
1888 */
1889 if (inode->i_nlink)
1890 ext4_orphan_del(NULL, inode);
1891 }
bfc1af65
NP
1892
1893 return ret ? ret : copied;
ac27a0ec 1894}
d2a17637 1895
9d0be502
TT
1896/*
1897 * Reserve a single block located at lblock
1898 */
01f49d0b 1899static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)
d2a17637 1900{
030ba6bc 1901 int retries = 0;
60e58e0f 1902 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
0637c6f4 1903 struct ext4_inode_info *ei = EXT4_I(inode);
72b8ab9d 1904 unsigned long md_needed;
5dd4056d 1905 int ret;
d2a17637
MC
1906
1907 /*
1908 * recalculate the amount of metadata blocks to reserve
1909 * in order to allocate nrblocks
1910 * worse case is one extent per block
1911 */
030ba6bc 1912repeat:
0637c6f4 1913 spin_lock(&ei->i_block_reservation_lock);
9d0be502 1914 md_needed = ext4_calc_metadata_amount(inode, lblock);
f8ec9d68 1915 trace_ext4_da_reserve_space(inode, md_needed);
0637c6f4 1916 spin_unlock(&ei->i_block_reservation_lock);
d2a17637 1917
60e58e0f 1918 /*
72b8ab9d
ES
1919 * We will charge metadata quota at writeout time; this saves
1920 * us from metadata over-estimation, though we may go over by
1921 * a small amount in the end. Here we just reserve for data.
60e58e0f 1922 */
72b8ab9d 1923 ret = dquot_reserve_block(inode, 1);
5dd4056d
CH
1924 if (ret)
1925 return ret;
72b8ab9d
ES
1926 /*
1927 * We do still charge estimated metadata to the sb though;
1928 * we cannot afford to run out of free blocks.
1929 */
9d0be502 1930 if (ext4_claim_free_blocks(sbi, md_needed + 1)) {
72b8ab9d 1931 dquot_release_reservation_block(inode, 1);
030ba6bc
AK
1932 if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
1933 yield();
1934 goto repeat;
1935 }
d2a17637
MC
1936 return -ENOSPC;
1937 }
0637c6f4 1938 spin_lock(&ei->i_block_reservation_lock);
9d0be502 1939 ei->i_reserved_data_blocks++;
0637c6f4
TT
1940 ei->i_reserved_meta_blocks += md_needed;
1941 spin_unlock(&ei->i_block_reservation_lock);
39bc680a 1942
d2a17637
MC
1943 return 0; /* success */
1944}
1945
12219aea 1946static void ext4_da_release_space(struct inode *inode, int to_free)
d2a17637
MC
1947{
1948 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
0637c6f4 1949 struct ext4_inode_info *ei = EXT4_I(inode);
d2a17637 1950
cd213226
MC
1951 if (!to_free)
1952 return; /* Nothing to release, exit */
1953
d2a17637 1954 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
cd213226 1955
5a58ec87 1956 trace_ext4_da_release_space(inode, to_free);
0637c6f4 1957 if (unlikely(to_free > ei->i_reserved_data_blocks)) {
cd213226 1958 /*
0637c6f4
TT
1959 * if there aren't enough reserved blocks, then the
1960 * counter is messed up somewhere. Since this
1961 * function is called from invalidate page, it's
1962 * harmless to return without any action.
cd213226 1963 */
0637c6f4
TT
1964 ext4_msg(inode->i_sb, KERN_NOTICE, "ext4_da_release_space: "
1965 "ino %lu, to_free %d with only %d reserved "
1966 "data blocks\n", inode->i_ino, to_free,
1967 ei->i_reserved_data_blocks);
1968 WARN_ON(1);
1969 to_free = ei->i_reserved_data_blocks;
cd213226 1970 }
0637c6f4 1971 ei->i_reserved_data_blocks -= to_free;
cd213226 1972
0637c6f4
TT
1973 if (ei->i_reserved_data_blocks == 0) {
1974 /*
1975 * We can release all of the reserved metadata blocks
1976 * only when we have written all of the delayed
1977 * allocation blocks.
1978 */
72b8ab9d
ES
1979 percpu_counter_sub(&sbi->s_dirtyblocks_counter,
1980 ei->i_reserved_meta_blocks);
ee5f4d9c 1981 ei->i_reserved_meta_blocks = 0;
9d0be502 1982 ei->i_da_metadata_calc_len = 0;
0637c6f4 1983 }
d2a17637 1984
72b8ab9d 1985 /* update fs dirty data blocks counter */
0637c6f4 1986 percpu_counter_sub(&sbi->s_dirtyblocks_counter, to_free);
d2a17637 1987
d2a17637 1988 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
60e58e0f 1989
5dd4056d 1990 dquot_release_reservation_block(inode, to_free);
d2a17637
MC
1991}
1992
1993static void ext4_da_page_release_reservation(struct page *page,
de9a55b8 1994 unsigned long offset)
d2a17637
MC
1995{
1996 int to_release = 0;
1997 struct buffer_head *head, *bh;
1998 unsigned int curr_off = 0;
1999
2000 head = page_buffers(page);
2001 bh = head;
2002 do {
2003 unsigned int next_off = curr_off + bh->b_size;
2004
2005 if ((offset <= curr_off) && (buffer_delay(bh))) {
2006 to_release++;
2007 clear_buffer_delay(bh);
2008 }
2009 curr_off = next_off;
2010 } while ((bh = bh->b_this_page) != head);
12219aea 2011 ext4_da_release_space(page->mapping->host, to_release);
d2a17637 2012}
ac27a0ec 2013
64769240
AT
2014/*
2015 * Delayed allocation stuff
2016 */
2017
64769240
AT
2018/*
2019 * mpage_da_submit_io - walks through extent of pages and try to write
a1d6cc56 2020 * them with writepage() call back
64769240
AT
2021 *
2022 * @mpd->inode: inode
2023 * @mpd->first_page: first page of the extent
2024 * @mpd->next_page: page after the last page of the extent
64769240
AT
2025 *
2026 * By the time mpage_da_submit_io() is called we expect all blocks
2027 * to be allocated. this may be wrong if allocation failed.
2028 *
2029 * As pages are already locked by write_cache_pages(), we can't use it
2030 */
1de3e3df
TT
2031static int mpage_da_submit_io(struct mpage_da_data *mpd,
2032 struct ext4_map_blocks *map)
64769240 2033{
791b7f08
AK
2034 struct pagevec pvec;
2035 unsigned long index, end;
2036 int ret = 0, err, nr_pages, i;
2037 struct inode *inode = mpd->inode;
2038 struct address_space *mapping = inode->i_mapping;
cb20d518 2039 loff_t size = i_size_read(inode);
3ecdb3a1
TT
2040 unsigned int len, block_start;
2041 struct buffer_head *bh, *page_bufs = NULL;
cb20d518 2042 int journal_data = ext4_should_journal_data(inode);
1de3e3df 2043 sector_t pblock = 0, cur_logical = 0;
bd2d0210 2044 struct ext4_io_submit io_submit;
64769240
AT
2045
2046 BUG_ON(mpd->next_page <= mpd->first_page);
bd2d0210 2047 memset(&io_submit, 0, sizeof(io_submit));
791b7f08
AK
2048 /*
2049 * We need to start from the first_page to the next_page - 1
2050 * to make sure we also write the mapped dirty buffer_heads.
8dc207c0 2051 * If we look at mpd->b_blocknr we would only be looking
791b7f08
AK
2052 * at the currently mapped buffer_heads.
2053 */
64769240
AT
2054 index = mpd->first_page;
2055 end = mpd->next_page - 1;
2056
791b7f08 2057 pagevec_init(&pvec, 0);
64769240 2058 while (index <= end) {
791b7f08 2059 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
64769240
AT
2060 if (nr_pages == 0)
2061 break;
2062 for (i = 0; i < nr_pages; i++) {
97498956 2063 int commit_write = 0, skip_page = 0;
64769240
AT
2064 struct page *page = pvec.pages[i];
2065
791b7f08
AK
2066 index = page->index;
2067 if (index > end)
2068 break;
cb20d518
TT
2069
2070 if (index == size >> PAGE_CACHE_SHIFT)
2071 len = size & ~PAGE_CACHE_MASK;
2072 else
2073 len = PAGE_CACHE_SIZE;
1de3e3df
TT
2074 if (map) {
2075 cur_logical = index << (PAGE_CACHE_SHIFT -
2076 inode->i_blkbits);
2077 pblock = map->m_pblk + (cur_logical -
2078 map->m_lblk);
2079 }
791b7f08
AK
2080 index++;
2081
2082 BUG_ON(!PageLocked(page));
2083 BUG_ON(PageWriteback(page));
2084
64769240 2085 /*
cb20d518
TT
2086 * If the page does not have buffers (for
2087 * whatever reason), try to create them using
a107e5a3 2088 * __block_write_begin. If this fails,
97498956 2089 * skip the page and move on.
64769240 2090 */
cb20d518 2091 if (!page_has_buffers(page)) {
a107e5a3 2092 if (__block_write_begin(page, 0, len,
cb20d518 2093 noalloc_get_block_write)) {
97498956 2094 skip_page:
cb20d518
TT
2095 unlock_page(page);
2096 continue;
2097 }
2098 commit_write = 1;
2099 }
64769240 2100
3ecdb3a1
TT
2101 bh = page_bufs = page_buffers(page);
2102 block_start = 0;
64769240 2103 do {
1de3e3df 2104 if (!bh)
97498956 2105 goto skip_page;
1de3e3df
TT
2106 if (map && (cur_logical >= map->m_lblk) &&
2107 (cur_logical <= (map->m_lblk +
2108 (map->m_len - 1)))) {
29fa89d0
AK
2109 if (buffer_delay(bh)) {
2110 clear_buffer_delay(bh);
2111 bh->b_blocknr = pblock;
29fa89d0 2112 }
1de3e3df
TT
2113 if (buffer_unwritten(bh) ||
2114 buffer_mapped(bh))
2115 BUG_ON(bh->b_blocknr != pblock);
2116 if (map->m_flags & EXT4_MAP_UNINIT)
2117 set_buffer_uninit(bh);
2118 clear_buffer_unwritten(bh);
2119 }
29fa89d0 2120
97498956 2121 /* skip page if block allocation undone */
1de3e3df 2122 if (buffer_delay(bh) || buffer_unwritten(bh))
97498956 2123 skip_page = 1;
3ecdb3a1
TT
2124 bh = bh->b_this_page;
2125 block_start += bh->b_size;
64769240
AT
2126 cur_logical++;
2127 pblock++;
1de3e3df
TT
2128 } while (bh != page_bufs);
2129
97498956
TT
2130 if (skip_page)
2131 goto skip_page;
cb20d518
TT
2132
2133 if (commit_write)
2134 /* mark the buffer_heads as dirty & uptodate */
2135 block_commit_write(page, 0, len);
2136
97498956 2137 clear_page_dirty_for_io(page);
bd2d0210
TT
2138 /*
2139 * Delalloc doesn't support data journalling,
2140 * but eventually maybe we'll lift this
2141 * restriction.
2142 */
2143 if (unlikely(journal_data && PageChecked(page)))
cb20d518 2144 err = __ext4_journalled_writepage(page, len);
1449032b 2145 else if (test_opt(inode->i_sb, MBLK_IO_SUBMIT))
bd2d0210
TT
2146 err = ext4_bio_write_page(&io_submit, page,
2147 len, mpd->wbc);
1449032b
TT
2148 else
2149 err = block_write_full_page(page,
2150 noalloc_get_block_write, mpd->wbc);
cb20d518
TT
2151
2152 if (!err)
a1d6cc56 2153 mpd->pages_written++;
64769240
AT
2154 /*
2155 * In error case, we have to continue because
2156 * remaining pages are still locked
64769240
AT
2157 */
2158 if (ret == 0)
2159 ret = err;
64769240
AT
2160 }
2161 pagevec_release(&pvec);
2162 }
bd2d0210 2163 ext4_io_submit(&io_submit);
64769240 2164 return ret;
64769240
AT
2165}
2166
c7f5938a 2167static void ext4_da_block_invalidatepages(struct mpage_da_data *mpd)
c4a0c46e
AK
2168{
2169 int nr_pages, i;
2170 pgoff_t index, end;
2171 struct pagevec pvec;
2172 struct inode *inode = mpd->inode;
2173 struct address_space *mapping = inode->i_mapping;
2174
c7f5938a
CW
2175 index = mpd->first_page;
2176 end = mpd->next_page - 1;
c4a0c46e
AK
2177 while (index <= end) {
2178 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
2179 if (nr_pages == 0)
2180 break;
2181 for (i = 0; i < nr_pages; i++) {
2182 struct page *page = pvec.pages[i];
9b1d0998 2183 if (page->index > end)
c4a0c46e 2184 break;
c4a0c46e
AK
2185 BUG_ON(!PageLocked(page));
2186 BUG_ON(PageWriteback(page));
2187 block_invalidatepage(page, 0);
2188 ClearPageUptodate(page);
2189 unlock_page(page);
2190 }
9b1d0998
JK
2191 index = pvec.pages[nr_pages - 1]->index + 1;
2192 pagevec_release(&pvec);
c4a0c46e
AK
2193 }
2194 return;
2195}
2196
df22291f
AK
2197static void ext4_print_free_blocks(struct inode *inode)
2198{
2199 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1693918e
TT
2200 printk(KERN_CRIT "Total free blocks count %lld\n",
2201 ext4_count_free_blocks(inode->i_sb));
2202 printk(KERN_CRIT "Free/Dirty block details\n");
2203 printk(KERN_CRIT "free_blocks=%lld\n",
2204 (long long) percpu_counter_sum(&sbi->s_freeblocks_counter));
2205 printk(KERN_CRIT "dirty_blocks=%lld\n",
2206 (long long) percpu_counter_sum(&sbi->s_dirtyblocks_counter));
2207 printk(KERN_CRIT "Block reservation details\n");
2208 printk(KERN_CRIT "i_reserved_data_blocks=%u\n",
2209 EXT4_I(inode)->i_reserved_data_blocks);
2210 printk(KERN_CRIT "i_reserved_meta_blocks=%u\n",
2211 EXT4_I(inode)->i_reserved_meta_blocks);
df22291f
AK
2212 return;
2213}
2214
64769240 2215/*
5a87b7a5
TT
2216 * mpage_da_map_and_submit - go through given space, map them
2217 * if necessary, and then submit them for I/O
64769240 2218 *
8dc207c0 2219 * @mpd - bh describing space
64769240
AT
2220 *
2221 * The function skips space we know is already mapped to disk blocks.
2222 *
64769240 2223 */
5a87b7a5 2224static void mpage_da_map_and_submit(struct mpage_da_data *mpd)
64769240 2225{
2ac3b6e0 2226 int err, blks, get_blocks_flags;
1de3e3df 2227 struct ext4_map_blocks map, *mapp = NULL;
2fa3cdfb
TT
2228 sector_t next = mpd->b_blocknr;
2229 unsigned max_blocks = mpd->b_size >> mpd->inode->i_blkbits;
2230 loff_t disksize = EXT4_I(mpd->inode)->i_disksize;
2231 handle_t *handle = NULL;
64769240
AT
2232
2233 /*
5a87b7a5
TT
2234 * If the blocks are mapped already, or we couldn't accumulate
2235 * any blocks, then proceed immediately to the submission stage.
2fa3cdfb 2236 */
5a87b7a5
TT
2237 if ((mpd->b_size == 0) ||
2238 ((mpd->b_state & (1 << BH_Mapped)) &&
2239 !(mpd->b_state & (1 << BH_Delay)) &&
2240 !(mpd->b_state & (1 << BH_Unwritten))))
2241 goto submit_io;
2fa3cdfb
TT
2242
2243 handle = ext4_journal_current_handle();
2244 BUG_ON(!handle);
2245
79ffab34 2246 /*
79e83036 2247 * Call ext4_map_blocks() to allocate any delayed allocation
2ac3b6e0
TT
2248 * blocks, or to convert an uninitialized extent to be
2249 * initialized (in the case where we have written into
2250 * one or more preallocated blocks).
2251 *
2252 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE to
2253 * indicate that we are on the delayed allocation path. This
2254 * affects functions in many different parts of the allocation
2255 * call path. This flag exists primarily because we don't
79e83036 2256 * want to change *many* call functions, so ext4_map_blocks()
f2321097 2257 * will set the EXT4_STATE_DELALLOC_RESERVED flag once the
2ac3b6e0
TT
2258 * inode's allocation semaphore is taken.
2259 *
2260 * If the blocks in questions were delalloc blocks, set
2261 * EXT4_GET_BLOCKS_DELALLOC_RESERVE so the delalloc accounting
2262 * variables are updated after the blocks have been allocated.
79ffab34 2263 */
2ed88685
TT
2264 map.m_lblk = next;
2265 map.m_len = max_blocks;
1296cc85 2266 get_blocks_flags = EXT4_GET_BLOCKS_CREATE;
744692dc
JZ
2267 if (ext4_should_dioread_nolock(mpd->inode))
2268 get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT;
2ac3b6e0 2269 if (mpd->b_state & (1 << BH_Delay))
1296cc85
AK
2270 get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE;
2271
2ed88685 2272 blks = ext4_map_blocks(handle, mpd->inode, &map, get_blocks_flags);
2fa3cdfb 2273 if (blks < 0) {
e3570639
ES
2274 struct super_block *sb = mpd->inode->i_sb;
2275
2fa3cdfb 2276 err = blks;
ed5bde0b 2277 /*
5a87b7a5 2278 * If get block returns EAGAIN or ENOSPC and there
97498956
TT
2279 * appears to be free blocks we will just let
2280 * mpage_da_submit_io() unlock all of the pages.
c4a0c46e
AK
2281 */
2282 if (err == -EAGAIN)
5a87b7a5 2283 goto submit_io;
df22291f
AK
2284
2285 if (err == -ENOSPC &&
e3570639 2286 ext4_count_free_blocks(sb)) {
df22291f 2287 mpd->retval = err;
5a87b7a5 2288 goto submit_io;
df22291f
AK
2289 }
2290
c4a0c46e 2291 /*
ed5bde0b
TT
2292 * get block failure will cause us to loop in
2293 * writepages, because a_ops->writepage won't be able
2294 * to make progress. The page will be redirtied by
2295 * writepage and writepages will again try to write
2296 * the same.
c4a0c46e 2297 */
e3570639
ES
2298 if (!(EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)) {
2299 ext4_msg(sb, KERN_CRIT,
2300 "delayed block allocation failed for inode %lu "
2301 "at logical offset %llu with max blocks %zd "
2302 "with error %d", mpd->inode->i_ino,
2303 (unsigned long long) next,
2304 mpd->b_size >> mpd->inode->i_blkbits, err);
2305 ext4_msg(sb, KERN_CRIT,
2306 "This should not happen!! Data will be lost\n");
2307 if (err == -ENOSPC)
2308 ext4_print_free_blocks(mpd->inode);
030ba6bc 2309 }
2fa3cdfb 2310 /* invalidate all the pages */
c7f5938a 2311 ext4_da_block_invalidatepages(mpd);
e0fd9b90
CW
2312
2313 /* Mark this page range as having been completed */
2314 mpd->io_done = 1;
5a87b7a5 2315 return;
c4a0c46e 2316 }
2fa3cdfb
TT
2317 BUG_ON(blks == 0);
2318
1de3e3df 2319 mapp = &map;
2ed88685
TT
2320 if (map.m_flags & EXT4_MAP_NEW) {
2321 struct block_device *bdev = mpd->inode->i_sb->s_bdev;
2322 int i;
64769240 2323
2ed88685
TT
2324 for (i = 0; i < map.m_len; i++)
2325 unmap_underlying_metadata(bdev, map.m_pblk + i);
2326 }
64769240 2327
2fa3cdfb
TT
2328 if (ext4_should_order_data(mpd->inode)) {
2329 err = ext4_jbd2_file_inode(handle, mpd->inode);
2330 if (err)
5a87b7a5
TT
2331 /* This only happens if the journal is aborted */
2332 return;
2fa3cdfb
TT
2333 }
2334
2335 /*
03f5d8bc 2336 * Update on-disk size along with block allocation.
2fa3cdfb
TT
2337 */
2338 disksize = ((loff_t) next + blks) << mpd->inode->i_blkbits;
2339 if (disksize > i_size_read(mpd->inode))
2340 disksize = i_size_read(mpd->inode);
2341 if (disksize > EXT4_I(mpd->inode)->i_disksize) {
2342 ext4_update_i_disksize(mpd->inode, disksize);
5a87b7a5
TT
2343 err = ext4_mark_inode_dirty(handle, mpd->inode);
2344 if (err)
2345 ext4_error(mpd->inode->i_sb,
2346 "Failed to mark inode %lu dirty",
2347 mpd->inode->i_ino);
2fa3cdfb
TT
2348 }
2349
5a87b7a5 2350submit_io:
1de3e3df 2351 mpage_da_submit_io(mpd, mapp);
5a87b7a5 2352 mpd->io_done = 1;
64769240
AT
2353}
2354
bf068ee2
AK
2355#define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | \
2356 (1 << BH_Delay) | (1 << BH_Unwritten))
64769240
AT
2357
2358/*
2359 * mpage_add_bh_to_extent - try to add one more block to extent of blocks
2360 *
2361 * @mpd->lbh - extent of blocks
2362 * @logical - logical number of the block in the file
2363 * @bh - bh of the block (used to access block's state)
2364 *
2365 * the function is used to collect contig. blocks in same state
2366 */
2367static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
8dc207c0
TT
2368 sector_t logical, size_t b_size,
2369 unsigned long b_state)
64769240 2370{
64769240 2371 sector_t next;
8dc207c0 2372 int nrblocks = mpd->b_size >> mpd->inode->i_blkbits;
64769240 2373
c445e3e0
ES
2374 /*
2375 * XXX Don't go larger than mballoc is willing to allocate
2376 * This is a stopgap solution. We eventually need to fold
2377 * mpage_da_submit_io() into this function and then call
79e83036 2378 * ext4_map_blocks() multiple times in a loop
c445e3e0
ES
2379 */
2380 if (nrblocks >= 8*1024*1024/mpd->inode->i_sb->s_blocksize)
2381 goto flush_it;
2382
525f4ed8 2383 /* check if thereserved journal credits might overflow */
12e9b892 2384 if (!(ext4_test_inode_flag(mpd->inode, EXT4_INODE_EXTENTS))) {
525f4ed8
MC
2385 if (nrblocks >= EXT4_MAX_TRANS_DATA) {
2386 /*
2387 * With non-extent format we are limited by the journal
2388 * credit available. Total credit needed to insert
2389 * nrblocks contiguous blocks is dependent on the
2390 * nrblocks. So limit nrblocks.
2391 */
2392 goto flush_it;
2393 } else if ((nrblocks + (b_size >> mpd->inode->i_blkbits)) >
2394 EXT4_MAX_TRANS_DATA) {
2395 /*
2396 * Adding the new buffer_head would make it cross the
2397 * allowed limit for which we have journal credit
2398 * reserved. So limit the new bh->b_size
2399 */
2400 b_size = (EXT4_MAX_TRANS_DATA - nrblocks) <<
2401 mpd->inode->i_blkbits;
2402 /* we will do mpage_da_submit_io in the next loop */
2403 }
2404 }
64769240
AT
2405 /*
2406 * First block in the extent
2407 */
8dc207c0
TT
2408 if (mpd->b_size == 0) {
2409 mpd->b_blocknr = logical;
2410 mpd->b_size = b_size;
2411 mpd->b_state = b_state & BH_FLAGS;
64769240
AT
2412 return;
2413 }
2414
8dc207c0 2415 next = mpd->b_blocknr + nrblocks;
64769240
AT
2416 /*
2417 * Can we merge the block to our big extent?
2418 */
8dc207c0
TT
2419 if (logical == next && (b_state & BH_FLAGS) == mpd->b_state) {
2420 mpd->b_size += b_size;
64769240
AT
2421 return;
2422 }
2423
525f4ed8 2424flush_it:
64769240
AT
2425 /*
2426 * We couldn't merge the block to our extent, so we
2427 * need to flush current extent and start new one
2428 */
5a87b7a5 2429 mpage_da_map_and_submit(mpd);
a1d6cc56 2430 return;
64769240
AT
2431}
2432
c364b22c 2433static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
29fa89d0 2434{
c364b22c 2435 return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
29fa89d0
AK
2436}
2437
64769240 2438/*
b920c755
TT
2439 * This is a special get_blocks_t callback which is used by
2440 * ext4_da_write_begin(). It will either return mapped block or
2441 * reserve space for a single block.
29fa89d0
AK
2442 *
2443 * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
2444 * We also have b_blocknr = -1 and b_bdev initialized properly
2445 *
2446 * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
2447 * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
2448 * initialized properly.
64769240
AT
2449 */
2450static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
2ed88685 2451 struct buffer_head *bh, int create)
64769240 2452{
2ed88685 2453 struct ext4_map_blocks map;
64769240 2454 int ret = 0;
33b9817e
AK
2455 sector_t invalid_block = ~((sector_t) 0xffff);
2456
2457 if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
2458 invalid_block = ~0;
64769240
AT
2459
2460 BUG_ON(create == 0);
2ed88685
TT
2461 BUG_ON(bh->b_size != inode->i_sb->s_blocksize);
2462
2463 map.m_lblk = iblock;
2464 map.m_len = 1;
64769240
AT
2465
2466 /*
2467 * first, we need to know whether the block is allocated already
2468 * preallocated blocks are unmapped but should treated
2469 * the same as allocated blocks.
2470 */
2ed88685
TT
2471 ret = ext4_map_blocks(NULL, inode, &map, 0);
2472 if (ret < 0)
2473 return ret;
2474 if (ret == 0) {
2475 if (buffer_delay(bh))
2476 return 0; /* Not sure this could or should happen */
64769240 2477 /*
ebdec241 2478 * XXX: __block_write_begin() unmaps passed block, is it OK?
64769240 2479 */
9d0be502 2480 ret = ext4_da_reserve_space(inode, iblock);
d2a17637
MC
2481 if (ret)
2482 /* not enough space to reserve */
2483 return ret;
2484
2ed88685
TT
2485 map_bh(bh, inode->i_sb, invalid_block);
2486 set_buffer_new(bh);
2487 set_buffer_delay(bh);
2488 return 0;
64769240
AT
2489 }
2490
2ed88685
TT
2491 map_bh(bh, inode->i_sb, map.m_pblk);
2492 bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
2493
2494 if (buffer_unwritten(bh)) {
2495 /* A delayed write to unwritten bh should be marked
2496 * new and mapped. Mapped ensures that we don't do
2497 * get_block multiple times when we write to the same
2498 * offset and new ensures that we do proper zero out
2499 * for partial write.
2500 */
2501 set_buffer_new(bh);
2502 set_buffer_mapped(bh);
2503 }
2504 return 0;
64769240 2505}
61628a3f 2506
b920c755
TT
2507/*
2508 * This function is used as a standard get_block_t calback function
2509 * when there is no desire to allocate any blocks. It is used as a
ebdec241 2510 * callback function for block_write_begin() and block_write_full_page().
206f7ab4 2511 * These functions should only try to map a single block at a time.
b920c755
TT
2512 *
2513 * Since this function doesn't do block allocations even if the caller
2514 * requests it by passing in create=1, it is critically important that
2515 * any caller checks to make sure that any buffer heads are returned
2516 * by this function are either all already mapped or marked for
206f7ab4
CH
2517 * delayed allocation before calling block_write_full_page(). Otherwise,
2518 * b_blocknr could be left unitialized, and the page write functions will
2519 * be taken by surprise.
b920c755
TT
2520 */
2521static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
f0e6c985
AK
2522 struct buffer_head *bh_result, int create)
2523{
a2dc52b5 2524 BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
2ed88685 2525 return _ext4_get_block(inode, iblock, bh_result, 0);
61628a3f
MC
2526}
2527
62e086be
AK
2528static int bget_one(handle_t *handle, struct buffer_head *bh)
2529{
2530 get_bh(bh);
2531 return 0;
2532}
2533
2534static int bput_one(handle_t *handle, struct buffer_head *bh)
2535{
2536 put_bh(bh);
2537 return 0;
2538}
2539
2540static int __ext4_journalled_writepage(struct page *page,
62e086be
AK
2541 unsigned int len)
2542{
2543 struct address_space *mapping = page->mapping;
2544 struct inode *inode = mapping->host;
2545 struct buffer_head *page_bufs;
2546 handle_t *handle = NULL;
2547 int ret = 0;
2548 int err;
2549
cb20d518 2550 ClearPageChecked(page);
62e086be
AK
2551 page_bufs = page_buffers(page);
2552 BUG_ON(!page_bufs);
2553 walk_page_buffers(handle, page_bufs, 0, len, NULL, bget_one);
2554 /* As soon as we unlock the page, it can go away, but we have
2555 * references to buffers so we are safe */
2556 unlock_page(page);
2557
2558 handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
2559 if (IS_ERR(handle)) {
2560 ret = PTR_ERR(handle);
2561 goto out;
2562 }
2563
2564 ret = walk_page_buffers(handle, page_bufs, 0, len, NULL,
2565 do_journal_get_write_access);
2566
2567 err = walk_page_buffers(handle, page_bufs, 0, len, NULL,
2568 write_end_fn);
2569 if (ret == 0)
2570 ret = err;
2571 err = ext4_journal_stop(handle);
2572 if (!ret)
2573 ret = err;
2574
2575 walk_page_buffers(handle, page_bufs, 0, len, NULL, bput_one);
19f5fb7a 2576 ext4_set_inode_state(inode, EXT4_STATE_JDATA);
62e086be
AK
2577out:
2578 return ret;
2579}
2580
744692dc
JZ
2581static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode);
2582static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate);
2583
61628a3f 2584/*
43ce1d23
AK
2585 * Note that we don't need to start a transaction unless we're journaling data
2586 * because we should have holes filled from ext4_page_mkwrite(). We even don't
2587 * need to file the inode to the transaction's list in ordered mode because if
2588 * we are writing back data added by write(), the inode is already there and if
2589 * we are writing back data modified via mmap(), noone guarantees in which
2590 * transaction the data will hit the disk. In case we are journaling data, we
2591 * cannot start transaction directly because transaction start ranks above page
2592 * lock so we have to do some magic.
2593 *
b920c755
TT
2594 * This function can get called via...
2595 * - ext4_da_writepages after taking page lock (have journal handle)
2596 * - journal_submit_inode_data_buffers (no journal handle)
2597 * - shrink_page_list via pdflush (no journal handle)
2598 * - grab_page_cache when doing write_begin (have journal handle)
43ce1d23
AK
2599 *
2600 * We don't do any block allocation in this function. If we have page with
2601 * multiple blocks we need to write those buffer_heads that are mapped. This
2602 * is important for mmaped based write. So if we do with blocksize 1K
2603 * truncate(f, 1024);
2604 * a = mmap(f, 0, 4096);
2605 * a[0] = 'a';
2606 * truncate(f, 4096);
2607 * we have in the page first buffer_head mapped via page_mkwrite call back
2608 * but other bufer_heads would be unmapped but dirty(dirty done via the
2609 * do_wp_page). So writepage should write the first block. If we modify
2610 * the mmap area beyond 1024 we will again get a page_fault and the
2611 * page_mkwrite callback will do the block allocation and mark the
2612 * buffer_heads mapped.
2613 *
2614 * We redirty the page if we have any buffer_heads that is either delay or
2615 * unwritten in the page.
2616 *
2617 * We can get recursively called as show below.
2618 *
2619 * ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
2620 * ext4_writepage()
2621 *
2622 * But since we don't do any block allocation we should not deadlock.
2623 * Page also have the dirty flag cleared so we don't get recurive page_lock.
61628a3f 2624 */
43ce1d23 2625static int ext4_writepage(struct page *page,
62e086be 2626 struct writeback_control *wbc)
64769240 2627{
a42afc5f 2628 int ret = 0, commit_write = 0;
61628a3f 2629 loff_t size;
498e5f24 2630 unsigned int len;
744692dc 2631 struct buffer_head *page_bufs = NULL;
61628a3f
MC
2632 struct inode *inode = page->mapping->host;
2633
43ce1d23 2634 trace_ext4_writepage(inode, page);
f0e6c985
AK
2635 size = i_size_read(inode);
2636 if (page->index == size >> PAGE_CACHE_SHIFT)
2637 len = size & ~PAGE_CACHE_MASK;
2638 else
2639 len = PAGE_CACHE_SIZE;
64769240 2640
a42afc5f
TT
2641 /*
2642 * If the page does not have buffers (for whatever reason),
a107e5a3 2643 * try to create them using __block_write_begin. If this
a42afc5f
TT
2644 * fails, redirty the page and move on.
2645 */
b1142e8f 2646 if (!page_has_buffers(page)) {
a107e5a3 2647 if (__block_write_begin(page, 0, len,
a42afc5f
TT
2648 noalloc_get_block_write)) {
2649 redirty_page:
f0e6c985
AK
2650 redirty_page_for_writepage(wbc, page);
2651 unlock_page(page);
2652 return 0;
2653 }
a42afc5f
TT
2654 commit_write = 1;
2655 }
2656 page_bufs = page_buffers(page);
2657 if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
2658 ext4_bh_delay_or_unwritten)) {
f0e6c985 2659 /*
b1142e8f
TT
2660 * We don't want to do block allocation, so redirty
2661 * the page and return. We may reach here when we do
2662 * a journal commit via journal_submit_inode_data_buffers.
2663 * We can also reach here via shrink_page_list
f0e6c985 2664 */
a42afc5f
TT
2665 goto redirty_page;
2666 }
2667 if (commit_write)
ed9b3e33 2668 /* now mark the buffer_heads as dirty and uptodate */
b767e78a 2669 block_commit_write(page, 0, len);
64769240 2670
cb20d518 2671 if (PageChecked(page) && ext4_should_journal_data(inode))
43ce1d23
AK
2672 /*
2673 * It's mmapped pagecache. Add buffers and journal it. There
2674 * doesn't seem much point in redirtying the page here.
2675 */
3f0ca309 2676 return __ext4_journalled_writepage(page, len);
43ce1d23 2677
a42afc5f 2678 if (buffer_uninit(page_bufs)) {
744692dc
JZ
2679 ext4_set_bh_endio(page_bufs, inode);
2680 ret = block_write_full_page_endio(page, noalloc_get_block_write,
2681 wbc, ext4_end_io_buffer_write);
2682 } else
b920c755
TT
2683 ret = block_write_full_page(page, noalloc_get_block_write,
2684 wbc);
64769240 2685
64769240
AT
2686 return ret;
2687}
2688
61628a3f 2689/*
525f4ed8
MC
2690 * This is called via ext4_da_writepages() to
2691 * calulate the total number of credits to reserve to fit
2692 * a single extent allocation into a single transaction,
2693 * ext4_da_writpeages() will loop calling this before
2694 * the block allocation.
61628a3f 2695 */
525f4ed8
MC
2696
2697static int ext4_da_writepages_trans_blocks(struct inode *inode)
2698{
2699 int max_blocks = EXT4_I(inode)->i_reserved_data_blocks;
2700
2701 /*
2702 * With non-extent format the journal credit needed to
2703 * insert nrblocks contiguous block is dependent on
2704 * number of contiguous block. So we will limit
2705 * number of contiguous block to a sane value
2706 */
12e9b892 2707 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) &&
525f4ed8
MC
2708 (max_blocks > EXT4_MAX_TRANS_DATA))
2709 max_blocks = EXT4_MAX_TRANS_DATA;
2710
2711 return ext4_chunk_trans_blocks(inode, max_blocks);
2712}
61628a3f 2713
8e48dcfb
TT
2714/*
2715 * write_cache_pages_da - walk the list of dirty pages of the given
8eb9e5ce
TT
2716 * address space and accumulate pages that need writing, and call
2717 * mpage_da_map_and_submit to map the pages and then write them.
8e48dcfb
TT
2718 */
2719static int write_cache_pages_da(struct address_space *mapping,
2720 struct writeback_control *wbc,
72f84e65
ES
2721 struct mpage_da_data *mpd,
2722 pgoff_t *done_index)
8e48dcfb 2723{
4f01b02c
TT
2724 struct buffer_head *bh, *head;
2725 struct inode *inode = mpd->inode;
2726 struct pagevec pvec;
2727 unsigned int nr_pages;
2728 sector_t logical;
2729 pgoff_t index, end;
2730 long nr_to_write = wbc->nr_to_write;
2731 int i, tag, ret = 0;
8e48dcfb
TT
2732
2733 pagevec_init(&pvec, 0);
2734 index = wbc->range_start >> PAGE_CACHE_SHIFT;
2735 end = wbc->range_end >> PAGE_CACHE_SHIFT;
2736
5b41d924
ES
2737 if (wbc->sync_mode == WB_SYNC_ALL)
2738 tag = PAGECACHE_TAG_TOWRITE;
2739 else
2740 tag = PAGECACHE_TAG_DIRTY;
2741
72f84e65 2742 *done_index = index;
4f01b02c 2743 while (index <= end) {
5b41d924 2744 nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
8e48dcfb
TT
2745 min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
2746 if (nr_pages == 0)
4f01b02c 2747 return 0;
8e48dcfb
TT
2748
2749 for (i = 0; i < nr_pages; i++) {
2750 struct page *page = pvec.pages[i];
2751
2752 /*
2753 * At this point, the page may be truncated or
2754 * invalidated (changing page->mapping to NULL), or
2755 * even swizzled back from swapper_space to tmpfs file
2756 * mapping. However, page->index will not change
2757 * because we have a reference on the page.
2758 */
4f01b02c
TT
2759 if (page->index > end)
2760 goto out;
8e48dcfb 2761
72f84e65
ES
2762 *done_index = page->index + 1;
2763
8e48dcfb
TT
2764 lock_page(page);
2765
2766 /*
4f01b02c
TT
2767 * If the page is no longer dirty, or its
2768 * mapping no longer corresponds to inode we
2769 * are writing (which means it has been
2770 * truncated or invalidated), or the page is
2771 * already under writeback and we are not
2772 * doing a data integrity writeback, skip the page
8e48dcfb 2773 */
4f01b02c
TT
2774 if (!PageDirty(page) ||
2775 (PageWriteback(page) &&
2776 (wbc->sync_mode == WB_SYNC_NONE)) ||
2777 unlikely(page->mapping != mapping)) {
8e48dcfb
TT
2778 unlock_page(page);
2779 continue;
2780 }
2781
4f01b02c
TT
2782 if (PageWriteback(page))
2783 wait_on_page_writeback(page);
8e48dcfb
TT
2784
2785 BUG_ON(PageWriteback(page));
8e48dcfb 2786
8eb9e5ce
TT
2787 /*
2788 * Can we merge this page to current extent?
2789 */
2790 if (mpd->next_page != page->index) {
2791 /*
2792 * Nope, we can't. So, we map
2793 * non-allocated blocks and start IO
2794 * on them
2795 */
2796 if (mpd->next_page != mpd->first_page) {
2797 mpage_da_map_and_submit(mpd);
2798 /*
2799 * skip rest of the page in the page_vec
2800 */
8e48dcfb 2801 unlock_page(page);
4f01b02c 2802 goto ret_extent_tail;
8e48dcfb 2803 }
8eb9e5ce
TT
2804
2805 /*
2806 * Start next extent of pages and blocks
2807 */
2808 mpd->first_page = page->index;
2809 mpd->b_size = 0;
2810 mpd->b_state = 0;
2811 mpd->b_blocknr = 0;
2812 }
2813
2814 mpd->next_page = page->index + 1;
2815 logical = (sector_t) page->index <<
2816 (PAGE_CACHE_SHIFT - inode->i_blkbits);
2817
2818 if (!page_has_buffers(page)) {
4f01b02c
TT
2819 mpage_add_bh_to_extent(mpd, logical,
2820 PAGE_CACHE_SIZE,
8eb9e5ce 2821 (1 << BH_Dirty) | (1 << BH_Uptodate));
4f01b02c
TT
2822 if (mpd->io_done)
2823 goto ret_extent_tail;
8eb9e5ce
TT
2824 } else {
2825 /*
4f01b02c
TT
2826 * Page with regular buffer heads,
2827 * just add all dirty ones
8eb9e5ce
TT
2828 */
2829 head = page_buffers(page);
2830 bh = head;
2831 do {
2832 BUG_ON(buffer_locked(bh));
2833 /*
2834 * We need to try to allocate
2835 * unmapped blocks in the same page.
2836 * Otherwise we won't make progress
2837 * with the page in ext4_writepage
2838 */
2839 if (ext4_bh_delay_or_unwritten(NULL, bh)) {
2840 mpage_add_bh_to_extent(mpd, logical,
2841 bh->b_size,
2842 bh->b_state);
4f01b02c
TT
2843 if (mpd->io_done)
2844 goto ret_extent_tail;
8eb9e5ce
TT
2845 } else if (buffer_dirty(bh) && (buffer_mapped(bh))) {
2846 /*
4f01b02c
TT
2847 * mapped dirty buffer. We need
2848 * to update the b_state
2849 * because we look at b_state
2850 * in mpage_da_map_blocks. We
2851 * don't update b_size because
2852 * if we find an unmapped
2853 * buffer_head later we need to
2854 * use the b_state flag of that
2855 * buffer_head.
8eb9e5ce
TT
2856 */
2857 if (mpd->b_size == 0)
2858 mpd->b_state = bh->b_state & BH_FLAGS;
2859 }
2860 logical++;
2861 } while ((bh = bh->b_this_page) != head);
8e48dcfb
TT
2862 }
2863
2864 if (nr_to_write > 0) {
2865 nr_to_write--;
2866 if (nr_to_write == 0 &&
4f01b02c 2867 wbc->sync_mode == WB_SYNC_NONE)
8e48dcfb
TT
2868 /*
2869 * We stop writing back only if we are
2870 * not doing integrity sync. In case of
2871 * integrity sync we have to keep going
2872 * because someone may be concurrently
2873 * dirtying pages, and we might have
2874 * synced a lot of newly appeared dirty
2875 * pages, but have not synced all of the
2876 * old dirty pages.
2877 */
4f01b02c 2878 goto out;
8e48dcfb
TT
2879 }
2880 }
2881 pagevec_release(&pvec);
2882 cond_resched();
2883 }
4f01b02c
TT
2884 return 0;
2885ret_extent_tail:
2886 ret = MPAGE_DA_EXTENT_TAIL;
8eb9e5ce
TT
2887out:
2888 pagevec_release(&pvec);
2889 cond_resched();
2890 return ret;
8e48dcfb
TT
2891}
2892
2893
64769240 2894static int ext4_da_writepages(struct address_space *mapping,
a1d6cc56 2895 struct writeback_control *wbc)
64769240 2896{
22208ded
AK
2897 pgoff_t index;
2898 int range_whole = 0;
61628a3f 2899 handle_t *handle = NULL;
df22291f 2900 struct mpage_da_data mpd;
5e745b04 2901 struct inode *inode = mapping->host;
498e5f24 2902 int pages_written = 0;
55138e0b 2903 unsigned int max_pages;
2acf2c26 2904 int range_cyclic, cycled = 1, io_done = 0;
55138e0b
TT
2905 int needed_blocks, ret = 0;
2906 long desired_nr_to_write, nr_to_writebump = 0;
de89de6e 2907 loff_t range_start = wbc->range_start;
5e745b04 2908 struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
72f84e65 2909 pgoff_t done_index = 0;
5b41d924 2910 pgoff_t end;
61628a3f 2911
9bffad1e 2912 trace_ext4_da_writepages(inode, wbc);
ba80b101 2913
61628a3f
MC
2914 /*
2915 * No pages to write? This is mainly a kludge to avoid starting
2916 * a transaction for special inodes like journal inode on last iput()
2917 * because that could violate lock ordering on umount
2918 */
a1d6cc56 2919 if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
61628a3f 2920 return 0;
2a21e37e
TT
2921
2922 /*
2923 * If the filesystem has aborted, it is read-only, so return
2924 * right away instead of dumping stack traces later on that
2925 * will obscure the real source of the problem. We test
4ab2f15b 2926 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2a21e37e
TT
2927 * the latter could be true if the filesystem is mounted
2928 * read-only, and in that case, ext4_da_writepages should
2929 * *never* be called, so if that ever happens, we would want
2930 * the stack trace.
2931 */
4ab2f15b 2932 if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED))
2a21e37e
TT
2933 return -EROFS;
2934
22208ded
AK
2935 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2936 range_whole = 1;
61628a3f 2937
2acf2c26
AK
2938 range_cyclic = wbc->range_cyclic;
2939 if (wbc->range_cyclic) {
22208ded 2940 index = mapping->writeback_index;
2acf2c26
AK
2941 if (index)
2942 cycled = 0;
2943 wbc->range_start = index << PAGE_CACHE_SHIFT;
2944 wbc->range_end = LLONG_MAX;
2945 wbc->range_cyclic = 0;
5b41d924
ES
2946 end = -1;
2947 } else {
22208ded 2948 index = wbc->range_start >> PAGE_CACHE_SHIFT;
5b41d924
ES
2949 end = wbc->range_end >> PAGE_CACHE_SHIFT;
2950 }
a1d6cc56 2951
55138e0b
TT
2952 /*
2953 * This works around two forms of stupidity. The first is in
2954 * the writeback code, which caps the maximum number of pages
2955 * written to be 1024 pages. This is wrong on multiple
2956 * levels; different architectues have a different page size,
2957 * which changes the maximum amount of data which gets
2958 * written. Secondly, 4 megabytes is way too small. XFS
2959 * forces this value to be 16 megabytes by multiplying
2960 * nr_to_write parameter by four, and then relies on its
2961 * allocator to allocate larger extents to make them
2962 * contiguous. Unfortunately this brings us to the second
2963 * stupidity, which is that ext4's mballoc code only allocates
2964 * at most 2048 blocks. So we force contiguous writes up to
2965 * the number of dirty blocks in the inode, or
2966 * sbi->max_writeback_mb_bump whichever is smaller.
2967 */
2968 max_pages = sbi->s_max_writeback_mb_bump << (20 - PAGE_CACHE_SHIFT);
b443e733
ES
2969 if (!range_cyclic && range_whole) {
2970 if (wbc->nr_to_write == LONG_MAX)
2971 desired_nr_to_write = wbc->nr_to_write;
2972 else
2973 desired_nr_to_write = wbc->nr_to_write * 8;
2974 } else
55138e0b
TT
2975 desired_nr_to_write = ext4_num_dirty_pages(inode, index,
2976 max_pages);
2977 if (desired_nr_to_write > max_pages)
2978 desired_nr_to_write = max_pages;
2979
2980 if (wbc->nr_to_write < desired_nr_to_write) {
2981 nr_to_writebump = desired_nr_to_write - wbc->nr_to_write;
2982 wbc->nr_to_write = desired_nr_to_write;
2983 }
2984
df22291f
AK
2985 mpd.wbc = wbc;
2986 mpd.inode = mapping->host;
2987
2acf2c26 2988retry:
5b41d924
ES
2989 if (wbc->sync_mode == WB_SYNC_ALL)
2990 tag_pages_for_writeback(mapping, index, end);
2991
22208ded 2992 while (!ret && wbc->nr_to_write > 0) {
a1d6cc56
AK
2993
2994 /*
2995 * we insert one extent at a time. So we need
2996 * credit needed for single extent allocation.
2997 * journalled mode is currently not supported
2998 * by delalloc
2999 */
3000 BUG_ON(ext4_should_journal_data(inode));
525f4ed8 3001 needed_blocks = ext4_da_writepages_trans_blocks(inode);
a1d6cc56 3002
61628a3f
MC
3003 /* start a new transaction*/
3004 handle = ext4_journal_start(inode, needed_blocks);
3005 if (IS_ERR(handle)) {
3006 ret = PTR_ERR(handle);
1693918e 3007 ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
fbe845dd 3008 "%ld pages, ino %lu; err %d", __func__,
a1d6cc56 3009 wbc->nr_to_write, inode->i_ino, ret);
61628a3f
MC
3010 goto out_writepages;
3011 }
f63e6005
TT
3012
3013 /*
8eb9e5ce 3014 * Now call write_cache_pages_da() to find the next
f63e6005 3015 * contiguous region of logical blocks that need
8eb9e5ce 3016 * blocks to be allocated by ext4 and submit them.
f63e6005
TT
3017 */
3018 mpd.b_size = 0;
3019 mpd.b_state = 0;
3020 mpd.b_blocknr = 0;
3021 mpd.first_page = 0;
3022 mpd.next_page = 0;
3023 mpd.io_done = 0;
3024 mpd.pages_written = 0;
3025 mpd.retval = 0;
72f84e65 3026 ret = write_cache_pages_da(mapping, wbc, &mpd, &done_index);
f63e6005 3027 /*
af901ca1 3028 * If we have a contiguous extent of pages and we
f63e6005
TT
3029 * haven't done the I/O yet, map the blocks and submit
3030 * them for I/O.
3031 */
3032 if (!mpd.io_done && mpd.next_page != mpd.first_page) {
5a87b7a5 3033 mpage_da_map_and_submit(&mpd);
f63e6005
TT
3034 ret = MPAGE_DA_EXTENT_TAIL;
3035 }
b3a3ca8c 3036 trace_ext4_da_write_pages(inode, &mpd);
f63e6005 3037 wbc->nr_to_write -= mpd.pages_written;
df22291f 3038
61628a3f 3039 ext4_journal_stop(handle);
df22291f 3040
8f64b32e 3041 if ((mpd.retval == -ENOSPC) && sbi->s_journal) {
22208ded
AK
3042 /* commit the transaction which would
3043 * free blocks released in the transaction
3044 * and try again
3045 */
df22291f 3046 jbd2_journal_force_commit_nested(sbi->s_journal);
22208ded
AK
3047 ret = 0;
3048 } else if (ret == MPAGE_DA_EXTENT_TAIL) {
a1d6cc56
AK
3049 /*
3050 * got one extent now try with
3051 * rest of the pages
3052 */
22208ded 3053 pages_written += mpd.pages_written;
a1d6cc56 3054 ret = 0;
2acf2c26 3055 io_done = 1;
22208ded 3056 } else if (wbc->nr_to_write)
61628a3f
MC
3057 /*
3058 * There is no more writeout needed
3059 * or we requested for a noblocking writeout
3060 * and we found the device congested
3061 */
61628a3f 3062 break;
a1d6cc56 3063 }
2acf2c26
AK
3064 if (!io_done && !cycled) {
3065 cycled = 1;
3066 index = 0;
3067 wbc->range_start = index << PAGE_CACHE_SHIFT;
3068 wbc->range_end = mapping->writeback_index - 1;
3069 goto retry;
3070 }
22208ded
AK
3071
3072 /* Update index */
2acf2c26 3073 wbc->range_cyclic = range_cyclic;
22208ded
AK
3074 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
3075 /*
3076 * set the writeback_index so that range_cyclic
3077 * mode will write it back later
3078 */
72f84e65 3079 mapping->writeback_index = done_index;
a1d6cc56 3080
61628a3f 3081out_writepages:
2faf2e19 3082 wbc->nr_to_write -= nr_to_writebump;
de89de6e 3083 wbc->range_start = range_start;
9bffad1e 3084 trace_ext4_da_writepages_result(inode, wbc, ret, pages_written);
61628a3f 3085 return ret;
64769240
AT
3086}
3087
79f0be8d
AK
3088#define FALL_BACK_TO_NONDELALLOC 1
3089static int ext4_nonda_switch(struct super_block *sb)
3090{
3091 s64 free_blocks, dirty_blocks;
3092 struct ext4_sb_info *sbi = EXT4_SB(sb);
3093
3094 /*
3095 * switch to non delalloc mode if we are running low
3096 * on free block. The free block accounting via percpu
179f7ebf 3097 * counters can get slightly wrong with percpu_counter_batch getting
79f0be8d
AK
3098 * accumulated on each CPU without updating global counters
3099 * Delalloc need an accurate free block accounting. So switch
3100 * to non delalloc when we are near to error range.
3101 */
3102 free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
3103 dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyblocks_counter);
3104 if (2 * free_blocks < 3 * dirty_blocks ||
3105 free_blocks < (dirty_blocks + EXT4_FREEBLOCKS_WATERMARK)) {
3106 /*
c8afb446
ES
3107 * free block count is less than 150% of dirty blocks
3108 * or free blocks is less than watermark
79f0be8d
AK
3109 */
3110 return 1;
3111 }
c8afb446
ES
3112 /*
3113 * Even if we don't switch but are nearing capacity,
3114 * start pushing delalloc when 1/2 of free blocks are dirty.
3115 */
3116 if (free_blocks < 2 * dirty_blocks)
3117 writeback_inodes_sb_if_idle(sb);
3118
79f0be8d
AK
3119 return 0;
3120}
3121
64769240 3122static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
de9a55b8
TT
3123 loff_t pos, unsigned len, unsigned flags,
3124 struct page **pagep, void **fsdata)
64769240 3125{
72b8ab9d 3126 int ret, retries = 0;
64769240
AT
3127 struct page *page;
3128 pgoff_t index;
64769240
AT
3129 struct inode *inode = mapping->host;
3130 handle_t *handle;
3131
3132 index = pos >> PAGE_CACHE_SHIFT;
79f0be8d
AK
3133
3134 if (ext4_nonda_switch(inode->i_sb)) {
3135 *fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
3136 return ext4_write_begin(file, mapping, pos,
3137 len, flags, pagep, fsdata);
3138 }
3139 *fsdata = (void *)0;
9bffad1e 3140 trace_ext4_da_write_begin(inode, pos, len, flags);
d2a17637 3141retry:
64769240
AT
3142 /*
3143 * With delayed allocation, we don't log the i_disksize update
3144 * if there is delayed block allocation. But we still need
3145 * to journalling the i_disksize update if writes to the end
3146 * of file which has an already mapped buffer.
3147 */
3148 handle = ext4_journal_start(inode, 1);
3149 if (IS_ERR(handle)) {
3150 ret = PTR_ERR(handle);
3151 goto out;
3152 }
ebd3610b
JK
3153 /* We cannot recurse into the filesystem as the transaction is already
3154 * started */
3155 flags |= AOP_FLAG_NOFS;
64769240 3156
54566b2c 3157 page = grab_cache_page_write_begin(mapping, index, flags);
d5a0d4f7
ES
3158 if (!page) {
3159 ext4_journal_stop(handle);
3160 ret = -ENOMEM;
3161 goto out;
3162 }
64769240
AT
3163 *pagep = page;
3164
6e1db88d 3165 ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
64769240
AT
3166 if (ret < 0) {
3167 unlock_page(page);
3168 ext4_journal_stop(handle);
3169 page_cache_release(page);
ae4d5372
AK
3170 /*
3171 * block_write_begin may have instantiated a few blocks
3172 * outside i_size. Trim these off again. Don't need
3173 * i_size_read because we hold i_mutex.
3174 */
3175 if (pos + len > inode->i_size)
b9a4207d 3176 ext4_truncate_failed_write(inode);
64769240
AT
3177 }
3178
d2a17637
MC
3179 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
3180 goto retry;
64769240
AT
3181out:
3182 return ret;
3183}
3184
632eaeab
MC
3185/*
3186 * Check if we should update i_disksize
3187 * when write to the end of file but not require block allocation
3188 */
3189static int ext4_da_should_update_i_disksize(struct page *page,
de9a55b8 3190 unsigned long offset)
632eaeab
MC
3191{
3192 struct buffer_head *bh;
3193 struct inode *inode = page->mapping->host;
3194 unsigned int idx;
3195 int i;
3196
3197 bh = page_buffers(page);
3198 idx = offset >> inode->i_blkbits;
3199
af5bc92d 3200 for (i = 0; i < idx; i++)
632eaeab
MC
3201 bh = bh->b_this_page;
3202
29fa89d0 3203 if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
632eaeab
MC
3204 return 0;
3205 return 1;
3206}
3207
64769240 3208static int ext4_da_write_end(struct file *file,
de9a55b8
TT
3209 struct address_space *mapping,
3210 loff_t pos, unsigned len, unsigned copied,
3211 struct page *page, void *fsdata)
64769240
AT
3212{
3213 struct inode *inode = mapping->host;
3214 int ret = 0, ret2;
3215 handle_t *handle = ext4_journal_current_handle();
3216 loff_t new_i_size;
632eaeab 3217 unsigned long start, end;
79f0be8d
AK
3218 int write_mode = (int)(unsigned long)fsdata;
3219
3220 if (write_mode == FALL_BACK_TO_NONDELALLOC) {
3221 if (ext4_should_order_data(inode)) {
3222 return ext4_ordered_write_end(file, mapping, pos,
3223 len, copied, page, fsdata);
3224 } else if (ext4_should_writeback_data(inode)) {
3225 return ext4_writeback_write_end(file, mapping, pos,
3226 len, copied, page, fsdata);
3227 } else {
3228 BUG();
3229 }
3230 }
632eaeab 3231
9bffad1e 3232 trace_ext4_da_write_end(inode, pos, len, copied);
632eaeab 3233 start = pos & (PAGE_CACHE_SIZE - 1);
af5bc92d 3234 end = start + copied - 1;
64769240
AT
3235
3236 /*
3237 * generic_write_end() will run mark_inode_dirty() if i_size
3238 * changes. So let's piggyback the i_disksize mark_inode_dirty
3239 * into that.
3240 */
3241
3242 new_i_size = pos + copied;
632eaeab
MC
3243 if (new_i_size > EXT4_I(inode)->i_disksize) {
3244 if (ext4_da_should_update_i_disksize(page, end)) {
3245 down_write(&EXT4_I(inode)->i_data_sem);
3246 if (new_i_size > EXT4_I(inode)->i_disksize) {
3247 /*
3248 * Updating i_disksize when extending file
3249 * without needing block allocation
3250 */
3251 if (ext4_should_order_data(inode))
3252 ret = ext4_jbd2_file_inode(handle,
3253 inode);
64769240 3254
632eaeab
MC
3255 EXT4_I(inode)->i_disksize = new_i_size;
3256 }
3257 up_write(&EXT4_I(inode)->i_data_sem);
cf17fea6
AK
3258 /* We need to mark inode dirty even if
3259 * new_i_size is less that inode->i_size
3260 * bu greater than i_disksize.(hint delalloc)
3261 */
3262 ext4_mark_inode_dirty(handle, inode);
64769240 3263 }
632eaeab 3264 }
64769240
AT
3265 ret2 = generic_write_end(file, mapping, pos, len, copied,
3266 page, fsdata);
3267 copied = ret2;
3268 if (ret2 < 0)
3269 ret = ret2;
3270 ret2 = ext4_journal_stop(handle);
3271 if (!ret)
3272 ret = ret2;
3273
3274 return ret ? ret : copied;
3275}
3276
3277static void ext4_da_invalidatepage(struct page *page, unsigned long offset)
3278{
64769240
AT
3279 /*
3280 * Drop reserved blocks
3281 */
3282 BUG_ON(!PageLocked(page));
3283 if (!page_has_buffers(page))
3284 goto out;
3285
d2a17637 3286 ext4_da_page_release_reservation(page, offset);
64769240
AT
3287
3288out:
3289 ext4_invalidatepage(page, offset);
3290
3291 return;
3292}
3293
ccd2506b
TT
3294/*
3295 * Force all delayed allocation blocks to be allocated for a given inode.
3296 */
3297int ext4_alloc_da_blocks(struct inode *inode)
3298{
fb40ba0d
TT
3299 trace_ext4_alloc_da_blocks(inode);
3300
ccd2506b
TT
3301 if (!EXT4_I(inode)->i_reserved_data_blocks &&
3302 !EXT4_I(inode)->i_reserved_meta_blocks)
3303 return 0;
3304
3305 /*
3306 * We do something simple for now. The filemap_flush() will
3307 * also start triggering a write of the data blocks, which is
3308 * not strictly speaking necessary (and for users of
3309 * laptop_mode, not even desirable). However, to do otherwise
3310 * would require replicating code paths in:
de9a55b8 3311 *
ccd2506b
TT
3312 * ext4_da_writepages() ->
3313 * write_cache_pages() ---> (via passed in callback function)
3314 * __mpage_da_writepage() -->
3315 * mpage_add_bh_to_extent()
3316 * mpage_da_map_blocks()
3317 *
3318 * The problem is that write_cache_pages(), located in
3319 * mm/page-writeback.c, marks pages clean in preparation for
3320 * doing I/O, which is not desirable if we're not planning on
3321 * doing I/O at all.
3322 *
3323 * We could call write_cache_pages(), and then redirty all of
380cf090 3324 * the pages by calling redirty_page_for_writepage() but that
ccd2506b
TT
3325 * would be ugly in the extreme. So instead we would need to
3326 * replicate parts of the code in the above functions,
3327 * simplifying them becuase we wouldn't actually intend to
3328 * write out the pages, but rather only collect contiguous
3329 * logical block extents, call the multi-block allocator, and
3330 * then update the buffer heads with the block allocations.
de9a55b8 3331 *
ccd2506b
TT
3332 * For now, though, we'll cheat by calling filemap_flush(),
3333 * which will map the blocks, and start the I/O, but not
3334 * actually wait for the I/O to complete.
3335 */
3336 return filemap_flush(inode->i_mapping);
3337}
64769240 3338
ac27a0ec
DK
3339/*
3340 * bmap() is special. It gets used by applications such as lilo and by
3341 * the swapper to find the on-disk block of a specific piece of data.
3342 *
3343 * Naturally, this is dangerous if the block concerned is still in the
617ba13b 3344 * journal. If somebody makes a swapfile on an ext4 data-journaling
ac27a0ec
DK
3345 * filesystem and enables swap, then they may get a nasty shock when the
3346 * data getting swapped to that swapfile suddenly gets overwritten by
3347 * the original zero's written out previously to the journal and
3348 * awaiting writeback in the kernel's buffer cache.
3349 *
3350 * So, if we see any bmap calls here on a modified, data-journaled file,
3351 * take extra steps to flush any blocks which might be in the cache.
3352 */
617ba13b 3353static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
ac27a0ec
DK
3354{
3355 struct inode *inode = mapping->host;
3356 journal_t *journal;
3357 int err;
3358
64769240
AT
3359 if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) &&
3360 test_opt(inode->i_sb, DELALLOC)) {
3361 /*
3362 * With delalloc we want to sync the file
3363 * so that we can make sure we allocate
3364 * blocks for file
3365 */
3366 filemap_write_and_wait(mapping);
3367 }
3368
19f5fb7a
TT
3369 if (EXT4_JOURNAL(inode) &&
3370 ext4_test_inode_state(inode, EXT4_STATE_JDATA)) {
ac27a0ec
DK
3371 /*
3372 * This is a REALLY heavyweight approach, but the use of
3373 * bmap on dirty files is expected to be extremely rare:
3374 * only if we run lilo or swapon on a freshly made file
3375 * do we expect this to happen.
3376 *
3377 * (bmap requires CAP_SYS_RAWIO so this does not
3378 * represent an unprivileged user DOS attack --- we'd be
3379 * in trouble if mortal users could trigger this path at
3380 * will.)
3381 *
617ba13b 3382 * NB. EXT4_STATE_JDATA is not set on files other than
ac27a0ec
DK
3383 * regular files. If somebody wants to bmap a directory
3384 * or symlink and gets confused because the buffer
3385 * hasn't yet been flushed to disk, they deserve
3386 * everything they get.
3387 */
3388
19f5fb7a 3389 ext4_clear_inode_state(inode, EXT4_STATE_JDATA);
617ba13b 3390 journal = EXT4_JOURNAL(inode);
dab291af
MC
3391 jbd2_journal_lock_updates(journal);
3392 err = jbd2_journal_flush(journal);
3393 jbd2_journal_unlock_updates(journal);
ac27a0ec
DK
3394
3395 if (err)
3396 return 0;
3397 }
3398
af5bc92d 3399 return generic_block_bmap(mapping, block, ext4_get_block);
ac27a0ec
DK
3400}
3401
617ba13b 3402static int ext4_readpage(struct file *file, struct page *page)
ac27a0ec 3403{
617ba13b 3404 return mpage_readpage(page, ext4_get_block);
ac27a0ec
DK
3405}
3406
3407static int
617ba13b 3408ext4_readpages(struct file *file, struct address_space *mapping,
ac27a0ec
DK
3409 struct list_head *pages, unsigned nr_pages)
3410{
617ba13b 3411 return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
ac27a0ec
DK
3412}
3413
744692dc
JZ
3414static void ext4_invalidatepage_free_endio(struct page *page, unsigned long offset)
3415{
3416 struct buffer_head *head, *bh;
3417 unsigned int curr_off = 0;
3418
3419 if (!page_has_buffers(page))
3420 return;
3421 head = bh = page_buffers(page);
3422 do {
3423 if (offset <= curr_off && test_clear_buffer_uninit(bh)
3424 && bh->b_private) {
3425 ext4_free_io_end(bh->b_private);
3426 bh->b_private = NULL;
3427 bh->b_end_io = NULL;
3428 }
3429 curr_off = curr_off + bh->b_size;
3430 bh = bh->b_this_page;
3431 } while (bh != head);
3432}
3433
617ba13b 3434static void ext4_invalidatepage(struct page *page, unsigned long offset)
ac27a0ec 3435{
617ba13b 3436 journal_t *journal = EXT4_JOURNAL(page->mapping->host);
ac27a0ec 3437
744692dc
JZ
3438 /*
3439 * free any io_end structure allocated for buffers to be discarded
3440 */
3441 if (ext4_should_dioread_nolock(page->mapping->host))
3442 ext4_invalidatepage_free_endio(page, offset);
ac27a0ec
DK
3443 /*
3444 * If it's a full truncate we just forget about the pending dirtying
3445 */
3446 if (offset == 0)
3447 ClearPageChecked(page);
3448
0390131b
FM
3449 if (journal)
3450 jbd2_journal_invalidatepage(journal, page, offset);
3451 else
3452 block_invalidatepage(page, offset);
ac27a0ec
DK
3453}
3454
617ba13b 3455static int ext4_releasepage(struct page *page, gfp_t wait)
ac27a0ec 3456{
617ba13b 3457 journal_t *journal = EXT4_JOURNAL(page->mapping->host);
ac27a0ec
DK
3458
3459 WARN_ON(PageChecked(page));
3460 if (!page_has_buffers(page))
3461 return 0;
0390131b
FM
3462 if (journal)
3463 return jbd2_journal_try_to_free_buffers(journal, page, wait);
3464 else
3465 return try_to_free_buffers(page);
ac27a0ec
DK
3466}
3467
3468/*
4c0425ff
MC
3469 * O_DIRECT for ext3 (or indirect map) based files
3470 *
ac27a0ec
DK
3471 * If the O_DIRECT write will extend the file then add this inode to the
3472 * orphan list. So recovery will truncate it back to the original size
3473 * if the machine crashes during the write.
3474 *
3475 * If the O_DIRECT write is intantiating holes inside i_size and the machine
7fb5409d
JK
3476 * crashes then stale disk data _may_ be exposed inside the file. But current
3477 * VFS code falls back into buffered path in that case so we are safe.
ac27a0ec 3478 */
4c0425ff 3479static ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb,
de9a55b8
TT
3480 const struct iovec *iov, loff_t offset,
3481 unsigned long nr_segs)
ac27a0ec
DK
3482{
3483 struct file *file = iocb->ki_filp;
3484 struct inode *inode = file->f_mapping->host;
617ba13b 3485 struct ext4_inode_info *ei = EXT4_I(inode);
7fb5409d 3486 handle_t *handle;
ac27a0ec
DK
3487 ssize_t ret;
3488 int orphan = 0;
3489 size_t count = iov_length(iov, nr_segs);
fbbf6945 3490 int retries = 0;
ac27a0ec
DK
3491
3492 if (rw == WRITE) {
3493 loff_t final_size = offset + count;
3494
ac27a0ec 3495 if (final_size > inode->i_size) {
7fb5409d
JK
3496 /* Credits for sb + inode write */
3497 handle = ext4_journal_start(inode, 2);
3498 if (IS_ERR(handle)) {
3499 ret = PTR_ERR(handle);
3500 goto out;
3501 }
617ba13b 3502 ret = ext4_orphan_add(handle, inode);
7fb5409d
JK
3503 if (ret) {
3504 ext4_journal_stop(handle);
3505 goto out;
3506 }
ac27a0ec
DK
3507 orphan = 1;
3508 ei->i_disksize = inode->i_size;
7fb5409d 3509 ext4_journal_stop(handle);
ac27a0ec
DK
3510 }
3511 }
3512
fbbf6945 3513retry:
b7adc1f3 3514 if (rw == READ && ext4_should_dioread_nolock(inode))
eafdc7d1 3515 ret = __blockdev_direct_IO(rw, iocb, inode,
b7adc1f3
JZ
3516 inode->i_sb->s_bdev, iov,
3517 offset, nr_segs,
eafdc7d1
CH
3518 ext4_get_block, NULL, NULL, 0);
3519 else {
b7adc1f3
JZ
3520 ret = blockdev_direct_IO(rw, iocb, inode,
3521 inode->i_sb->s_bdev, iov,
ac27a0ec 3522 offset, nr_segs,
617ba13b 3523 ext4_get_block, NULL);
eafdc7d1
CH
3524
3525 if (unlikely((rw & WRITE) && ret < 0)) {
3526 loff_t isize = i_size_read(inode);
3527 loff_t end = offset + iov_length(iov, nr_segs);
3528
3529 if (end > isize)
3530 vmtruncate(inode, isize);
3531 }
3532 }
fbbf6945
ES
3533 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
3534 goto retry;
ac27a0ec 3535
7fb5409d 3536 if (orphan) {
ac27a0ec
DK
3537 int err;
3538
7fb5409d
JK
3539 /* Credits for sb + inode write */
3540 handle = ext4_journal_start(inode, 2);
3541 if (IS_ERR(handle)) {
3542 /* This is really bad luck. We've written the data
3543 * but cannot extend i_size. Bail out and pretend
3544 * the write failed... */
3545 ret = PTR_ERR(handle);
da1dafca
DM
3546 if (inode->i_nlink)
3547 ext4_orphan_del(NULL, inode);
3548
7fb5409d
JK
3549 goto out;
3550 }
3551 if (inode->i_nlink)
617ba13b 3552 ext4_orphan_del(handle, inode);
7fb5409d 3553 if (ret > 0) {
ac27a0ec
DK
3554 loff_t end = offset + ret;
3555 if (end > inode->i_size) {
3556 ei->i_disksize = end;
3557 i_size_write(inode, end);
3558 /*
3559 * We're going to return a positive `ret'
3560 * here due to non-zero-length I/O, so there's
3561 * no way of reporting error returns from
617ba13b 3562 * ext4_mark_inode_dirty() to userspace. So
ac27a0ec
DK
3563 * ignore it.
3564 */
617ba13b 3565 ext4_mark_inode_dirty(handle, inode);
ac27a0ec
DK
3566 }
3567 }
617ba13b 3568 err = ext4_journal_stop(handle);
ac27a0ec
DK
3569 if (ret == 0)
3570 ret = err;
3571 }
3572out:
3573 return ret;
3574}
3575
2ed88685
TT
3576/*
3577 * ext4_get_block used when preparing for a DIO write or buffer write.
3578 * We allocate an uinitialized extent if blocks haven't been allocated.
3579 * The extent will be converted to initialized after the IO is complete.
3580 */
c7064ef1 3581static int ext4_get_block_write(struct inode *inode, sector_t iblock,
4c0425ff
MC
3582 struct buffer_head *bh_result, int create)
3583{
c7064ef1 3584 ext4_debug("ext4_get_block_write: inode %lu, create flag %d\n",
8d5d02e6 3585 inode->i_ino, create);
2ed88685
TT
3586 return _ext4_get_block(inode, iblock, bh_result,
3587 EXT4_GET_BLOCKS_IO_CREATE_EXT);
4c0425ff
MC
3588}
3589
4c0425ff 3590static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
552ef802
CH
3591 ssize_t size, void *private, int ret,
3592 bool is_async)
4c0425ff
MC
3593{
3594 ext4_io_end_t *io_end = iocb->private;
3595 struct workqueue_struct *wq;
744692dc
JZ
3596 unsigned long flags;
3597 struct ext4_inode_info *ei;
4c0425ff 3598
4b70df18
M
3599 /* if not async direct IO or dio with 0 bytes write, just return */
3600 if (!io_end || !size)
552ef802 3601 goto out;
4b70df18 3602
8d5d02e6
MC
3603 ext_debug("ext4_end_io_dio(): io_end 0x%p"
3604 "for inode %lu, iocb 0x%p, offset %llu, size %llu\n",
3605 iocb->private, io_end->inode->i_ino, iocb, offset,
3606 size);
8d5d02e6
MC
3607
3608 /* if not aio dio with unwritten extents, just free io and return */
bd2d0210 3609 if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
8d5d02e6
MC
3610 ext4_free_io_end(io_end);
3611 iocb->private = NULL;
5b3ff237
JZ
3612out:
3613 if (is_async)
3614 aio_complete(iocb, ret, 0);
3615 return;
8d5d02e6
MC
3616 }
3617
4c0425ff
MC
3618 io_end->offset = offset;
3619 io_end->size = size;
5b3ff237
JZ
3620 if (is_async) {
3621 io_end->iocb = iocb;
3622 io_end->result = ret;
3623 }
4c0425ff
MC
3624 wq = EXT4_SB(io_end->inode->i_sb)->dio_unwritten_wq;
3625
8d5d02e6 3626 /* Add the io_end to per-inode completed aio dio list*/
744692dc
JZ
3627 ei = EXT4_I(io_end->inode);
3628 spin_lock_irqsave(&ei->i_completed_io_lock, flags);
3629 list_add_tail(&io_end->list, &ei->i_completed_io_list);
3630 spin_unlock_irqrestore(&ei->i_completed_io_lock, flags);
c999af2b
ES
3631
3632 /* queue the work to convert unwritten extents to written */
3633 queue_work(wq, &io_end->work);
4c0425ff
MC
3634 iocb->private = NULL;
3635}
c7064ef1 3636
744692dc
JZ
3637static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate)
3638{
3639 ext4_io_end_t *io_end = bh->b_private;
3640 struct workqueue_struct *wq;
3641 struct inode *inode;
3642 unsigned long flags;
3643
3644 if (!test_clear_buffer_uninit(bh) || !io_end)
3645 goto out;
3646
3647 if (!(io_end->inode->i_sb->s_flags & MS_ACTIVE)) {
3648 printk("sb umounted, discard end_io request for inode %lu\n",
3649 io_end->inode->i_ino);
3650 ext4_free_io_end(io_end);
3651 goto out;
3652 }
3653
bd2d0210 3654 io_end->flag = EXT4_IO_END_UNWRITTEN;
744692dc
JZ
3655 inode = io_end->inode;
3656
3657 /* Add the io_end to per-inode completed io list*/
3658 spin_lock_irqsave(&EXT4_I(inode)->i_completed_io_lock, flags);
3659 list_add_tail(&io_end->list, &EXT4_I(inode)->i_completed_io_list);
3660 spin_unlock_irqrestore(&EXT4_I(inode)->i_completed_io_lock, flags);
3661
3662 wq = EXT4_SB(inode->i_sb)->dio_unwritten_wq;
3663 /* queue the work to convert unwritten extents to written */
3664 queue_work(wq, &io_end->work);
3665out:
3666 bh->b_private = NULL;
3667 bh->b_end_io = NULL;
3668 clear_buffer_uninit(bh);
3669 end_buffer_async_write(bh, uptodate);
3670}
3671
3672static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode)
3673{
3674 ext4_io_end_t *io_end;
3675 struct page *page = bh->b_page;
3676 loff_t offset = (sector_t)page->index << PAGE_CACHE_SHIFT;
3677 size_t size = bh->b_size;
3678
3679retry:
3680 io_end = ext4_init_io_end(inode, GFP_ATOMIC);
3681 if (!io_end) {
6db26ffc 3682 pr_warn_ratelimited("%s: allocation fail\n", __func__);
744692dc
JZ
3683 schedule();
3684 goto retry;
3685 }
3686 io_end->offset = offset;
3687 io_end->size = size;
3688 /*
3689 * We need to hold a reference to the page to make sure it
3690 * doesn't get evicted before ext4_end_io_work() has a chance
3691 * to convert the extent from written to unwritten.
3692 */
3693 io_end->page = page;
3694 get_page(io_end->page);
3695
3696 bh->b_private = io_end;
3697 bh->b_end_io = ext4_end_io_buffer_write;
3698 return 0;
3699}
3700
4c0425ff
MC
3701/*
3702 * For ext4 extent files, ext4 will do direct-io write to holes,
3703 * preallocated extents, and those write extend the file, no need to
3704 * fall back to buffered IO.
3705 *
b595076a 3706 * For holes, we fallocate those blocks, mark them as uninitialized
4c0425ff 3707 * If those blocks were preallocated, we mark sure they are splited, but
b595076a 3708 * still keep the range to write as uninitialized.
4c0425ff 3709 *
8d5d02e6
MC
3710 * The unwrritten extents will be converted to written when DIO is completed.
3711 * For async direct IO, since the IO may still pending when return, we
3712 * set up an end_io call back function, which will do the convertion
3713 * when async direct IO completed.
4c0425ff
MC
3714 *
3715 * If the O_DIRECT write will extend the file then add this inode to the
3716 * orphan list. So recovery will truncate it back to the original size
3717 * if the machine crashes during the write.
3718 *
3719 */
3720static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
3721 const struct iovec *iov, loff_t offset,
3722 unsigned long nr_segs)
3723{
3724 struct file *file = iocb->ki_filp;
3725 struct inode *inode = file->f_mapping->host;
3726 ssize_t ret;
3727 size_t count = iov_length(iov, nr_segs);
3728
3729 loff_t final_size = offset + count;
3730 if (rw == WRITE && final_size <= inode->i_size) {
3731 /*
8d5d02e6
MC
3732 * We could direct write to holes and fallocate.
3733 *
3734 * Allocated blocks to fill the hole are marked as uninitialized
4c0425ff
MC
3735 * to prevent paralel buffered read to expose the stale data
3736 * before DIO complete the data IO.
8d5d02e6
MC
3737 *
3738 * As to previously fallocated extents, ext4 get_block
4c0425ff
MC
3739 * will just simply mark the buffer mapped but still
3740 * keep the extents uninitialized.
3741 *
8d5d02e6
MC
3742 * for non AIO case, we will convert those unwritten extents
3743 * to written after return back from blockdev_direct_IO.
3744 *
3745 * for async DIO, the conversion needs to be defered when
3746 * the IO is completed. The ext4 end_io callback function
3747 * will be called to take care of the conversion work.
3748 * Here for async case, we allocate an io_end structure to
3749 * hook to the iocb.
4c0425ff 3750 */
8d5d02e6
MC
3751 iocb->private = NULL;
3752 EXT4_I(inode)->cur_aio_dio = NULL;
3753 if (!is_sync_kiocb(iocb)) {
744692dc 3754 iocb->private = ext4_init_io_end(inode, GFP_NOFS);
8d5d02e6
MC
3755 if (!iocb->private)
3756 return -ENOMEM;
3757 /*
3758 * we save the io structure for current async
79e83036 3759 * direct IO, so that later ext4_map_blocks()
8d5d02e6
MC
3760 * could flag the io structure whether there
3761 * is a unwritten extents needs to be converted
3762 * when IO is completed.
3763 */
3764 EXT4_I(inode)->cur_aio_dio = iocb->private;
3765 }
3766
4c0425ff
MC
3767 ret = blockdev_direct_IO(rw, iocb, inode,
3768 inode->i_sb->s_bdev, iov,
3769 offset, nr_segs,
c7064ef1 3770 ext4_get_block_write,
4c0425ff 3771 ext4_end_io_dio);
8d5d02e6
MC
3772 if (iocb->private)
3773 EXT4_I(inode)->cur_aio_dio = NULL;
3774 /*
3775 * The io_end structure takes a reference to the inode,
3776 * that structure needs to be destroyed and the
3777 * reference to the inode need to be dropped, when IO is
3778 * complete, even with 0 byte write, or failed.
3779 *
3780 * In the successful AIO DIO case, the io_end structure will be
3781 * desctroyed and the reference to the inode will be dropped
3782 * after the end_io call back function is called.
3783 *
3784 * In the case there is 0 byte write, or error case, since
3785 * VFS direct IO won't invoke the end_io call back function,
3786 * we need to free the end_io structure here.
3787 */
3788 if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) {
3789 ext4_free_io_end(iocb->private);
3790 iocb->private = NULL;
19f5fb7a
TT
3791 } else if (ret > 0 && ext4_test_inode_state(inode,
3792 EXT4_STATE_DIO_UNWRITTEN)) {
109f5565 3793 int err;
8d5d02e6
MC
3794 /*
3795 * for non AIO case, since the IO is already
3796 * completed, we could do the convertion right here
3797 */
109f5565
M
3798 err = ext4_convert_unwritten_extents(inode,
3799 offset, ret);
3800 if (err < 0)
3801 ret = err;
19f5fb7a 3802 ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
109f5565 3803 }
4c0425ff
MC
3804 return ret;
3805 }
8d5d02e6
MC
3806
3807 /* for write the the end of file case, we fall back to old way */
4c0425ff
MC
3808 return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
3809}
3810
3811static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
3812 const struct iovec *iov, loff_t offset,
3813 unsigned long nr_segs)
3814{
3815 struct file *file = iocb->ki_filp;
3816 struct inode *inode = file->f_mapping->host;
3817
12e9b892 3818 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
4c0425ff
MC
3819 return ext4_ext_direct_IO(rw, iocb, iov, offset, nr_segs);
3820
3821 return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
3822}
3823
ac27a0ec 3824/*
617ba13b 3825 * Pages can be marked dirty completely asynchronously from ext4's journalling
ac27a0ec
DK
3826 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
3827 * much here because ->set_page_dirty is called under VFS locks. The page is
3828 * not necessarily locked.
3829 *
3830 * We cannot just dirty the page and leave attached buffers clean, because the
3831 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
3832 * or jbddirty because all the journalling code will explode.
3833 *
3834 * So what we do is to mark the page "pending dirty" and next time writepage
3835 * is called, propagate that into the buffers appropriately.
3836 */
617ba13b 3837static int ext4_journalled_set_page_dirty(struct page *page)
ac27a0ec
DK
3838{
3839 SetPageChecked(page);
3840 return __set_page_dirty_nobuffers(page);
3841}
3842
617ba13b 3843static const struct address_space_operations ext4_ordered_aops = {
8ab22b9a
HH
3844 .readpage = ext4_readpage,
3845 .readpages = ext4_readpages,
43ce1d23 3846 .writepage = ext4_writepage,
8ab22b9a
HH
3847 .sync_page = block_sync_page,
3848 .write_begin = ext4_write_begin,
3849 .write_end = ext4_ordered_write_end,
3850 .bmap = ext4_bmap,
3851 .invalidatepage = ext4_invalidatepage,
3852 .releasepage = ext4_releasepage,
3853 .direct_IO = ext4_direct_IO,
3854 .migratepage = buffer_migrate_page,
3855 .is_partially_uptodate = block_is_partially_uptodate,
aa261f54 3856 .error_remove_page = generic_error_remove_page,
ac27a0ec
DK
3857};
3858
617ba13b 3859static const struct address_space_operations ext4_writeback_aops = {
8ab22b9a
HH
3860 .readpage = ext4_readpage,
3861 .readpages = ext4_readpages,
43ce1d23 3862 .writepage = ext4_writepage,
8ab22b9a
HH
3863 .sync_page = block_sync_page,
3864 .write_begin = ext4_write_begin,
3865 .write_end = ext4_writeback_write_end,
3866 .bmap = ext4_bmap,
3867 .invalidatepage = ext4_invalidatepage,
3868 .releasepage = ext4_releasepage,
3869 .direct_IO = ext4_direct_IO,
3870 .migratepage = buffer_migrate_page,
3871 .is_partially_uptodate = block_is_partially_uptodate,
aa261f54 3872 .error_remove_page = generic_error_remove_page,
ac27a0ec
DK
3873};
3874
617ba13b 3875static const struct address_space_operations ext4_journalled_aops = {
8ab22b9a
HH
3876 .readpage = ext4_readpage,
3877 .readpages = ext4_readpages,
43ce1d23 3878 .writepage = ext4_writepage,
8ab22b9a
HH
3879 .sync_page = block_sync_page,
3880 .write_begin = ext4_write_begin,
3881 .write_end = ext4_journalled_write_end,
3882 .set_page_dirty = ext4_journalled_set_page_dirty,
3883 .bmap = ext4_bmap,
3884 .invalidatepage = ext4_invalidatepage,
3885 .releasepage = ext4_releasepage,
3886 .is_partially_uptodate = block_is_partially_uptodate,
aa261f54 3887 .error_remove_page = generic_error_remove_page,
ac27a0ec
DK
3888};
3889
64769240 3890static const struct address_space_operations ext4_da_aops = {
8ab22b9a
HH
3891 .readpage = ext4_readpage,
3892 .readpages = ext4_readpages,
43ce1d23 3893 .writepage = ext4_writepage,
8ab22b9a
HH
3894 .writepages = ext4_da_writepages,
3895 .sync_page = block_sync_page,
3896 .write_begin = ext4_da_write_begin,
3897 .write_end = ext4_da_write_end,
3898 .bmap = ext4_bmap,
3899 .invalidatepage = ext4_da_invalidatepage,
3900 .releasepage = ext4_releasepage,
3901 .direct_IO = ext4_direct_IO,
3902 .migratepage = buffer_migrate_page,
3903 .is_partially_uptodate = block_is_partially_uptodate,
aa261f54 3904 .error_remove_page = generic_error_remove_page,
64769240
AT
3905};
3906
617ba13b 3907void ext4_set_aops(struct inode *inode)
ac27a0ec 3908{
cd1aac32
AK
3909 if (ext4_should_order_data(inode) &&
3910 test_opt(inode->i_sb, DELALLOC))
3911 inode->i_mapping->a_ops = &ext4_da_aops;
3912 else if (ext4_should_order_data(inode))
617ba13b 3913 inode->i_mapping->a_ops = &ext4_ordered_aops;
64769240
AT
3914 else if (ext4_should_writeback_data(inode) &&
3915 test_opt(inode->i_sb, DELALLOC))
3916 inode->i_mapping->a_ops = &ext4_da_aops;
617ba13b
MC
3917 else if (ext4_should_writeback_data(inode))
3918 inode->i_mapping->a_ops = &ext4_writeback_aops;
ac27a0ec 3919 else
617ba13b 3920 inode->i_mapping->a_ops = &ext4_journalled_aops;
ac27a0ec
DK
3921}
3922
3923/*
617ba13b 3924 * ext4_block_truncate_page() zeroes out a mapping from file offset `from'
ac27a0ec
DK
3925 * up to the end of the block which corresponds to `from'.
3926 * This required during truncate. We need to physically zero the tail end
3927 * of that block so it doesn't yield old data if the file is later grown.
3928 */
cf108bca 3929int ext4_block_truncate_page(handle_t *handle,
ac27a0ec
DK
3930 struct address_space *mapping, loff_t from)
3931{
617ba13b 3932 ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT;
ac27a0ec 3933 unsigned offset = from & (PAGE_CACHE_SIZE-1);
725d26d3
AK
3934 unsigned blocksize, length, pos;
3935 ext4_lblk_t iblock;
ac27a0ec
DK
3936 struct inode *inode = mapping->host;
3937 struct buffer_head *bh;
cf108bca 3938 struct page *page;
ac27a0ec 3939 int err = 0;
ac27a0ec 3940
f4a01017
TT
3941 page = find_or_create_page(mapping, from >> PAGE_CACHE_SHIFT,
3942 mapping_gfp_mask(mapping) & ~__GFP_FS);
cf108bca
JK
3943 if (!page)
3944 return -EINVAL;
3945
ac27a0ec
DK
3946 blocksize = inode->i_sb->s_blocksize;
3947 length = blocksize - (offset & (blocksize - 1));
3948 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
3949
ac27a0ec
DK
3950 if (!page_has_buffers(page))
3951 create_empty_buffers(page, blocksize, 0);
3952
3953 /* Find the buffer that contains "offset" */
3954 bh = page_buffers(page);
3955 pos = blocksize;
3956 while (offset >= pos) {
3957 bh = bh->b_this_page;
3958 iblock++;
3959 pos += blocksize;
3960 }
3961
3962 err = 0;
3963 if (buffer_freed(bh)) {
3964 BUFFER_TRACE(bh, "freed: skip");
3965 goto unlock;
3966 }
3967
3968 if (!buffer_mapped(bh)) {
3969 BUFFER_TRACE(bh, "unmapped");
617ba13b 3970 ext4_get_block(inode, iblock, bh, 0);
ac27a0ec
DK
3971 /* unmapped? It's a hole - nothing to do */
3972 if (!buffer_mapped(bh)) {
3973 BUFFER_TRACE(bh, "still unmapped");
3974 goto unlock;
3975 }
3976 }
3977
3978 /* Ok, it's mapped. Make sure it's up-to-date */
3979 if (PageUptodate(page))
3980 set_buffer_uptodate(bh);
3981
3982 if (!buffer_uptodate(bh)) {
3983 err = -EIO;
3984 ll_rw_block(READ, 1, &bh);
3985 wait_on_buffer(bh);
3986 /* Uhhuh. Read error. Complain and punt. */
3987 if (!buffer_uptodate(bh))
3988 goto unlock;
3989 }
3990
617ba13b 3991 if (ext4_should_journal_data(inode)) {
ac27a0ec 3992 BUFFER_TRACE(bh, "get write access");
617ba13b 3993 err = ext4_journal_get_write_access(handle, bh);
ac27a0ec
DK
3994 if (err)
3995 goto unlock;
3996 }
3997
eebd2aa3 3998 zero_user(page, offset, length);
ac27a0ec
DK
3999
4000 BUFFER_TRACE(bh, "zeroed end of block");
4001
4002 err = 0;
617ba13b 4003 if (ext4_should_journal_data(inode)) {
0390131b 4004 err = ext4_handle_dirty_metadata(handle, inode, bh);
ac27a0ec 4005 } else {
8aefcd55 4006 if (ext4_should_order_data(inode) && EXT4_I(inode)->jinode)
678aaf48 4007 err = ext4_jbd2_file_inode(handle, inode);
ac27a0ec
DK
4008 mark_buffer_dirty(bh);
4009 }
4010
4011unlock:
4012 unlock_page(page);
4013 page_cache_release(page);
4014 return err;
4015}
4016
4017/*
4018 * Probably it should be a library function... search for first non-zero word
4019 * or memcmp with zero_page, whatever is better for particular architecture.
4020 * Linus?
4021 */
4022static inline int all_zeroes(__le32 *p, __le32 *q)
4023{
4024 while (p < q)
4025 if (*p++)
4026 return 0;
4027 return 1;
4028}
4029
4030/**
617ba13b 4031 * ext4_find_shared - find the indirect blocks for partial truncation.
ac27a0ec
DK
4032 * @inode: inode in question
4033 * @depth: depth of the affected branch
617ba13b 4034 * @offsets: offsets of pointers in that branch (see ext4_block_to_path)
ac27a0ec
DK
4035 * @chain: place to store the pointers to partial indirect blocks
4036 * @top: place to the (detached) top of branch
4037 *
617ba13b 4038 * This is a helper function used by ext4_truncate().
ac27a0ec
DK
4039 *
4040 * When we do truncate() we may have to clean the ends of several
4041 * indirect blocks but leave the blocks themselves alive. Block is
4042 * partially truncated if some data below the new i_size is refered
4043 * from it (and it is on the path to the first completely truncated
4044 * data block, indeed). We have to free the top of that path along
4045 * with everything to the right of the path. Since no allocation
617ba13b 4046 * past the truncation point is possible until ext4_truncate()
ac27a0ec
DK
4047 * finishes, we may safely do the latter, but top of branch may
4048 * require special attention - pageout below the truncation point
4049 * might try to populate it.
4050 *
4051 * We atomically detach the top of branch from the tree, store the
4052 * block number of its root in *@top, pointers to buffer_heads of
4053 * partially truncated blocks - in @chain[].bh and pointers to
4054 * their last elements that should not be removed - in
4055 * @chain[].p. Return value is the pointer to last filled element
4056 * of @chain.
4057 *
4058 * The work left to caller to do the actual freeing of subtrees:
4059 * a) free the subtree starting from *@top
4060 * b) free the subtrees whose roots are stored in
4061 * (@chain[i].p+1 .. end of @chain[i].bh->b_data)
4062 * c) free the subtrees growing from the inode past the @chain[0].
4063 * (no partially truncated stuff there). */
4064
617ba13b 4065static Indirect *ext4_find_shared(struct inode *inode, int depth,
de9a55b8
TT
4066 ext4_lblk_t offsets[4], Indirect chain[4],
4067 __le32 *top)
ac27a0ec
DK
4068{
4069 Indirect *partial, *p;
4070 int k, err;
4071
4072 *top = 0;
bf48aabb 4073 /* Make k index the deepest non-null offset + 1 */
ac27a0ec
DK
4074 for (k = depth; k > 1 && !offsets[k-1]; k--)
4075 ;
617ba13b 4076 partial = ext4_get_branch(inode, k, offsets, chain, &err);
ac27a0ec
DK
4077 /* Writer: pointers */
4078 if (!partial)
4079 partial = chain + k-1;
4080 /*
4081 * If the branch acquired continuation since we've looked at it -
4082 * fine, it should all survive and (new) top doesn't belong to us.
4083 */
4084 if (!partial->key && *partial->p)
4085 /* Writer: end */
4086 goto no_top;
af5bc92d 4087 for (p = partial; (p > chain) && all_zeroes((__le32 *) p->bh->b_data, p->p); p--)
ac27a0ec
DK
4088 ;
4089 /*
4090 * OK, we've found the last block that must survive. The rest of our
4091 * branch should be detached before unlocking. However, if that rest
4092 * of branch is all ours and does not grow immediately from the inode
4093 * it's easier to cheat and just decrement partial->p.
4094 */
4095 if (p == chain + k - 1 && p > chain) {
4096 p->p--;
4097 } else {
4098 *top = *p->p;
617ba13b 4099 /* Nope, don't do this in ext4. Must leave the tree intact */
ac27a0ec
DK
4100#if 0
4101 *p->p = 0;
4102#endif
4103 }
4104 /* Writer: end */
4105
af5bc92d 4106 while (partial > p) {
ac27a0ec
DK
4107 brelse(partial->bh);
4108 partial--;
4109 }
4110no_top:
4111 return partial;
4112}
4113
4114/*
4115 * Zero a number of block pointers in either an inode or an indirect block.
4116 * If we restart the transaction we must again get write access to the
4117 * indirect block for further modification.
4118 *
4119 * We release `count' blocks on disk, but (last - first) may be greater
4120 * than `count' because there can be holes in there.
4121 */
1f2acb60
TT
4122static int ext4_clear_blocks(handle_t *handle, struct inode *inode,
4123 struct buffer_head *bh,
4124 ext4_fsblk_t block_to_free,
4125 unsigned long count, __le32 *first,
4126 __le32 *last)
ac27a0ec
DK
4127{
4128 __le32 *p;
1f2acb60 4129 int flags = EXT4_FREE_BLOCKS_FORGET | EXT4_FREE_BLOCKS_VALIDATED;
b4097142 4130 int err;
e6362609
TT
4131
4132 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
4133 flags |= EXT4_FREE_BLOCKS_METADATA;
50689696 4134
1f2acb60
TT
4135 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), block_to_free,
4136 count)) {
24676da4
TT
4137 EXT4_ERROR_INODE(inode, "attempt to clear invalid "
4138 "blocks %llu len %lu",
4139 (unsigned long long) block_to_free, count);
1f2acb60
TT
4140 return 1;
4141 }
4142
ac27a0ec
DK
4143 if (try_to_extend_transaction(handle, inode)) {
4144 if (bh) {
0390131b 4145 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
b4097142
TT
4146 err = ext4_handle_dirty_metadata(handle, inode, bh);
4147 if (unlikely(err)) {
4148 ext4_std_error(inode->i_sb, err);
4149 return 1;
4150 }
4151 }
4152 err = ext4_mark_inode_dirty(handle, inode);
4153 if (unlikely(err)) {
4154 ext4_std_error(inode->i_sb, err);
4155 return 1;
4156 }
4157 err = ext4_truncate_restart_trans(handle, inode,
4158 blocks_for_truncate(inode));
4159 if (unlikely(err)) {
4160 ext4_std_error(inode->i_sb, err);
4161 return 1;
ac27a0ec 4162 }
ac27a0ec
DK
4163 if (bh) {
4164 BUFFER_TRACE(bh, "retaking write access");
617ba13b 4165 ext4_journal_get_write_access(handle, bh);
ac27a0ec
DK
4166 }
4167 }
4168
e6362609
TT
4169 for (p = first; p < last; p++)
4170 *p = 0;
ac27a0ec 4171
7dc57615 4172 ext4_free_blocks(handle, inode, NULL, block_to_free, count, flags);
1f2acb60 4173 return 0;
ac27a0ec
DK
4174}
4175
4176/**
617ba13b 4177 * ext4_free_data - free a list of data blocks
ac27a0ec
DK
4178 * @handle: handle for this transaction
4179 * @inode: inode we are dealing with
4180 * @this_bh: indirect buffer_head which contains *@first and *@last
4181 * @first: array of block numbers
4182 * @last: points immediately past the end of array
4183 *
4184 * We are freeing all blocks refered from that array (numbers are stored as
4185 * little-endian 32-bit) and updating @inode->i_blocks appropriately.
4186 *
4187 * We accumulate contiguous runs of blocks to free. Conveniently, if these
4188 * blocks are contiguous then releasing them at one time will only affect one
4189 * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
4190 * actually use a lot of journal space.
4191 *
4192 * @this_bh will be %NULL if @first and @last point into the inode's direct
4193 * block pointers.
4194 */
617ba13b 4195static void ext4_free_data(handle_t *handle, struct inode *inode,
ac27a0ec
DK
4196 struct buffer_head *this_bh,
4197 __le32 *first, __le32 *last)
4198{
617ba13b 4199 ext4_fsblk_t block_to_free = 0; /* Starting block # of a run */
ac27a0ec
DK
4200 unsigned long count = 0; /* Number of blocks in the run */
4201 __le32 *block_to_free_p = NULL; /* Pointer into inode/ind
4202 corresponding to
4203 block_to_free */
617ba13b 4204 ext4_fsblk_t nr; /* Current block # */
ac27a0ec
DK
4205 __le32 *p; /* Pointer into inode/ind
4206 for current block */
4207 int err;
4208
4209 if (this_bh) { /* For indirect block */
4210 BUFFER_TRACE(this_bh, "get_write_access");
617ba13b 4211 err = ext4_journal_get_write_access(handle, this_bh);
ac27a0ec
DK
4212 /* Important: if we can't update the indirect pointers
4213 * to the blocks, we can't free them. */
4214 if (err)
4215 return;
4216 }
4217
4218 for (p = first; p < last; p++) {
4219 nr = le32_to_cpu(*p);
4220 if (nr) {
4221 /* accumulate blocks to free if they're contiguous */
4222 if (count == 0) {
4223 block_to_free = nr;
4224 block_to_free_p = p;
4225 count = 1;
4226 } else if (nr == block_to_free + count) {
4227 count++;
4228 } else {
1f2acb60
TT
4229 if (ext4_clear_blocks(handle, inode, this_bh,
4230 block_to_free, count,
4231 block_to_free_p, p))
4232 break;
ac27a0ec
DK
4233 block_to_free = nr;
4234 block_to_free_p = p;
4235 count = 1;
4236 }
4237 }
4238 }
4239
4240 if (count > 0)
617ba13b 4241 ext4_clear_blocks(handle, inode, this_bh, block_to_free,
ac27a0ec
DK
4242 count, block_to_free_p, p);
4243
4244 if (this_bh) {
0390131b 4245 BUFFER_TRACE(this_bh, "call ext4_handle_dirty_metadata");
71dc8fbc
DG
4246
4247 /*
4248 * The buffer head should have an attached journal head at this
4249 * point. However, if the data is corrupted and an indirect
4250 * block pointed to itself, it would have been detached when
4251 * the block was cleared. Check for this instead of OOPSing.
4252 */
e7f07968 4253 if ((EXT4_JOURNAL(inode) == NULL) || bh2jh(this_bh))
0390131b 4254 ext4_handle_dirty_metadata(handle, inode, this_bh);
71dc8fbc 4255 else
24676da4
TT
4256 EXT4_ERROR_INODE(inode,
4257 "circular indirect block detected at "
4258 "block %llu",
4259 (unsigned long long) this_bh->b_blocknr);
ac27a0ec
DK
4260 }
4261}
4262
4263/**
617ba13b 4264 * ext4_free_branches - free an array of branches
ac27a0ec
DK
4265 * @handle: JBD handle for this transaction
4266 * @inode: inode we are dealing with
4267 * @parent_bh: the buffer_head which contains *@first and *@last
4268 * @first: array of block numbers
4269 * @last: pointer immediately past the end of array
4270 * @depth: depth of the branches to free
4271 *
4272 * We are freeing all blocks refered from these branches (numbers are
4273 * stored as little-endian 32-bit) and updating @inode->i_blocks
4274 * appropriately.
4275 */
617ba13b 4276static void ext4_free_branches(handle_t *handle, struct inode *inode,
ac27a0ec
DK
4277 struct buffer_head *parent_bh,
4278 __le32 *first, __le32 *last, int depth)
4279{
617ba13b 4280 ext4_fsblk_t nr;
ac27a0ec
DK
4281 __le32 *p;
4282
0390131b 4283 if (ext4_handle_is_aborted(handle))
ac27a0ec
DK
4284 return;
4285
4286 if (depth--) {
4287 struct buffer_head *bh;
617ba13b 4288 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb);
ac27a0ec
DK
4289 p = last;
4290 while (--p >= first) {
4291 nr = le32_to_cpu(*p);
4292 if (!nr)
4293 continue; /* A hole */
4294
1f2acb60
TT
4295 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb),
4296 nr, 1)) {
24676da4
TT
4297 EXT4_ERROR_INODE(inode,
4298 "invalid indirect mapped "
4299 "block %lu (level %d)",
4300 (unsigned long) nr, depth);
1f2acb60
TT
4301 break;
4302 }
4303
ac27a0ec
DK
4304 /* Go read the buffer for the next level down */
4305 bh = sb_bread(inode->i_sb, nr);
4306
4307 /*
4308 * A read failure? Report error and clear slot
4309 * (should be rare).
4310 */
4311 if (!bh) {
c398eda0
TT
4312 EXT4_ERROR_INODE_BLOCK(inode, nr,
4313 "Read failure");
ac27a0ec
DK
4314 continue;
4315 }
4316
4317 /* This zaps the entire block. Bottom up. */
4318 BUFFER_TRACE(bh, "free child branches");
617ba13b 4319 ext4_free_branches(handle, inode, bh,
af5bc92d
TT
4320 (__le32 *) bh->b_data,
4321 (__le32 *) bh->b_data + addr_per_block,
4322 depth);
1c5b9e90 4323 brelse(bh);
ac27a0ec 4324
ac27a0ec
DK
4325 /*
4326 * Everything below this this pointer has been
4327 * released. Now let this top-of-subtree go.
4328 *
4329 * We want the freeing of this indirect block to be
4330 * atomic in the journal with the updating of the
4331 * bitmap block which owns it. So make some room in
4332 * the journal.
4333 *
4334 * We zero the parent pointer *after* freeing its
4335 * pointee in the bitmaps, so if extend_transaction()
4336 * for some reason fails to put the bitmap changes and
4337 * the release into the same transaction, recovery
4338 * will merely complain about releasing a free block,
4339 * rather than leaking blocks.
4340 */
0390131b 4341 if (ext4_handle_is_aborted(handle))
ac27a0ec
DK
4342 return;
4343 if (try_to_extend_transaction(handle, inode)) {
617ba13b 4344 ext4_mark_inode_dirty(handle, inode);
487caeef
JK
4345 ext4_truncate_restart_trans(handle, inode,
4346 blocks_for_truncate(inode));
ac27a0ec
DK
4347 }
4348
40389687
A
4349 /*
4350 * The forget flag here is critical because if
4351 * we are journaling (and not doing data
4352 * journaling), we have to make sure a revoke
4353 * record is written to prevent the journal
4354 * replay from overwriting the (former)
4355 * indirect block if it gets reallocated as a
4356 * data block. This must happen in the same
4357 * transaction where the data blocks are
4358 * actually freed.
4359 */
7dc57615 4360 ext4_free_blocks(handle, inode, NULL, nr, 1,
40389687
A
4361 EXT4_FREE_BLOCKS_METADATA|
4362 EXT4_FREE_BLOCKS_FORGET);
ac27a0ec
DK
4363
4364 if (parent_bh) {
4365 /*
4366 * The block which we have just freed is
4367 * pointed to by an indirect block: journal it
4368 */
4369 BUFFER_TRACE(parent_bh, "get_write_access");
617ba13b 4370 if (!ext4_journal_get_write_access(handle,
ac27a0ec
DK
4371 parent_bh)){
4372 *p = 0;
4373 BUFFER_TRACE(parent_bh,
0390131b
FM
4374 "call ext4_handle_dirty_metadata");
4375 ext4_handle_dirty_metadata(handle,
4376 inode,
4377 parent_bh);
ac27a0ec
DK
4378 }
4379 }
4380 }
4381 } else {
4382 /* We have reached the bottom of the tree. */
4383 BUFFER_TRACE(parent_bh, "free data blocks");
617ba13b 4384 ext4_free_data(handle, inode, parent_bh, first, last);
ac27a0ec
DK
4385 }
4386}
4387
91ef4caf
DG
4388int ext4_can_truncate(struct inode *inode)
4389{
4390 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
4391 return 0;
4392 if (S_ISREG(inode->i_mode))
4393 return 1;
4394 if (S_ISDIR(inode->i_mode))
4395 return 1;
4396 if (S_ISLNK(inode->i_mode))
4397 return !ext4_inode_is_fast_symlink(inode);
4398 return 0;
4399}
4400
ac27a0ec 4401/*
617ba13b 4402 * ext4_truncate()
ac27a0ec 4403 *
617ba13b
MC
4404 * We block out ext4_get_block() block instantiations across the entire
4405 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
ac27a0ec
DK
4406 * simultaneously on behalf of the same inode.
4407 *
4408 * As we work through the truncate and commmit bits of it to the journal there
4409 * is one core, guiding principle: the file's tree must always be consistent on
4410 * disk. We must be able to restart the truncate after a crash.
4411 *
4412 * The file's tree may be transiently inconsistent in memory (although it
4413 * probably isn't), but whenever we close off and commit a journal transaction,
4414 * the contents of (the filesystem + the journal) must be consistent and
4415 * restartable. It's pretty simple, really: bottom up, right to left (although
4416 * left-to-right works OK too).
4417 *
4418 * Note that at recovery time, journal replay occurs *before* the restart of
4419 * truncate against the orphan inode list.
4420 *
4421 * The committed inode has the new, desired i_size (which is the same as
617ba13b 4422 * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see
ac27a0ec 4423 * that this inode's truncate did not complete and it will again call
617ba13b
MC
4424 * ext4_truncate() to have another go. So there will be instantiated blocks
4425 * to the right of the truncation point in a crashed ext4 filesystem. But
ac27a0ec 4426 * that's fine - as long as they are linked from the inode, the post-crash
617ba13b 4427 * ext4_truncate() run will find them and release them.
ac27a0ec 4428 */
617ba13b 4429void ext4_truncate(struct inode *inode)
ac27a0ec
DK
4430{
4431 handle_t *handle;
617ba13b 4432 struct ext4_inode_info *ei = EXT4_I(inode);
ac27a0ec 4433 __le32 *i_data = ei->i_data;
617ba13b 4434 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb);
ac27a0ec 4435 struct address_space *mapping = inode->i_mapping;
725d26d3 4436 ext4_lblk_t offsets[4];
ac27a0ec
DK
4437 Indirect chain[4];
4438 Indirect *partial;
4439 __le32 nr = 0;
4440 int n;
725d26d3 4441 ext4_lblk_t last_block;
ac27a0ec 4442 unsigned blocksize = inode->i_sb->s_blocksize;
ac27a0ec 4443
91ef4caf 4444 if (!ext4_can_truncate(inode))
ac27a0ec
DK
4445 return;
4446
12e9b892 4447 ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
c8d46e41 4448
5534fb5b 4449 if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
19f5fb7a 4450 ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
7d8f9f7d 4451
12e9b892 4452 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
cf108bca 4453 ext4_ext_truncate(inode);
1d03ec98
AK
4454 return;
4455 }
a86c6181 4456
ac27a0ec 4457 handle = start_transaction(inode);
cf108bca 4458 if (IS_ERR(handle))
ac27a0ec 4459 return; /* AKPM: return what? */
ac27a0ec
DK
4460
4461 last_block = (inode->i_size + blocksize-1)
617ba13b 4462 >> EXT4_BLOCK_SIZE_BITS(inode->i_sb);
ac27a0ec 4463
cf108bca
JK
4464 if (inode->i_size & (blocksize - 1))
4465 if (ext4_block_truncate_page(handle, mapping, inode->i_size))
4466 goto out_stop;
ac27a0ec 4467
617ba13b 4468 n = ext4_block_to_path(inode, last_block, offsets, NULL);
ac27a0ec
DK
4469 if (n == 0)
4470 goto out_stop; /* error */
4471
4472 /*
4473 * OK. This truncate is going to happen. We add the inode to the
4474 * orphan list, so that if this truncate spans multiple transactions,
4475 * and we crash, we will resume the truncate when the filesystem
4476 * recovers. It also marks the inode dirty, to catch the new size.
4477 *
4478 * Implication: the file must always be in a sane, consistent
4479 * truncatable state while each transaction commits.
4480 */
617ba13b 4481 if (ext4_orphan_add(handle, inode))
ac27a0ec
DK
4482 goto out_stop;
4483
632eaeab
MC
4484 /*
4485 * From here we block out all ext4_get_block() callers who want to
4486 * modify the block allocation tree.
4487 */
4488 down_write(&ei->i_data_sem);
b4df2030 4489
c2ea3fde 4490 ext4_discard_preallocations(inode);
b4df2030 4491
ac27a0ec
DK
4492 /*
4493 * The orphan list entry will now protect us from any crash which
4494 * occurs before the truncate completes, so it is now safe to propagate
4495 * the new, shorter inode size (held for now in i_size) into the
4496 * on-disk inode. We do this via i_disksize, which is the value which
617ba13b 4497 * ext4 *really* writes onto the disk inode.
ac27a0ec
DK
4498 */
4499 ei->i_disksize = inode->i_size;
4500
ac27a0ec 4501 if (n == 1) { /* direct blocks */
617ba13b
MC
4502 ext4_free_data(handle, inode, NULL, i_data+offsets[0],
4503 i_data + EXT4_NDIR_BLOCKS);
ac27a0ec
DK
4504 goto do_indirects;
4505 }
4506
617ba13b 4507 partial = ext4_find_shared(inode, n, offsets, chain, &nr);
ac27a0ec
DK
4508 /* Kill the top of shared branch (not detached) */
4509 if (nr) {
4510 if (partial == chain) {
4511 /* Shared branch grows from the inode */
617ba13b 4512 ext4_free_branches(handle, inode, NULL,
ac27a0ec
DK
4513 &nr, &nr+1, (chain+n-1) - partial);
4514 *partial->p = 0;
4515 /*
4516 * We mark the inode dirty prior to restart,
4517 * and prior to stop. No need for it here.
4518 */
4519 } else {
4520 /* Shared branch grows from an indirect block */
4521 BUFFER_TRACE(partial->bh, "get_write_access");
617ba13b 4522 ext4_free_branches(handle, inode, partial->bh,
ac27a0ec
DK
4523 partial->p,
4524 partial->p+1, (chain+n-1) - partial);
4525 }
4526 }
4527 /* Clear the ends of indirect blocks on the shared branch */
4528 while (partial > chain) {
617ba13b 4529 ext4_free_branches(handle, inode, partial->bh, partial->p + 1,
ac27a0ec
DK
4530 (__le32*)partial->bh->b_data+addr_per_block,
4531 (chain+n-1) - partial);
4532 BUFFER_TRACE(partial->bh, "call brelse");
de9a55b8 4533 brelse(partial->bh);
ac27a0ec
DK
4534 partial--;
4535 }
4536do_indirects:
4537 /* Kill the remaining (whole) subtrees */
4538 switch (offsets[0]) {
4539 default:
617ba13b 4540 nr = i_data[EXT4_IND_BLOCK];
ac27a0ec 4541 if (nr) {
617ba13b
MC
4542 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
4543 i_data[EXT4_IND_BLOCK] = 0;
ac27a0ec 4544 }
617ba13b
MC
4545 case EXT4_IND_BLOCK:
4546 nr = i_data[EXT4_DIND_BLOCK];
ac27a0ec 4547 if (nr) {
617ba13b
MC
4548 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
4549 i_data[EXT4_DIND_BLOCK] = 0;
ac27a0ec 4550 }
617ba13b
MC
4551 case EXT4_DIND_BLOCK:
4552 nr = i_data[EXT4_TIND_BLOCK];
ac27a0ec 4553 if (nr) {
617ba13b
MC
4554 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
4555 i_data[EXT4_TIND_BLOCK] = 0;
ac27a0ec 4556 }
617ba13b 4557 case EXT4_TIND_BLOCK:
ac27a0ec
DK
4558 ;
4559 }
4560
0e855ac8 4561 up_write(&ei->i_data_sem);
ef7f3835 4562 inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
617ba13b 4563 ext4_mark_inode_dirty(handle, inode);
ac27a0ec
DK
4564
4565 /*
4566 * In a multi-transaction truncate, we only make the final transaction
4567 * synchronous
4568 */
4569 if (IS_SYNC(inode))
0390131b 4570 ext4_handle_sync(handle);
ac27a0ec
DK
4571out_stop:
4572 /*
4573 * If this was a simple ftruncate(), and the file will remain alive
4574 * then we need to clear up the orphan record which we created above.
4575 * However, if this was a real unlink then we were called by
617ba13b 4576 * ext4_delete_inode(), and we allow that function to clean up the
ac27a0ec
DK
4577 * orphan info for us.
4578 */
4579 if (inode->i_nlink)
617ba13b 4580 ext4_orphan_del(handle, inode);
ac27a0ec 4581
617ba13b 4582 ext4_journal_stop(handle);
ac27a0ec
DK
4583}
4584
ac27a0ec 4585/*
617ba13b 4586 * ext4_get_inode_loc returns with an extra refcount against the inode's
ac27a0ec
DK
4587 * underlying buffer_head on success. If 'in_mem' is true, we have all
4588 * data in memory that is needed to recreate the on-disk version of this
4589 * inode.
4590 */
617ba13b
MC
4591static int __ext4_get_inode_loc(struct inode *inode,
4592 struct ext4_iloc *iloc, int in_mem)
ac27a0ec 4593{
240799cd
TT
4594 struct ext4_group_desc *gdp;
4595 struct buffer_head *bh;
4596 struct super_block *sb = inode->i_sb;
4597 ext4_fsblk_t block;
4598 int inodes_per_block, inode_offset;
4599
3a06d778 4600 iloc->bh = NULL;
240799cd
TT
4601 if (!ext4_valid_inum(sb, inode->i_ino))
4602 return -EIO;
ac27a0ec 4603
240799cd
TT
4604 iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
4605 gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
4606 if (!gdp)
ac27a0ec
DK
4607 return -EIO;
4608
240799cd
TT
4609 /*
4610 * Figure out the offset within the block group inode table
4611 */
4612 inodes_per_block = (EXT4_BLOCK_SIZE(sb) / EXT4_INODE_SIZE(sb));
4613 inode_offset = ((inode->i_ino - 1) %
4614 EXT4_INODES_PER_GROUP(sb));
4615 block = ext4_inode_table(sb, gdp) + (inode_offset / inodes_per_block);
4616 iloc->offset = (inode_offset % inodes_per_block) * EXT4_INODE_SIZE(sb);
4617
4618 bh = sb_getblk(sb, block);
ac27a0ec 4619 if (!bh) {
c398eda0
TT
4620 EXT4_ERROR_INODE_BLOCK(inode, block,
4621 "unable to read itable block");
ac27a0ec
DK
4622 return -EIO;
4623 }
4624 if (!buffer_uptodate(bh)) {
4625 lock_buffer(bh);
9c83a923
HK
4626
4627 /*
4628 * If the buffer has the write error flag, we have failed
4629 * to write out another inode in the same block. In this
4630 * case, we don't have to read the block because we may
4631 * read the old inode data successfully.
4632 */
4633 if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
4634 set_buffer_uptodate(bh);
4635
ac27a0ec
DK
4636 if (buffer_uptodate(bh)) {
4637 /* someone brought it uptodate while we waited */
4638 unlock_buffer(bh);
4639 goto has_buffer;
4640 }
4641
4642 /*
4643 * If we have all information of the inode in memory and this
4644 * is the only valid inode in the block, we need not read the
4645 * block.
4646 */
4647 if (in_mem) {
4648 struct buffer_head *bitmap_bh;
240799cd 4649 int i, start;
ac27a0ec 4650
240799cd 4651 start = inode_offset & ~(inodes_per_block - 1);
ac27a0ec 4652
240799cd
TT
4653 /* Is the inode bitmap in cache? */
4654 bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
ac27a0ec
DK
4655 if (!bitmap_bh)
4656 goto make_io;
4657
4658 /*
4659 * If the inode bitmap isn't in cache then the
4660 * optimisation may end up performing two reads instead
4661 * of one, so skip it.
4662 */
4663 if (!buffer_uptodate(bitmap_bh)) {
4664 brelse(bitmap_bh);
4665 goto make_io;
4666 }
240799cd 4667 for (i = start; i < start + inodes_per_block; i++) {
ac27a0ec
DK
4668 if (i == inode_offset)
4669 continue;
617ba13b 4670 if (ext4_test_bit(i, bitmap_bh->b_data))
ac27a0ec
DK
4671 break;
4672 }
4673 brelse(bitmap_bh);
240799cd 4674 if (i == start + inodes_per_block) {
ac27a0ec
DK
4675 /* all other inodes are free, so skip I/O */
4676 memset(bh->b_data, 0, bh->b_size);
4677 set_buffer_uptodate(bh);
4678 unlock_buffer(bh);
4679 goto has_buffer;
4680 }
4681 }
4682
4683make_io:
240799cd
TT
4684 /*
4685 * If we need to do any I/O, try to pre-readahead extra
4686 * blocks from the inode table.
4687 */
4688 if (EXT4_SB(sb)->s_inode_readahead_blks) {
4689 ext4_fsblk_t b, end, table;
4690 unsigned num;
4691
4692 table = ext4_inode_table(sb, gdp);
b713a5ec 4693 /* s_inode_readahead_blks is always a power of 2 */
240799cd
TT
4694 b = block & ~(EXT4_SB(sb)->s_inode_readahead_blks-1);
4695 if (table > b)
4696 b = table;
4697 end = b + EXT4_SB(sb)->s_inode_readahead_blks;
4698 num = EXT4_INODES_PER_GROUP(sb);
4699 if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
4700 EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
560671a0 4701 num -= ext4_itable_unused_count(sb, gdp);
240799cd
TT
4702 table += num / inodes_per_block;
4703 if (end > table)
4704 end = table;
4705 while (b <= end)
4706 sb_breadahead(sb, b++);
4707 }
4708
ac27a0ec
DK
4709 /*
4710 * There are other valid inodes in the buffer, this inode
4711 * has in-inode xattrs, or we don't have this inode in memory.
4712 * Read the block from disk.
4713 */
4714 get_bh(bh);
4715 bh->b_end_io = end_buffer_read_sync;
4716 submit_bh(READ_META, bh);
4717 wait_on_buffer(bh);
4718 if (!buffer_uptodate(bh)) {
c398eda0
TT
4719 EXT4_ERROR_INODE_BLOCK(inode, block,
4720 "unable to read itable block");
ac27a0ec
DK
4721 brelse(bh);
4722 return -EIO;
4723 }
4724 }
4725has_buffer:
4726 iloc->bh = bh;
4727 return 0;
4728}
4729
617ba13b 4730int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
ac27a0ec
DK
4731{
4732 /* We have all inode data except xattrs in memory here. */
617ba13b 4733 return __ext4_get_inode_loc(inode, iloc,
19f5fb7a 4734 !ext4_test_inode_state(inode, EXT4_STATE_XATTR));
ac27a0ec
DK
4735}
4736
617ba13b 4737void ext4_set_inode_flags(struct inode *inode)
ac27a0ec 4738{
617ba13b 4739 unsigned int flags = EXT4_I(inode)->i_flags;
ac27a0ec
DK
4740
4741 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
617ba13b 4742 if (flags & EXT4_SYNC_FL)
ac27a0ec 4743 inode->i_flags |= S_SYNC;
617ba13b 4744 if (flags & EXT4_APPEND_FL)
ac27a0ec 4745 inode->i_flags |= S_APPEND;
617ba13b 4746 if (flags & EXT4_IMMUTABLE_FL)
ac27a0ec 4747 inode->i_flags |= S_IMMUTABLE;
617ba13b 4748 if (flags & EXT4_NOATIME_FL)
ac27a0ec 4749 inode->i_flags |= S_NOATIME;
617ba13b 4750 if (flags & EXT4_DIRSYNC_FL)
ac27a0ec
DK
4751 inode->i_flags |= S_DIRSYNC;
4752}
4753
ff9ddf7e
JK
4754/* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
4755void ext4_get_inode_flags(struct ext4_inode_info *ei)
4756{
84a8dce2
DM
4757 unsigned int vfs_fl;
4758 unsigned long old_fl, new_fl;
4759
4760 do {
4761 vfs_fl = ei->vfs_inode.i_flags;
4762 old_fl = ei->i_flags;
4763 new_fl = old_fl & ~(EXT4_SYNC_FL|EXT4_APPEND_FL|
4764 EXT4_IMMUTABLE_FL|EXT4_NOATIME_FL|
4765 EXT4_DIRSYNC_FL);
4766 if (vfs_fl & S_SYNC)
4767 new_fl |= EXT4_SYNC_FL;
4768 if (vfs_fl & S_APPEND)
4769 new_fl |= EXT4_APPEND_FL;
4770 if (vfs_fl & S_IMMUTABLE)
4771 new_fl |= EXT4_IMMUTABLE_FL;
4772 if (vfs_fl & S_NOATIME)
4773 new_fl |= EXT4_NOATIME_FL;
4774 if (vfs_fl & S_DIRSYNC)
4775 new_fl |= EXT4_DIRSYNC_FL;
4776 } while (cmpxchg(&ei->i_flags, old_fl, new_fl) != old_fl);
ff9ddf7e 4777}
de9a55b8 4778
0fc1b451 4779static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
de9a55b8 4780 struct ext4_inode_info *ei)
0fc1b451
AK
4781{
4782 blkcnt_t i_blocks ;
8180a562
AK
4783 struct inode *inode = &(ei->vfs_inode);
4784 struct super_block *sb = inode->i_sb;
0fc1b451
AK
4785
4786 if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
4787 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
4788 /* we are using combined 48 bit field */
4789 i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
4790 le32_to_cpu(raw_inode->i_blocks_lo);
07a03824 4791 if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) {
8180a562
AK
4792 /* i_blocks represent file system block size */
4793 return i_blocks << (inode->i_blkbits - 9);
4794 } else {
4795 return i_blocks;
4796 }
0fc1b451
AK
4797 } else {
4798 return le32_to_cpu(raw_inode->i_blocks_lo);
4799 }
4800}
ff9ddf7e 4801
1d1fe1ee 4802struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
ac27a0ec 4803{
617ba13b
MC
4804 struct ext4_iloc iloc;
4805 struct ext4_inode *raw_inode;
1d1fe1ee 4806 struct ext4_inode_info *ei;
1d1fe1ee 4807 struct inode *inode;
b436b9be 4808 journal_t *journal = EXT4_SB(sb)->s_journal;
1d1fe1ee 4809 long ret;
ac27a0ec
DK
4810 int block;
4811
1d1fe1ee
DH
4812 inode = iget_locked(sb, ino);
4813 if (!inode)
4814 return ERR_PTR(-ENOMEM);
4815 if (!(inode->i_state & I_NEW))
4816 return inode;
4817
4818 ei = EXT4_I(inode);
7dc57615 4819 iloc.bh = NULL;
ac27a0ec 4820
1d1fe1ee
DH
4821 ret = __ext4_get_inode_loc(inode, &iloc, 0);
4822 if (ret < 0)
ac27a0ec 4823 goto bad_inode;
617ba13b 4824 raw_inode = ext4_raw_inode(&iloc);
ac27a0ec
DK
4825 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
4826 inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
4827 inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
af5bc92d 4828 if (!(test_opt(inode->i_sb, NO_UID32))) {
ac27a0ec
DK
4829 inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
4830 inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
4831 }
4832 inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
ac27a0ec 4833
353eb83c 4834 ext4_clear_state_flags(ei); /* Only relevant on 32-bit archs */
ac27a0ec
DK
4835 ei->i_dir_start_lookup = 0;
4836 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
4837 /* We now have enough fields to check if the inode was active or not.
4838 * This is needed because nfsd might try to access dead inodes
4839 * the test is that same one that e2fsck uses
4840 * NeilBrown 1999oct15
4841 */
4842 if (inode->i_nlink == 0) {
4843 if (inode->i_mode == 0 ||
617ba13b 4844 !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
ac27a0ec 4845 /* this inode is deleted */
1d1fe1ee 4846 ret = -ESTALE;
ac27a0ec
DK
4847 goto bad_inode;
4848 }
4849 /* The only unlinked inodes we let through here have
4850 * valid i_mode and are being read by the orphan
4851 * recovery code: that's fine, we're about to complete
4852 * the process of deleting those. */
4853 }
ac27a0ec 4854 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
0fc1b451 4855 inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
7973c0c1 4856 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
a9e81742 4857 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT))
a1ddeb7e
BP
4858 ei->i_file_acl |=
4859 ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
a48380f7 4860 inode->i_size = ext4_isize(raw_inode);
ac27a0ec 4861 ei->i_disksize = inode->i_size;
a9e7f447
DM
4862#ifdef CONFIG_QUOTA
4863 ei->i_reserved_quota = 0;
4864#endif
ac27a0ec
DK
4865 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
4866 ei->i_block_group = iloc.block_group;
a4912123 4867 ei->i_last_alloc_group = ~0;
ac27a0ec
DK
4868 /*
4869 * NOTE! The in-memory inode i_data array is in little-endian order
4870 * even on big-endian machines: we do NOT byteswap the block numbers!
4871 */
617ba13b 4872 for (block = 0; block < EXT4_N_BLOCKS; block++)
ac27a0ec
DK
4873 ei->i_data[block] = raw_inode->i_block[block];
4874 INIT_LIST_HEAD(&ei->i_orphan);
4875
b436b9be
JK
4876 /*
4877 * Set transaction id's of transactions that have to be committed
4878 * to finish f[data]sync. We set them to currently running transaction
4879 * as we cannot be sure that the inode or some of its metadata isn't
4880 * part of the transaction - the inode could have been reclaimed and
4881 * now it is reread from disk.
4882 */
4883 if (journal) {
4884 transaction_t *transaction;
4885 tid_t tid;
4886
a931da6a 4887 read_lock(&journal->j_state_lock);
b436b9be
JK
4888 if (journal->j_running_transaction)
4889 transaction = journal->j_running_transaction;
4890 else
4891 transaction = journal->j_committing_transaction;
4892 if (transaction)
4893 tid = transaction->t_tid;
4894 else
4895 tid = journal->j_commit_sequence;
a931da6a 4896 read_unlock(&journal->j_state_lock);
b436b9be
JK
4897 ei->i_sync_tid = tid;
4898 ei->i_datasync_tid = tid;
4899 }
4900
0040d987 4901 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
ac27a0ec 4902 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
617ba13b 4903 if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
e5d2861f 4904 EXT4_INODE_SIZE(inode->i_sb)) {
1d1fe1ee 4905 ret = -EIO;
ac27a0ec 4906 goto bad_inode;
e5d2861f 4907 }
ac27a0ec
DK
4908 if (ei->i_extra_isize == 0) {
4909 /* The extra space is currently unused. Use it. */
617ba13b
MC
4910 ei->i_extra_isize = sizeof(struct ext4_inode) -
4911 EXT4_GOOD_OLD_INODE_SIZE;
ac27a0ec
DK
4912 } else {
4913 __le32 *magic = (void *)raw_inode +
617ba13b 4914 EXT4_GOOD_OLD_INODE_SIZE +
ac27a0ec 4915 ei->i_extra_isize;
617ba13b 4916 if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC))
19f5fb7a 4917 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
ac27a0ec
DK
4918 }
4919 } else
4920 ei->i_extra_isize = 0;
4921
ef7f3835
KS
4922 EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode);
4923 EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode);
4924 EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
4925 EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
4926
25ec56b5
JNC
4927 inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
4928 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
4929 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
4930 inode->i_version |=
4931 (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
4932 }
4933
c4b5a614 4934 ret = 0;
485c26ec 4935 if (ei->i_file_acl &&
1032988c 4936 !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
24676da4
TT
4937 EXT4_ERROR_INODE(inode, "bad extended attribute block %llu",
4938 ei->i_file_acl);
485c26ec
TT
4939 ret = -EIO;
4940 goto bad_inode;
07a03824 4941 } else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
c4b5a614
TT
4942 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
4943 (S_ISLNK(inode->i_mode) &&
4944 !ext4_inode_is_fast_symlink(inode)))
4945 /* Validate extent which is part of inode */
4946 ret = ext4_ext_check_inode(inode);
de9a55b8 4947 } else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
fe2c8191
TN
4948 (S_ISLNK(inode->i_mode) &&
4949 !ext4_inode_is_fast_symlink(inode))) {
de9a55b8 4950 /* Validate block references which are part of inode */
fe2c8191
TN
4951 ret = ext4_check_inode_blockref(inode);
4952 }
567f3e9a 4953 if (ret)
de9a55b8 4954 goto bad_inode;
7a262f7c 4955
ac27a0ec 4956 if (S_ISREG(inode->i_mode)) {
617ba13b
MC
4957 inode->i_op = &ext4_file_inode_operations;
4958 inode->i_fop = &ext4_file_operations;
4959 ext4_set_aops(inode);
ac27a0ec 4960 } else if (S_ISDIR(inode->i_mode)) {
617ba13b
MC
4961 inode->i_op = &ext4_dir_inode_operations;
4962 inode->i_fop = &ext4_dir_operations;
ac27a0ec 4963 } else if (S_ISLNK(inode->i_mode)) {
e83c1397 4964 if (ext4_inode_is_fast_symlink(inode)) {
617ba13b 4965 inode->i_op = &ext4_fast_symlink_inode_operations;
e83c1397
DG
4966 nd_terminate_link(ei->i_data, inode->i_size,
4967 sizeof(ei->i_data) - 1);
4968 } else {
617ba13b
MC
4969 inode->i_op = &ext4_symlink_inode_operations;
4970 ext4_set_aops(inode);
ac27a0ec 4971 }
563bdd61
TT
4972 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
4973 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
617ba13b 4974 inode->i_op = &ext4_special_inode_operations;
ac27a0ec
DK
4975 if (raw_inode->i_block[0])
4976 init_special_inode(inode, inode->i_mode,
4977 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
4978 else
4979 init_special_inode(inode, inode->i_mode,
4980 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
563bdd61 4981 } else {
563bdd61 4982 ret = -EIO;
24676da4 4983 EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode);
563bdd61 4984 goto bad_inode;
ac27a0ec 4985 }
af5bc92d 4986 brelse(iloc.bh);
617ba13b 4987 ext4_set_inode_flags(inode);
1d1fe1ee
DH
4988 unlock_new_inode(inode);
4989 return inode;
ac27a0ec
DK
4990
4991bad_inode:
567f3e9a 4992 brelse(iloc.bh);
1d1fe1ee
DH
4993 iget_failed(inode);
4994 return ERR_PTR(ret);
ac27a0ec
DK
4995}
4996
0fc1b451
AK
4997static int ext4_inode_blocks_set(handle_t *handle,
4998 struct ext4_inode *raw_inode,
4999 struct ext4_inode_info *ei)
5000{
5001 struct inode *inode = &(ei->vfs_inode);
5002 u64 i_blocks = inode->i_blocks;
5003 struct super_block *sb = inode->i_sb;
0fc1b451
AK
5004
5005 if (i_blocks <= ~0U) {
5006 /*
5007 * i_blocks can be represnted in a 32 bit variable
5008 * as multiple of 512 bytes
5009 */
8180a562 5010 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
0fc1b451 5011 raw_inode->i_blocks_high = 0;
84a8dce2 5012 ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
f287a1a5
TT
5013 return 0;
5014 }
5015 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE))
5016 return -EFBIG;
5017
5018 if (i_blocks <= 0xffffffffffffULL) {
0fc1b451
AK
5019 /*
5020 * i_blocks can be represented in a 48 bit variable
5021 * as multiple of 512 bytes
5022 */
8180a562 5023 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
0fc1b451 5024 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
84a8dce2 5025 ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
0fc1b451 5026 } else {
84a8dce2 5027 ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE);
8180a562
AK
5028 /* i_block is stored in file system block size */
5029 i_blocks = i_blocks >> (inode->i_blkbits - 9);
5030 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
5031 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
0fc1b451 5032 }
f287a1a5 5033 return 0;
0fc1b451
AK
5034}
5035
ac27a0ec
DK
5036/*
5037 * Post the struct inode info into an on-disk inode location in the
5038 * buffer-cache. This gobbles the caller's reference to the
5039 * buffer_head in the inode location struct.
5040 *
5041 * The caller must have write access to iloc->bh.
5042 */
617ba13b 5043static int ext4_do_update_inode(handle_t *handle,
ac27a0ec 5044 struct inode *inode,
830156c7 5045 struct ext4_iloc *iloc)
ac27a0ec 5046{
617ba13b
MC
5047 struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
5048 struct ext4_inode_info *ei = EXT4_I(inode);
ac27a0ec
DK
5049 struct buffer_head *bh = iloc->bh;
5050 int err = 0, rc, block;
5051
5052 /* For fields not not tracking in the in-memory inode,
5053 * initialise them to zero for new inodes. */
19f5fb7a 5054 if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
617ba13b 5055 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
ac27a0ec 5056
ff9ddf7e 5057 ext4_get_inode_flags(ei);
ac27a0ec 5058 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
af5bc92d 5059 if (!(test_opt(inode->i_sb, NO_UID32))) {
ac27a0ec
DK
5060 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
5061 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
5062/*
5063 * Fix up interoperability with old kernels. Otherwise, old inodes get
5064 * re-used with the upper 16 bits of the uid/gid intact
5065 */
af5bc92d 5066 if (!ei->i_dtime) {
ac27a0ec
DK
5067 raw_inode->i_uid_high =
5068 cpu_to_le16(high_16_bits(inode->i_uid));
5069 raw_inode->i_gid_high =
5070 cpu_to_le16(high_16_bits(inode->i_gid));
5071 } else {
5072 raw_inode->i_uid_high = 0;
5073 raw_inode->i_gid_high = 0;
5074 }
5075 } else {
5076 raw_inode->i_uid_low =
5077 cpu_to_le16(fs_high2lowuid(inode->i_uid));
5078 raw_inode->i_gid_low =
5079 cpu_to_le16(fs_high2lowgid(inode->i_gid));
5080 raw_inode->i_uid_high = 0;
5081 raw_inode->i_gid_high = 0;
5082 }
5083 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
ef7f3835
KS
5084
5085 EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
5086 EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
5087 EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
5088 EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
5089
0fc1b451
AK
5090 if (ext4_inode_blocks_set(handle, raw_inode, ei))
5091 goto out_brelse;
ac27a0ec 5092 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
353eb83c 5093 raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF);
9b8f1f01
MC
5094 if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
5095 cpu_to_le32(EXT4_OS_HURD))
a1ddeb7e
BP
5096 raw_inode->i_file_acl_high =
5097 cpu_to_le16(ei->i_file_acl >> 32);
7973c0c1 5098 raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
a48380f7
AK
5099 ext4_isize_set(raw_inode, ei->i_disksize);
5100 if (ei->i_disksize > 0x7fffffffULL) {
5101 struct super_block *sb = inode->i_sb;
5102 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
5103 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
5104 EXT4_SB(sb)->s_es->s_rev_level ==
5105 cpu_to_le32(EXT4_GOOD_OLD_REV)) {
5106 /* If this is the first large file
5107 * created, add a flag to the superblock.
5108 */
5109 err = ext4_journal_get_write_access(handle,
5110 EXT4_SB(sb)->s_sbh);
5111 if (err)
5112 goto out_brelse;
5113 ext4_update_dynamic_rev(sb);
5114 EXT4_SET_RO_COMPAT_FEATURE(sb,
617ba13b 5115 EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
a48380f7 5116 sb->s_dirt = 1;
0390131b 5117 ext4_handle_sync(handle);
73b50c1c 5118 err = ext4_handle_dirty_metadata(handle, NULL,
a48380f7 5119 EXT4_SB(sb)->s_sbh);
ac27a0ec
DK
5120 }
5121 }
5122 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
5123 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
5124 if (old_valid_dev(inode->i_rdev)) {
5125 raw_inode->i_block[0] =
5126 cpu_to_le32(old_encode_dev(inode->i_rdev));
5127 raw_inode->i_block[1] = 0;
5128 } else {
5129 raw_inode->i_block[0] = 0;
5130 raw_inode->i_block[1] =
5131 cpu_to_le32(new_encode_dev(inode->i_rdev));
5132 raw_inode->i_block[2] = 0;
5133 }
de9a55b8
TT
5134 } else
5135 for (block = 0; block < EXT4_N_BLOCKS; block++)
5136 raw_inode->i_block[block] = ei->i_data[block];
ac27a0ec 5137
25ec56b5
JNC
5138 raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
5139 if (ei->i_extra_isize) {
5140 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
5141 raw_inode->i_version_hi =
5142 cpu_to_le32(inode->i_version >> 32);
ac27a0ec 5143 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
25ec56b5
JNC
5144 }
5145
830156c7 5146 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
73b50c1c 5147 rc = ext4_handle_dirty_metadata(handle, NULL, bh);
830156c7
FM
5148 if (!err)
5149 err = rc;
19f5fb7a 5150 ext4_clear_inode_state(inode, EXT4_STATE_NEW);
ac27a0ec 5151
b436b9be 5152 ext4_update_inode_fsync_trans(handle, inode, 0);
ac27a0ec 5153out_brelse:
af5bc92d 5154 brelse(bh);
617ba13b 5155 ext4_std_error(inode->i_sb, err);
ac27a0ec
DK
5156 return err;
5157}
5158
5159/*
617ba13b 5160 * ext4_write_inode()
ac27a0ec
DK
5161 *
5162 * We are called from a few places:
5163 *
5164 * - Within generic_file_write() for O_SYNC files.
5165 * Here, there will be no transaction running. We wait for any running
5166 * trasnaction to commit.
5167 *
5168 * - Within sys_sync(), kupdate and such.
5169 * We wait on commit, if tol to.
5170 *
5171 * - Within prune_icache() (PF_MEMALLOC == true)
5172 * Here we simply return. We can't afford to block kswapd on the
5173 * journal commit.
5174 *
5175 * In all cases it is actually safe for us to return without doing anything,
5176 * because the inode has been copied into a raw inode buffer in
617ba13b 5177 * ext4_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
ac27a0ec
DK
5178 * knfsd.
5179 *
5180 * Note that we are absolutely dependent upon all inode dirtiers doing the
5181 * right thing: they *must* call mark_inode_dirty() after dirtying info in
5182 * which we are interested.
5183 *
5184 * It would be a bug for them to not do this. The code:
5185 *
5186 * mark_inode_dirty(inode)
5187 * stuff();
5188 * inode->i_size = expr;
5189 *
5190 * is in error because a kswapd-driven write_inode() could occur while
5191 * `stuff()' is running, and the new i_size will be lost. Plus the inode
5192 * will no longer be on the superblock's dirty inode list.
5193 */
a9185b41 5194int ext4_write_inode(struct inode *inode, struct writeback_control *wbc)
ac27a0ec 5195{
91ac6f43
FM
5196 int err;
5197
ac27a0ec
DK
5198 if (current->flags & PF_MEMALLOC)
5199 return 0;
5200
91ac6f43
FM
5201 if (EXT4_SB(inode->i_sb)->s_journal) {
5202 if (ext4_journal_current_handle()) {
5203 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
5204 dump_stack();
5205 return -EIO;
5206 }
ac27a0ec 5207
a9185b41 5208 if (wbc->sync_mode != WB_SYNC_ALL)
91ac6f43
FM
5209 return 0;
5210
5211 err = ext4_force_commit(inode->i_sb);
5212 } else {
5213 struct ext4_iloc iloc;
ac27a0ec 5214
8b472d73 5215 err = __ext4_get_inode_loc(inode, &iloc, 0);
91ac6f43
FM
5216 if (err)
5217 return err;
a9185b41 5218 if (wbc->sync_mode == WB_SYNC_ALL)
830156c7
FM
5219 sync_dirty_buffer(iloc.bh);
5220 if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
c398eda0
TT
5221 EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr,
5222 "IO error syncing inode");
830156c7
FM
5223 err = -EIO;
5224 }
fd2dd9fb 5225 brelse(iloc.bh);
91ac6f43
FM
5226 }
5227 return err;
ac27a0ec
DK
5228}
5229
5230/*
617ba13b 5231 * ext4_setattr()
ac27a0ec
DK
5232 *
5233 * Called from notify_change.
5234 *
5235 * We want to trap VFS attempts to truncate the file as soon as
5236 * possible. In particular, we want to make sure that when the VFS
5237 * shrinks i_size, we put the inode on the orphan list and modify
5238 * i_disksize immediately, so that during the subsequent flushing of
5239 * dirty pages and freeing of disk blocks, we can guarantee that any
5240 * commit will leave the blocks being flushed in an unused state on
5241 * disk. (On recovery, the inode will get truncated and the blocks will
5242 * be freed, so we have a strong guarantee that no future commit will
5243 * leave these blocks visible to the user.)
5244 *
678aaf48
JK
5245 * Another thing we have to assure is that if we are in ordered mode
5246 * and inode is still attached to the committing transaction, we must
5247 * we start writeout of all the dirty pages which are being truncated.
5248 * This way we are sure that all the data written in the previous
5249 * transaction are already on disk (truncate waits for pages under
5250 * writeback).
5251 *
5252 * Called with inode->i_mutex down.
ac27a0ec 5253 */
617ba13b 5254int ext4_setattr(struct dentry *dentry, struct iattr *attr)
ac27a0ec
DK
5255{
5256 struct inode *inode = dentry->d_inode;
5257 int error, rc = 0;
3d287de3 5258 int orphan = 0;
ac27a0ec
DK
5259 const unsigned int ia_valid = attr->ia_valid;
5260
5261 error = inode_change_ok(inode, attr);
5262 if (error)
5263 return error;
5264
12755627 5265 if (is_quota_modification(inode, attr))
871a2931 5266 dquot_initialize(inode);
ac27a0ec
DK
5267 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
5268 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
5269 handle_t *handle;
5270
5271 /* (user+group)*(old+new) structure, inode write (sb,
5272 * inode block, ? - but truncate inode update has it) */
5aca07eb 5273 handle = ext4_journal_start(inode, (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
194074ac 5274 EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb))+3);
ac27a0ec
DK
5275 if (IS_ERR(handle)) {
5276 error = PTR_ERR(handle);
5277 goto err_out;
5278 }
b43fa828 5279 error = dquot_transfer(inode, attr);
ac27a0ec 5280 if (error) {
617ba13b 5281 ext4_journal_stop(handle);
ac27a0ec
DK
5282 return error;
5283 }
5284 /* Update corresponding info in inode so that everything is in
5285 * one transaction */
5286 if (attr->ia_valid & ATTR_UID)
5287 inode->i_uid = attr->ia_uid;
5288 if (attr->ia_valid & ATTR_GID)
5289 inode->i_gid = attr->ia_gid;
617ba13b
MC
5290 error = ext4_mark_inode_dirty(handle, inode);
5291 ext4_journal_stop(handle);
ac27a0ec
DK
5292 }
5293
e2b46574 5294 if (attr->ia_valid & ATTR_SIZE) {
12e9b892 5295 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
e2b46574
ES
5296 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
5297
0c095c7f
TT
5298 if (attr->ia_size > sbi->s_bitmap_maxbytes)
5299 return -EFBIG;
e2b46574
ES
5300 }
5301 }
5302
ac27a0ec 5303 if (S_ISREG(inode->i_mode) &&
c8d46e41
JZ
5304 attr->ia_valid & ATTR_SIZE &&
5305 (attr->ia_size < inode->i_size ||
12e9b892 5306 (ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS)))) {
ac27a0ec
DK
5307 handle_t *handle;
5308
617ba13b 5309 handle = ext4_journal_start(inode, 3);
ac27a0ec
DK
5310 if (IS_ERR(handle)) {
5311 error = PTR_ERR(handle);
5312 goto err_out;
5313 }
3d287de3
DM
5314 if (ext4_handle_valid(handle)) {
5315 error = ext4_orphan_add(handle, inode);
5316 orphan = 1;
5317 }
617ba13b
MC
5318 EXT4_I(inode)->i_disksize = attr->ia_size;
5319 rc = ext4_mark_inode_dirty(handle, inode);
ac27a0ec
DK
5320 if (!error)
5321 error = rc;
617ba13b 5322 ext4_journal_stop(handle);
678aaf48
JK
5323
5324 if (ext4_should_order_data(inode)) {
5325 error = ext4_begin_ordered_truncate(inode,
5326 attr->ia_size);
5327 if (error) {
5328 /* Do as much error cleanup as possible */
5329 handle = ext4_journal_start(inode, 3);
5330 if (IS_ERR(handle)) {
5331 ext4_orphan_del(NULL, inode);
5332 goto err_out;
5333 }
5334 ext4_orphan_del(handle, inode);
3d287de3 5335 orphan = 0;
678aaf48
JK
5336 ext4_journal_stop(handle);
5337 goto err_out;
5338 }
5339 }
c8d46e41 5340 /* ext4_truncate will clear the flag */
12e9b892 5341 if ((ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS)))
c8d46e41 5342 ext4_truncate(inode);
ac27a0ec
DK
5343 }
5344
1025774c
CH
5345 if ((attr->ia_valid & ATTR_SIZE) &&
5346 attr->ia_size != i_size_read(inode))
5347 rc = vmtruncate(inode, attr->ia_size);
ac27a0ec 5348
1025774c
CH
5349 if (!rc) {
5350 setattr_copy(inode, attr);
5351 mark_inode_dirty(inode);
5352 }
5353
5354 /*
5355 * If the call to ext4_truncate failed to get a transaction handle at
5356 * all, we need to clean up the in-core orphan list manually.
5357 */
3d287de3 5358 if (orphan && inode->i_nlink)
617ba13b 5359 ext4_orphan_del(NULL, inode);
ac27a0ec
DK
5360
5361 if (!rc && (ia_valid & ATTR_MODE))
617ba13b 5362 rc = ext4_acl_chmod(inode);
ac27a0ec
DK
5363
5364err_out:
617ba13b 5365 ext4_std_error(inode->i_sb, error);
ac27a0ec
DK
5366 if (!error)
5367 error = rc;
5368 return error;
5369}
5370
3e3398a0
MC
5371int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
5372 struct kstat *stat)
5373{
5374 struct inode *inode;
5375 unsigned long delalloc_blocks;
5376
5377 inode = dentry->d_inode;
5378 generic_fillattr(inode, stat);
5379
5380 /*
5381 * We can't update i_blocks if the block allocation is delayed
5382 * otherwise in the case of system crash before the real block
5383 * allocation is done, we will have i_blocks inconsistent with
5384 * on-disk file blocks.
5385 * We always keep i_blocks updated together with real
5386 * allocation. But to not confuse with user, stat
5387 * will return the blocks that include the delayed allocation
5388 * blocks for this file.
5389 */
3e3398a0 5390 delalloc_blocks = EXT4_I(inode)->i_reserved_data_blocks;
3e3398a0
MC
5391
5392 stat->blocks += (delalloc_blocks << inode->i_sb->s_blocksize_bits)>>9;
5393 return 0;
5394}
ac27a0ec 5395
a02908f1
MC
5396static int ext4_indirect_trans_blocks(struct inode *inode, int nrblocks,
5397 int chunk)
5398{
5399 int indirects;
5400
5401 /* if nrblocks are contiguous */
5402 if (chunk) {
5403 /*
5404 * With N contiguous data blocks, it need at most
5405 * N/EXT4_ADDR_PER_BLOCK(inode->i_sb) indirect blocks
5406 * 2 dindirect blocks
5407 * 1 tindirect block
5408 */
5409 indirects = nrblocks / EXT4_ADDR_PER_BLOCK(inode->i_sb);
5410 return indirects + 3;
5411 }
5412 /*
5413 * if nrblocks are not contiguous, worse case, each block touch
5414 * a indirect block, and each indirect block touch a double indirect
5415 * block, plus a triple indirect block
5416 */
5417 indirects = nrblocks * 2 + 1;
5418 return indirects;
5419}
5420
5421static int ext4_index_trans_blocks(struct inode *inode, int nrblocks, int chunk)
5422{
12e9b892 5423 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
ac51d837
TT
5424 return ext4_indirect_trans_blocks(inode, nrblocks, chunk);
5425 return ext4_ext_index_trans_blocks(inode, nrblocks, chunk);
a02908f1 5426}
ac51d837 5427
ac27a0ec 5428/*
a02908f1
MC
5429 * Account for index blocks, block groups bitmaps and block group
5430 * descriptor blocks if modify datablocks and index blocks
5431 * worse case, the indexs blocks spread over different block groups
ac27a0ec 5432 *
a02908f1 5433 * If datablocks are discontiguous, they are possible to spread over
af901ca1 5434 * different block groups too. If they are contiuguous, with flexbg,
a02908f1 5435 * they could still across block group boundary.
ac27a0ec 5436 *
a02908f1
MC
5437 * Also account for superblock, inode, quota and xattr blocks
5438 */
1f109d5a 5439static int ext4_meta_trans_blocks(struct inode *inode, int nrblocks, int chunk)
a02908f1 5440{
8df9675f
TT
5441 ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
5442 int gdpblocks;
a02908f1
MC
5443 int idxblocks;
5444 int ret = 0;
5445
5446 /*
5447 * How many index blocks need to touch to modify nrblocks?
5448 * The "Chunk" flag indicating whether the nrblocks is
5449 * physically contiguous on disk
5450 *
5451 * For Direct IO and fallocate, they calls get_block to allocate
5452 * one single extent at a time, so they could set the "Chunk" flag
5453 */
5454 idxblocks = ext4_index_trans_blocks(inode, nrblocks, chunk);
5455
5456 ret = idxblocks;
5457
5458 /*
5459 * Now let's see how many group bitmaps and group descriptors need
5460 * to account
5461 */
5462 groups = idxblocks;
5463 if (chunk)
5464 groups += 1;
5465 else
5466 groups += nrblocks;
5467
5468 gdpblocks = groups;
8df9675f
TT
5469 if (groups > ngroups)
5470 groups = ngroups;
a02908f1
MC
5471 if (groups > EXT4_SB(inode->i_sb)->s_gdb_count)
5472 gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count;
5473
5474 /* bitmaps and block group descriptor blocks */
5475 ret += groups + gdpblocks;
5476
5477 /* Blocks for super block, inode, quota and xattr blocks */
5478 ret += EXT4_META_TRANS_BLOCKS(inode->i_sb);
5479
5480 return ret;
5481}
5482
5483/*
5484 * Calulate the total number of credits to reserve to fit
f3bd1f3f
MC
5485 * the modification of a single pages into a single transaction,
5486 * which may include multiple chunks of block allocations.
ac27a0ec 5487 *
525f4ed8 5488 * This could be called via ext4_write_begin()
ac27a0ec 5489 *
525f4ed8 5490 * We need to consider the worse case, when
a02908f1 5491 * one new block per extent.
ac27a0ec 5492 */
a86c6181 5493int ext4_writepage_trans_blocks(struct inode *inode)
ac27a0ec 5494{
617ba13b 5495 int bpp = ext4_journal_blocks_per_page(inode);
ac27a0ec
DK
5496 int ret;
5497
a02908f1 5498 ret = ext4_meta_trans_blocks(inode, bpp, 0);
a86c6181 5499
a02908f1 5500 /* Account for data blocks for journalled mode */
617ba13b 5501 if (ext4_should_journal_data(inode))
a02908f1 5502 ret += bpp;
ac27a0ec
DK
5503 return ret;
5504}
f3bd1f3f
MC
5505
5506/*
5507 * Calculate the journal credits for a chunk of data modification.
5508 *
5509 * This is called from DIO, fallocate or whoever calling
79e83036 5510 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
f3bd1f3f
MC
5511 *
5512 * journal buffers for data blocks are not included here, as DIO
5513 * and fallocate do no need to journal data buffers.
5514 */
5515int ext4_chunk_trans_blocks(struct inode *inode, int nrblocks)
5516{
5517 return ext4_meta_trans_blocks(inode, nrblocks, 1);
5518}
5519
ac27a0ec 5520/*
617ba13b 5521 * The caller must have previously called ext4_reserve_inode_write().
ac27a0ec
DK
5522 * Give this, we know that the caller already has write access to iloc->bh.
5523 */
617ba13b 5524int ext4_mark_iloc_dirty(handle_t *handle,
de9a55b8 5525 struct inode *inode, struct ext4_iloc *iloc)
ac27a0ec
DK
5526{
5527 int err = 0;
5528
25ec56b5
JNC
5529 if (test_opt(inode->i_sb, I_VERSION))
5530 inode_inc_iversion(inode);
5531
ac27a0ec
DK
5532 /* the do_update_inode consumes one bh->b_count */
5533 get_bh(iloc->bh);
5534
dab291af 5535 /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
830156c7 5536 err = ext4_do_update_inode(handle, inode, iloc);
ac27a0ec
DK
5537 put_bh(iloc->bh);
5538 return err;
5539}
5540
5541/*
5542 * On success, We end up with an outstanding reference count against
5543 * iloc->bh. This _must_ be cleaned up later.
5544 */
5545
5546int
617ba13b
MC
5547ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
5548 struct ext4_iloc *iloc)
ac27a0ec 5549{
0390131b
FM
5550 int err;
5551
5552 err = ext4_get_inode_loc(inode, iloc);
5553 if (!err) {
5554 BUFFER_TRACE(iloc->bh, "get_write_access");
5555 err = ext4_journal_get_write_access(handle, iloc->bh);
5556 if (err) {
5557 brelse(iloc->bh);
5558 iloc->bh = NULL;
ac27a0ec
DK
5559 }
5560 }
617ba13b 5561 ext4_std_error(inode->i_sb, err);
ac27a0ec
DK
5562 return err;
5563}
5564
6dd4ee7c
KS
5565/*
5566 * Expand an inode by new_extra_isize bytes.
5567 * Returns 0 on success or negative error number on failure.
5568 */
1d03ec98
AK
5569static int ext4_expand_extra_isize(struct inode *inode,
5570 unsigned int new_extra_isize,
5571 struct ext4_iloc iloc,
5572 handle_t *handle)
6dd4ee7c
KS
5573{
5574 struct ext4_inode *raw_inode;
5575 struct ext4_xattr_ibody_header *header;
6dd4ee7c
KS
5576
5577 if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
5578 return 0;
5579
5580 raw_inode = ext4_raw_inode(&iloc);
5581
5582 header = IHDR(inode, raw_inode);
6dd4ee7c
KS
5583
5584 /* No extended attributes present */
19f5fb7a
TT
5585 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
5586 header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
6dd4ee7c
KS
5587 memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0,
5588 new_extra_isize);
5589 EXT4_I(inode)->i_extra_isize = new_extra_isize;
5590 return 0;
5591 }
5592
5593 /* try to expand with EAs present */
5594 return ext4_expand_extra_isize_ea(inode, new_extra_isize,
5595 raw_inode, handle);
5596}
5597
ac27a0ec
DK
5598/*
5599 * What we do here is to mark the in-core inode as clean with respect to inode
5600 * dirtiness (it may still be data-dirty).
5601 * This means that the in-core inode may be reaped by prune_icache
5602 * without having to perform any I/O. This is a very good thing,
5603 * because *any* task may call prune_icache - even ones which
5604 * have a transaction open against a different journal.
5605 *
5606 * Is this cheating? Not really. Sure, we haven't written the
5607 * inode out, but prune_icache isn't a user-visible syncing function.
5608 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
5609 * we start and wait on commits.
5610 *
5611 * Is this efficient/effective? Well, we're being nice to the system
5612 * by cleaning up our inodes proactively so they can be reaped
5613 * without I/O. But we are potentially leaving up to five seconds'
5614 * worth of inodes floating about which prune_icache wants us to
5615 * write out. One way to fix that would be to get prune_icache()
5616 * to do a write_super() to free up some memory. It has the desired
5617 * effect.
5618 */
617ba13b 5619int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
ac27a0ec 5620{
617ba13b 5621 struct ext4_iloc iloc;
6dd4ee7c
KS
5622 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
5623 static unsigned int mnt_count;
5624 int err, ret;
ac27a0ec
DK
5625
5626 might_sleep();
7ff9c073 5627 trace_ext4_mark_inode_dirty(inode, _RET_IP_);
617ba13b 5628 err = ext4_reserve_inode_write(handle, inode, &iloc);
0390131b
FM
5629 if (ext4_handle_valid(handle) &&
5630 EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize &&
19f5fb7a 5631 !ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND)) {
6dd4ee7c
KS
5632 /*
5633 * We need extra buffer credits since we may write into EA block
5634 * with this same handle. If journal_extend fails, then it will
5635 * only result in a minor loss of functionality for that inode.
5636 * If this is felt to be critical, then e2fsck should be run to
5637 * force a large enough s_min_extra_isize.
5638 */
5639 if ((jbd2_journal_extend(handle,
5640 EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
5641 ret = ext4_expand_extra_isize(inode,
5642 sbi->s_want_extra_isize,
5643 iloc, handle);
5644 if (ret) {
19f5fb7a
TT
5645 ext4_set_inode_state(inode,
5646 EXT4_STATE_NO_EXPAND);
c1bddad9
AK
5647 if (mnt_count !=
5648 le16_to_cpu(sbi->s_es->s_mnt_count)) {
12062ddd 5649 ext4_warning(inode->i_sb,
6dd4ee7c
KS
5650 "Unable to expand inode %lu. Delete"
5651 " some EAs or run e2fsck.",
5652 inode->i_ino);
c1bddad9
AK
5653 mnt_count =
5654 le16_to_cpu(sbi->s_es->s_mnt_count);
6dd4ee7c
KS
5655 }
5656 }
5657 }
5658 }
ac27a0ec 5659 if (!err)
617ba13b 5660 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
ac27a0ec
DK
5661 return err;
5662}
5663
5664/*
617ba13b 5665 * ext4_dirty_inode() is called from __mark_inode_dirty()
ac27a0ec
DK
5666 *
5667 * We're really interested in the case where a file is being extended.
5668 * i_size has been changed by generic_commit_write() and we thus need
5669 * to include the updated inode in the current transaction.
5670 *
5dd4056d 5671 * Also, dquot_alloc_block() will always dirty the inode when blocks
ac27a0ec
DK
5672 * are allocated to the file.
5673 *
5674 * If the inode is marked synchronous, we don't honour that here - doing
5675 * so would cause a commit on atime updates, which we don't bother doing.
5676 * We handle synchronous inodes at the highest possible level.
5677 */
617ba13b 5678void ext4_dirty_inode(struct inode *inode)
ac27a0ec 5679{
ac27a0ec
DK
5680 handle_t *handle;
5681
617ba13b 5682 handle = ext4_journal_start(inode, 2);
ac27a0ec
DK
5683 if (IS_ERR(handle))
5684 goto out;
f3dc272f 5685
f3dc272f
CW
5686 ext4_mark_inode_dirty(handle, inode);
5687
617ba13b 5688 ext4_journal_stop(handle);
ac27a0ec
DK
5689out:
5690 return;
5691}
5692
5693#if 0
5694/*
5695 * Bind an inode's backing buffer_head into this transaction, to prevent
5696 * it from being flushed to disk early. Unlike
617ba13b 5697 * ext4_reserve_inode_write, this leaves behind no bh reference and
ac27a0ec
DK
5698 * returns no iloc structure, so the caller needs to repeat the iloc
5699 * lookup to mark the inode dirty later.
5700 */
617ba13b 5701static int ext4_pin_inode(handle_t *handle, struct inode *inode)
ac27a0ec 5702{
617ba13b 5703 struct ext4_iloc iloc;
ac27a0ec
DK
5704
5705 int err = 0;
5706 if (handle) {
617ba13b 5707 err = ext4_get_inode_loc(inode, &iloc);
ac27a0ec
DK
5708 if (!err) {
5709 BUFFER_TRACE(iloc.bh, "get_write_access");
dab291af 5710 err = jbd2_journal_get_write_access(handle, iloc.bh);
ac27a0ec 5711 if (!err)
0390131b 5712 err = ext4_handle_dirty_metadata(handle,
73b50c1c 5713 NULL,
0390131b 5714 iloc.bh);
ac27a0ec
DK
5715 brelse(iloc.bh);
5716 }
5717 }
617ba13b 5718 ext4_std_error(inode->i_sb, err);
ac27a0ec
DK
5719 return err;
5720}
5721#endif
5722
617ba13b 5723int ext4_change_inode_journal_flag(struct inode *inode, int val)
ac27a0ec
DK
5724{
5725 journal_t *journal;
5726 handle_t *handle;
5727 int err;
5728
5729 /*
5730 * We have to be very careful here: changing a data block's
5731 * journaling status dynamically is dangerous. If we write a
5732 * data block to the journal, change the status and then delete
5733 * that block, we risk forgetting to revoke the old log record
5734 * from the journal and so a subsequent replay can corrupt data.
5735 * So, first we make sure that the journal is empty and that
5736 * nobody is changing anything.
5737 */
5738
617ba13b 5739 journal = EXT4_JOURNAL(inode);
0390131b
FM
5740 if (!journal)
5741 return 0;
d699594d 5742 if (is_journal_aborted(journal))
ac27a0ec
DK
5743 return -EROFS;
5744
dab291af
MC
5745 jbd2_journal_lock_updates(journal);
5746 jbd2_journal_flush(journal);
ac27a0ec
DK
5747
5748 /*
5749 * OK, there are no updates running now, and all cached data is
5750 * synced to disk. We are now in a completely consistent state
5751 * which doesn't have anything in the journal, and we know that
5752 * no filesystem updates are running, so it is safe to modify
5753 * the inode's in-core data-journaling state flag now.
5754 */
5755
5756 if (val)
12e9b892 5757 ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
ac27a0ec 5758 else
12e9b892 5759 ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
617ba13b 5760 ext4_set_aops(inode);
ac27a0ec 5761
dab291af 5762 jbd2_journal_unlock_updates(journal);
ac27a0ec
DK
5763
5764 /* Finally we can mark the inode as dirty. */
5765
617ba13b 5766 handle = ext4_journal_start(inode, 1);
ac27a0ec
DK
5767 if (IS_ERR(handle))
5768 return PTR_ERR(handle);
5769
617ba13b 5770 err = ext4_mark_inode_dirty(handle, inode);
0390131b 5771 ext4_handle_sync(handle);
617ba13b
MC
5772 ext4_journal_stop(handle);
5773 ext4_std_error(inode->i_sb, err);
ac27a0ec
DK
5774
5775 return err;
5776}
2e9ee850
AK
5777
5778static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh)
5779{
5780 return !buffer_mapped(bh);
5781}
5782
c2ec175c 5783int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2e9ee850 5784{
c2ec175c 5785 struct page *page = vmf->page;
2e9ee850
AK
5786 loff_t size;
5787 unsigned long len;
5788 int ret = -EINVAL;
79f0be8d 5789 void *fsdata;
2e9ee850
AK
5790 struct file *file = vma->vm_file;
5791 struct inode *inode = file->f_path.dentry->d_inode;
5792 struct address_space *mapping = inode->i_mapping;
5793
5794 /*
5795 * Get i_alloc_sem to stop truncates messing with the inode. We cannot
5796 * get i_mutex because we are already holding mmap_sem.
5797 */
5798 down_read(&inode->i_alloc_sem);
5799 size = i_size_read(inode);
5800 if (page->mapping != mapping || size <= page_offset(page)
5801 || !PageUptodate(page)) {
5802 /* page got truncated from under us? */
5803 goto out_unlock;
5804 }
5805 ret = 0;
5806 if (PageMappedToDisk(page))
5807 goto out_unlock;
5808
5809 if (page->index == size >> PAGE_CACHE_SHIFT)
5810 len = size & ~PAGE_CACHE_MASK;
5811 else
5812 len = PAGE_CACHE_SIZE;
5813
a827eaff
AK
5814 lock_page(page);
5815 /*
5816 * return if we have all the buffers mapped. This avoid
5817 * the need to call write_begin/write_end which does a
5818 * journal_start/journal_stop which can block and take
5819 * long time
5820 */
2e9ee850 5821 if (page_has_buffers(page)) {
2e9ee850 5822 if (!walk_page_buffers(NULL, page_buffers(page), 0, len, NULL,
a827eaff
AK
5823 ext4_bh_unmapped)) {
5824 unlock_page(page);
2e9ee850 5825 goto out_unlock;
a827eaff 5826 }
2e9ee850 5827 }
a827eaff 5828 unlock_page(page);
2e9ee850
AK
5829 /*
5830 * OK, we need to fill the hole... Do write_begin write_end
5831 * to do block allocation/reservation.We are not holding
5832 * inode.i__mutex here. That allow * parallel write_begin,
5833 * write_end call. lock_page prevent this from happening
5834 * on the same page though
5835 */
5836 ret = mapping->a_ops->write_begin(file, mapping, page_offset(page),
79f0be8d 5837 len, AOP_FLAG_UNINTERRUPTIBLE, &page, &fsdata);
2e9ee850
AK
5838 if (ret < 0)
5839 goto out_unlock;
5840 ret = mapping->a_ops->write_end(file, mapping, page_offset(page),
79f0be8d 5841 len, len, page, fsdata);
2e9ee850
AK
5842 if (ret < 0)
5843 goto out_unlock;
5844 ret = 0;
5845out_unlock:
c2ec175c
NP
5846 if (ret)
5847 ret = VM_FAULT_SIGBUS;
2e9ee850
AK
5848 up_read(&inode->i_alloc_sem);
5849 return ret;
5850}