Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
inode.c
Go to the documentation of this file.
1 /*
2  * linux/fs/ext4/inode.c
3  *
4  * Copyright (C) 1992, 1993, 1994, 1995
5  * Remy Card ([email protected])
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  * 64-bit file support on 64-bit platforms by Jakub Jelinek
17  *
18  * Assorted race fixes, rewrite of ext4_get_block() by Al Viro, 2000
19  */
20 
21 #include <linux/fs.h>
22 #include <linux/time.h>
23 #include <linux/jbd2.h>
24 #include <linux/highuid.h>
25 #include <linux/pagemap.h>
26 #include <linux/quotaops.h>
27 #include <linux/string.h>
28 #include <linux/buffer_head.h>
29 #include <linux/writeback.h>
30 #include <linux/pagevec.h>
31 #include <linux/mpage.h>
32 #include <linux/namei.h>
33 #include <linux/uio.h>
34 #include <linux/bio.h>
35 #include <linux/workqueue.h>
36 #include <linux/kernel.h>
37 #include <linux/printk.h>
38 #include <linux/slab.h>
39 #include <linux/ratelimit.h>
40 
41 #include "ext4_jbd2.h"
42 #include "xattr.h"
43 #include "acl.h"
44 #include "truncate.h"
45 
46 #include <trace/events/ext4.h>
47 
48 #define MPAGE_DA_EXTENT_TAIL 0x01
49 
50 static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw,
51  struct ext4_inode_info *ei)
52 {
53  struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
54  __u16 csum_lo;
55  __u16 csum_hi = 0;
56  __u32 csum;
57 
58  csum_lo = raw->i_checksum_lo;
59  raw->i_checksum_lo = 0;
61  EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) {
62  csum_hi = raw->i_checksum_hi;
63  raw->i_checksum_hi = 0;
64  }
65 
66  csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)raw,
67  EXT4_INODE_SIZE(inode->i_sb));
68 
69  raw->i_checksum_lo = csum_lo;
71  EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))
72  raw->i_checksum_hi = csum_hi;
73 
74  return csum;
75 }
76 
77 static int ext4_inode_csum_verify(struct inode *inode, struct ext4_inode *raw,
78  struct ext4_inode_info *ei)
79 {
80  __u32 provided, calculated;
81 
82  if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
86  return 1;
87 
88  provided = le16_to_cpu(raw->i_checksum_lo);
89  calculated = ext4_inode_csum(inode, raw, ei);
91  EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))
92  provided |= ((__u32)le16_to_cpu(raw->i_checksum_hi)) << 16;
93  else
94  calculated &= 0xFFFF;
95 
96  return provided == calculated;
97 }
98 
99 static void ext4_inode_csum_set(struct inode *inode, struct ext4_inode *raw,
100  struct ext4_inode_info *ei)
101 {
102  __u32 csum;
103 
104  if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
108  return;
109 
110  csum = ext4_inode_csum(inode, raw, ei);
111  raw->i_checksum_lo = cpu_to_le16(csum & 0xFFFF);
113  EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))
114  raw->i_checksum_hi = cpu_to_le16(csum >> 16);
115 }
116 
117 static inline int ext4_begin_ordered_truncate(struct inode *inode,
118  loff_t new_size)
119 {
120  trace_ext4_begin_ordered_truncate(inode, new_size);
121  /*
122  * If jinode is zero, then we never opened the file for
123  * writing, so there's no need to call
124  * jbd2_journal_begin_ordered_truncate() since there's no
125  * outstanding writes we need to flush.
126  */
127  if (!EXT4_I(inode)->jinode)
128  return 0;
130  EXT4_I(inode)->jinode,
131  new_size);
132 }
133 
134 static void ext4_invalidatepage(struct page *page, unsigned long offset);
135 static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
136  struct buffer_head *bh_result, int create);
137 static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode);
138 static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate);
139 static int __ext4_journalled_writepage(struct page *page, unsigned int len);
140 static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh);
141 static int ext4_discard_partial_page_buffers_no_lock(handle_t *handle,
142  struct inode *inode, struct page *page, loff_t from,
143  loff_t length, int flags);
144 
145 /*
146  * Test whether an inode is a fast symlink.
147  */
148 static int ext4_inode_is_fast_symlink(struct inode *inode)
149 {
150  int ea_blocks = EXT4_I(inode)->i_file_acl ?
151  (inode->i_sb->s_blocksize >> 9) : 0;
152 
153  return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
154 }
155 
156 /*
157  * Restart the transaction associated with *handle. This does a commit,
158  * so before we call here everything must be consistently dirtied against
159  * this transaction.
160  */
161 int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode,
162  int nblocks)
163 {
164  int ret;
165 
166  /*
167  * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
168  * moment, get_block can be called only for blocks inside i_size since
169  * page cache has been already dropped and writes are blocked by
170  * i_mutex. So we can safely drop the i_data_sem here.
171  */
172  BUG_ON(EXT4_JOURNAL(inode) == NULL);
173  jbd_debug(2, "restarting handle %p\n", handle);
174  up_write(&EXT4_I(inode)->i_data_sem);
175  ret = ext4_journal_restart(handle, nblocks);
176  down_write(&EXT4_I(inode)->i_data_sem);
178 
179  return ret;
180 }
181 
182 /*
183  * Called at the last iput() if i_nlink is zero.
184  */
185 void ext4_evict_inode(struct inode *inode)
186 {
187  handle_t *handle;
188  int err;
189 
190  trace_ext4_evict_inode(inode);
191 
192  ext4_ioend_wait(inode);
193 
194  if (inode->i_nlink) {
195  /*
196  * When journalling data dirty buffers are tracked only in the
197  * journal. So although mm thinks everything is clean and
198  * ready for reaping the inode might still have some pages to
199  * write in the running transaction or waiting to be
200  * checkpointed. Thus calling jbd2_journal_invalidatepage()
201  * (via truncate_inode_pages()) to discard these buffers can
202  * cause data loss. Also even if we did not discard these
203  * buffers, we would have no way to find them after the inode
204  * is reaped and thus user could see stale data if he tries to
205  * read them before the transaction is checkpointed. So be
206  * careful and force everything to disk here... We use
207  * ei->i_datasync_tid to store the newest transaction
208  * containing inode's data.
209  *
210  * Note that directories do not have this problem because they
211  * don't use page cache.
212  */
213  if (ext4_should_journal_data(inode) &&
214  (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode))) {
215  journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
216  tid_t commit_tid = EXT4_I(inode)->i_datasync_tid;
217 
218  jbd2_log_start_commit(journal, commit_tid);
219  jbd2_log_wait_commit(journal, commit_tid);
221  }
222  truncate_inode_pages(&inode->i_data, 0);
223  goto no_delete;
224  }
225 
226  if (!is_bad_inode(inode))
227  dquot_initialize(inode);
228 
229  if (ext4_should_order_data(inode))
230  ext4_begin_ordered_truncate(inode, 0);
231  truncate_inode_pages(&inode->i_data, 0);
232 
233  if (is_bad_inode(inode))
234  goto no_delete;
235 
236  /*
237  * Protect us against freezing - iput() caller didn't have to have any
238  * protection against it
239  */
240  sb_start_intwrite(inode->i_sb);
241  handle = ext4_journal_start(inode, ext4_blocks_for_truncate(inode)+3);
242  if (IS_ERR(handle)) {
243  ext4_std_error(inode->i_sb, PTR_ERR(handle));
244  /*
245  * If we're going to skip the normal cleanup, we still need to
246  * make sure that the in-core orphan linked list is properly
247  * cleaned up.
248  */
249  ext4_orphan_del(NULL, inode);
250  sb_end_intwrite(inode->i_sb);
251  goto no_delete;
252  }
253 
254  if (IS_SYNC(inode))
255  ext4_handle_sync(handle);
256  inode->i_size = 0;
257  err = ext4_mark_inode_dirty(handle, inode);
258  if (err) {
259  ext4_warning(inode->i_sb,
260  "couldn't mark inode dirty (err %d)", err);
261  goto stop_handle;
262  }
263  if (inode->i_blocks)
264  ext4_truncate(inode);
265 
266  /*
267  * ext4_ext_truncate() doesn't reserve any slop when it
268  * restarts journal transactions; therefore there may not be
269  * enough credits left in the handle to remove the inode from
270  * the orphan list and set the dtime field.
271  */
272  if (!ext4_handle_has_enough_credits(handle, 3)) {
273  err = ext4_journal_extend(handle, 3);
274  if (err > 0)
275  err = ext4_journal_restart(handle, 3);
276  if (err != 0) {
277  ext4_warning(inode->i_sb,
278  "couldn't extend journal (err %d)", err);
279  stop_handle:
280  ext4_journal_stop(handle);
281  ext4_orphan_del(NULL, inode);
282  sb_end_intwrite(inode->i_sb);
283  goto no_delete;
284  }
285  }
286 
287  /*
288  * Kill off the orphan record which ext4_truncate created.
289  * AKPM: I think this can be inside the above `if'.
290  * Note that ext4_orphan_del() has to be able to cope with the
291  * deletion of a non-existent orphan - this is because we don't
292  * know if ext4_truncate() actually created an orphan record.
293  * (Well, we could do this if we need to, but heck - it works)
294  */
295  ext4_orphan_del(handle, inode);
296  EXT4_I(inode)->i_dtime = get_seconds();
297 
298  /*
299  * One subtle ordering requirement: if anything has gone wrong
300  * (transaction abort, IO errors, whatever), then we can still
301  * do these next steps (the fs will already have been marked as
302  * having errors), but we can't free the inode if the mark_dirty
303  * fails.
304  */
305  if (ext4_mark_inode_dirty(handle, inode))
306  /* If that failed, just do the required in-core inode clear. */
307  ext4_clear_inode(inode);
308  else
309  ext4_free_inode(handle, inode);
310  ext4_journal_stop(handle);
311  sb_end_intwrite(inode->i_sb);
312  return;
313 no_delete:
314  ext4_clear_inode(inode); /* We must guarantee clearing of inode... */
315 }
316 
317 #ifdef CONFIG_QUOTA
318 qsize_t *ext4_get_reserved_space(struct inode *inode)
319 {
320  return &EXT4_I(inode)->i_reserved_quota;
321 }
322 #endif
323 
324 /*
325  * Calculate the number of metadata blocks need to reserve
326  * to allocate a block located at @lblock
327  */
328 static int ext4_calc_metadata_amount(struct inode *inode, ext4_lblk_t lblock)
329 {
330  if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
331  return ext4_ext_calc_metadata_amount(inode, lblock);
332 
333  return ext4_ind_calc_metadata_amount(inode, lblock);
334 }
335 
336 /*
337  * Called with i_data_sem down, which is important since we can call
338  * ext4_discard_preallocations() from here.
339  */
340 void ext4_da_update_reserve_space(struct inode *inode,
341  int used, int quota_claim)
342 {
343  struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
344  struct ext4_inode_info *ei = EXT4_I(inode);
345 
346  spin_lock(&ei->i_block_reservation_lock);
347  trace_ext4_da_update_reserve_space(inode, used, quota_claim);
348  if (unlikely(used > ei->i_reserved_data_blocks)) {
349  ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, used %d "
350  "with only %d reserved data blocks",
351  __func__, inode->i_ino, used,
353  WARN_ON(1);
354  used = ei->i_reserved_data_blocks;
355  }
356 
358  ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, allocated %d "
359  "with only %d reserved metadata blocks\n", __func__,
360  inode->i_ino, ei->i_allocated_meta_blocks,
362  WARN_ON(1);
364  }
365 
366  /* Update per-inode reservations */
369  percpu_counter_sub(&sbi->s_dirtyclusters_counter,
370  used + ei->i_allocated_meta_blocks);
371  ei->i_allocated_meta_blocks = 0;
372 
373  if (ei->i_reserved_data_blocks == 0) {
374  /*
375  * We can release all of the reserved metadata blocks
376  * only when we have written all of the delayed
377  * allocation blocks.
378  */
379  percpu_counter_sub(&sbi->s_dirtyclusters_counter,
381  ei->i_reserved_meta_blocks = 0;
382  ei->i_da_metadata_calc_len = 0;
383  }
384  spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
385 
386  /* Update quota subsystem for data blocks */
387  if (quota_claim)
388  dquot_claim_block(inode, EXT4_C2B(sbi, used));
389  else {
390  /*
391  * We did fallocate with an offset that is already delayed
392  * allocated. So on delayed allocated writeback we should
393  * not re-claim the quota for fallocated blocks.
394  */
395  dquot_release_reservation_block(inode, EXT4_C2B(sbi, used));
396  }
397 
398  /*
399  * If we have done all the pending block allocations and if
400  * there aren't any writers on the inode, we can discard the
401  * inode's preallocations.
402  */
403  if ((ei->i_reserved_data_blocks == 0) &&
404  (atomic_read(&inode->i_writecount) == 0))
406 }
407 
408 static int __check_block_validity(struct inode *inode, const char *func,
409  unsigned int line,
410  struct ext4_map_blocks *map)
411 {
412  if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk,
413  map->m_len)) {
414  ext4_error_inode(inode, func, line, map->m_pblk,
415  "lblock %lu mapped to illegal pblock "
416  "(length %d)", (unsigned long) map->m_lblk,
417  map->m_len);
418  return -EIO;
419  }
420  return 0;
421 }
422 
423 #define check_block_validity(inode, map) \
424  __check_block_validity((inode), __func__, __LINE__, (map))
425 
426 /*
427  * Return the number of contiguous dirty pages in a given inode
428  * starting at page frame idx.
429  */
430 static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx,
431  unsigned int max_pages)
432 {
433  struct address_space *mapping = inode->i_mapping;
434  pgoff_t index;
435  struct pagevec pvec;
436  pgoff_t num = 0;
437  int i, nr_pages, done = 0;
438 
439  if (max_pages == 0)
440  return 0;
441  pagevec_init(&pvec, 0);
442  while (!done) {
443  index = idx;
444  nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
447  if (nr_pages == 0)
448  break;
449  for (i = 0; i < nr_pages; i++) {
450  struct page *page = pvec.pages[i];
451  struct buffer_head *bh, *head;
452 
453  lock_page(page);
454  if (unlikely(page->mapping != mapping) ||
455  !PageDirty(page) ||
456  PageWriteback(page) ||
457  page->index != idx) {
458  done = 1;
459  unlock_page(page);
460  break;
461  }
462  if (page_has_buffers(page)) {
463  bh = head = page_buffers(page);
464  do {
465  if (!buffer_delay(bh) &&
466  !buffer_unwritten(bh))
467  done = 1;
468  bh = bh->b_this_page;
469  } while (!done && (bh != head));
470  }
471  unlock_page(page);
472  if (done)
473  break;
474  idx++;
475  num++;
476  if (num >= max_pages) {
477  done = 1;
478  break;
479  }
480  }
481  pagevec_release(&pvec);
482  }
483  return num;
484 }
485 
486 /*
487  * Sets the BH_Da_Mapped bit on the buffer heads corresponding to the given map.
488  */
489 static void set_buffers_da_mapped(struct inode *inode,
490  struct ext4_map_blocks *map)
491 {
492  struct address_space *mapping = inode->i_mapping;
493  struct pagevec pvec;
494  int i, nr_pages;
495  pgoff_t index, end;
496 
497  index = map->m_lblk >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
498  end = (map->m_lblk + map->m_len - 1) >>
499  (PAGE_CACHE_SHIFT - inode->i_blkbits);
500 
501  pagevec_init(&pvec, 0);
502  while (index <= end) {
503  nr_pages = pagevec_lookup(&pvec, mapping, index,
504  min(end - index + 1,
506  if (nr_pages == 0)
507  break;
508  for (i = 0; i < nr_pages; i++) {
509  struct page *page = pvec.pages[i];
510  struct buffer_head *bh, *head;
511 
512  if (unlikely(page->mapping != mapping) ||
513  !PageDirty(page))
514  break;
515 
516  if (page_has_buffers(page)) {
517  bh = head = page_buffers(page);
518  do {
519  set_buffer_da_mapped(bh);
520  bh = bh->b_this_page;
521  } while (bh != head);
522  }
523  index++;
524  }
525  pagevec_release(&pvec);
526  }
527 }
528 
529 /*
530  * The ext4_map_blocks() function tries to look up the requested blocks,
531  * and returns if the blocks are already mapped.
532  *
533  * Otherwise it takes the write lock of the i_data_sem and allocate blocks
534  * and store the allocated blocks in the result buffer head and mark it
535  * mapped.
536  *
537  * If file type is extents based, it will call ext4_ext_map_blocks(),
538  * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
539  * based files
540  *
541  * On success, it returns the number of blocks being mapped or allocate.
542  * if create==0 and the blocks are pre-allocated and uninitialized block,
543  * the result buffer head is unmapped. If the create ==1, it will make sure
544  * the buffer head is mapped.
545  *
546  * It returns 0 if plain look up failed (blocks have not been allocated), in
547  * that case, buffer head is unmapped
548  *
549  * It returns the error in case of allocation failure.
550  */
551 int ext4_map_blocks(handle_t *handle, struct inode *inode,
552  struct ext4_map_blocks *map, int flags)
553 {
554  int retval;
555 
556  map->m_flags = 0;
557  ext_debug("ext4_map_blocks(): inode %lu, flag %d, max_blocks %u,"
558  "logical block %lu\n", inode->i_ino, flags, map->m_len,
559  (unsigned long) map->m_lblk);
560  /*
561  * Try to see if we can get the block without requesting a new
562  * file system block.
563  */
564  if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
565  down_read((&EXT4_I(inode)->i_data_sem));
566  if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
567  retval = ext4_ext_map_blocks(handle, inode, map, flags &
569  } else {
570  retval = ext4_ind_map_blocks(handle, inode, map, flags &
572  }
573  if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
574  up_read((&EXT4_I(inode)->i_data_sem));
575 
576  if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
577  int ret = check_block_validity(inode, map);
578  if (ret != 0)
579  return ret;
580  }
581 
582  /* If it is only a block(s) look up */
583  if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
584  return retval;
585 
586  /*
587  * Returns if the blocks have already allocated
588  *
589  * Note that if blocks have been preallocated
590  * ext4_ext_get_block() returns the create = 0
591  * with buffer head unmapped.
592  */
593  if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
594  return retval;
595 
596  /*
597  * When we call get_blocks without the create flag, the
598  * BH_Unwritten flag could have gotten set if the blocks
599  * requested were part of a uninitialized extent. We need to
600  * clear this flag now that we are committed to convert all or
601  * part of the uninitialized extent to be an initialized
602  * extent. This is because we need to avoid the combination
603  * of BH_Unwritten and BH_Mapped flags being simultaneously
604  * set on the buffer_head.
605  */
606  map->m_flags &= ~EXT4_MAP_UNWRITTEN;
607 
608  /*
609  * New blocks allocate and/or writing to uninitialized extent
610  * will possibly result in updating i_data, so we take
611  * the write lock of i_data_sem, and call get_blocks()
612  * with create == 1 flag.
613  */
614  down_write((&EXT4_I(inode)->i_data_sem));
615 
616  /*
617  * if the caller is from delayed allocation writeout path
618  * we have already reserved fs blocks for allocation
619  * let the underlying get_block() function know to
620  * avoid double accounting
621  */
623  ext4_set_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
624  /*
625  * We need to check for EXT4 here because migrate
626  * could have changed the inode type in between
627  */
628  if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
629  retval = ext4_ext_map_blocks(handle, inode, map, flags);
630  } else {
631  retval = ext4_ind_map_blocks(handle, inode, map, flags);
632 
633  if (retval > 0 && map->m_flags & EXT4_MAP_NEW) {
634  /*
635  * We allocated new blocks which will result in
636  * i_data's format changing. Force the migrate
637  * to fail by clearing migrate flags
638  */
639  ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
640  }
641 
642  /*
643  * Update reserved blocks/metadata blocks after successful
644  * block allocation which had been deferred till now. We don't
645  * support fallocate for non extent files. So we can update
646  * reserve space here.
647  */
648  if ((retval > 0) &&
649  (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE))
650  ext4_da_update_reserve_space(inode, retval, 1);
651  }
652  if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
653  ext4_clear_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
654 
655  /* If we have successfully mapped the delayed allocated blocks,
656  * set the BH_Da_Mapped bit on them. Its important to do this
657  * under the protection of i_data_sem.
658  */
659  if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
660  set_buffers_da_mapped(inode, map);
661  }
662 
663  up_write((&EXT4_I(inode)->i_data_sem));
664  if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
665  int ret = check_block_validity(inode, map);
666  if (ret != 0)
667  return ret;
668  }
669  return retval;
670 }
671 
672 /* Maximum number of blocks we map for direct IO at once. */
673 #define DIO_MAX_BLOCKS 4096
674 
675 static int _ext4_get_block(struct inode *inode, sector_t iblock,
676  struct buffer_head *bh, int flags)
677 {
678  handle_t *handle = ext4_journal_current_handle();
679  struct ext4_map_blocks map;
680  int ret = 0, started = 0;
681  int dio_credits;
682 
683  map.m_lblk = iblock;
684  map.m_len = bh->b_size >> inode->i_blkbits;
685 
686  if (flags && !handle) {
687  /* Direct IO write... */
688  if (map.m_len > DIO_MAX_BLOCKS)
689  map.m_len = DIO_MAX_BLOCKS;
690  dio_credits = ext4_chunk_trans_blocks(inode, map.m_len);
691  handle = ext4_journal_start(inode, dio_credits);
692  if (IS_ERR(handle)) {
693  ret = PTR_ERR(handle);
694  return ret;
695  }
696  started = 1;
697  }
698 
699  ret = ext4_map_blocks(handle, inode, &map, flags);
700  if (ret > 0) {
701  map_bh(bh, inode->i_sb, map.m_pblk);
702  bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
703  bh->b_size = inode->i_sb->s_blocksize * map.m_len;
704  ret = 0;
705  }
706  if (started)
707  ext4_journal_stop(handle);
708  return ret;
709 }
710 
711 int ext4_get_block(struct inode *inode, sector_t iblock,
712  struct buffer_head *bh, int create)
713 {
714  return _ext4_get_block(inode, iblock, bh,
715  create ? EXT4_GET_BLOCKS_CREATE : 0);
716 }
717 
718 /*
719  * `handle' can be NULL if create is zero
720  */
721 struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
722  ext4_lblk_t block, int create, int *errp)
723 {
724  struct ext4_map_blocks map;
725  struct buffer_head *bh;
726  int fatal = 0, err;
727 
728  J_ASSERT(handle != NULL || create == 0);
729 
730  map.m_lblk = block;
731  map.m_len = 1;
732  err = ext4_map_blocks(handle, inode, &map,
733  create ? EXT4_GET_BLOCKS_CREATE : 0);
734 
735  /* ensure we send some value back into *errp */
736  *errp = 0;
737 
738  if (err < 0)
739  *errp = err;
740  if (err <= 0)
741  return NULL;
742 
743  bh = sb_getblk(inode->i_sb, map.m_pblk);
744  if (!bh) {
745  *errp = -EIO;
746  return NULL;
747  }
748  if (map.m_flags & EXT4_MAP_NEW) {
749  J_ASSERT(create != 0);
750  J_ASSERT(handle != NULL);
751 
752  /*
753  * Now that we do not always journal data, we should
754  * keep in mind whether this should always journal the
755  * new buffer as metadata. For now, regular file
756  * writes use ext4_get_block instead, so it's not a
757  * problem.
758  */
759  lock_buffer(bh);
760  BUFFER_TRACE(bh, "call get_create_access");
761  fatal = ext4_journal_get_create_access(handle, bh);
762  if (!fatal && !buffer_uptodate(bh)) {
763  memset(bh->b_data, 0, inode->i_sb->s_blocksize);
764  set_buffer_uptodate(bh);
765  }
766  unlock_buffer(bh);
767  BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
768  err = ext4_handle_dirty_metadata(handle, inode, bh);
769  if (!fatal)
770  fatal = err;
771  } else {
772  BUFFER_TRACE(bh, "not a new buffer");
773  }
774  if (fatal) {
775  *errp = fatal;
776  brelse(bh);
777  bh = NULL;
778  }
779  return bh;
780 }
781 
782 struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
783  ext4_lblk_t block, int create, int *err)
784 {
785  struct buffer_head *bh;
786 
787  bh = ext4_getblk(handle, inode, block, create, err);
788  if (!bh)
789  return bh;
790  if (buffer_uptodate(bh))
791  return bh;
792  ll_rw_block(READ | REQ_META | REQ_PRIO, 1, &bh);
793  wait_on_buffer(bh);
794  if (buffer_uptodate(bh))
795  return bh;
796  put_bh(bh);
797  *err = -EIO;
798  return NULL;
799 }
800 
801 static int walk_page_buffers(handle_t *handle,
802  struct buffer_head *head,
803  unsigned from,
804  unsigned to,
805  int *partial,
806  int (*fn)(handle_t *handle,
807  struct buffer_head *bh))
808 {
809  struct buffer_head *bh;
810  unsigned block_start, block_end;
811  unsigned blocksize = head->b_size;
812  int err, ret = 0;
813  struct buffer_head *next;
814 
815  for (bh = head, block_start = 0;
816  ret == 0 && (bh != head || !block_start);
817  block_start = block_end, bh = next) {
818  next = bh->b_this_page;
819  block_end = block_start + blocksize;
820  if (block_end <= from || block_start >= to) {
821  if (partial && !buffer_uptodate(bh))
822  *partial = 1;
823  continue;
824  }
825  err = (*fn)(handle, bh);
826  if (!ret)
827  ret = err;
828  }
829  return ret;
830 }
831 
832 /*
833  * To preserve ordering, it is essential that the hole instantiation and
834  * the data write be encapsulated in a single transaction. We cannot
835  * close off a transaction and start a new one between the ext4_get_block()
836  * and the commit_write(). So doing the jbd2_journal_start at the start of
837  * prepare_write() is the right place.
838  *
839  * Also, this function can nest inside ext4_writepage() ->
840  * block_write_full_page(). In that case, we *know* that ext4_writepage()
841  * has generated enough buffer credits to do the whole page. So we won't
842  * block on the journal in that case, which is good, because the caller may
843  * be PF_MEMALLOC.
844  *
845  * By accident, ext4 can be reentered when a transaction is open via
846  * quota file writes. If we were to commit the transaction while thus
847  * reentered, there can be a deadlock - we would be holding a quota
848  * lock, and the commit would never complete if another thread had a
849  * transaction open and was blocking on the quota lock - a ranking
850  * violation.
851  *
852  * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
853  * will _not_ run commit under these circumstances because handle->h_ref
854  * is elevated. We'll still have enough credits for the tiny quotafile
855  * write.
856  */
857 static int do_journal_get_write_access(handle_t *handle,
858  struct buffer_head *bh)
859 {
860  int dirty = buffer_dirty(bh);
861  int ret;
862 
863  if (!buffer_mapped(bh) || buffer_freed(bh))
864  return 0;
865  /*
866  * __block_write_begin() could have dirtied some buffers. Clean
867  * the dirty bit as jbd2_journal_get_write_access() could complain
868  * otherwise about fs integrity issues. Setting of the dirty bit
869  * by __block_write_begin() isn't a real problem here as we clear
870  * the bit before releasing a page lock and thus writeback cannot
871  * ever write the buffer.
872  */
873  if (dirty)
874  clear_buffer_dirty(bh);
875  ret = ext4_journal_get_write_access(handle, bh);
876  if (!ret && dirty)
877  ret = ext4_handle_dirty_metadata(handle, NULL, bh);
878  return ret;
879 }
880 
881 static int ext4_get_block_write(struct inode *inode, sector_t iblock,
882  struct buffer_head *bh_result, int create);
883 static int ext4_write_begin(struct file *file, struct address_space *mapping,
884  loff_t pos, unsigned len, unsigned flags,
885  struct page **pagep, void **fsdata)
886 {
887  struct inode *inode = mapping->host;
888  int ret, needed_blocks;
889  handle_t *handle;
890  int retries = 0;
891  struct page *page;
892  pgoff_t index;
893  unsigned from, to;
894 
895  trace_ext4_write_begin(inode, pos, len, flags);
896  /*
897  * Reserve one block more for addition to orphan list in case
898  * we allocate blocks but write fails for some reason
899  */
900  needed_blocks = ext4_writepage_trans_blocks(inode) + 1;
901  index = pos >> PAGE_CACHE_SHIFT;
902  from = pos & (PAGE_CACHE_SIZE - 1);
903  to = from + len;
904 
905 retry:
906  handle = ext4_journal_start(inode, needed_blocks);
907  if (IS_ERR(handle)) {
908  ret = PTR_ERR(handle);
909  goto out;
910  }
911 
912  /* We cannot recurse into the filesystem as the transaction is already
913  * started */
914  flags |= AOP_FLAG_NOFS;
915 
916  page = grab_cache_page_write_begin(mapping, index, flags);
917  if (!page) {
918  ext4_journal_stop(handle);
919  ret = -ENOMEM;
920  goto out;
921  }
922  *pagep = page;
923 
924  if (ext4_should_dioread_nolock(inode))
925  ret = __block_write_begin(page, pos, len, ext4_get_block_write);
926  else
927  ret = __block_write_begin(page, pos, len, ext4_get_block);
928 
929  if (!ret && ext4_should_journal_data(inode)) {
930  ret = walk_page_buffers(handle, page_buffers(page),
931  from, to, NULL, do_journal_get_write_access);
932  }
933 
934  if (ret) {
935  unlock_page(page);
936  page_cache_release(page);
937  /*
938  * __block_write_begin may have instantiated a few blocks
939  * outside i_size. Trim these off again. Don't need
940  * i_size_read because we hold i_mutex.
941  *
942  * Add inode to orphan list in case we crash before
943  * truncate finishes
944  */
945  if (pos + len > inode->i_size && ext4_can_truncate(inode))
946  ext4_orphan_add(handle, inode);
947 
948  ext4_journal_stop(handle);
949  if (pos + len > inode->i_size) {
950  ext4_truncate_failed_write(inode);
951  /*
952  * If truncate failed early the inode might
953  * still be on the orphan list; we need to
954  * make sure the inode is removed from the
955  * orphan list in that case.
956  */
957  if (inode->i_nlink)
958  ext4_orphan_del(NULL, inode);
959  }
960  }
961 
962  if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
963  goto retry;
964 out:
965  return ret;
966 }
967 
968 /* For write_end() in data=journal mode */
969 static int write_end_fn(handle_t *handle, struct buffer_head *bh)
970 {
971  if (!buffer_mapped(bh) || buffer_freed(bh))
972  return 0;
973  set_buffer_uptodate(bh);
974  return ext4_handle_dirty_metadata(handle, NULL, bh);
975 }
976 
977 static int ext4_generic_write_end(struct file *file,
978  struct address_space *mapping,
979  loff_t pos, unsigned len, unsigned copied,
980  struct page *page, void *fsdata)
981 {
982  int i_size_changed = 0;
983  struct inode *inode = mapping->host;
984  handle_t *handle = ext4_journal_current_handle();
985 
986  copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
987 
988  /*
989  * No need to use i_size_read() here, the i_size
990  * cannot change under us because we hold i_mutex.
991  *
992  * But it's important to update i_size while still holding page lock:
993  * page writeout could otherwise come in and zero beyond i_size.
994  */
995  if (pos + copied > inode->i_size) {
996  i_size_write(inode, pos + copied);
997  i_size_changed = 1;
998  }
999 
1000  if (pos + copied > EXT4_I(inode)->i_disksize) {
1001  /* We need to mark inode dirty even if
1002  * new_i_size is less that inode->i_size
1003  * bu greater than i_disksize.(hint delalloc)
1004  */
1005  ext4_update_i_disksize(inode, (pos + copied));
1006  i_size_changed = 1;
1007  }
1008  unlock_page(page);
1009  page_cache_release(page);
1010 
1011  /*
1012  * Don't mark the inode dirty under page lock. First, it unnecessarily
1013  * makes the holding time of page lock longer. Second, it forces lock
1014  * ordering of page lock and transaction start for journaling
1015  * filesystems.
1016  */
1017  if (i_size_changed)
1018  ext4_mark_inode_dirty(handle, inode);
1019 
1020  return copied;
1021 }
1022 
1023 /*
1024  * We need to pick up the new inode size which generic_commit_write gave us
1025  * `file' can be NULL - eg, when called from page_symlink().
1026  *
1027  * ext4 never places buffers on inode->i_mapping->private_list. metadata
1028  * buffers are managed internally.
1029  */
1030 static int ext4_ordered_write_end(struct file *file,
1031  struct address_space *mapping,
1032  loff_t pos, unsigned len, unsigned copied,
1033  struct page *page, void *fsdata)
1034 {
1035  handle_t *handle = ext4_journal_current_handle();
1036  struct inode *inode = mapping->host;
1037  int ret = 0, ret2;
1038 
1039  trace_ext4_ordered_write_end(inode, pos, len, copied);
1040  ret = ext4_jbd2_file_inode(handle, inode);
1041 
1042  if (ret == 0) {
1043  ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
1044  page, fsdata);
1045  copied = ret2;
1046  if (pos + len > inode->i_size && ext4_can_truncate(inode))
1047  /* if we have allocated more blocks and copied
1048  * less. We will have blocks allocated outside
1049  * inode->i_size. So truncate them
1050  */
1051  ext4_orphan_add(handle, inode);
1052  if (ret2 < 0)
1053  ret = ret2;
1054  } else {
1055  unlock_page(page);
1056  page_cache_release(page);
1057  }
1058 
1059  ret2 = ext4_journal_stop(handle);
1060  if (!ret)
1061  ret = ret2;
1062 
1063  if (pos + len > inode->i_size) {
1064  ext4_truncate_failed_write(inode);
1065  /*
1066  * If truncate failed early the inode might still be
1067  * on the orphan list; we need to make sure the inode
1068  * is removed from the orphan list in that case.
1069  */
1070  if (inode->i_nlink)
1071  ext4_orphan_del(NULL, inode);
1072  }
1073 
1074 
1075  return ret ? ret : copied;
1076 }
1077 
1078 static int ext4_writeback_write_end(struct file *file,
1079  struct address_space *mapping,
1080  loff_t pos, unsigned len, unsigned copied,
1081  struct page *page, void *fsdata)
1082 {
1083  handle_t *handle = ext4_journal_current_handle();
1084  struct inode *inode = mapping->host;
1085  int ret = 0, ret2;
1086 
1087  trace_ext4_writeback_write_end(inode, pos, len, copied);
1088  ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
1089  page, fsdata);
1090  copied = ret2;
1091  if (pos + len > inode->i_size && ext4_can_truncate(inode))
1092  /* if we have allocated more blocks and copied
1093  * less. We will have blocks allocated outside
1094  * inode->i_size. So truncate them
1095  */
1096  ext4_orphan_add(handle, inode);
1097 
1098  if (ret2 < 0)
1099  ret = ret2;
1100 
1101  ret2 = ext4_journal_stop(handle);
1102  if (!ret)
1103  ret = ret2;
1104 
1105  if (pos + len > inode->i_size) {
1106  ext4_truncate_failed_write(inode);
1107  /*
1108  * If truncate failed early the inode might still be
1109  * on the orphan list; we need to make sure the inode
1110  * is removed from the orphan list in that case.
1111  */
1112  if (inode->i_nlink)
1113  ext4_orphan_del(NULL, inode);
1114  }
1115 
1116  return ret ? ret : copied;
1117 }
1118 
1119 static int ext4_journalled_write_end(struct file *file,
1120  struct address_space *mapping,
1121  loff_t pos, unsigned len, unsigned copied,
1122  struct page *page, void *fsdata)
1123 {
1124  handle_t *handle = ext4_journal_current_handle();
1125  struct inode *inode = mapping->host;
1126  int ret = 0, ret2;
1127  int partial = 0;
1128  unsigned from, to;
1129  loff_t new_i_size;
1130 
1131  trace_ext4_journalled_write_end(inode, pos, len, copied);
1132  from = pos & (PAGE_CACHE_SIZE - 1);
1133  to = from + len;
1134 
1135  BUG_ON(!ext4_handle_valid(handle));
1136 
1137  if (copied < len) {
1138  if (!PageUptodate(page))
1139  copied = 0;
1140  page_zero_new_buffers(page, from+copied, to);
1141  }
1142 
1143  ret = walk_page_buffers(handle, page_buffers(page), from,
1144  to, &partial, write_end_fn);
1145  if (!partial)
1146  SetPageUptodate(page);
1147  new_i_size = pos + copied;
1148  if (new_i_size > inode->i_size)
1149  i_size_write(inode, pos+copied);
1150  ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1151  EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1152  if (new_i_size > EXT4_I(inode)->i_disksize) {
1153  ext4_update_i_disksize(inode, new_i_size);
1154  ret2 = ext4_mark_inode_dirty(handle, inode);
1155  if (!ret)
1156  ret = ret2;
1157  }
1158 
1159  unlock_page(page);
1160  page_cache_release(page);
1161  if (pos + len > inode->i_size && ext4_can_truncate(inode))
1162  /* if we have allocated more blocks and copied
1163  * less. We will have blocks allocated outside
1164  * inode->i_size. So truncate them
1165  */
1166  ext4_orphan_add(handle, inode);
1167 
1168  ret2 = ext4_journal_stop(handle);
1169  if (!ret)
1170  ret = ret2;
1171  if (pos + len > inode->i_size) {
1172  ext4_truncate_failed_write(inode);
1173  /*
1174  * If truncate failed early the inode might still be
1175  * on the orphan list; we need to make sure the inode
1176  * is removed from the orphan list in that case.
1177  */
1178  if (inode->i_nlink)
1179  ext4_orphan_del(NULL, inode);
1180  }
1181 
1182  return ret ? ret : copied;
1183 }
1184 
1185 /*
1186  * Reserve a single cluster located at lblock
1187  */
1188 static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)
1189 {
1190  int retries = 0;
1191  struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1192  struct ext4_inode_info *ei = EXT4_I(inode);
1193  unsigned int md_needed;
1194  int ret;
1195  ext4_lblk_t save_last_lblock;
1196  int save_len;
1197 
1198  /*
1199  * We will charge metadata quota at writeout time; this saves
1200  * us from metadata over-estimation, though we may go over by
1201  * a small amount in the end. Here we just reserve for data.
1202  */
1203  ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1));
1204  if (ret)
1205  return ret;
1206 
1207  /*
1208  * recalculate the amount of metadata blocks to reserve
1209  * in order to allocate nrblocks
1210  * worse case is one extent per block
1211  */
1212 repeat:
1213  spin_lock(&ei->i_block_reservation_lock);
1214  /*
1215  * ext4_calc_metadata_amount() has side effects, which we have
1216  * to be prepared undo if we fail to claim space.
1217  */
1218  save_len = ei->i_da_metadata_calc_len;
1219  save_last_lblock = ei->i_da_metadata_calc_last_lblock;
1220  md_needed = EXT4_NUM_B2C(sbi,
1221  ext4_calc_metadata_amount(inode, lblock));
1222  trace_ext4_da_reserve_space(inode, md_needed);
1223 
1224  /*
1225  * We do still charge estimated metadata to the sb though;
1226  * we cannot afford to run out of free blocks.
1227  */
1228  if (ext4_claim_free_clusters(sbi, md_needed + 1, 0)) {
1229  ei->i_da_metadata_calc_len = save_len;
1230  ei->i_da_metadata_calc_last_lblock = save_last_lblock;
1231  spin_unlock(&ei->i_block_reservation_lock);
1232  if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
1233  yield();
1234  goto repeat;
1235  }
1236  dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));
1237  return -ENOSPC;
1238  }
1239  ei->i_reserved_data_blocks++;
1240  ei->i_reserved_meta_blocks += md_needed;
1241  spin_unlock(&ei->i_block_reservation_lock);
1242 
1243  return 0; /* success */
1244 }
1245 
1246 static void ext4_da_release_space(struct inode *inode, int to_free)
1247 {
1248  struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1249  struct ext4_inode_info *ei = EXT4_I(inode);
1250 
1251  if (!to_free)
1252  return; /* Nothing to release, exit */
1253 
1254  spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1255 
1256  trace_ext4_da_release_space(inode, to_free);
1257  if (unlikely(to_free > ei->i_reserved_data_blocks)) {
1258  /*
1259  * if there aren't enough reserved blocks, then the
1260  * counter is messed up somewhere. Since this
1261  * function is called from invalidate page, it's
1262  * harmless to return without any action.
1263  */
1264  ext4_msg(inode->i_sb, KERN_NOTICE, "ext4_da_release_space: "
1265  "ino %lu, to_free %d with only %d reserved "
1266  "data blocks", inode->i_ino, to_free,
1268  WARN_ON(1);
1269  to_free = ei->i_reserved_data_blocks;
1270  }
1271  ei->i_reserved_data_blocks -= to_free;
1272 
1273  if (ei->i_reserved_data_blocks == 0) {
1274  /*
1275  * We can release all of the reserved metadata blocks
1276  * only when we have written all of the delayed
1277  * allocation blocks.
1278  * Note that in case of bigalloc, i_reserved_meta_blocks,
1279  * i_reserved_data_blocks, etc. refer to number of clusters.
1280  */
1281  percpu_counter_sub(&sbi->s_dirtyclusters_counter,
1283  ei->i_reserved_meta_blocks = 0;
1284  ei->i_da_metadata_calc_len = 0;
1285  }
1286 
1287  /* update fs dirty data blocks counter */
1288  percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free);
1289 
1290  spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1291 
1292  dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free));
1293 }
1294 
1295 static void ext4_da_page_release_reservation(struct page *page,
1296  unsigned long offset)
1297 {
1298  int to_release = 0;
1299  struct buffer_head *head, *bh;
1300  unsigned int curr_off = 0;
1301  struct inode *inode = page->mapping->host;
1302  struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1303  int num_clusters;
1304 
1305  head = page_buffers(page);
1306  bh = head;
1307  do {
1308  unsigned int next_off = curr_off + bh->b_size;
1309 
1310  if ((offset <= curr_off) && (buffer_delay(bh))) {
1311  to_release++;
1312  clear_buffer_delay(bh);
1313  clear_buffer_da_mapped(bh);
1314  }
1315  curr_off = next_off;
1316  } while ((bh = bh->b_this_page) != head);
1317 
1318  /* If we have released all the blocks belonging to a cluster, then we
1319  * need to release the reserved space for that cluster. */
1320  num_clusters = EXT4_NUM_B2C(sbi, to_release);
1321  while (num_clusters > 0) {
1322  ext4_fsblk_t lblk;
1323  lblk = (page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits)) +
1324  ((num_clusters - 1) << sbi->s_cluster_bits);
1325  if (sbi->s_cluster_ratio == 1 ||
1326  !ext4_find_delalloc_cluster(inode, lblk, 1))
1327  ext4_da_release_space(inode, 1);
1328 
1329  num_clusters--;
1330  }
1331 }
1332 
1333 /*
1334  * Delayed allocation stuff
1335  */
1336 
1337 /*
1338  * mpage_da_submit_io - walks through extent of pages and try to write
1339  * them with writepage() call back
1340  *
1341  * @mpd->inode: inode
1342  * @mpd->first_page: first page of the extent
1343  * @mpd->next_page: page after the last page of the extent
1344  *
1345  * By the time mpage_da_submit_io() is called we expect all blocks
1346  * to be allocated. this may be wrong if allocation failed.
1347  *
1348  * As pages are already locked by write_cache_pages(), we can't use it
1349  */
1350 static int mpage_da_submit_io(struct mpage_da_data *mpd,
1351  struct ext4_map_blocks *map)
1352 {
1353  struct pagevec pvec;
1354  unsigned long index, end;
1355  int ret = 0, err, nr_pages, i;
1356  struct inode *inode = mpd->inode;
1357  struct address_space *mapping = inode->i_mapping;
1358  loff_t size = i_size_read(inode);
1359  unsigned int len, block_start;
1360  struct buffer_head *bh, *page_bufs = NULL;
1361  int journal_data = ext4_should_journal_data(inode);
1362  sector_t pblock = 0, cur_logical = 0;
1363  struct ext4_io_submit io_submit;
1364 
1365  BUG_ON(mpd->next_page <= mpd->first_page);
1366  memset(&io_submit, 0, sizeof(io_submit));
1367  /*
1368  * We need to start from the first_page to the next_page - 1
1369  * to make sure we also write the mapped dirty buffer_heads.
1370  * If we look at mpd->b_blocknr we would only be looking
1371  * at the currently mapped buffer_heads.
1372  */
1373  index = mpd->first_page;
1374  end = mpd->next_page - 1;
1375 
1376  pagevec_init(&pvec, 0);
1377  while (index <= end) {
1378  nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1379  if (nr_pages == 0)
1380  break;
1381  for (i = 0; i < nr_pages; i++) {
1382  int commit_write = 0, skip_page = 0;
1383  struct page *page = pvec.pages[i];
1384 
1385  index = page->index;
1386  if (index > end)
1387  break;
1388 
1389  if (index == size >> PAGE_CACHE_SHIFT)
1390  len = size & ~PAGE_CACHE_MASK;
1391  else
1392  len = PAGE_CACHE_SIZE;
1393  if (map) {
1394  cur_logical = index << (PAGE_CACHE_SHIFT -
1395  inode->i_blkbits);
1396  pblock = map->m_pblk + (cur_logical -
1397  map->m_lblk);
1398  }
1399  index++;
1400 
1401  BUG_ON(!PageLocked(page));
1402  BUG_ON(PageWriteback(page));
1403 
1404  /*
1405  * If the page does not have buffers (for
1406  * whatever reason), try to create them using
1407  * __block_write_begin. If this fails,
1408  * skip the page and move on.
1409  */
1410  if (!page_has_buffers(page)) {
1411  if (__block_write_begin(page, 0, len,
1412  noalloc_get_block_write)) {
1413  skip_page:
1414  unlock_page(page);
1415  continue;
1416  }
1417  commit_write = 1;
1418  }
1419 
1420  bh = page_bufs = page_buffers(page);
1421  block_start = 0;
1422  do {
1423  if (!bh)
1424  goto skip_page;
1425  if (map && (cur_logical >= map->m_lblk) &&
1426  (cur_logical <= (map->m_lblk +
1427  (map->m_len - 1)))) {
1428  if (buffer_delay(bh)) {
1429  clear_buffer_delay(bh);
1430  bh->b_blocknr = pblock;
1431  }
1432  if (buffer_da_mapped(bh))
1433  clear_buffer_da_mapped(bh);
1434  if (buffer_unwritten(bh) ||
1435  buffer_mapped(bh))
1436  BUG_ON(bh->b_blocknr != pblock);
1437  if (map->m_flags & EXT4_MAP_UNINIT)
1438  set_buffer_uninit(bh);
1439  clear_buffer_unwritten(bh);
1440  }
1441 
1442  /*
1443  * skip page if block allocation undone and
1444  * block is dirty
1445  */
1446  if (ext4_bh_delay_or_unwritten(NULL, bh))
1447  skip_page = 1;
1448  bh = bh->b_this_page;
1449  block_start += bh->b_size;
1450  cur_logical++;
1451  pblock++;
1452  } while (bh != page_bufs);
1453 
1454  if (skip_page)
1455  goto skip_page;
1456 
1457  if (commit_write)
1458  /* mark the buffer_heads as dirty & uptodate */
1459  block_commit_write(page, 0, len);
1460 
1462  /*
1463  * Delalloc doesn't support data journalling,
1464  * but eventually maybe we'll lift this
1465  * restriction.
1466  */
1467  if (unlikely(journal_data && PageChecked(page)))
1468  err = __ext4_journalled_writepage(page, len);
1469  else if (test_opt(inode->i_sb, MBLK_IO_SUBMIT))
1470  err = ext4_bio_write_page(&io_submit, page,
1471  len, mpd->wbc);
1472  else if (buffer_uninit(page_bufs)) {
1473  ext4_set_bh_endio(page_bufs, inode);
1474  err = block_write_full_page_endio(page,
1475  noalloc_get_block_write,
1476  mpd->wbc, ext4_end_io_buffer_write);
1477  } else
1478  err = block_write_full_page(page,
1479  noalloc_get_block_write, mpd->wbc);
1480 
1481  if (!err)
1482  mpd->pages_written++;
1483  /*
1484  * In error case, we have to continue because
1485  * remaining pages are still locked
1486  */
1487  if (ret == 0)
1488  ret = err;
1489  }
1490  pagevec_release(&pvec);
1491  }
1492  ext4_io_submit(&io_submit);
1493  return ret;
1494 }
1495 
1496 static void ext4_da_block_invalidatepages(struct mpage_da_data *mpd)
1497 {
1498  int nr_pages, i;
1499  pgoff_t index, end;
1500  struct pagevec pvec;
1501  struct inode *inode = mpd->inode;
1502  struct address_space *mapping = inode->i_mapping;
1503 
1504  index = mpd->first_page;
1505  end = mpd->next_page - 1;
1506  while (index <= end) {
1507  nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1508  if (nr_pages == 0)
1509  break;
1510  for (i = 0; i < nr_pages; i++) {
1511  struct page *page = pvec.pages[i];
1512  if (page->index > end)
1513  break;
1514  BUG_ON(!PageLocked(page));
1515  BUG_ON(PageWriteback(page));
1516  block_invalidatepage(page, 0);
1517  ClearPageUptodate(page);
1518  unlock_page(page);
1519  }
1520  index = pvec.pages[nr_pages - 1]->index + 1;
1521  pagevec_release(&pvec);
1522  }
1523  return;
1524 }
1525 
1526 static void ext4_print_free_blocks(struct inode *inode)
1527 {
1528  struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1529  struct super_block *sb = inode->i_sb;
1530 
1531  ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld",
1532  EXT4_C2B(EXT4_SB(inode->i_sb),
1533  ext4_count_free_clusters(inode->i_sb)));
1534  ext4_msg(sb, KERN_CRIT, "Free/Dirty block details");
1535  ext4_msg(sb, KERN_CRIT, "free_blocks=%lld",
1536  (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
1537  percpu_counter_sum(&sbi->s_freeclusters_counter)));
1538  ext4_msg(sb, KERN_CRIT, "dirty_blocks=%lld",
1539  (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
1540  percpu_counter_sum(&sbi->s_dirtyclusters_counter)));
1541  ext4_msg(sb, KERN_CRIT, "Block reservation details");
1542  ext4_msg(sb, KERN_CRIT, "i_reserved_data_blocks=%u",
1543  EXT4_I(inode)->i_reserved_data_blocks);
1544  ext4_msg(sb, KERN_CRIT, "i_reserved_meta_blocks=%u",
1545  EXT4_I(inode)->i_reserved_meta_blocks);
1546  return;
1547 }
1548 
1549 /*
1550  * mpage_da_map_and_submit - go through given space, map them
1551  * if necessary, and then submit them for I/O
1552  *
1553  * @mpd - bh describing space
1554  *
1555  * The function skips space we know is already mapped to disk blocks.
1556  *
1557  */
1558 static void mpage_da_map_and_submit(struct mpage_da_data *mpd)
1559 {
1560  int err, blks, get_blocks_flags;
1561  struct ext4_map_blocks map, *mapp = NULL;
1562  sector_t next = mpd->b_blocknr;
1563  unsigned max_blocks = mpd->b_size >> mpd->inode->i_blkbits;
1564  loff_t disksize = EXT4_I(mpd->inode)->i_disksize;
1565  handle_t *handle = NULL;
1566 
1567  /*
1568  * If the blocks are mapped already, or we couldn't accumulate
1569  * any blocks, then proceed immediately to the submission stage.
1570  */
1571  if ((mpd->b_size == 0) ||
1572  ((mpd->b_state & (1 << BH_Mapped)) &&
1573  !(mpd->b_state & (1 << BH_Delay)) &&
1574  !(mpd->b_state & (1 << BH_Unwritten))))
1575  goto submit_io;
1576 
1577  handle = ext4_journal_current_handle();
1578  BUG_ON(!handle);
1579 
1580  /*
1581  * Call ext4_map_blocks() to allocate any delayed allocation
1582  * blocks, or to convert an uninitialized extent to be
1583  * initialized (in the case where we have written into
1584  * one or more preallocated blocks).
1585  *
1586  * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE to
1587  * indicate that we are on the delayed allocation path. This
1588  * affects functions in many different parts of the allocation
1589  * call path. This flag exists primarily because we don't
1590  * want to change *many* call functions, so ext4_map_blocks()
1591  * will set the EXT4_STATE_DELALLOC_RESERVED flag once the
1592  * inode's allocation semaphore is taken.
1593  *
1594  * If the blocks in questions were delalloc blocks, set
1595  * EXT4_GET_BLOCKS_DELALLOC_RESERVE so the delalloc accounting
1596  * variables are updated after the blocks have been allocated.
1597  */
1598  map.m_lblk = next;
1599  map.m_len = max_blocks;
1600  get_blocks_flags = EXT4_GET_BLOCKS_CREATE;
1601  if (ext4_should_dioread_nolock(mpd->inode))
1602  get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT;
1603  if (mpd->b_state & (1 << BH_Delay))
1604  get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE;
1605 
1606  blks = ext4_map_blocks(handle, mpd->inode, &map, get_blocks_flags);
1607  if (blks < 0) {
1608  struct super_block *sb = mpd->inode->i_sb;
1609 
1610  err = blks;
1611  /*
1612  * If get block returns EAGAIN or ENOSPC and there
1613  * appears to be free blocks we will just let
1614  * mpage_da_submit_io() unlock all of the pages.
1615  */
1616  if (err == -EAGAIN)
1617  goto submit_io;
1618 
1619  if (err == -ENOSPC && ext4_count_free_clusters(sb)) {
1620  mpd->retval = err;
1621  goto submit_io;
1622  }
1623 
1624  /*
1625  * get block failure will cause us to loop in
1626  * writepages, because a_ops->writepage won't be able
1627  * to make progress. The page will be redirtied by
1628  * writepage and writepages will again try to write
1629  * the same.
1630  */
1631  if (!(EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)) {
1632  ext4_msg(sb, KERN_CRIT,
1633  "delayed block allocation failed for inode %lu "
1634  "at logical offset %llu with max blocks %zd "
1635  "with error %d", mpd->inode->i_ino,
1636  (unsigned long long) next,
1637  mpd->b_size >> mpd->inode->i_blkbits, err);
1638  ext4_msg(sb, KERN_CRIT,
1639  "This should not happen!! Data will be lost\n");
1640  if (err == -ENOSPC)
1641  ext4_print_free_blocks(mpd->inode);
1642  }
1643  /* invalidate all the pages */
1644  ext4_da_block_invalidatepages(mpd);
1645 
1646  /* Mark this page range as having been completed */
1647  mpd->io_done = 1;
1648  return;
1649  }
1650  BUG_ON(blks == 0);
1651 
1652  mapp = &map;
1653  if (map.m_flags & EXT4_MAP_NEW) {
1654  struct block_device *bdev = mpd->inode->i_sb->s_bdev;
1655  int i;
1656 
1657  for (i = 0; i < map.m_len; i++)
1658  unmap_underlying_metadata(bdev, map.m_pblk + i);
1659 
1660  if (ext4_should_order_data(mpd->inode)) {
1661  err = ext4_jbd2_file_inode(handle, mpd->inode);
1662  if (err) {
1663  /* Only if the journal is aborted */
1664  mpd->retval = err;
1665  goto submit_io;
1666  }
1667  }
1668  }
1669 
1670  /*
1671  * Update on-disk size along with block allocation.
1672  */
1673  disksize = ((loff_t) next + blks) << mpd->inode->i_blkbits;
1674  if (disksize > i_size_read(mpd->inode))
1675  disksize = i_size_read(mpd->inode);
1676  if (disksize > EXT4_I(mpd->inode)->i_disksize) {
1677  ext4_update_i_disksize(mpd->inode, disksize);
1678  err = ext4_mark_inode_dirty(handle, mpd->inode);
1679  if (err)
1680  ext4_error(mpd->inode->i_sb,
1681  "Failed to mark inode %lu dirty",
1682  mpd->inode->i_ino);
1683  }
1684 
1685 submit_io:
1686  mpage_da_submit_io(mpd, mapp);
1687  mpd->io_done = 1;
1688 }
1689 
1690 #define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | \
1691  (1 << BH_Delay) | (1 << BH_Unwritten))
1692 
1693 /*
1694  * mpage_add_bh_to_extent - try to add one more block to extent of blocks
1695  *
1696  * @mpd->lbh - extent of blocks
1697  * @logical - logical number of the block in the file
1698  * @bh - bh of the block (used to access block's state)
1699  *
1700  * the function is used to collect contig. blocks in same state
1701  */
1702 static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
1703  sector_t logical, size_t b_size,
1704  unsigned long b_state)
1705 {
1706  sector_t next;
1707  int nrblocks = mpd->b_size >> mpd->inode->i_blkbits;
1708 
1709  /*
1710  * XXX Don't go larger than mballoc is willing to allocate
1711  * This is a stopgap solution. We eventually need to fold
1712  * mpage_da_submit_io() into this function and then call
1713  * ext4_map_blocks() multiple times in a loop
1714  */
1715  if (nrblocks >= 8*1024*1024/mpd->inode->i_sb->s_blocksize)
1716  goto flush_it;
1717 
1718  /* check if thereserved journal credits might overflow */
1719  if (!(ext4_test_inode_flag(mpd->inode, EXT4_INODE_EXTENTS))) {
1720  if (nrblocks >= EXT4_MAX_TRANS_DATA) {
1721  /*
1722  * With non-extent format we are limited by the journal
1723  * credit available. Total credit needed to insert
1724  * nrblocks contiguous blocks is dependent on the
1725  * nrblocks. So limit nrblocks.
1726  */
1727  goto flush_it;
1728  } else if ((nrblocks + (b_size >> mpd->inode->i_blkbits)) >
1730  /*
1731  * Adding the new buffer_head would make it cross the
1732  * allowed limit for which we have journal credit
1733  * reserved. So limit the new bh->b_size
1734  */
1735  b_size = (EXT4_MAX_TRANS_DATA - nrblocks) <<
1736  mpd->inode->i_blkbits;
1737  /* we will do mpage_da_submit_io in the next loop */
1738  }
1739  }
1740  /*
1741  * First block in the extent
1742  */
1743  if (mpd->b_size == 0) {
1744  mpd->b_blocknr = logical;
1745  mpd->b_size = b_size;
1746  mpd->b_state = b_state & BH_FLAGS;
1747  return;
1748  }
1749 
1750  next = mpd->b_blocknr + nrblocks;
1751  /*
1752  * Can we merge the block to our big extent?
1753  */
1754  if (logical == next && (b_state & BH_FLAGS) == mpd->b_state) {
1755  mpd->b_size += b_size;
1756  return;
1757  }
1758 
1759 flush_it:
1760  /*
1761  * We couldn't merge the block to our extent, so we
1762  * need to flush current extent and start new one
1763  */
1764  mpage_da_map_and_submit(mpd);
1765  return;
1766 }
1767 
1768 static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
1769 {
1770  return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
1771 }
1772 
1773 /*
1774  * This function is grabs code from the very beginning of
1775  * ext4_map_blocks, but assumes that the caller is from delayed write
1776  * time. This function looks up the requested blocks and sets the
1777  * buffer delay bit under the protection of i_data_sem.
1778  */
1779 static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
1780  struct ext4_map_blocks *map,
1781  struct buffer_head *bh)
1782 {
1783  int retval;
1784  sector_t invalid_block = ~((sector_t) 0xffff);
1785 
1786  if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
1787  invalid_block = ~0;
1788 
1789  map->m_flags = 0;
1790  ext_debug("ext4_da_map_blocks(): inode %lu, max_blocks %u,"
1791  "logical block %lu\n", inode->i_ino, map->m_len,
1792  (unsigned long) map->m_lblk);
1793  /*
1794  * Try to see if we can get the block without requesting a new
1795  * file system block.
1796  */
1797  down_read((&EXT4_I(inode)->i_data_sem));
1798  if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
1799  retval = ext4_ext_map_blocks(NULL, inode, map, 0);
1800  else
1801  retval = ext4_ind_map_blocks(NULL, inode, map, 0);
1802 
1803  if (retval == 0) {
1804  /*
1805  * XXX: __block_prepare_write() unmaps passed block,
1806  * is it OK?
1807  */
1808  /* If the block was allocated from previously allocated cluster,
1809  * then we dont need to reserve it again. */
1810  if (!(map->m_flags & EXT4_MAP_FROM_CLUSTER)) {
1811  retval = ext4_da_reserve_space(inode, iblock);
1812  if (retval)
1813  /* not enough space to reserve */
1814  goto out_unlock;
1815  }
1816 
1817  /* Clear EXT4_MAP_FROM_CLUSTER flag since its purpose is served
1818  * and it should not appear on the bh->b_state.
1819  */
1820  map->m_flags &= ~EXT4_MAP_FROM_CLUSTER;
1821 
1822  map_bh(bh, inode->i_sb, invalid_block);
1823  set_buffer_new(bh);
1824  set_buffer_delay(bh);
1825  }
1826 
1827 out_unlock:
1828  up_read((&EXT4_I(inode)->i_data_sem));
1829 
1830  return retval;
1831 }
1832 
1833 /*
1834  * This is a special get_blocks_t callback which is used by
1835  * ext4_da_write_begin(). It will either return mapped block or
1836  * reserve space for a single block.
1837  *
1838  * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
1839  * We also have b_blocknr = -1 and b_bdev initialized properly
1840  *
1841  * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
1842  * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
1843  * initialized properly.
1844  */
1845 static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
1846  struct buffer_head *bh, int create)
1847 {
1848  struct ext4_map_blocks map;
1849  int ret = 0;
1850 
1851  BUG_ON(create == 0);
1852  BUG_ON(bh->b_size != inode->i_sb->s_blocksize);
1853 
1854  map.m_lblk = iblock;
1855  map.m_len = 1;
1856 
1857  /*
1858  * first, we need to know whether the block is allocated already
1859  * preallocated blocks are unmapped but should treated
1860  * the same as allocated blocks.
1861  */
1862  ret = ext4_da_map_blocks(inode, iblock, &map, bh);
1863  if (ret <= 0)
1864  return ret;
1865 
1866  map_bh(bh, inode->i_sb, map.m_pblk);
1867  bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
1868 
1869  if (buffer_unwritten(bh)) {
1870  /* A delayed write to unwritten bh should be marked
1871  * new and mapped. Mapped ensures that we don't do
1872  * get_block multiple times when we write to the same
1873  * offset and new ensures that we do proper zero out
1874  * for partial write.
1875  */
1876  set_buffer_new(bh);
1877  set_buffer_mapped(bh);
1878  }
1879  return 0;
1880 }
1881 
1882 /*
1883  * This function is used as a standard get_block_t calback function
1884  * when there is no desire to allocate any blocks. It is used as a
1885  * callback function for block_write_begin() and block_write_full_page().
1886  * These functions should only try to map a single block at a time.
1887  *
1888  * Since this function doesn't do block allocations even if the caller
1889  * requests it by passing in create=1, it is critically important that
1890  * any caller checks to make sure that any buffer heads are returned
1891  * by this function are either all already mapped or marked for
1892  * delayed allocation before calling block_write_full_page(). Otherwise,
1893  * b_blocknr could be left unitialized, and the page write functions will
1894  * be taken by surprise.
1895  */
1896 static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
1897  struct buffer_head *bh_result, int create)
1898 {
1899  BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
1900  return _ext4_get_block(inode, iblock, bh_result, 0);
1901 }
1902 
1903 static int bget_one(handle_t *handle, struct buffer_head *bh)
1904 {
1905  get_bh(bh);
1906  return 0;
1907 }
1908 
1909 static int bput_one(handle_t *handle, struct buffer_head *bh)
1910 {
1911  put_bh(bh);
1912  return 0;
1913 }
1914 
1915 static int __ext4_journalled_writepage(struct page *page,
1916  unsigned int len)
1917 {
1918  struct address_space *mapping = page->mapping;
1919  struct inode *inode = mapping->host;
1920  struct buffer_head *page_bufs;
1921  handle_t *handle = NULL;
1922  int ret = 0;
1923  int err;
1924 
1925  ClearPageChecked(page);
1926  page_bufs = page_buffers(page);
1927  BUG_ON(!page_bufs);
1928  walk_page_buffers(handle, page_bufs, 0, len, NULL, bget_one);
1929  /* As soon as we unlock the page, it can go away, but we have
1930  * references to buffers so we are safe */
1931  unlock_page(page);
1932 
1933  handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
1934  if (IS_ERR(handle)) {
1935  ret = PTR_ERR(handle);
1936  goto out;
1937  }
1938 
1939  BUG_ON(!ext4_handle_valid(handle));
1940 
1941  ret = walk_page_buffers(handle, page_bufs, 0, len, NULL,
1942  do_journal_get_write_access);
1943 
1944  err = walk_page_buffers(handle, page_bufs, 0, len, NULL,
1945  write_end_fn);
1946  if (ret == 0)
1947  ret = err;
1948  EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1949  err = ext4_journal_stop(handle);
1950  if (!ret)
1951  ret = err;
1952 
1953  walk_page_buffers(handle, page_bufs, 0, len, NULL, bput_one);
1954  ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1955 out:
1956  return ret;
1957 }
1958 
1959 /*
1960  * Note that we don't need to start a transaction unless we're journaling data
1961  * because we should have holes filled from ext4_page_mkwrite(). We even don't
1962  * need to file the inode to the transaction's list in ordered mode because if
1963  * we are writing back data added by write(), the inode is already there and if
1964  * we are writing back data modified via mmap(), no one guarantees in which
1965  * transaction the data will hit the disk. In case we are journaling data, we
1966  * cannot start transaction directly because transaction start ranks above page
1967  * lock so we have to do some magic.
1968  *
1969  * This function can get called via...
1970  * - ext4_da_writepages after taking page lock (have journal handle)
1971  * - journal_submit_inode_data_buffers (no journal handle)
1972  * - shrink_page_list via the kswapd/direct reclaim (no journal handle)
1973  * - grab_page_cache when doing write_begin (have journal handle)
1974  *
1975  * We don't do any block allocation in this function. If we have page with
1976  * multiple blocks we need to write those buffer_heads that are mapped. This
1977  * is important for mmaped based write. So if we do with blocksize 1K
1978  * truncate(f, 1024);
1979  * a = mmap(f, 0, 4096);
1980  * a[0] = 'a';
1981  * truncate(f, 4096);
1982  * we have in the page first buffer_head mapped via page_mkwrite call back
1983  * but other buffer_heads would be unmapped but dirty (dirty done via the
1984  * do_wp_page). So writepage should write the first block. If we modify
1985  * the mmap area beyond 1024 we will again get a page_fault and the
1986  * page_mkwrite callback will do the block allocation and mark the
1987  * buffer_heads mapped.
1988  *
1989  * We redirty the page if we have any buffer_heads that is either delay or
1990  * unwritten in the page.
1991  *
1992  * We can get recursively called as show below.
1993  *
1994  * ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1995  * ext4_writepage()
1996  *
1997  * But since we don't do any block allocation we should not deadlock.
1998  * Page also have the dirty flag cleared so we don't get recurive page_lock.
1999  */
2000 static int ext4_writepage(struct page *page,
2001  struct writeback_control *wbc)
2002 {
2003  int ret = 0, commit_write = 0;
2004  loff_t size;
2005  unsigned int len;
2006  struct buffer_head *page_bufs = NULL;
2007  struct inode *inode = page->mapping->host;
2008 
2009  trace_ext4_writepage(page);
2010  size = i_size_read(inode);
2011  if (page->index == size >> PAGE_CACHE_SHIFT)
2012  len = size & ~PAGE_CACHE_MASK;
2013  else
2014  len = PAGE_CACHE_SIZE;
2015 
2016  /*
2017  * If the page does not have buffers (for whatever reason),
2018  * try to create them using __block_write_begin. If this
2019  * fails, redirty the page and move on.
2020  */
2021  if (!page_has_buffers(page)) {
2022  if (__block_write_begin(page, 0, len,
2023  noalloc_get_block_write)) {
2024  redirty_page:
2025  redirty_page_for_writepage(wbc, page);
2026  unlock_page(page);
2027  return 0;
2028  }
2029  commit_write = 1;
2030  }
2031  page_bufs = page_buffers(page);
2032  if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
2033  ext4_bh_delay_or_unwritten)) {
2034  /*
2035  * We don't want to do block allocation, so redirty
2036  * the page and return. We may reach here when we do
2037  * a journal commit via journal_submit_inode_data_buffers.
2038  * We can also reach here via shrink_page_list but it
2039  * should never be for direct reclaim so warn if that
2040  * happens
2041  */
2042  WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
2043  PF_MEMALLOC);
2044  goto redirty_page;
2045  }
2046  if (commit_write)
2047  /* now mark the buffer_heads as dirty and uptodate */
2048  block_commit_write(page, 0, len);
2049 
2050  if (PageChecked(page) && ext4_should_journal_data(inode))
2051  /*
2052  * It's mmapped pagecache. Add buffers and journal it. There
2053  * doesn't seem much point in redirtying the page here.
2054  */
2055  return __ext4_journalled_writepage(page, len);
2056 
2057  if (buffer_uninit(page_bufs)) {
2058  ext4_set_bh_endio(page_bufs, inode);
2059  ret = block_write_full_page_endio(page, noalloc_get_block_write,
2060  wbc, ext4_end_io_buffer_write);
2061  } else
2062  ret = block_write_full_page(page, noalloc_get_block_write,
2063  wbc);
2064 
2065  return ret;
2066 }
2067 
2068 /*
2069  * This is called via ext4_da_writepages() to
2070  * calculate the total number of credits to reserve to fit
2071  * a single extent allocation into a single transaction,
2072  * ext4_da_writpeages() will loop calling this before
2073  * the block allocation.
2074  */
2075 
2076 static int ext4_da_writepages_trans_blocks(struct inode *inode)
2077 {
2078  int max_blocks = EXT4_I(inode)->i_reserved_data_blocks;
2079 
2080  /*
2081  * With non-extent format the journal credit needed to
2082  * insert nrblocks contiguous block is dependent on
2083  * number of contiguous block. So we will limit
2084  * number of contiguous block to a sane value
2085  */
2086  if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) &&
2087  (max_blocks > EXT4_MAX_TRANS_DATA))
2088  max_blocks = EXT4_MAX_TRANS_DATA;
2089 
2090  return ext4_chunk_trans_blocks(inode, max_blocks);
2091 }
2092 
2093 /*
2094  * write_cache_pages_da - walk the list of dirty pages of the given
2095  * address space and accumulate pages that need writing, and call
2096  * mpage_da_map_and_submit to map a single contiguous memory region
2097  * and then write them.
2098  */
2099 static int write_cache_pages_da(struct address_space *mapping,
2100  struct writeback_control *wbc,
2101  struct mpage_da_data *mpd,
2102  pgoff_t *done_index)
2103 {
2104  struct buffer_head *bh, *head;
2105  struct inode *inode = mapping->host;
2106  struct pagevec pvec;
2107  unsigned int nr_pages;
2108  sector_t logical;
2109  pgoff_t index, end;
2110  long nr_to_write = wbc->nr_to_write;
2111  int i, tag, ret = 0;
2112 
2113  memset(mpd, 0, sizeof(struct mpage_da_data));
2114  mpd->wbc = wbc;
2115  mpd->inode = inode;
2116  pagevec_init(&pvec, 0);
2117  index = wbc->range_start >> PAGE_CACHE_SHIFT;
2118  end = wbc->range_end >> PAGE_CACHE_SHIFT;
2119 
2120  if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
2121  tag = PAGECACHE_TAG_TOWRITE;
2122  else
2123  tag = PAGECACHE_TAG_DIRTY;
2124 
2125  *done_index = index;
2126  while (index <= end) {
2127  nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
2128  min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
2129  if (nr_pages == 0)
2130  return 0;
2131 
2132  for (i = 0; i < nr_pages; i++) {
2133  struct page *page = pvec.pages[i];
2134 
2135  /*
2136  * At this point, the page may be truncated or
2137  * invalidated (changing page->mapping to NULL), or
2138  * even swizzled back from swapper_space to tmpfs file
2139  * mapping. However, page->index will not change
2140  * because we have a reference on the page.
2141  */
2142  if (page->index > end)
2143  goto out;
2144 
2145  *done_index = page->index + 1;
2146 
2147  /*
2148  * If we can't merge this page, and we have
2149  * accumulated an contiguous region, write it
2150  */
2151  if ((mpd->next_page != page->index) &&
2152  (mpd->next_page != mpd->first_page)) {
2153  mpage_da_map_and_submit(mpd);
2154  goto ret_extent_tail;
2155  }
2156 
2157  lock_page(page);
2158 
2159  /*
2160  * If the page is no longer dirty, or its
2161  * mapping no longer corresponds to inode we
2162  * are writing (which means it has been
2163  * truncated or invalidated), or the page is
2164  * already under writeback and we are not
2165  * doing a data integrity writeback, skip the page
2166  */
2167  if (!PageDirty(page) ||
2168  (PageWriteback(page) &&
2169  (wbc->sync_mode == WB_SYNC_NONE)) ||
2170  unlikely(page->mapping != mapping)) {
2171  unlock_page(page);
2172  continue;
2173  }
2174 
2175  wait_on_page_writeback(page);
2176  BUG_ON(PageWriteback(page));
2177 
2178  if (mpd->next_page != page->index)
2179  mpd->first_page = page->index;
2180  mpd->next_page = page->index + 1;
2181  logical = (sector_t) page->index <<
2182  (PAGE_CACHE_SHIFT - inode->i_blkbits);
2183 
2184  if (!page_has_buffers(page)) {
2185  mpage_add_bh_to_extent(mpd, logical,
2187  (1 << BH_Dirty) | (1 << BH_Uptodate));
2188  if (mpd->io_done)
2189  goto ret_extent_tail;
2190  } else {
2191  /*
2192  * Page with regular buffer heads,
2193  * just add all dirty ones
2194  */
2195  head = page_buffers(page);
2196  bh = head;
2197  do {
2198  BUG_ON(buffer_locked(bh));
2199  /*
2200  * We need to try to allocate
2201  * unmapped blocks in the same page.
2202  * Otherwise we won't make progress
2203  * with the page in ext4_writepage
2204  */
2205  if (ext4_bh_delay_or_unwritten(NULL, bh)) {
2206  mpage_add_bh_to_extent(mpd, logical,
2207  bh->b_size,
2208  bh->b_state);
2209  if (mpd->io_done)
2210  goto ret_extent_tail;
2211  } else if (buffer_dirty(bh) && (buffer_mapped(bh))) {
2212  /*
2213  * mapped dirty buffer. We need
2214  * to update the b_state
2215  * because we look at b_state
2216  * in mpage_da_map_blocks. We
2217  * don't update b_size because
2218  * if we find an unmapped
2219  * buffer_head later we need to
2220  * use the b_state flag of that
2221  * buffer_head.
2222  */
2223  if (mpd->b_size == 0)
2224  mpd->b_state = bh->b_state & BH_FLAGS;
2225  }
2226  logical++;
2227  } while ((bh = bh->b_this_page) != head);
2228  }
2229 
2230  if (nr_to_write > 0) {
2231  nr_to_write--;
2232  if (nr_to_write == 0 &&
2233  wbc->sync_mode == WB_SYNC_NONE)
2234  /*
2235  * We stop writing back only if we are
2236  * not doing integrity sync. In case of
2237  * integrity sync we have to keep going
2238  * because someone may be concurrently
2239  * dirtying pages, and we might have
2240  * synced a lot of newly appeared dirty
2241  * pages, but have not synced all of the
2242  * old dirty pages.
2243  */
2244  goto out;
2245  }
2246  }
2247  pagevec_release(&pvec);
2248  cond_resched();
2249  }
2250  return 0;
2251 ret_extent_tail:
2252  ret = MPAGE_DA_EXTENT_TAIL;
2253 out:
2254  pagevec_release(&pvec);
2255  cond_resched();
2256  return ret;
2257 }
2258 
2259 
2260 static int ext4_da_writepages(struct address_space *mapping,
2261  struct writeback_control *wbc)
2262 {
2263  pgoff_t index;
2264  int range_whole = 0;
2265  handle_t *handle = NULL;
2266  struct mpage_da_data mpd;
2267  struct inode *inode = mapping->host;
2268  int pages_written = 0;
2269  unsigned int max_pages;
2270  int range_cyclic, cycled = 1, io_done = 0;
2271  int needed_blocks, ret = 0;
2272  long desired_nr_to_write, nr_to_writebump = 0;
2273  loff_t range_start = wbc->range_start;
2274  struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
2275  pgoff_t done_index = 0;
2276  pgoff_t end;
2277  struct blk_plug plug;
2278 
2279  trace_ext4_da_writepages(inode, wbc);
2280 
2281  /*
2282  * No pages to write? This is mainly a kludge to avoid starting
2283  * a transaction for special inodes like journal inode on last iput()
2284  * because that could violate lock ordering on umount
2285  */
2286  if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2287  return 0;
2288 
2289  /*
2290  * If the filesystem has aborted, it is read-only, so return
2291  * right away instead of dumping stack traces later on that
2292  * will obscure the real source of the problem. We test
2293  * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2294  * the latter could be true if the filesystem is mounted
2295  * read-only, and in that case, ext4_da_writepages should
2296  * *never* be called, so if that ever happens, we would want
2297  * the stack trace.
2298  */
2299  if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED))
2300  return -EROFS;
2301 
2302  if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2303  range_whole = 1;
2304 
2305  range_cyclic = wbc->range_cyclic;
2306  if (wbc->range_cyclic) {
2307  index = mapping->writeback_index;
2308  if (index)
2309  cycled = 0;
2310  wbc->range_start = index << PAGE_CACHE_SHIFT;
2311  wbc->range_end = LLONG_MAX;
2312  wbc->range_cyclic = 0;
2313  end = -1;
2314  } else {
2315  index = wbc->range_start >> PAGE_CACHE_SHIFT;
2316  end = wbc->range_end >> PAGE_CACHE_SHIFT;
2317  }
2318 
2319  /*
2320  * This works around two forms of stupidity. The first is in
2321  * the writeback code, which caps the maximum number of pages
2322  * written to be 1024 pages. This is wrong on multiple
2323  * levels; different architectues have a different page size,
2324  * which changes the maximum amount of data which gets
2325  * written. Secondly, 4 megabytes is way too small. XFS
2326  * forces this value to be 16 megabytes by multiplying
2327  * nr_to_write parameter by four, and then relies on its
2328  * allocator to allocate larger extents to make them
2329  * contiguous. Unfortunately this brings us to the second
2330  * stupidity, which is that ext4's mballoc code only allocates
2331  * at most 2048 blocks. So we force contiguous writes up to
2332  * the number of dirty blocks in the inode, or
2333  * sbi->max_writeback_mb_bump whichever is smaller.
2334  */
2335  max_pages = sbi->s_max_writeback_mb_bump << (20 - PAGE_CACHE_SHIFT);
2336  if (!range_cyclic && range_whole) {
2337  if (wbc->nr_to_write == LONG_MAX)
2338  desired_nr_to_write = wbc->nr_to_write;
2339  else
2340  desired_nr_to_write = wbc->nr_to_write * 8;
2341  } else
2342  desired_nr_to_write = ext4_num_dirty_pages(inode, index,
2343  max_pages);
2344  if (desired_nr_to_write > max_pages)
2345  desired_nr_to_write = max_pages;
2346 
2347  if (wbc->nr_to_write < desired_nr_to_write) {
2348  nr_to_writebump = desired_nr_to_write - wbc->nr_to_write;
2349  wbc->nr_to_write = desired_nr_to_write;
2350  }
2351 
2352 retry:
2353  if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
2354  tag_pages_for_writeback(mapping, index, end);
2355 
2356  blk_start_plug(&plug);
2357  while (!ret && wbc->nr_to_write > 0) {
2358 
2359  /*
2360  * we insert one extent at a time. So we need
2361  * credit needed for single extent allocation.
2362  * journalled mode is currently not supported
2363  * by delalloc
2364  */
2365  BUG_ON(ext4_should_journal_data(inode));
2366  needed_blocks = ext4_da_writepages_trans_blocks(inode);
2367 
2368  /* start a new transaction*/
2369  handle = ext4_journal_start(inode, needed_blocks);
2370  if (IS_ERR(handle)) {
2371  ret = PTR_ERR(handle);
2372  ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2373  "%ld pages, ino %lu; err %d", __func__,
2374  wbc->nr_to_write, inode->i_ino, ret);
2375  blk_finish_plug(&plug);
2376  goto out_writepages;
2377  }
2378 
2379  /*
2380  * Now call write_cache_pages_da() to find the next
2381  * contiguous region of logical blocks that need
2382  * blocks to be allocated by ext4 and submit them.
2383  */
2384  ret = write_cache_pages_da(mapping, wbc, &mpd, &done_index);
2385  /*
2386  * If we have a contiguous extent of pages and we
2387  * haven't done the I/O yet, map the blocks and submit
2388  * them for I/O.
2389  */
2390  if (!mpd.io_done && mpd.next_page != mpd.first_page) {
2391  mpage_da_map_and_submit(&mpd);
2392  ret = MPAGE_DA_EXTENT_TAIL;
2393  }
2394  trace_ext4_da_write_pages(inode, &mpd);
2395  wbc->nr_to_write -= mpd.pages_written;
2396 
2397  ext4_journal_stop(handle);
2398 
2399  if ((mpd.retval == -ENOSPC) && sbi->s_journal) {
2400  /* commit the transaction which would
2401  * free blocks released in the transaction
2402  * and try again
2403  */
2404  jbd2_journal_force_commit_nested(sbi->s_journal);
2405  ret = 0;
2406  } else if (ret == MPAGE_DA_EXTENT_TAIL) {
2407  /*
2408  * Got one extent now try with rest of the pages.
2409  * If mpd.retval is set -EIO, journal is aborted.
2410  * So we don't need to write any more.
2411  */
2412  pages_written += mpd.pages_written;
2413  ret = mpd.retval;
2414  io_done = 1;
2415  } else if (wbc->nr_to_write)
2416  /*
2417  * There is no more writeout needed
2418  * or we requested for a noblocking writeout
2419  * and we found the device congested
2420  */
2421  break;
2422  }
2423  blk_finish_plug(&plug);
2424  if (!io_done && !cycled) {
2425  cycled = 1;
2426  index = 0;
2427  wbc->range_start = index << PAGE_CACHE_SHIFT;
2428  wbc->range_end = mapping->writeback_index - 1;
2429  goto retry;
2430  }
2431 
2432  /* Update index */
2433  wbc->range_cyclic = range_cyclic;
2434  if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2435  /*
2436  * set the writeback_index so that range_cyclic
2437  * mode will write it back later
2438  */
2439  mapping->writeback_index = done_index;
2440 
2441 out_writepages:
2442  wbc->nr_to_write -= nr_to_writebump;
2443  wbc->range_start = range_start;
2444  trace_ext4_da_writepages_result(inode, wbc, ret, pages_written);
2445  return ret;
2446 }
2447 
2448 #define FALL_BACK_TO_NONDELALLOC 1
2449 static int ext4_nonda_switch(struct super_block *sb)
2450 {
2451  s64 free_blocks, dirty_blocks;
2452  struct ext4_sb_info *sbi = EXT4_SB(sb);
2453 
2454  /*
2455  * switch to non delalloc mode if we are running low
2456  * on free block. The free block accounting via percpu
2457  * counters can get slightly wrong with percpu_counter_batch getting
2458  * accumulated on each CPU without updating global counters
2459  * Delalloc need an accurate free block accounting. So switch
2460  * to non delalloc when we are near to error range.
2461  */
2462  free_blocks = EXT4_C2B(sbi,
2463  percpu_counter_read_positive(&sbi->s_freeclusters_counter));
2464  dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
2465  /*
2466  * Start pushing delalloc when 1/2 of free blocks are dirty.
2467  */
2468  if (dirty_blocks && (free_blocks < 2 * dirty_blocks) &&
2469  !writeback_in_progress(sb->s_bdi) &&
2470  down_read_trylock(&sb->s_umount)) {
2472  up_read(&sb->s_umount);
2473  }
2474 
2475  if (2 * free_blocks < 3 * dirty_blocks ||
2476  free_blocks < (dirty_blocks + EXT4_FREECLUSTERS_WATERMARK)) {
2477  /*
2478  * free block count is less than 150% of dirty blocks
2479  * or free blocks is less than watermark
2480  */
2481  return 1;
2482  }
2483  return 0;
2484 }
2485 
2486 static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
2487  loff_t pos, unsigned len, unsigned flags,
2488  struct page **pagep, void **fsdata)
2489 {
2490  int ret, retries = 0;
2491  struct page *page;
2492  pgoff_t index;
2493  struct inode *inode = mapping->host;
2494  handle_t *handle;
2495 
2496  index = pos >> PAGE_CACHE_SHIFT;
2497 
2498  if (ext4_nonda_switch(inode->i_sb)) {
2499  *fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
2500  return ext4_write_begin(file, mapping, pos,
2501  len, flags, pagep, fsdata);
2502  }
2503  *fsdata = (void *)0;
2504  trace_ext4_da_write_begin(inode, pos, len, flags);
2505 retry:
2506  /*
2507  * With delayed allocation, we don't log the i_disksize update
2508  * if there is delayed block allocation. But we still need
2509  * to journalling the i_disksize update if writes to the end
2510  * of file which has an already mapped buffer.
2511  */
2512  handle = ext4_journal_start(inode, 1);
2513  if (IS_ERR(handle)) {
2514  ret = PTR_ERR(handle);
2515  goto out;
2516  }
2517  /* We cannot recurse into the filesystem as the transaction is already
2518  * started */
2519  flags |= AOP_FLAG_NOFS;
2520 
2521  page = grab_cache_page_write_begin(mapping, index, flags);
2522  if (!page) {
2523  ext4_journal_stop(handle);
2524  ret = -ENOMEM;
2525  goto out;
2526  }
2527  *pagep = page;
2528 
2529  ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
2530  if (ret < 0) {
2531  unlock_page(page);
2532  ext4_journal_stop(handle);
2533  page_cache_release(page);
2534  /*
2535  * block_write_begin may have instantiated a few blocks
2536  * outside i_size. Trim these off again. Don't need
2537  * i_size_read because we hold i_mutex.
2538  */
2539  if (pos + len > inode->i_size)
2540  ext4_truncate_failed_write(inode);
2541  }
2542 
2543  if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
2544  goto retry;
2545 out:
2546  return ret;
2547 }
2548 
2549 /*
2550  * Check if we should update i_disksize
2551  * when write to the end of file but not require block allocation
2552  */
2553 static int ext4_da_should_update_i_disksize(struct page *page,
2554  unsigned long offset)
2555 {
2556  struct buffer_head *bh;
2557  struct inode *inode = page->mapping->host;
2558  unsigned int idx;
2559  int i;
2560 
2561  bh = page_buffers(page);
2562  idx = offset >> inode->i_blkbits;
2563 
2564  for (i = 0; i < idx; i++)
2565  bh = bh->b_this_page;
2566 
2567  if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
2568  return 0;
2569  return 1;
2570 }
2571 
2572 static int ext4_da_write_end(struct file *file,
2573  struct address_space *mapping,
2574  loff_t pos, unsigned len, unsigned copied,
2575  struct page *page, void *fsdata)
2576 {
2577  struct inode *inode = mapping->host;
2578  int ret = 0, ret2;
2579  handle_t *handle = ext4_journal_current_handle();
2580  loff_t new_i_size;
2581  unsigned long start, end;
2582  int write_mode = (int)(unsigned long)fsdata;
2583 
2584  if (write_mode == FALL_BACK_TO_NONDELALLOC) {
2585  switch (ext4_inode_journal_mode(inode)) {
2587  return ext4_ordered_write_end(file, mapping, pos,
2588  len, copied, page, fsdata);
2590  return ext4_writeback_write_end(file, mapping, pos,
2591  len, copied, page, fsdata);
2592  default:
2593  BUG();
2594  }
2595  }
2596 
2597  trace_ext4_da_write_end(inode, pos, len, copied);
2598  start = pos & (PAGE_CACHE_SIZE - 1);
2599  end = start + copied - 1;
2600 
2601  /*
2602  * generic_write_end() will run mark_inode_dirty() if i_size
2603  * changes. So let's piggyback the i_disksize mark_inode_dirty
2604  * into that.
2605  */
2606 
2607  new_i_size = pos + copied;
2608  if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
2609  if (ext4_da_should_update_i_disksize(page, end)) {
2610  down_write(&EXT4_I(inode)->i_data_sem);
2611  if (new_i_size > EXT4_I(inode)->i_disksize) {
2612  /*
2613  * Updating i_disksize when extending file
2614  * without needing block allocation
2615  */
2616  if (ext4_should_order_data(inode))
2617  ret = ext4_jbd2_file_inode(handle,
2618  inode);
2619 
2620  EXT4_I(inode)->i_disksize = new_i_size;
2621  }
2622  up_write(&EXT4_I(inode)->i_data_sem);
2623  /* We need to mark inode dirty even if
2624  * new_i_size is less that inode->i_size
2625  * bu greater than i_disksize.(hint delalloc)
2626  */
2627  ext4_mark_inode_dirty(handle, inode);
2628  }
2629  }
2630  ret2 = generic_write_end(file, mapping, pos, len, copied,
2631  page, fsdata);
2632  copied = ret2;
2633  if (ret2 < 0)
2634  ret = ret2;
2635  ret2 = ext4_journal_stop(handle);
2636  if (!ret)
2637  ret = ret2;
2638 
2639  return ret ? ret : copied;
2640 }
2641 
2642 static void ext4_da_invalidatepage(struct page *page, unsigned long offset)
2643 {
2644  /*
2645  * Drop reserved blocks
2646  */
2647  BUG_ON(!PageLocked(page));
2648  if (!page_has_buffers(page))
2649  goto out;
2650 
2651  ext4_da_page_release_reservation(page, offset);
2652 
2653 out:
2654  ext4_invalidatepage(page, offset);
2655 
2656  return;
2657 }
2658 
2659 /*
2660  * Force all delayed allocation blocks to be allocated for a given inode.
2661  */
2662 int ext4_alloc_da_blocks(struct inode *inode)
2663 {
2664  trace_ext4_alloc_da_blocks(inode);
2665 
2666  if (!EXT4_I(inode)->i_reserved_data_blocks &&
2667  !EXT4_I(inode)->i_reserved_meta_blocks)
2668  return 0;
2669 
2670  /*
2671  * We do something simple for now. The filemap_flush() will
2672  * also start triggering a write of the data blocks, which is
2673  * not strictly speaking necessary (and for users of
2674  * laptop_mode, not even desirable). However, to do otherwise
2675  * would require replicating code paths in:
2676  *
2677  * ext4_da_writepages() ->
2678  * write_cache_pages() ---> (via passed in callback function)
2679  * __mpage_da_writepage() -->
2680  * mpage_add_bh_to_extent()
2681  * mpage_da_map_blocks()
2682  *
2683  * The problem is that write_cache_pages(), located in
2684  * mm/page-writeback.c, marks pages clean in preparation for
2685  * doing I/O, which is not desirable if we're not planning on
2686  * doing I/O at all.
2687  *
2688  * We could call write_cache_pages(), and then redirty all of
2689  * the pages by calling redirty_page_for_writepage() but that
2690  * would be ugly in the extreme. So instead we would need to
2691  * replicate parts of the code in the above functions,
2692  * simplifying them because we wouldn't actually intend to
2693  * write out the pages, but rather only collect contiguous
2694  * logical block extents, call the multi-block allocator, and
2695  * then update the buffer heads with the block allocations.
2696  *
2697  * For now, though, we'll cheat by calling filemap_flush(),
2698  * which will map the blocks, and start the I/O, but not
2699  * actually wait for the I/O to complete.
2700  */
2701  return filemap_flush(inode->i_mapping);
2702 }
2703 
2704 /*
2705  * bmap() is special. It gets used by applications such as lilo and by
2706  * the swapper to find the on-disk block of a specific piece of data.
2707  *
2708  * Naturally, this is dangerous if the block concerned is still in the
2709  * journal. If somebody makes a swapfile on an ext4 data-journaling
2710  * filesystem and enables swap, then they may get a nasty shock when the
2711  * data getting swapped to that swapfile suddenly gets overwritten by
2712  * the original zero's written out previously to the journal and
2713  * awaiting writeback in the kernel's buffer cache.
2714  *
2715  * So, if we see any bmap calls here on a modified, data-journaled file,
2716  * take extra steps to flush any blocks which might be in the cache.
2717  */
2718 static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
2719 {
2720  struct inode *inode = mapping->host;
2721  journal_t *journal;
2722  int err;
2723 
2724  if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) &&
2725  test_opt(inode->i_sb, DELALLOC)) {
2726  /*
2727  * With delalloc we want to sync the file
2728  * so that we can make sure we allocate
2729  * blocks for file
2730  */
2731  filemap_write_and_wait(mapping);
2732  }
2733 
2734  if (EXT4_JOURNAL(inode) &&
2735  ext4_test_inode_state(inode, EXT4_STATE_JDATA)) {
2736  /*
2737  * This is a REALLY heavyweight approach, but the use of
2738  * bmap on dirty files is expected to be extremely rare:
2739  * only if we run lilo or swapon on a freshly made file
2740  * do we expect this to happen.
2741  *
2742  * (bmap requires CAP_SYS_RAWIO so this does not
2743  * represent an unprivileged user DOS attack --- we'd be
2744  * in trouble if mortal users could trigger this path at
2745  * will.)
2746  *
2747  * NB. EXT4_STATE_JDATA is not set on files other than
2748  * regular files. If somebody wants to bmap a directory
2749  * or symlink and gets confused because the buffer
2750  * hasn't yet been flushed to disk, they deserve
2751  * everything they get.
2752  */
2753 
2754  ext4_clear_inode_state(inode, EXT4_STATE_JDATA);
2755  journal = EXT4_JOURNAL(inode);
2756  jbd2_journal_lock_updates(journal);
2757  err = jbd2_journal_flush(journal);
2758  jbd2_journal_unlock_updates(journal);
2759 
2760  if (err)
2761  return 0;
2762  }
2763 
2764  return generic_block_bmap(mapping, block, ext4_get_block);
2765 }
2766 
2767 static int ext4_readpage(struct file *file, struct page *page)
2768 {
2769  trace_ext4_readpage(page);
2770  return mpage_readpage(page, ext4_get_block);
2771 }
2772 
2773 static int
2774 ext4_readpages(struct file *file, struct address_space *mapping,
2775  struct list_head *pages, unsigned nr_pages)
2776 {
2777  return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
2778 }
2779 
2780 static void ext4_invalidatepage_free_endio(struct page *page, unsigned long offset)
2781 {
2782  struct buffer_head *head, *bh;
2783  unsigned int curr_off = 0;
2784 
2785  if (!page_has_buffers(page))
2786  return;
2787  head = bh = page_buffers(page);
2788  do {
2789  if (offset <= curr_off && test_clear_buffer_uninit(bh)
2790  && bh->b_private) {
2791  ext4_free_io_end(bh->b_private);
2792  bh->b_private = NULL;
2793  bh->b_end_io = NULL;
2794  }
2795  curr_off = curr_off + bh->b_size;
2796  bh = bh->b_this_page;
2797  } while (bh != head);
2798 }
2799 
2800 static void ext4_invalidatepage(struct page *page, unsigned long offset)
2801 {
2802  journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2803 
2804  trace_ext4_invalidatepage(page, offset);
2805 
2806  /*
2807  * free any io_end structure allocated for buffers to be discarded
2808  */
2809  if (ext4_should_dioread_nolock(page->mapping->host))
2810  ext4_invalidatepage_free_endio(page, offset);
2811  /*
2812  * If it's a full truncate we just forget about the pending dirtying
2813  */
2814  if (offset == 0)
2815  ClearPageChecked(page);
2816 
2817  if (journal)
2818  jbd2_journal_invalidatepage(journal, page, offset);
2819  else
2820  block_invalidatepage(page, offset);
2821 }
2822 
2823 static int ext4_releasepage(struct page *page, gfp_t wait)
2824 {
2825  journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2826 
2827  trace_ext4_releasepage(page);
2828 
2829  WARN_ON(PageChecked(page));
2830  if (!page_has_buffers(page))
2831  return 0;
2832  if (journal)
2833  return jbd2_journal_try_to_free_buffers(journal, page, wait);
2834  else
2835  return try_to_free_buffers(page);
2836 }
2837 
2838 /*
2839  * ext4_get_block used when preparing for a DIO write or buffer write.
2840  * We allocate an uinitialized extent if blocks haven't been allocated.
2841  * The extent will be converted to initialized after the IO is complete.
2842  */
2843 static int ext4_get_block_write(struct inode *inode, sector_t iblock,
2844  struct buffer_head *bh_result, int create)
2845 {
2846  ext4_debug("ext4_get_block_write: inode %lu, create flag %d\n",
2847  inode->i_ino, create);
2848  return _ext4_get_block(inode, iblock, bh_result,
2850 }
2851 
2852 static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
2853  struct buffer_head *bh_result, int flags)
2854 {
2855  handle_t *handle = ext4_journal_current_handle();
2856  struct ext4_map_blocks map;
2857  int ret = 0;
2858 
2859  ext4_debug("ext4_get_block_write_nolock: inode %lu, flag %d\n",
2860  inode->i_ino, flags);
2861 
2862  flags = EXT4_GET_BLOCKS_NO_LOCK;
2863 
2864  map.m_lblk = iblock;
2865  map.m_len = bh_result->b_size >> inode->i_blkbits;
2866 
2867  ret = ext4_map_blocks(handle, inode, &map, flags);
2868  if (ret > 0) {
2869  map_bh(bh_result, inode->i_sb, map.m_pblk);
2870  bh_result->b_state = (bh_result->b_state & ~EXT4_MAP_FLAGS) |
2871  map.m_flags;
2872  bh_result->b_size = inode->i_sb->s_blocksize * map.m_len;
2873  ret = 0;
2874  }
2875  return ret;
2876 }
2877 
2878 static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
2879  ssize_t size, void *private, int ret,
2880  bool is_async)
2881 {
2882  struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2883  ext4_io_end_t *io_end = iocb->private;
2884 
2885  /* if not async direct IO or dio with 0 bytes write, just return */
2886  if (!io_end || !size)
2887  goto out;
2888 
2889  ext_debug("ext4_end_io_dio(): io_end 0x%p "
2890  "for inode %lu, iocb 0x%p, offset %llu, size %zd\n",
2891  iocb->private, io_end->inode->i_ino, iocb, offset,
2892  size);
2893 
2894  iocb->private = NULL;
2895 
2896  /* if not aio dio with unwritten extents, just free io and return */
2897  if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
2898  ext4_free_io_end(io_end);
2899 out:
2900  if (is_async)
2901  aio_complete(iocb, ret, 0);
2902  inode_dio_done(inode);
2903  return;
2904  }
2905 
2906  io_end->offset = offset;
2907  io_end->size = size;
2908  if (is_async) {
2909  io_end->iocb = iocb;
2910  io_end->result = ret;
2911  }
2912 
2913  ext4_add_complete_io(io_end);
2914 }
2915 
2916 static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate)
2917 {
2918  ext4_io_end_t *io_end = bh->b_private;
2919  struct inode *inode;
2920 
2921  if (!test_clear_buffer_uninit(bh) || !io_end)
2922  goto out;
2923 
2924  if (!(io_end->inode->i_sb->s_flags & MS_ACTIVE)) {
2925  ext4_msg(io_end->inode->i_sb, KERN_INFO,
2926  "sb umounted, discard end_io request for inode %lu",
2927  io_end->inode->i_ino);
2928  ext4_free_io_end(io_end);
2929  goto out;
2930  }
2931 
2932  /*
2933  * It may be over-defensive here to check EXT4_IO_END_UNWRITTEN now,
2934  * but being more careful is always safe for the future change.
2935  */
2936  inode = io_end->inode;
2937  ext4_set_io_unwritten_flag(inode, io_end);
2938  ext4_add_complete_io(io_end);
2939 out:
2940  bh->b_private = NULL;
2941  bh->b_end_io = NULL;
2942  clear_buffer_uninit(bh);
2943  end_buffer_async_write(bh, uptodate);
2944 }
2945 
2946 static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode)
2947 {
2948  ext4_io_end_t *io_end;
2949  struct page *page = bh->b_page;
2950  loff_t offset = (sector_t)page->index << PAGE_CACHE_SHIFT;
2951  size_t size = bh->b_size;
2952 
2953 retry:
2954  io_end = ext4_init_io_end(inode, GFP_ATOMIC);
2955  if (!io_end) {
2956  pr_warn_ratelimited("%s: allocation fail\n", __func__);
2957  schedule();
2958  goto retry;
2959  }
2960  io_end->offset = offset;
2961  io_end->size = size;
2962  /*
2963  * We need to hold a reference to the page to make sure it
2964  * doesn't get evicted before ext4_end_io_work() has a chance
2965  * to convert the extent from written to unwritten.
2966  */
2967  io_end->page = page;
2968  get_page(io_end->page);
2969 
2970  bh->b_private = io_end;
2971  bh->b_end_io = ext4_end_io_buffer_write;
2972  return 0;
2973 }
2974 
2975 /*
2976  * For ext4 extent files, ext4 will do direct-io write to holes,
2977  * preallocated extents, and those write extend the file, no need to
2978  * fall back to buffered IO.
2979  *
2980  * For holes, we fallocate those blocks, mark them as uninitialized
2981  * If those blocks were preallocated, we mark sure they are splited, but
2982  * still keep the range to write as uninitialized.
2983  *
2984  * The unwrritten extents will be converted to written when DIO is completed.
2985  * For async direct IO, since the IO may still pending when return, we
2986  * set up an end_io call back function, which will do the conversion
2987  * when async direct IO completed.
2988  *
2989  * If the O_DIRECT write will extend the file then add this inode to the
2990  * orphan list. So recovery will truncate it back to the original size
2991  * if the machine crashes during the write.
2992  *
2993  */
2994 static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
2995  const struct iovec *iov, loff_t offset,
2996  unsigned long nr_segs)
2997 {
2998  struct file *file = iocb->ki_filp;
2999  struct inode *inode = file->f_mapping->host;
3000  ssize_t ret;
3001  size_t count = iov_length(iov, nr_segs);
3002 
3003  loff_t final_size = offset + count;
3004  if (rw == WRITE && final_size <= inode->i_size) {
3005  int overwrite = 0;
3006 
3007  BUG_ON(iocb->private == NULL);
3008 
3009  /* If we do a overwrite dio, i_mutex locking can be released */
3010  overwrite = *((int *)iocb->private);
3011 
3012  if (overwrite) {
3013  atomic_inc(&inode->i_dio_count);
3014  down_read(&EXT4_I(inode)->i_data_sem);
3015  mutex_unlock(&inode->i_mutex);
3016  }
3017 
3018  /*
3019  * We could direct write to holes and fallocate.
3020  *
3021  * Allocated blocks to fill the hole are marked as uninitialized
3022  * to prevent parallel buffered read to expose the stale data
3023  * before DIO complete the data IO.
3024  *
3025  * As to previously fallocated extents, ext4 get_block
3026  * will just simply mark the buffer mapped but still
3027  * keep the extents uninitialized.
3028  *
3029  * for non AIO case, we will convert those unwritten extents
3030  * to written after return back from blockdev_direct_IO.
3031  *
3032  * for async DIO, the conversion needs to be defered when
3033  * the IO is completed. The ext4 end_io callback function
3034  * will be called to take care of the conversion work.
3035  * Here for async case, we allocate an io_end structure to
3036  * hook to the iocb.
3037  */
3038  iocb->private = NULL;
3039  ext4_inode_aio_set(inode, NULL);
3040  if (!is_sync_kiocb(iocb)) {
3041  ext4_io_end_t *io_end =
3042  ext4_init_io_end(inode, GFP_NOFS);
3043  if (!io_end) {
3044  ret = -ENOMEM;
3045  goto retake_lock;
3046  }
3047  io_end->flag |= EXT4_IO_END_DIRECT;
3048  iocb->private = io_end;
3049  /*
3050  * we save the io structure for current async
3051  * direct IO, so that later ext4_map_blocks()
3052  * could flag the io structure whether there
3053  * is a unwritten extents needs to be converted
3054  * when IO is completed.
3055  */
3056  ext4_inode_aio_set(inode, io_end);
3057  }
3058 
3059  if (overwrite)
3060  ret = __blockdev_direct_IO(rw, iocb, inode,
3061  inode->i_sb->s_bdev, iov,
3062  offset, nr_segs,
3063  ext4_get_block_write_nolock,
3064  ext4_end_io_dio,
3065  NULL,
3066  0);
3067  else
3068  ret = __blockdev_direct_IO(rw, iocb, inode,
3069  inode->i_sb->s_bdev, iov,
3070  offset, nr_segs,
3071  ext4_get_block_write,
3072  ext4_end_io_dio,
3073  NULL,
3074  DIO_LOCKING);
3075  if (iocb->private)
3076  ext4_inode_aio_set(inode, NULL);
3077  /*
3078  * The io_end structure takes a reference to the inode,
3079  * that structure needs to be destroyed and the
3080  * reference to the inode need to be dropped, when IO is
3081  * complete, even with 0 byte write, or failed.
3082  *
3083  * In the successful AIO DIO case, the io_end structure will be
3084  * desctroyed and the reference to the inode will be dropped
3085  * after the end_io call back function is called.
3086  *
3087  * In the case there is 0 byte write, or error case, since
3088  * VFS direct IO won't invoke the end_io call back function,
3089  * we need to free the end_io structure here.
3090  */
3091  if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) {
3092  ext4_free_io_end(iocb->private);
3093  iocb->private = NULL;
3094  } else if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
3095  EXT4_STATE_DIO_UNWRITTEN)) {
3096  int err;
3097  /*
3098  * for non AIO case, since the IO is already
3099  * completed, we could do the conversion right here
3100  */
3101  err = ext4_convert_unwritten_extents(inode,
3102  offset, ret);
3103  if (err < 0)
3104  ret = err;
3105  ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
3106  }
3107 
3108  retake_lock:
3109  /* take i_mutex locking again if we do a ovewrite dio */
3110  if (overwrite) {
3111  inode_dio_done(inode);
3112  up_read(&EXT4_I(inode)->i_data_sem);
3113  mutex_lock(&inode->i_mutex);
3114  }
3115 
3116  return ret;
3117  }
3118 
3119  /* for write the the end of file case, we fall back to old way */
3120  return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
3121 }
3122 
3123 static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
3124  const struct iovec *iov, loff_t offset,
3125  unsigned long nr_segs)
3126 {
3127  struct file *file = iocb->ki_filp;
3128  struct inode *inode = file->f_mapping->host;
3129  ssize_t ret;
3130 
3131  /*
3132  * If we are doing data journalling we don't support O_DIRECT
3133  */
3134  if (ext4_should_journal_data(inode))
3135  return 0;
3136 
3137  trace_ext4_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw);
3138  if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3139  ret = ext4_ext_direct_IO(rw, iocb, iov, offset, nr_segs);
3140  else
3141  ret = ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
3142  trace_ext4_direct_IO_exit(inode, offset,
3143  iov_length(iov, nr_segs), rw, ret);
3144  return ret;
3145 }
3146 
3147 /*
3148  * Pages can be marked dirty completely asynchronously from ext4's journalling
3149  * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
3150  * much here because ->set_page_dirty is called under VFS locks. The page is
3151  * not necessarily locked.
3152  *
3153  * We cannot just dirty the page and leave attached buffers clean, because the
3154  * buffers' dirty state is "definitive". We cannot just set the buffers dirty
3155  * or jbddirty because all the journalling code will explode.
3156  *
3157  * So what we do is to mark the page "pending dirty" and next time writepage
3158  * is called, propagate that into the buffers appropriately.
3159  */
3160 static int ext4_journalled_set_page_dirty(struct page *page)
3161 {
3162  SetPageChecked(page);
3163  return __set_page_dirty_nobuffers(page);
3164 }
3165 
3166 static const struct address_space_operations ext4_ordered_aops = {
3167  .readpage = ext4_readpage,
3168  .readpages = ext4_readpages,
3169  .writepage = ext4_writepage,
3170  .write_begin = ext4_write_begin,
3171  .write_end = ext4_ordered_write_end,
3172  .bmap = ext4_bmap,
3173  .invalidatepage = ext4_invalidatepage,
3174  .releasepage = ext4_releasepage,
3175  .direct_IO = ext4_direct_IO,
3176  .migratepage = buffer_migrate_page,
3177  .is_partially_uptodate = block_is_partially_uptodate,
3178  .error_remove_page = generic_error_remove_page,
3179 };
3180 
3181 static const struct address_space_operations ext4_writeback_aops = {
3182  .readpage = ext4_readpage,
3183  .readpages = ext4_readpages,
3184  .writepage = ext4_writepage,
3185  .write_begin = ext4_write_begin,
3186  .write_end = ext4_writeback_write_end,
3187  .bmap = ext4_bmap,
3188  .invalidatepage = ext4_invalidatepage,
3189  .releasepage = ext4_releasepage,
3190  .direct_IO = ext4_direct_IO,
3191  .migratepage = buffer_migrate_page,
3192  .is_partially_uptodate = block_is_partially_uptodate,
3193  .error_remove_page = generic_error_remove_page,
3194 };
3195 
3196 static const struct address_space_operations ext4_journalled_aops = {
3197  .readpage = ext4_readpage,
3198  .readpages = ext4_readpages,
3199  .writepage = ext4_writepage,
3200  .write_begin = ext4_write_begin,
3201  .write_end = ext4_journalled_write_end,
3202  .set_page_dirty = ext4_journalled_set_page_dirty,
3203  .bmap = ext4_bmap,
3204  .invalidatepage = ext4_invalidatepage,
3205  .releasepage = ext4_releasepage,
3206  .direct_IO = ext4_direct_IO,
3207  .is_partially_uptodate = block_is_partially_uptodate,
3208  .error_remove_page = generic_error_remove_page,
3209 };
3210 
3211 static const struct address_space_operations ext4_da_aops = {
3212  .readpage = ext4_readpage,
3213  .readpages = ext4_readpages,
3214  .writepage = ext4_writepage,
3215  .writepages = ext4_da_writepages,
3216  .write_begin = ext4_da_write_begin,
3217  .write_end = ext4_da_write_end,
3218  .bmap = ext4_bmap,
3219  .invalidatepage = ext4_da_invalidatepage,
3220  .releasepage = ext4_releasepage,
3221  .direct_IO = ext4_direct_IO,
3222  .migratepage = buffer_migrate_page,
3223  .is_partially_uptodate = block_is_partially_uptodate,
3224  .error_remove_page = generic_error_remove_page,
3225 };
3226 
3227 void ext4_set_aops(struct inode *inode)
3228 {
3229  switch (ext4_inode_journal_mode(inode)) {
3231  if (test_opt(inode->i_sb, DELALLOC))
3232  inode->i_mapping->a_ops = &ext4_da_aops;
3233  else
3234  inode->i_mapping->a_ops = &ext4_ordered_aops;
3235  break;
3237  if (test_opt(inode->i_sb, DELALLOC))
3238  inode->i_mapping->a_ops = &ext4_da_aops;
3239  else
3240  inode->i_mapping->a_ops = &ext4_writeback_aops;
3241  break;
3243  inode->i_mapping->a_ops = &ext4_journalled_aops;
3244  break;
3245  default:
3246  BUG();
3247  }
3248 }
3249 
3250 
3251 /*
3252  * ext4_discard_partial_page_buffers()
3253  * Wrapper function for ext4_discard_partial_page_buffers_no_lock.
3254  * This function finds and locks the page containing the offset
3255  * "from" and passes it to ext4_discard_partial_page_buffers_no_lock.
3256  * Calling functions that already have the page locked should call
3257  * ext4_discard_partial_page_buffers_no_lock directly.
3258  */
3260  struct address_space *mapping, loff_t from,
3261  loff_t length, int flags)
3262 {
3263  struct inode *inode = mapping->host;
3264  struct page *page;
3265  int err = 0;
3266 
3267  page = find_or_create_page(mapping, from >> PAGE_CACHE_SHIFT,
3268  mapping_gfp_mask(mapping) & ~__GFP_FS);
3269  if (!page)
3270  return -ENOMEM;
3271 
3272  err = ext4_discard_partial_page_buffers_no_lock(handle, inode, page,
3273  from, length, flags);
3274 
3275  unlock_page(page);
3276  page_cache_release(page);
3277  return err;
3278 }
3279 
3280 /*
3281  * ext4_discard_partial_page_buffers_no_lock()
3282  * Zeros a page range of length 'length' starting from offset 'from'.
3283  * Buffer heads that correspond to the block aligned regions of the
3284  * zeroed range will be unmapped. Unblock aligned regions
3285  * will have the corresponding buffer head mapped if needed so that
3286  * that region of the page can be updated with the partial zero out.
3287  *
3288  * This function assumes that the page has already been locked. The
3289  * The range to be discarded must be contained with in the given page.
3290  * If the specified range exceeds the end of the page it will be shortened
3291  * to the end of the page that corresponds to 'from'. This function is
3292  * appropriate for updating a page and it buffer heads to be unmapped and
3293  * zeroed for blocks that have been either released, or are going to be
3294  * released.
3295  *
3296  * handle: The journal handle
3297  * inode: The files inode
3298  * page: A locked page that contains the offset "from"
3299  * from: The starting byte offset (from the beginning of the file)
3300  * to begin discarding
3301  * len: The length of bytes to discard
3302  * flags: Optional flags that may be used:
3303  *
3304  * EXT4_DISCARD_PARTIAL_PG_ZERO_UNMAPPED
3305  * Only zero the regions of the page whose buffer heads
3306  * have already been unmapped. This flag is appropriate
3307  * for updating the contents of a page whose blocks may
3308  * have already been released, and we only want to zero
3309  * out the regions that correspond to those released blocks.
3310  *
3311  * Returns zero on success or negative on failure.
3312  */
3313 static int ext4_discard_partial_page_buffers_no_lock(handle_t *handle,
3314  struct inode *inode, struct page *page, loff_t from,
3315  loff_t length, int flags)
3316 {
3317  ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT;
3318  unsigned int offset = from & (PAGE_CACHE_SIZE-1);
3319  unsigned int blocksize, max, pos;
3320  ext4_lblk_t iblock;
3321  struct buffer_head *bh;
3322  int err = 0;
3323 
3324  blocksize = inode->i_sb->s_blocksize;
3325  max = PAGE_CACHE_SIZE - offset;
3326 
3327  if (index != page->index)
3328  return -EINVAL;
3329 
3330  /*
3331  * correct length if it does not fall between
3332  * 'from' and the end of the page
3333  */
3334  if (length > max || length < 0)
3335  length = max;
3336 
3337  iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
3338 
3339  if (!page_has_buffers(page))
3340  create_empty_buffers(page, blocksize, 0);
3341 
3342  /* Find the buffer that contains "offset" */
3343  bh = page_buffers(page);
3344  pos = blocksize;
3345  while (offset >= pos) {
3346  bh = bh->b_this_page;
3347  iblock++;
3348  pos += blocksize;
3349  }
3350 
3351  pos = offset;
3352  while (pos < offset + length) {
3353  unsigned int end_of_block, range_to_discard;
3354 
3355  err = 0;
3356 
3357  /* The length of space left to zero and unmap */
3358  range_to_discard = offset + length - pos;
3359 
3360  /* The length of space until the end of the block */
3361  end_of_block = blocksize - (pos & (blocksize-1));
3362 
3363  /*
3364  * Do not unmap or zero past end of block
3365  * for this buffer head
3366  */
3367  if (range_to_discard > end_of_block)
3368  range_to_discard = end_of_block;
3369 
3370 
3371  /*
3372  * Skip this buffer head if we are only zeroing unampped
3373  * regions of the page
3374  */
3376  buffer_mapped(bh))
3377  goto next;
3378 
3379  /* If the range is block aligned, unmap */
3380  if (range_to_discard == blocksize) {
3381  clear_buffer_dirty(bh);
3382  bh->b_bdev = NULL;
3383  clear_buffer_mapped(bh);
3384  clear_buffer_req(bh);
3385  clear_buffer_new(bh);
3386  clear_buffer_delay(bh);
3387  clear_buffer_unwritten(bh);
3388  clear_buffer_uptodate(bh);
3389  zero_user(page, pos, range_to_discard);
3390  BUFFER_TRACE(bh, "Buffer discarded");
3391  goto next;
3392  }
3393 
3394  /*
3395  * If this block is not completely contained in the range
3396  * to be discarded, then it is not going to be released. Because
3397  * we need to keep this block, we need to make sure this part
3398  * of the page is uptodate before we modify it by writeing
3399  * partial zeros on it.
3400  */
3401  if (!buffer_mapped(bh)) {
3402  /*
3403  * Buffer head must be mapped before we can read
3404  * from the block
3405  */
3406  BUFFER_TRACE(bh, "unmapped");
3407  ext4_get_block(inode, iblock, bh, 0);
3408  /* unmapped? It's a hole - nothing to do */
3409  if (!buffer_mapped(bh)) {
3410  BUFFER_TRACE(bh, "still unmapped");
3411  goto next;
3412  }
3413  }
3414 
3415  /* Ok, it's mapped. Make sure it's up-to-date */
3416  if (PageUptodate(page))
3417  set_buffer_uptodate(bh);
3418 
3419  if (!buffer_uptodate(bh)) {
3420  err = -EIO;
3421  ll_rw_block(READ, 1, &bh);
3422  wait_on_buffer(bh);
3423  /* Uhhuh. Read error. Complain and punt.*/
3424  if (!buffer_uptodate(bh))
3425  goto next;
3426  }
3427 
3428  if (ext4_should_journal_data(inode)) {
3429  BUFFER_TRACE(bh, "get write access");
3430  err = ext4_journal_get_write_access(handle, bh);
3431  if (err)
3432  goto next;
3433  }
3434 
3435  zero_user(page, pos, range_to_discard);
3436 
3437  err = 0;
3438  if (ext4_should_journal_data(inode)) {
3439  err = ext4_handle_dirty_metadata(handle, inode, bh);
3440  } else
3441  mark_buffer_dirty(bh);
3442 
3443  BUFFER_TRACE(bh, "Partial buffer zeroed");
3444 next:
3445  bh = bh->b_this_page;
3446  iblock++;
3447  pos += range_to_discard;
3448  }
3449 
3450  return err;
3451 }
3452 
3453 int ext4_can_truncate(struct inode *inode)
3454 {
3455  if (S_ISREG(inode->i_mode))
3456  return 1;
3457  if (S_ISDIR(inode->i_mode))
3458  return 1;
3459  if (S_ISLNK(inode->i_mode))
3460  return !ext4_inode_is_fast_symlink(inode);
3461  return 0;
3462 }
3463 
3464 /*
3465  * ext4_punch_hole: punches a hole in a file by releaseing the blocks
3466  * associated with the given offset and length
3467  *
3468  * @inode: File inode
3469  * @offset: The offset where the hole will begin
3470  * @len: The length of the hole
3471  *
3472  * Returns: 0 on success or negative on failure
3473  */
3474 
3475 int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)
3476 {
3477  struct inode *inode = file->f_path.dentry->d_inode;
3478  if (!S_ISREG(inode->i_mode))
3479  return -EOPNOTSUPP;
3480 
3481  if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
3482  /* TODO: Add support for non extent hole punching */
3483  return -EOPNOTSUPP;
3484  }
3485 
3486  if (EXT4_SB(inode->i_sb)->s_cluster_ratio > 1) {
3487  /* TODO: Add support for bigalloc file systems */
3488  return -EOPNOTSUPP;
3489  }
3490 
3491  return ext4_ext_punch_hole(file, offset, length);
3492 }
3493 
3494 /*
3495  * ext4_truncate()
3496  *
3497  * We block out ext4_get_block() block instantiations across the entire
3498  * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3499  * simultaneously on behalf of the same inode.
3500  *
3501  * As we work through the truncate and commit bits of it to the journal there
3502  * is one core, guiding principle: the file's tree must always be consistent on
3503  * disk. We must be able to restart the truncate after a crash.
3504  *
3505  * The file's tree may be transiently inconsistent in memory (although it
3506  * probably isn't), but whenever we close off and commit a journal transaction,
3507  * the contents of (the filesystem + the journal) must be consistent and
3508  * restartable. It's pretty simple, really: bottom up, right to left (although
3509  * left-to-right works OK too).
3510  *
3511  * Note that at recovery time, journal replay occurs *before* the restart of
3512  * truncate against the orphan inode list.
3513  *
3514  * The committed inode has the new, desired i_size (which is the same as
3515  * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see
3516  * that this inode's truncate did not complete and it will again call
3517  * ext4_truncate() to have another go. So there will be instantiated blocks
3518  * to the right of the truncation point in a crashed ext4 filesystem. But
3519  * that's fine - as long as they are linked from the inode, the post-crash
3520  * ext4_truncate() run will find them and release them.
3521  */
3522 void ext4_truncate(struct inode *inode)
3523 {
3524  trace_ext4_truncate_enter(inode);
3525 
3526  if (!ext4_can_truncate(inode))
3527  return;
3528 
3529  ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
3530 
3531  if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
3532  ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
3533 
3534  if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3535  ext4_ext_truncate(inode);
3536  else
3537  ext4_ind_truncate(inode);
3538 
3539  trace_ext4_truncate_exit(inode);
3540 }
3541 
3542 /*
3543  * ext4_get_inode_loc returns with an extra refcount against the inode's
3544  * underlying buffer_head on success. If 'in_mem' is true, we have all
3545  * data in memory that is needed to recreate the on-disk version of this
3546  * inode.
3547  */
3548 static int __ext4_get_inode_loc(struct inode *inode,
3549  struct ext4_iloc *iloc, int in_mem)
3550 {
3551  struct ext4_group_desc *gdp;
3552  struct buffer_head *bh;
3553  struct super_block *sb = inode->i_sb;
3555  int inodes_per_block, inode_offset;
3556 
3557  iloc->bh = NULL;
3558  if (!ext4_valid_inum(sb, inode->i_ino))
3559  return -EIO;
3560 
3561  iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
3562  gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
3563  if (!gdp)
3564  return -EIO;
3565 
3566  /*
3567  * Figure out the offset within the block group inode table
3568  */
3569  inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
3570  inode_offset = ((inode->i_ino - 1) %
3571  EXT4_INODES_PER_GROUP(sb));
3572  block = ext4_inode_table(sb, gdp) + (inode_offset / inodes_per_block);
3573  iloc->offset = (inode_offset % inodes_per_block) * EXT4_INODE_SIZE(sb);
3574 
3575  bh = sb_getblk(sb, block);
3576  if (!bh) {
3577  EXT4_ERROR_INODE_BLOCK(inode, block,
3578  "unable to read itable block");
3579  return -EIO;
3580  }
3581  if (!buffer_uptodate(bh)) {
3582  lock_buffer(bh);
3583 
3584  /*
3585  * If the buffer has the write error flag, we have failed
3586  * to write out another inode in the same block. In this
3587  * case, we don't have to read the block because we may
3588  * read the old inode data successfully.
3589  */
3590  if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
3591  set_buffer_uptodate(bh);
3592 
3593  if (buffer_uptodate(bh)) {
3594  /* someone brought it uptodate while we waited */
3595  unlock_buffer(bh);
3596  goto has_buffer;
3597  }
3598 
3599  /*
3600  * If we have all information of the inode in memory and this
3601  * is the only valid inode in the block, we need not read the
3602  * block.
3603  */
3604  if (in_mem) {
3605  struct buffer_head *bitmap_bh;
3606  int i, start;
3607 
3608  start = inode_offset & ~(inodes_per_block - 1);
3609 
3610  /* Is the inode bitmap in cache? */
3611  bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
3612  if (!bitmap_bh)
3613  goto make_io;
3614 
3615  /*
3616  * If the inode bitmap isn't in cache then the
3617  * optimisation may end up performing two reads instead
3618  * of one, so skip it.
3619  */
3620  if (!buffer_uptodate(bitmap_bh)) {
3621  brelse(bitmap_bh);
3622  goto make_io;
3623  }
3624  for (i = start; i < start + inodes_per_block; i++) {
3625  if (i == inode_offset)
3626  continue;
3627  if (ext4_test_bit(i, bitmap_bh->b_data))
3628  break;
3629  }
3630  brelse(bitmap_bh);
3631  if (i == start + inodes_per_block) {
3632  /* all other inodes are free, so skip I/O */
3633  memset(bh->b_data, 0, bh->b_size);
3634  set_buffer_uptodate(bh);
3635  unlock_buffer(bh);
3636  goto has_buffer;
3637  }
3638  }
3639 
3640 make_io:
3641  /*
3642  * If we need to do any I/O, try to pre-readahead extra
3643  * blocks from the inode table.
3644  */
3645  if (EXT4_SB(sb)->s_inode_readahead_blks) {
3646  ext4_fsblk_t b, end, table;
3647  unsigned num;
3648 
3649  table = ext4_inode_table(sb, gdp);
3650  /* s_inode_readahead_blks is always a power of 2 */
3651  b = block & ~(EXT4_SB(sb)->s_inode_readahead_blks-1);
3652  if (table > b)
3653  b = table;
3654  end = b + EXT4_SB(sb)->s_inode_readahead_blks;
3655  num = EXT4_INODES_PER_GROUP(sb);
3656  if (ext4_has_group_desc_csum(sb))
3657  num -= ext4_itable_unused_count(sb, gdp);
3658  table += num / inodes_per_block;
3659  if (end > table)
3660  end = table;
3661  while (b <= end)
3662  sb_breadahead(sb, b++);
3663  }
3664 
3665  /*
3666  * There are other valid inodes in the buffer, this inode
3667  * has in-inode xattrs, or we don't have this inode in memory.
3668  * Read the block from disk.
3669  */
3670  trace_ext4_load_inode(inode);
3671  get_bh(bh);
3672  bh->b_end_io = end_buffer_read_sync;
3673  submit_bh(READ | REQ_META | REQ_PRIO, bh);
3674  wait_on_buffer(bh);
3675  if (!buffer_uptodate(bh)) {
3676  EXT4_ERROR_INODE_BLOCK(inode, block,
3677  "unable to read itable block");
3678  brelse(bh);
3679  return -EIO;
3680  }
3681  }
3682 has_buffer:
3683  iloc->bh = bh;
3684  return 0;
3685 }
3686 
3687 int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
3688 {
3689  /* We have all inode data except xattrs in memory here. */
3690  return __ext4_get_inode_loc(inode, iloc,
3691  !ext4_test_inode_state(inode, EXT4_STATE_XATTR));
3692 }
3693 
3694 void ext4_set_inode_flags(struct inode *inode)
3695 {
3696  unsigned int flags = EXT4_I(inode)->i_flags;
3697 
3699  if (flags & EXT4_SYNC_FL)
3700  inode->i_flags |= S_SYNC;
3701  if (flags & EXT4_APPEND_FL)
3702  inode->i_flags |= S_APPEND;
3703  if (flags & EXT4_IMMUTABLE_FL)
3704  inode->i_flags |= S_IMMUTABLE;
3705  if (flags & EXT4_NOATIME_FL)
3706  inode->i_flags |= S_NOATIME;
3707  if (flags & EXT4_DIRSYNC_FL)
3708  inode->i_flags |= S_DIRSYNC;
3709 }
3710 
3711 /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
3713 {
3714  unsigned int vfs_fl;
3715  unsigned long old_fl, new_fl;
3716 
3717  do {
3718  vfs_fl = ei->vfs_inode.i_flags;
3719  old_fl = ei->i_flags;
3720  new_fl = old_fl & ~(EXT4_SYNC_FL|EXT4_APPEND_FL|
3722  EXT4_DIRSYNC_FL);
3723  if (vfs_fl & S_SYNC)
3724  new_fl |= EXT4_SYNC_FL;
3725  if (vfs_fl & S_APPEND)
3726  new_fl |= EXT4_APPEND_FL;
3727  if (vfs_fl & S_IMMUTABLE)
3728  new_fl |= EXT4_IMMUTABLE_FL;
3729  if (vfs_fl & S_NOATIME)
3730  new_fl |= EXT4_NOATIME_FL;
3731  if (vfs_fl & S_DIRSYNC)
3732  new_fl |= EXT4_DIRSYNC_FL;
3733  } while (cmpxchg(&ei->i_flags, old_fl, new_fl) != old_fl);
3734 }
3735 
3736 static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
3737  struct ext4_inode_info *ei)
3738 {
3739  blkcnt_t i_blocks ;
3740  struct inode *inode = &(ei->vfs_inode);
3741  struct super_block *sb = inode->i_sb;
3742 
3745  /* we are using combined 48 bit field */
3746  i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
3747  le32_to_cpu(raw_inode->i_blocks_lo);
3748  if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) {
3749  /* i_blocks represent file system block size */
3750  return i_blocks << (inode->i_blkbits - 9);
3751  } else {
3752  return i_blocks;
3753  }
3754  } else {
3755  return le32_to_cpu(raw_inode->i_blocks_lo);
3756  }
3757 }
3758 
3759 struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
3760 {
3761  struct ext4_iloc iloc;
3762  struct ext4_inode *raw_inode;
3763  struct ext4_inode_info *ei;
3764  struct inode *inode;
3765  journal_t *journal = EXT4_SB(sb)->s_journal;
3766  long ret;
3767  int block;
3768  uid_t i_uid;
3769  gid_t i_gid;
3770 
3771  inode = iget_locked(sb, ino);
3772  if (!inode)
3773  return ERR_PTR(-ENOMEM);
3774  if (!(inode->i_state & I_NEW))
3775  return inode;
3776 
3777  ei = EXT4_I(inode);
3778  iloc.bh = NULL;
3779 
3780  ret = __ext4_get_inode_loc(inode, &iloc, 0);
3781  if (ret < 0)
3782  goto bad_inode;
3783  raw_inode = ext4_raw_inode(&iloc);
3784 
3786  ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
3788  EXT4_INODE_SIZE(inode->i_sb)) {
3789  EXT4_ERROR_INODE(inode, "bad extra_isize (%u != %u)",
3791  EXT4_INODE_SIZE(inode->i_sb));
3792  ret = -EIO;
3793  goto bad_inode;
3794  }
3795  } else
3796  ei->i_extra_isize = 0;
3797 
3798  /* Precompute checksum seed for inode metadata */
3801  struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
3802  __u32 csum;
3803  __le32 inum = cpu_to_le32(inode->i_ino);
3804  __le32 gen = raw_inode->i_generation;
3805  csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum,
3806  sizeof(inum));
3807  ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen,
3808  sizeof(gen));
3809  }
3810 
3811  if (!ext4_inode_csum_verify(inode, raw_inode, ei)) {
3812  EXT4_ERROR_INODE(inode, "checksum invalid");
3813  ret = -EIO;
3814  goto bad_inode;
3815  }
3816 
3817  inode->i_mode = le16_to_cpu(raw_inode->i_mode);
3818  i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
3819  i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
3820  if (!(test_opt(inode->i_sb, NO_UID32))) {
3821  i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
3822  i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
3823  }
3824  i_uid_write(inode, i_uid);
3825  i_gid_write(inode, i_gid);
3826  set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
3827 
3828  ext4_clear_state_flags(ei); /* Only relevant on 32-bit archs */
3829  ei->i_dir_start_lookup = 0;
3830  ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
3831  /* We now have enough fields to check if the inode was active or not.
3832  * This is needed because nfsd might try to access dead inodes
3833  * the test is that same one that e2fsck uses
3834  * NeilBrown 1999oct15
3835  */
3836  if (inode->i_nlink == 0) {
3837  if (inode->i_mode == 0 ||
3838  !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
3839  /* this inode is deleted */
3840  ret = -ESTALE;
3841  goto bad_inode;
3842  }
3843  /* The only unlinked inodes we let through here have
3844  * valid i_mode and are being read by the orphan
3845  * recovery code: that's fine, we're about to complete
3846  * the process of deleting those. */
3847  }
3848  ei->i_flags = le32_to_cpu(raw_inode->i_flags);
3849  inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
3850  ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
3852  ei->i_file_acl |=
3853  ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
3854  inode->i_size = ext4_isize(raw_inode);
3855  ei->i_disksize = inode->i_size;
3856 #ifdef CONFIG_QUOTA
3857  ei->i_reserved_quota = 0;
3858 #endif
3859  inode->i_generation = le32_to_cpu(raw_inode->i_generation);
3860  ei->i_block_group = iloc.block_group;
3861  ei->i_last_alloc_group = ~0;
3862  /*
3863  * NOTE! The in-memory inode i_data array is in little-endian order
3864  * even on big-endian machines: we do NOT byteswap the block numbers!
3865  */
3866  for (block = 0; block < EXT4_N_BLOCKS; block++)
3867  ei->i_data[block] = raw_inode->i_block[block];
3868  INIT_LIST_HEAD(&ei->i_orphan);
3869 
3870  /*
3871  * Set transaction id's of transactions that have to be committed
3872  * to finish f[data]sync. We set them to currently running transaction
3873  * as we cannot be sure that the inode or some of its metadata isn't
3874  * part of the transaction - the inode could have been reclaimed and
3875  * now it is reread from disk.
3876  */
3877  if (journal) {
3879  tid_t tid;
3880 
3881  read_lock(&journal->j_state_lock);
3882  if (journal->j_running_transaction)
3883  transaction = journal->j_running_transaction;
3884  else
3885  transaction = journal->j_committing_transaction;
3886  if (transaction)
3887  tid = transaction->t_tid;
3888  else
3889  tid = journal->j_commit_sequence;
3890  read_unlock(&journal->j_state_lock);
3891  ei->i_sync_tid = tid;
3892  ei->i_datasync_tid = tid;
3893  }
3894 
3896  if (ei->i_extra_isize == 0) {
3897  /* The extra space is currently unused. Use it. */
3898  ei->i_extra_isize = sizeof(struct ext4_inode) -
3899  EXT4_GOOD_OLD_INODE_SIZE;
3900  } else {
3901  __le32 *magic = (void *)raw_inode +
3903  ei->i_extra_isize;
3904  if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC))
3905  ext4_set_inode_state(inode, EXT4_STATE_XATTR);
3906  }
3907  }
3908 
3909  EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode);
3910  EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode);
3911  EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
3912  EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
3913 
3914  inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
3916  if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
3917  inode->i_version |=
3918  (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
3919  }
3920 
3921  ret = 0;
3922  if (ei->i_file_acl &&
3923  !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
3924  EXT4_ERROR_INODE(inode, "bad extended attribute block %llu",
3925  ei->i_file_acl);
3926  ret = -EIO;
3927  goto bad_inode;
3928  } else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
3929  if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
3930  (S_ISLNK(inode->i_mode) &&
3931  !ext4_inode_is_fast_symlink(inode)))
3932  /* Validate extent which is part of inode */
3933  ret = ext4_ext_check_inode(inode);
3934  } else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
3935  (S_ISLNK(inode->i_mode) &&
3936  !ext4_inode_is_fast_symlink(inode))) {
3937  /* Validate block references which are part of inode */
3938  ret = ext4_ind_check_inode(inode);
3939  }
3940  if (ret)
3941  goto bad_inode;
3942 
3943  if (S_ISREG(inode->i_mode)) {
3944  inode->i_op = &ext4_file_inode_operations;
3945  inode->i_fop = &ext4_file_operations;
3946  ext4_set_aops(inode);
3947  } else if (S_ISDIR(inode->i_mode)) {
3948  inode->i_op = &ext4_dir_inode_operations;
3949  inode->i_fop = &ext4_dir_operations;
3950  } else if (S_ISLNK(inode->i_mode)) {
3951  if (ext4_inode_is_fast_symlink(inode)) {
3953  nd_terminate_link(ei->i_data, inode->i_size,
3954  sizeof(ei->i_data) - 1);
3955  } else {
3957  ext4_set_aops(inode);
3958  }
3959  } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
3960  S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
3962  if (raw_inode->i_block[0])
3963  init_special_inode(inode, inode->i_mode,
3964  old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
3965  else
3966  init_special_inode(inode, inode->i_mode,
3967  new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
3968  } else {
3969  ret = -EIO;
3970  EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode);
3971  goto bad_inode;
3972  }
3973  brelse(iloc.bh);
3974  ext4_set_inode_flags(inode);
3975  unlock_new_inode(inode);
3976  return inode;
3977 
3978 bad_inode:
3979  brelse(iloc.bh);
3980  iget_failed(inode);
3981  return ERR_PTR(ret);
3982 }
3983 
3984 static int ext4_inode_blocks_set(handle_t *handle,
3985  struct ext4_inode *raw_inode,
3986  struct ext4_inode_info *ei)
3987 {
3988  struct inode *inode = &(ei->vfs_inode);
3989  u64 i_blocks = inode->i_blocks;
3990  struct super_block *sb = inode->i_sb;
3991 
3992  if (i_blocks <= ~0U) {
3993  /*
3994  * i_blocks can be represented in a 32 bit variable
3995  * as multiple of 512 bytes
3996  */
3997  raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
3998  raw_inode->i_blocks_high = 0;
3999  ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4000  return 0;
4001  }
4003  return -EFBIG;
4004 
4005  if (i_blocks <= 0xffffffffffffULL) {
4006  /*
4007  * i_blocks can be represented in a 48 bit variable
4008  * as multiple of 512 bytes
4009  */
4010  raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
4011  raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
4012  ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4013  } else {
4014  ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4015  /* i_block is stored in file system block size */
4016  i_blocks = i_blocks >> (inode->i_blkbits - 9);
4017  raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
4018  raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
4019  }
4020  return 0;
4021 }
4022 
4023 /*
4024  * Post the struct inode info into an on-disk inode location in the
4025  * buffer-cache. This gobbles the caller's reference to the
4026  * buffer_head in the inode location struct.
4027  *
4028  * The caller must have write access to iloc->bh.
4029  */
4030 static int ext4_do_update_inode(handle_t *handle,
4031  struct inode *inode,
4032  struct ext4_iloc *iloc)
4033 {
4034  struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
4035  struct ext4_inode_info *ei = EXT4_I(inode);
4036  struct buffer_head *bh = iloc->bh;
4037  int err = 0, rc, block;
4038  int need_datasync = 0;
4039  uid_t i_uid;
4040  gid_t i_gid;
4041 
4042  /* For fields not not tracking in the in-memory inode,
4043  * initialise them to zero for new inodes. */
4044  if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
4045  memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
4046 
4048  raw_inode->i_mode = cpu_to_le16(inode->i_mode);
4049  i_uid = i_uid_read(inode);
4050  i_gid = i_gid_read(inode);
4051  if (!(test_opt(inode->i_sb, NO_UID32))) {
4052  raw_inode->i_uid_low = cpu_to_le16(low_16_bits(i_uid));
4053  raw_inode->i_gid_low = cpu_to_le16(low_16_bits(i_gid));
4054 /*
4055  * Fix up interoperability with old kernels. Otherwise, old inodes get
4056  * re-used with the upper 16 bits of the uid/gid intact
4057  */
4058  if (!ei->i_dtime) {
4059  raw_inode->i_uid_high =
4060  cpu_to_le16(high_16_bits(i_uid));
4061  raw_inode->i_gid_high =
4062  cpu_to_le16(high_16_bits(i_gid));
4063  } else {
4064  raw_inode->i_uid_high = 0;
4065  raw_inode->i_gid_high = 0;
4066  }
4067  } else {
4068  raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid));
4069  raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid));
4070  raw_inode->i_uid_high = 0;
4071  raw_inode->i_gid_high = 0;
4072  }
4073  raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
4074 
4075  EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
4076  EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
4077  EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
4078  EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
4079 
4080  if (ext4_inode_blocks_set(handle, raw_inode, ei))
4081  goto out_brelse;
4082  raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
4083  raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF);
4084  if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
4086  raw_inode->i_file_acl_high =
4087  cpu_to_le16(ei->i_file_acl >> 32);
4088  raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
4089  if (ei->i_disksize != ext4_isize(raw_inode)) {
4090  ext4_isize_set(raw_inode, ei->i_disksize);
4091  need_datasync = 1;
4092  }
4093  if (ei->i_disksize > 0x7fffffffULL) {
4094  struct super_block *sb = inode->i_sb;
4097  EXT4_SB(sb)->s_es->s_rev_level ==
4099  /* If this is the first large file
4100  * created, add a flag to the superblock.
4101  */
4102  err = ext4_journal_get_write_access(handle,
4103  EXT4_SB(sb)->s_sbh);
4104  if (err)
4105  goto out_brelse;
4109  ext4_handle_sync(handle);
4110  err = ext4_handle_dirty_super(handle, sb);
4111  }
4112  }
4113  raw_inode->i_generation = cpu_to_le32(inode->i_generation);
4114  if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
4115  if (old_valid_dev(inode->i_rdev)) {
4116  raw_inode->i_block[0] =
4117  cpu_to_le32(old_encode_dev(inode->i_rdev));
4118  raw_inode->i_block[1] = 0;
4119  } else {
4120  raw_inode->i_block[0] = 0;
4121  raw_inode->i_block[1] =
4122  cpu_to_le32(new_encode_dev(inode->i_rdev));
4123  raw_inode->i_block[2] = 0;
4124  }
4125  } else
4126  for (block = 0; block < EXT4_N_BLOCKS; block++)
4127  raw_inode->i_block[block] = ei->i_data[block];
4128 
4129  raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
4130  if (ei->i_extra_isize) {
4131  if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
4132  raw_inode->i_version_hi =
4133  cpu_to_le32(inode->i_version >> 32);
4134  raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
4135  }
4136 
4137  ext4_inode_csum_set(inode, raw_inode, ei);
4138 
4139  BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
4140  rc = ext4_handle_dirty_metadata(handle, NULL, bh);
4141  if (!err)
4142  err = rc;
4143  ext4_clear_inode_state(inode, EXT4_STATE_NEW);
4144 
4145  ext4_update_inode_fsync_trans(handle, inode, need_datasync);
4146 out_brelse:
4147  brelse(bh);
4148  ext4_std_error(inode->i_sb, err);
4149  return err;
4150 }
4151 
4152 /*
4153  * ext4_write_inode()
4154  *
4155  * We are called from a few places:
4156  *
4157  * - Within generic_file_write() for O_SYNC files.
4158  * Here, there will be no transaction running. We wait for any running
4159  * transaction to commit.
4160  *
4161  * - Within sys_sync(), kupdate and such.
4162  * We wait on commit, if tol to.
4163  *
4164  * - Within prune_icache() (PF_MEMALLOC == true)
4165  * Here we simply return. We can't afford to block kswapd on the
4166  * journal commit.
4167  *
4168  * In all cases it is actually safe for us to return without doing anything,
4169  * because the inode has been copied into a raw inode buffer in
4170  * ext4_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
4171  * knfsd.
4172  *
4173  * Note that we are absolutely dependent upon all inode dirtiers doing the
4174  * right thing: they *must* call mark_inode_dirty() after dirtying info in
4175  * which we are interested.
4176  *
4177  * It would be a bug for them to not do this. The code:
4178  *
4179  * mark_inode_dirty(inode)
4180  * stuff();
4181  * inode->i_size = expr;
4182  *
4183  * is in error because a kswapd-driven write_inode() could occur while
4184  * `stuff()' is running, and the new i_size will be lost. Plus the inode
4185  * will no longer be on the superblock's dirty inode list.
4186  */
4187 int ext4_write_inode(struct inode *inode, struct writeback_control *wbc)
4188 {
4189  int err;
4190 
4191  if (current->flags & PF_MEMALLOC)
4192  return 0;
4193 
4194  if (EXT4_SB(inode->i_sb)->s_journal) {
4195  if (ext4_journal_current_handle()) {
4196  jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
4197  dump_stack();
4198  return -EIO;
4199  }
4200 
4201  if (wbc->sync_mode != WB_SYNC_ALL)
4202  return 0;
4203 
4204  err = ext4_force_commit(inode->i_sb);
4205  } else {
4206  struct ext4_iloc iloc;
4207 
4208  err = __ext4_get_inode_loc(inode, &iloc, 0);
4209  if (err)
4210  return err;
4211  if (wbc->sync_mode == WB_SYNC_ALL)
4212  sync_dirty_buffer(iloc.bh);
4213  if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
4214  EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr,
4215  "IO error syncing inode");
4216  err = -EIO;
4217  }
4218  brelse(iloc.bh);
4219  }
4220  return err;
4221 }
4222 
4223 /*
4224  * ext4_setattr()
4225  *
4226  * Called from notify_change.
4227  *
4228  * We want to trap VFS attempts to truncate the file as soon as
4229  * possible. In particular, we want to make sure that when the VFS
4230  * shrinks i_size, we put the inode on the orphan list and modify
4231  * i_disksize immediately, so that during the subsequent flushing of
4232  * dirty pages and freeing of disk blocks, we can guarantee that any
4233  * commit will leave the blocks being flushed in an unused state on
4234  * disk. (On recovery, the inode will get truncated and the blocks will
4235  * be freed, so we have a strong guarantee that no future commit will
4236  * leave these blocks visible to the user.)
4237  *
4238  * Another thing we have to assure is that if we are in ordered mode
4239  * and inode is still attached to the committing transaction, we must
4240  * we start writeout of all the dirty pages which are being truncated.
4241  * This way we are sure that all the data written in the previous
4242  * transaction are already on disk (truncate waits for pages under
4243  * writeback).
4244  *
4245  * Called with inode->i_mutex down.
4246  */
4247 int ext4_setattr(struct dentry *dentry, struct iattr *attr)
4248 {
4249  struct inode *inode = dentry->d_inode;
4250  int error, rc = 0;
4251  int orphan = 0;
4252  const unsigned int ia_valid = attr->ia_valid;
4253 
4254  error = inode_change_ok(inode, attr);
4255  if (error)
4256  return error;
4257 
4258  if (is_quota_modification(inode, attr))
4259  dquot_initialize(inode);
4260  if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
4261  (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) {
4262  handle_t *handle;
4263 
4264  /* (user+group)*(old+new) structure, inode write (sb,
4265  * inode block, ? - but truncate inode update has it) */
4266  handle = ext4_journal_start(inode, (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
4267  EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb))+3);
4268  if (IS_ERR(handle)) {
4269  error = PTR_ERR(handle);
4270  goto err_out;
4271  }
4272  error = dquot_transfer(inode, attr);
4273  if (error) {
4274  ext4_journal_stop(handle);
4275  return error;
4276  }
4277  /* Update corresponding info in inode so that everything is in
4278  * one transaction */
4279  if (attr->ia_valid & ATTR_UID)
4280  inode->i_uid = attr->ia_uid;
4281  if (attr->ia_valid & ATTR_GID)
4282  inode->i_gid = attr->ia_gid;
4283  error = ext4_mark_inode_dirty(handle, inode);
4284  ext4_journal_stop(handle);
4285  }
4286 
4287  if (attr->ia_valid & ATTR_SIZE) {
4288 
4289  if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4290  struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4291 
4292  if (attr->ia_size > sbi->s_bitmap_maxbytes)
4293  return -EFBIG;
4294  }
4295  }
4296 
4297  if (S_ISREG(inode->i_mode) &&
4298  attr->ia_valid & ATTR_SIZE &&
4299  (attr->ia_size < inode->i_size)) {
4300  handle_t *handle;
4301 
4302  handle = ext4_journal_start(inode, 3);
4303  if (IS_ERR(handle)) {
4304  error = PTR_ERR(handle);
4305  goto err_out;
4306  }
4307  if (ext4_handle_valid(handle)) {
4308  error = ext4_orphan_add(handle, inode);
4309  orphan = 1;
4310  }
4311  EXT4_I(inode)->i_disksize = attr->ia_size;
4312  rc = ext4_mark_inode_dirty(handle, inode);
4313  if (!error)
4314  error = rc;
4315  ext4_journal_stop(handle);
4316 
4317  if (ext4_should_order_data(inode)) {
4318  error = ext4_begin_ordered_truncate(inode,
4319  attr->ia_size);
4320  if (error) {
4321  /* Do as much error cleanup as possible */
4322  handle = ext4_journal_start(inode, 3);
4323  if (IS_ERR(handle)) {
4324  ext4_orphan_del(NULL, inode);
4325  goto err_out;
4326  }
4327  ext4_orphan_del(handle, inode);
4328  orphan = 0;
4329  ext4_journal_stop(handle);
4330  goto err_out;
4331  }
4332  }
4333  }
4334 
4335  if (attr->ia_valid & ATTR_SIZE) {
4336  if (attr->ia_size != i_size_read(inode)) {
4337  truncate_setsize(inode, attr->ia_size);
4338  /* Inode size will be reduced, wait for dio in flight.
4339  * Temporarily disable dioread_nolock to prevent
4340  * livelock. */
4341  if (orphan) {
4342  ext4_inode_block_unlocked_dio(inode);
4343  inode_dio_wait(inode);
4344  ext4_inode_resume_unlocked_dio(inode);
4345  }
4346  }
4347  ext4_truncate(inode);
4348  }
4349 
4350  if (!rc) {
4351  setattr_copy(inode, attr);
4352  mark_inode_dirty(inode);
4353  }
4354 
4355  /*
4356  * If the call to ext4_truncate failed to get a transaction handle at
4357  * all, we need to clean up the in-core orphan list manually.
4358  */
4359  if (orphan && inode->i_nlink)
4360  ext4_orphan_del(NULL, inode);
4361 
4362  if (!rc && (ia_valid & ATTR_MODE))
4363  rc = ext4_acl_chmod(inode);
4364 
4365 err_out:
4366  ext4_std_error(inode->i_sb, error);
4367  if (!error)
4368  error = rc;
4369  return error;
4370 }
4371 
4372 int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
4373  struct kstat *stat)
4374 {
4375  struct inode *inode;
4376  unsigned long delalloc_blocks;
4377 
4378  inode = dentry->d_inode;
4379  generic_fillattr(inode, stat);
4380 
4381  /*
4382  * We can't update i_blocks if the block allocation is delayed
4383  * otherwise in the case of system crash before the real block
4384  * allocation is done, we will have i_blocks inconsistent with
4385  * on-disk file blocks.
4386  * We always keep i_blocks updated together with real
4387  * allocation. But to not confuse with user, stat
4388  * will return the blocks that include the delayed allocation
4389  * blocks for this file.
4390  */
4391  delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb),
4392  EXT4_I(inode)->i_reserved_data_blocks);
4393 
4394  stat->blocks += (delalloc_blocks << inode->i_sb->s_blocksize_bits)>>9;
4395  return 0;
4396 }
4397 
4398 static int ext4_index_trans_blocks(struct inode *inode, int nrblocks, int chunk)
4399 {
4400  if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
4401  return ext4_ind_trans_blocks(inode, nrblocks, chunk);
4402  return ext4_ext_index_trans_blocks(inode, nrblocks, chunk);
4403 }
4404 
4405 /*
4406  * Account for index blocks, block groups bitmaps and block group
4407  * descriptor blocks if modify datablocks and index blocks
4408  * worse case, the indexs blocks spread over different block groups
4409  *
4410  * If datablocks are discontiguous, they are possible to spread over
4411  * different block groups too. If they are contiguous, with flexbg,
4412  * they could still across block group boundary.
4413  *
4414  * Also account for superblock, inode, quota and xattr blocks
4415  */
4416 static int ext4_meta_trans_blocks(struct inode *inode, int nrblocks, int chunk)
4417 {
4418  ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
4419  int gdpblocks;
4420  int idxblocks;
4421  int ret = 0;
4422 
4423  /*
4424  * How many index blocks need to touch to modify nrblocks?
4425  * The "Chunk" flag indicating whether the nrblocks is
4426  * physically contiguous on disk
4427  *
4428  * For Direct IO and fallocate, they calls get_block to allocate
4429  * one single extent at a time, so they could set the "Chunk" flag
4430  */
4431  idxblocks = ext4_index_trans_blocks(inode, nrblocks, chunk);
4432 
4433  ret = idxblocks;
4434 
4435  /*
4436  * Now let's see how many group bitmaps and group descriptors need
4437  * to account
4438  */
4439  groups = idxblocks;
4440  if (chunk)
4441  groups += 1;
4442  else
4443  groups += nrblocks;
4444 
4445  gdpblocks = groups;
4446  if (groups > ngroups)
4447  groups = ngroups;
4448  if (groups > EXT4_SB(inode->i_sb)->s_gdb_count)
4449  gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count;
4450 
4451  /* bitmaps and block group descriptor blocks */
4452  ret += groups + gdpblocks;
4453 
4454  /* Blocks for super block, inode, quota and xattr blocks */
4455  ret += EXT4_META_TRANS_BLOCKS(inode->i_sb);
4456 
4457  return ret;
4458 }
4459 
4460 /*
4461  * Calculate the total number of credits to reserve to fit
4462  * the modification of a single pages into a single transaction,
4463  * which may include multiple chunks of block allocations.
4464  *
4465  * This could be called via ext4_write_begin()
4466  *
4467  * We need to consider the worse case, when
4468  * one new block per extent.
4469  */
4470 int ext4_writepage_trans_blocks(struct inode *inode)
4471 {
4472  int bpp = ext4_journal_blocks_per_page(inode);
4473  int ret;
4474 
4475  ret = ext4_meta_trans_blocks(inode, bpp, 0);
4476 
4477  /* Account for data blocks for journalled mode */
4478  if (ext4_should_journal_data(inode))
4479  ret += bpp;
4480  return ret;
4481 }
4482 
4483 /*
4484  * Calculate the journal credits for a chunk of data modification.
4485  *
4486  * This is called from DIO, fallocate or whoever calling
4487  * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
4488  *
4489  * journal buffers for data blocks are not included here, as DIO
4490  * and fallocate do no need to journal data buffers.
4491  */
4492 int ext4_chunk_trans_blocks(struct inode *inode, int nrblocks)
4493 {
4494  return ext4_meta_trans_blocks(inode, nrblocks, 1);
4495 }
4496 
4497 /*
4498  * The caller must have previously called ext4_reserve_inode_write().
4499  * Give this, we know that the caller already has write access to iloc->bh.
4500  */
4501 int ext4_mark_iloc_dirty(handle_t *handle,
4502  struct inode *inode, struct ext4_iloc *iloc)
4503 {
4504  int err = 0;
4505 
4506  if (IS_I_VERSION(inode))
4507  inode_inc_iversion(inode);
4508 
4509  /* the do_update_inode consumes one bh->b_count */
4510  get_bh(iloc->bh);
4511 
4512  /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4513  err = ext4_do_update_inode(handle, inode, iloc);
4514  put_bh(iloc->bh);
4515  return err;
4516 }
4517 
4518 /*
4519  * On success, We end up with an outstanding reference count against
4520  * iloc->bh. This _must_ be cleaned up later.
4521  */
4522 
4523 int
4524 ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
4525  struct ext4_iloc *iloc)
4526 {
4527  int err;
4528 
4529  err = ext4_get_inode_loc(inode, iloc);
4530  if (!err) {
4531  BUFFER_TRACE(iloc->bh, "get_write_access");
4532  err = ext4_journal_get_write_access(handle, iloc->bh);
4533  if (err) {
4534  brelse(iloc->bh);
4535  iloc->bh = NULL;
4536  }
4537  }
4538  ext4_std_error(inode->i_sb, err);
4539  return err;
4540 }
4541 
4542 /*
4543  * Expand an inode by new_extra_isize bytes.
4544  * Returns 0 on success or negative error number on failure.
4545  */
4546 static int ext4_expand_extra_isize(struct inode *inode,
4547  unsigned int new_extra_isize,
4548  struct ext4_iloc iloc,
4549  handle_t *handle)
4550 {
4551  struct ext4_inode *raw_inode;
4553 
4554  if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
4555  return 0;
4556 
4557  raw_inode = ext4_raw_inode(&iloc);
4558 
4559  header = IHDR(inode, raw_inode);
4560 
4561  /* No extended attributes present */
4562  if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
4563  header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
4564  memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0,
4565  new_extra_isize);
4566  EXT4_I(inode)->i_extra_isize = new_extra_isize;
4567  return 0;
4568  }
4569 
4570  /* try to expand with EAs present */
4571  return ext4_expand_extra_isize_ea(inode, new_extra_isize,
4572  raw_inode, handle);
4573 }
4574 
4575 /*
4576  * What we do here is to mark the in-core inode as clean with respect to inode
4577  * dirtiness (it may still be data-dirty).
4578  * This means that the in-core inode may be reaped by prune_icache
4579  * without having to perform any I/O. This is a very good thing,
4580  * because *any* task may call prune_icache - even ones which
4581  * have a transaction open against a different journal.
4582  *
4583  * Is this cheating? Not really. Sure, we haven't written the
4584  * inode out, but prune_icache isn't a user-visible syncing function.
4585  * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
4586  * we start and wait on commits.
4587  */
4588 int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
4589 {
4590  struct ext4_iloc iloc;
4591  struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4592  static unsigned int mnt_count;
4593  int err, ret;
4594 
4595  might_sleep();
4596  trace_ext4_mark_inode_dirty(inode, _RET_IP_);
4597  err = ext4_reserve_inode_write(handle, inode, &iloc);
4598  if (ext4_handle_valid(handle) &&
4599  EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize &&
4600  !ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND)) {
4601  /*
4602  * We need extra buffer credits since we may write into EA block
4603  * with this same handle. If journal_extend fails, then it will
4604  * only result in a minor loss of functionality for that inode.
4605  * If this is felt to be critical, then e2fsck should be run to
4606  * force a large enough s_min_extra_isize.
4607  */
4608  if ((jbd2_journal_extend(handle,
4609  EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
4610  ret = ext4_expand_extra_isize(inode,
4611  sbi->s_want_extra_isize,
4612  iloc, handle);
4613  if (ret) {
4614  ext4_set_inode_state(inode,
4615  EXT4_STATE_NO_EXPAND);
4616  if (mnt_count !=
4617  le16_to_cpu(sbi->s_es->s_mnt_count)) {
4618  ext4_warning(inode->i_sb,
4619  "Unable to expand inode %lu. Delete"
4620  " some EAs or run e2fsck.",
4621  inode->i_ino);
4622  mnt_count =
4623  le16_to_cpu(sbi->s_es->s_mnt_count);
4624  }
4625  }
4626  }
4627  }
4628  if (!err)
4629  err = ext4_mark_iloc_dirty(handle, inode, &iloc);
4630  return err;
4631 }
4632 
4633 /*
4634  * ext4_dirty_inode() is called from __mark_inode_dirty()
4635  *
4636  * We're really interested in the case where a file is being extended.
4637  * i_size has been changed by generic_commit_write() and we thus need
4638  * to include the updated inode in the current transaction.
4639  *
4640  * Also, dquot_alloc_block() will always dirty the inode when blocks
4641  * are allocated to the file.
4642  *
4643  * If the inode is marked synchronous, we don't honour that here - doing
4644  * so would cause a commit on atime updates, which we don't bother doing.
4645  * We handle synchronous inodes at the highest possible level.
4646  */
4647 void ext4_dirty_inode(struct inode *inode, int flags)
4648 {
4649  handle_t *handle;
4650 
4651  handle = ext4_journal_start(inode, 2);
4652  if (IS_ERR(handle))
4653  goto out;
4654 
4655  ext4_mark_inode_dirty(handle, inode);
4656 
4657  ext4_journal_stop(handle);
4658 out:
4659  return;
4660 }
4661 
4662 #if 0
4663 /*
4664  * Bind an inode's backing buffer_head into this transaction, to prevent
4665  * it from being flushed to disk early. Unlike
4666  * ext4_reserve_inode_write, this leaves behind no bh reference and
4667  * returns no iloc structure, so the caller needs to repeat the iloc
4668  * lookup to mark the inode dirty later.
4669  */
4670 static int ext4_pin_inode(handle_t *handle, struct inode *inode)
4671 {
4672  struct ext4_iloc iloc;
4673 
4674  int err = 0;
4675  if (handle) {
4676  err = ext4_get_inode_loc(inode, &iloc);
4677  if (!err) {
4678  BUFFER_TRACE(iloc.bh, "get_write_access");
4679  err = jbd2_journal_get_write_access(handle, iloc.bh);
4680  if (!err)
4681  err = ext4_handle_dirty_metadata(handle,
4682  NULL,
4683  iloc.bh);
4684  brelse(iloc.bh);
4685  }
4686  }
4687  ext4_std_error(inode->i_sb, err);
4688  return err;
4689 }
4690 #endif
4691 
4692 int ext4_change_inode_journal_flag(struct inode *inode, int val)
4693 {
4694  journal_t *journal;
4695  handle_t *handle;
4696  int err;
4697 
4698  /*
4699  * We have to be very careful here: changing a data block's
4700  * journaling status dynamically is dangerous. If we write a
4701  * data block to the journal, change the status and then delete
4702  * that block, we risk forgetting to revoke the old log record
4703  * from the journal and so a subsequent replay can corrupt data.
4704  * So, first we make sure that the journal is empty and that
4705  * nobody is changing anything.
4706  */
4707 
4708  journal = EXT4_JOURNAL(inode);
4709  if (!journal)
4710  return 0;
4711  if (is_journal_aborted(journal))
4712  return -EROFS;
4713  /* We have to allocate physical blocks for delalloc blocks
4714  * before flushing journal. otherwise delalloc blocks can not
4715  * be allocated any more. even more truncate on delalloc blocks
4716  * could trigger BUG by flushing delalloc blocks in journal.
4717  * There is no delalloc block in non-journal data mode.
4718  */
4719  if (val && test_opt(inode->i_sb, DELALLOC)) {
4720  err = ext4_alloc_da_blocks(inode);
4721  if (err < 0)
4722  return err;
4723  }
4724 
4725  /* Wait for all existing dio workers */
4726  ext4_inode_block_unlocked_dio(inode);
4727  inode_dio_wait(inode);
4728 
4729  jbd2_journal_lock_updates(journal);
4730 
4731  /*
4732  * OK, there are no updates running now, and all cached data is
4733  * synced to disk. We are now in a completely consistent state
4734  * which doesn't have anything in the journal, and we know that
4735  * no filesystem updates are running, so it is safe to modify
4736  * the inode's in-core data-journaling state flag now.
4737  */
4738 
4739  if (val)
4740  ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
4741  else {
4742  jbd2_journal_flush(journal);
4743  ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
4744  }
4745  ext4_set_aops(inode);
4746 
4747  jbd2_journal_unlock_updates(journal);
4748  ext4_inode_resume_unlocked_dio(inode);
4749 
4750  /* Finally we can mark the inode as dirty. */
4751 
4752  handle = ext4_journal_start(inode, 1);
4753  if (IS_ERR(handle))
4754  return PTR_ERR(handle);
4755 
4756  err = ext4_mark_inode_dirty(handle, inode);
4757  ext4_handle_sync(handle);
4758  ext4_journal_stop(handle);
4759  ext4_std_error(inode->i_sb, err);
4760 
4761  return err;
4762 }
4763 
4764 static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh)
4765 {
4766  return !buffer_mapped(bh);
4767 }
4768 
4769 int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
4770 {
4771  struct page *page = vmf->page;
4772  loff_t size;
4773  unsigned long len;
4774  int ret;
4775  struct file *file = vma->vm_file;
4776  struct inode *inode = file->f_path.dentry->d_inode;
4777  struct address_space *mapping = inode->i_mapping;
4778  handle_t *handle;
4779  get_block_t *get_block;
4780  int retries = 0;
4781 
4782  sb_start_pagefault(inode->i_sb);
4783  file_update_time(vma->vm_file);
4784  /* Delalloc case is easy... */
4785  if (test_opt(inode->i_sb, DELALLOC) &&
4786  !ext4_should_journal_data(inode) &&
4787  !ext4_nonda_switch(inode->i_sb)) {
4788  do {
4789  ret = __block_page_mkwrite(vma, vmf,
4790  ext4_da_get_block_prep);
4791  } while (ret == -ENOSPC &&
4792  ext4_should_retry_alloc(inode->i_sb, &retries));
4793  goto out_ret;
4794  }
4795 
4796  lock_page(page);
4797  size = i_size_read(inode);
4798  /* Page got truncated from under us? */
4799  if (page->mapping != mapping || page_offset(page) > size) {
4800  unlock_page(page);
4801  ret = VM_FAULT_NOPAGE;
4802  goto out;
4803  }
4804 
4805  if (page->index == size >> PAGE_CACHE_SHIFT)
4806  len = size & ~PAGE_CACHE_MASK;
4807  else
4808  len = PAGE_CACHE_SIZE;
4809  /*
4810  * Return if we have all the buffers mapped. This avoids the need to do
4811  * journal_start/journal_stop which can block and take a long time
4812  */
4813  if (page_has_buffers(page)) {
4814  if (!walk_page_buffers(NULL, page_buffers(page), 0, len, NULL,
4815  ext4_bh_unmapped)) {
4816  /* Wait so that we don't change page under IO */
4817  wait_on_page_writeback(page);
4818  ret = VM_FAULT_LOCKED;
4819  goto out;
4820  }
4821  }
4822  unlock_page(page);
4823  /* OK, we need to fill the hole... */
4824  if (ext4_should_dioread_nolock(inode))
4825  get_block = ext4_get_block_write;
4826  else
4827  get_block = ext4_get_block;
4828 retry_alloc:
4829  handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
4830  if (IS_ERR(handle)) {
4831  ret = VM_FAULT_SIGBUS;
4832  goto out;
4833  }
4834  ret = __block_page_mkwrite(vma, vmf, get_block);
4835  if (!ret && ext4_should_journal_data(inode)) {
4836  if (walk_page_buffers(handle, page_buffers(page), 0,
4837  PAGE_CACHE_SIZE, NULL, do_journal_get_write_access)) {
4838  unlock_page(page);
4839  ret = VM_FAULT_SIGBUS;
4840  ext4_journal_stop(handle);
4841  goto out;
4842  }
4843  ext4_set_inode_state(inode, EXT4_STATE_JDATA);
4844  }
4845  ext4_journal_stop(handle);
4846  if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
4847  goto retry_alloc;
4848 out_ret:
4849  ret = block_page_mkwrite_return(ret);
4850 out:
4851  sb_end_pagefault(inode->i_sb);
4852  return ret;
4853 }