~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ext4/inode.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  linux/fs/ext4/inode.c
  3  *
  4  * Copyright (C) 1992, 1993, 1994, 1995
  5  * Remy Card (card@masi.ibp.fr)
  6  * Laboratoire MASI - Institut Blaise Pascal
  7  * Universite Pierre et Marie Curie (Paris VI)
  8  *
  9  *  from
 10  *
 11  *  linux/fs/minix/inode.c
 12  *
 13  *  Copyright (C) 1991, 1992  Linus Torvalds
 14  *
 15  *  64-bit file support on 64-bit platforms by Jakub Jelinek
 16  *      (jj@sunsite.ms.mff.cuni.cz)
 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;
 60         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
 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;
 70         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
 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 !=
 83             cpu_to_le32(EXT4_OS_LINUX) ||
 84             !EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
 85                 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
 86                 return 1;
 87 
 88         provided = le16_to_cpu(raw->i_checksum_lo);
 89         calculated = ext4_inode_csum(inode, raw, ei);
 90         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
 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 !=
105             cpu_to_le32(EXT4_OS_LINUX) ||
106             !EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
107                 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
108                 return;
109 
110         csum = ext4_inode_csum(inode, raw, ei);
111         raw->i_checksum_lo = cpu_to_le16(csum & 0xFFFF);
112         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
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;
129         return jbd2_journal_begin_ordered_truncate(EXT4_JOURNAL(inode),
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);
177         ext4_discard_preallocations(inode);
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);
220                         filemap_write_and_wait(&inode->i_data);
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,
352                          ei->i_reserved_data_blocks);
353                 WARN_ON(1);
354                 used = ei->i_reserved_data_blocks;
355         }
356 
357         if (unlikely(ei->i_allocated_meta_blocks > ei->i_reserved_meta_blocks)) {
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,
361                          ei->i_reserved_meta_blocks);
362                 WARN_ON(1);
363                 ei->i_allocated_meta_blocks = ei->i_reserved_meta_blocks;
364         }
365 
366         /* Update per-inode reservations */
367         ei->i_reserved_data_blocks -= used;
368         ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks;
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,
380                                    ei->i_reserved_meta_blocks);
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))
405                 ext4_discard_preallocations(inode);
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,
445                                               PAGECACHE_TAG_DIRTY,
446                                               (pgoff_t)PAGEVEC_SIZE);
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,
505                                               (pgoff_t)PAGEVEC_SIZE));
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 &
568                                              EXT4_GET_BLOCKS_KEEP_SIZE);
569         } else {
570                 retval = ext4_ind_map_blocks(handle, inode, map, flags &
571                                              EXT4_GET_BLOCKS_KEEP_SIZE);
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          */
622         if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
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,
1267                          ei->i_reserved_data_blocks);
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,
1282                                    ei->i_reserved_meta_blocks);
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 
1461                         clear_page_dirty_for_io(page);
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 
1507         pagevec_init(&pvec, 0);
1508         while (index <= end) {
1509                 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1510                 if (nr_pages == 0)
1511                         break;
1512                 for (i = 0; i < nr_pages; i++) {
1513                         struct page *page = pvec.pages[i];
1514                         if (page->index > end)
1515                                 break;
1516                         BUG_ON(!PageLocked(page));
1517                         BUG_ON(PageWriteback(page));
1518                         block_invalidatepage(page, 0);
1519                         ClearPageUptodate(page);
1520                         unlock_page(page);
1521                 }
1522                 index = pvec.pages[nr_pages - 1]->index + 1;
1523                 pagevec_release(&pvec);
1524         }
1525         return;
1526 }
1527 
1528 static void ext4_print_free_blocks(struct inode *inode)
1529 {
1530         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1531         struct super_block *sb = inode->i_sb;
1532 
1533         ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld",
1534                EXT4_C2B(EXT4_SB(inode->i_sb),
1535                         ext4_count_free_clusters(inode->i_sb)));
1536         ext4_msg(sb, KERN_CRIT, "Free/Dirty block details");
1537         ext4_msg(sb, KERN_CRIT, "free_blocks=%lld",
1538                (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
1539                 percpu_counter_sum(&sbi->s_freeclusters_counter)));
1540         ext4_msg(sb, KERN_CRIT, "dirty_blocks=%lld",
1541                (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
1542                 percpu_counter_sum(&sbi->s_dirtyclusters_counter)));
1543         ext4_msg(sb, KERN_CRIT, "Block reservation details");
1544         ext4_msg(sb, KERN_CRIT, "i_reserved_data_blocks=%u",
1545                  EXT4_I(inode)->i_reserved_data_blocks);
1546         ext4_msg(sb, KERN_CRIT, "i_reserved_meta_blocks=%u",
1547                EXT4_I(inode)->i_reserved_meta_blocks);
1548         return;
1549 }
1550 
1551 /*
1552  * mpage_da_map_and_submit - go through given space, map them
1553  *       if necessary, and then submit them for I/O
1554  *
1555  * @mpd - bh describing space
1556  *
1557  * The function skips space we know is already mapped to disk blocks.
1558  *
1559  */
1560 static void mpage_da_map_and_submit(struct mpage_da_data *mpd)
1561 {
1562         int err, blks, get_blocks_flags;
1563         struct ext4_map_blocks map, *mapp = NULL;
1564         sector_t next = mpd->b_blocknr;
1565         unsigned max_blocks = mpd->b_size >> mpd->inode->i_blkbits;
1566         loff_t disksize = EXT4_I(mpd->inode)->i_disksize;
1567         handle_t *handle = NULL;
1568 
1569         /*
1570          * If the blocks are mapped already, or we couldn't accumulate
1571          * any blocks, then proceed immediately to the submission stage.
1572          */
1573         if ((mpd->b_size == 0) ||
1574             ((mpd->b_state  & (1 << BH_Mapped)) &&
1575              !(mpd->b_state & (1 << BH_Delay)) &&
1576              !(mpd->b_state & (1 << BH_Unwritten))))
1577                 goto submit_io;
1578 
1579         handle = ext4_journal_current_handle();
1580         BUG_ON(!handle);
1581 
1582         /*
1583          * Call ext4_map_blocks() to allocate any delayed allocation
1584          * blocks, or to convert an uninitialized extent to be
1585          * initialized (in the case where we have written into
1586          * one or more preallocated blocks).
1587          *
1588          * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE to
1589          * indicate that we are on the delayed allocation path.  This
1590          * affects functions in many different parts of the allocation
1591          * call path.  This flag exists primarily because we don't
1592          * want to change *many* call functions, so ext4_map_blocks()
1593          * will set the EXT4_STATE_DELALLOC_RESERVED flag once the
1594          * inode's allocation semaphore is taken.
1595          *
1596          * If the blocks in questions were delalloc blocks, set
1597          * EXT4_GET_BLOCKS_DELALLOC_RESERVE so the delalloc accounting
1598          * variables are updated after the blocks have been allocated.
1599          */
1600         map.m_lblk = next;
1601         map.m_len = max_blocks;
1602         get_blocks_flags = EXT4_GET_BLOCKS_CREATE;
1603         if (ext4_should_dioread_nolock(mpd->inode))
1604                 get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT;
1605         if (mpd->b_state & (1 << BH_Delay))
1606                 get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE;
1607 
1608         blks = ext4_map_blocks(handle, mpd->inode, &map, get_blocks_flags);
1609         if (blks < 0) {
1610                 struct super_block *sb = mpd->inode->i_sb;
1611 
1612                 err = blks;
1613                 /*
1614                  * If get block returns EAGAIN or ENOSPC and there
1615                  * appears to be free blocks we will just let
1616                  * mpage_da_submit_io() unlock all of the pages.
1617                  */
1618                 if (err == -EAGAIN)
1619                         goto submit_io;
1620 
1621                 if (err == -ENOSPC && ext4_count_free_clusters(sb)) {
1622                         mpd->retval = err;
1623                         goto submit_io;
1624                 }
1625 
1626                 /*
1627                  * get block failure will cause us to loop in
1628                  * writepages, because a_ops->writepage won't be able
1629                  * to make progress. The page will be redirtied by
1630                  * writepage and writepages will again try to write
1631                  * the same.
1632                  */
1633                 if (!(EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)) {
1634                         ext4_msg(sb, KERN_CRIT,
1635                                  "delayed block allocation failed for inode %lu "
1636                                  "at logical offset %llu with max blocks %zd "
1637                                  "with error %d", mpd->inode->i_ino,
1638                                  (unsigned long long) next,
1639                                  mpd->b_size >> mpd->inode->i_blkbits, err);
1640                         ext4_msg(sb, KERN_CRIT,
1641                                 "This should not happen!! Data will be lost\n");
1642                         if (err == -ENOSPC)
1643                                 ext4_print_free_blocks(mpd->inode);
1644                 }
1645                 /* invalidate all the pages */
1646                 ext4_da_block_invalidatepages(mpd);
1647 
1648                 /* Mark this page range as having been completed */
1649                 mpd->io_done = 1;
1650                 return;
1651         }
1652         BUG_ON(blks == 0);
1653 
1654         mapp = &map;
1655         if (map.m_flags & EXT4_MAP_NEW) {
1656                 struct block_device *bdev = mpd->inode->i_sb->s_bdev;
1657                 int i;
1658 
1659                 for (i = 0; i < map.m_len; i++)
1660                         unmap_underlying_metadata(bdev, map.m_pblk + i);
1661 
1662                 if (ext4_should_order_data(mpd->inode)) {
1663                         err = ext4_jbd2_file_inode(handle, mpd->inode);
1664                         if (err) {
1665                                 /* Only if the journal is aborted */
1666                                 mpd->retval = err;
1667                                 goto submit_io;
1668                         }
1669                 }
1670         }
1671 
1672         /*
1673          * Update on-disk size along with block allocation.
1674          */
1675         disksize = ((loff_t) next + blks) << mpd->inode->i_blkbits;
1676         if (disksize > i_size_read(mpd->inode))
1677                 disksize = i_size_read(mpd->inode);
1678         if (disksize > EXT4_I(mpd->inode)->i_disksize) {
1679                 ext4_update_i_disksize(mpd->inode, disksize);
1680                 err = ext4_mark_inode_dirty(handle, mpd->inode);
1681                 if (err)
1682                         ext4_error(mpd->inode->i_sb,
1683                                    "Failed to mark inode %lu dirty",
1684                                    mpd->inode->i_ino);
1685         }
1686 
1687 submit_io:
1688         mpage_da_submit_io(mpd, mapp);
1689         mpd->io_done = 1;
1690 }
1691 
1692 #define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | \
1693                 (1 << BH_Delay) | (1 << BH_Unwritten))
1694 
1695 /*
1696  * mpage_add_bh_to_extent - try to add one more block to extent of blocks
1697  *
1698  * @mpd->lbh - extent of blocks
1699  * @logical - logical number of the block in the file
1700  * @bh - bh of the block (used to access block's state)
1701  *
1702  * the function is used to collect contig. blocks in same state
1703  */
1704 static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
1705                                    sector_t logical, size_t b_size,
1706                                    unsigned long b_state)
1707 {
1708         sector_t next;
1709         int nrblocks = mpd->b_size >> mpd->inode->i_blkbits;
1710 
1711         /*
1712          * XXX Don't go larger than mballoc is willing to allocate
1713          * This is a stopgap solution.  We eventually need to fold
1714          * mpage_da_submit_io() into this function and then call
1715          * ext4_map_blocks() multiple times in a loop
1716          */
1717         if (nrblocks >= 8*1024*1024/mpd->inode->i_sb->s_blocksize)
1718                 goto flush_it;
1719 
1720         /* check if thereserved journal credits might overflow */
1721         if (!(ext4_test_inode_flag(mpd->inode, EXT4_INODE_EXTENTS))) {
1722                 if (nrblocks >= EXT4_MAX_TRANS_DATA) {
1723                         /*
1724                          * With non-extent format we are limited by the journal
1725                          * credit available.  Total credit needed to insert
1726                          * nrblocks contiguous blocks is dependent on the
1727                          * nrblocks.  So limit nrblocks.
1728                          */
1729                         goto flush_it;
1730                 } else if ((nrblocks + (b_size >> mpd->inode->i_blkbits)) >
1731                                 EXT4_MAX_TRANS_DATA) {
1732                         /*
1733                          * Adding the new buffer_head would make it cross the
1734                          * allowed limit for which we have journal credit
1735                          * reserved. So limit the new bh->b_size
1736                          */
1737                         b_size = (EXT4_MAX_TRANS_DATA - nrblocks) <<
1738                                                 mpd->inode->i_blkbits;
1739                         /* we will do mpage_da_submit_io in the next loop */
1740                 }
1741         }
1742         /*
1743          * First block in the extent
1744          */
1745         if (mpd->b_size == 0) {
1746                 mpd->b_blocknr = logical;
1747                 mpd->b_size = b_size;
1748                 mpd->b_state = b_state & BH_FLAGS;
1749                 return;
1750         }
1751 
1752         next = mpd->b_blocknr + nrblocks;
1753         /*
1754          * Can we merge the block to our big extent?
1755          */
1756         if (logical == next && (b_state & BH_FLAGS) == mpd->b_state) {
1757                 mpd->b_size += b_size;
1758                 return;
1759         }
1760 
1761 flush_it:
1762         /*
1763          * We couldn't merge the block to our extent, so we
1764          * need to flush current  extent and start new one
1765          */
1766         mpage_da_map_and_submit(mpd);
1767         return;
1768 }
1769 
1770 static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
1771 {
1772         return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
1773 }
1774 
1775 /*
1776  * This function is grabs code from the very beginning of
1777  * ext4_map_blocks, but assumes that the caller is from delayed write
1778  * time. This function looks up the requested blocks and sets the
1779  * buffer delay bit under the protection of i_data_sem.
1780  */
1781 static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
1782                               struct ext4_map_blocks *map,
1783                               struct buffer_head *bh)
1784 {
1785         int retval;
1786         sector_t invalid_block = ~((sector_t) 0xffff);
1787 
1788         if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
1789                 invalid_block = ~0;
1790 
1791         map->m_flags = 0;
1792         ext_debug("ext4_da_map_blocks(): inode %lu, max_blocks %u,"
1793                   "logical block %lu\n", inode->i_ino, map->m_len,
1794                   (unsigned long) map->m_lblk);
1795         /*
1796          * Try to see if we can get the block without requesting a new
1797          * file system block.
1798          */
1799         down_read((&EXT4_I(inode)->i_data_sem));
1800         if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
1801                 retval = ext4_ext_map_blocks(NULL, inode, map, 0);
1802         else
1803                 retval = ext4_ind_map_blocks(NULL, inode, map, 0);
1804 
1805         if (retval == 0) {
1806                 /*
1807                  * XXX: __block_prepare_write() unmaps passed block,
1808                  * is it OK?
1809                  */
1810                 /* If the block was allocated from previously allocated cluster,
1811                  * then we dont need to reserve it again. */
1812                 if (!(map->m_flags & EXT4_MAP_FROM_CLUSTER)) {
1813                         retval = ext4_da_reserve_space(inode, iblock);
1814                         if (retval)
1815                                 /* not enough space to reserve */
1816                                 goto out_unlock;
1817                 }
1818 
1819                 /* Clear EXT4_MAP_FROM_CLUSTER flag since its purpose is served
1820                  * and it should not appear on the bh->b_state.
1821                  */
1822                 map->m_flags &= ~EXT4_MAP_FROM_CLUSTER;
1823 
1824                 map_bh(bh, inode->i_sb, invalid_block);
1825                 set_buffer_new(bh);
1826                 set_buffer_delay(bh);
1827         }
1828 
1829 out_unlock:
1830         up_read((&EXT4_I(inode)->i_data_sem));
1831 
1832         return retval;
1833 }
1834 
1835 /*
1836  * This is a special get_blocks_t callback which is used by
1837  * ext4_da_write_begin().  It will either return mapped block or
1838  * reserve space for a single block.
1839  *
1840  * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
1841  * We also have b_blocknr = -1 and b_bdev initialized properly
1842  *
1843  * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
1844  * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
1845  * initialized properly.
1846  */
1847 static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
1848                                   struct buffer_head *bh, int create)
1849 {
1850         struct ext4_map_blocks map;
1851         int ret = 0;
1852 
1853         BUG_ON(create == 0);
1854         BUG_ON(bh->b_size != inode->i_sb->s_blocksize);
1855 
1856         map.m_lblk = iblock;
1857         map.m_len = 1;
1858 
1859         /*
1860          * first, we need to know whether the block is allocated already
1861          * preallocated blocks are unmapped but should treated
1862          * the same as allocated blocks.
1863          */
1864         ret = ext4_da_map_blocks(inode, iblock, &map, bh);
1865         if (ret <= 0)
1866                 return ret;
1867 
1868         map_bh(bh, inode->i_sb, map.m_pblk);
1869         bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
1870 
1871         if (buffer_unwritten(bh)) {
1872                 /* A delayed write to unwritten bh should be marked
1873                  * new and mapped.  Mapped ensures that we don't do
1874                  * get_block multiple times when we write to the same
1875                  * offset and new ensures that we do proper zero out
1876                  * for partial write.
1877                  */
1878                 set_buffer_new(bh);
1879                 set_buffer_mapped(bh);
1880         }
1881         return 0;
1882 }
1883 
1884 /*
1885  * This function is used as a standard get_block_t calback function
1886  * when there is no desire to allocate any blocks.  It is used as a
1887  * callback function for block_write_begin() and block_write_full_page().
1888  * These functions should only try to map a single block at a time.
1889  *
1890  * Since this function doesn't do block allocations even if the caller
1891  * requests it by passing in create=1, it is critically important that
1892  * any caller checks to make sure that any buffer heads are returned
1893  * by this function are either all already mapped or marked for
1894  * delayed allocation before calling  block_write_full_page().  Otherwise,
1895  * b_blocknr could be left unitialized, and the page write functions will
1896  * be taken by surprise.
1897  */
1898 static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
1899                                    struct buffer_head *bh_result, int create)
1900 {
1901         BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
1902         return _ext4_get_block(inode, iblock, bh_result, 0);
1903 }
1904 
1905 static int bget_one(handle_t *handle, struct buffer_head *bh)
1906 {
1907         get_bh(bh);
1908         return 0;
1909 }
1910 
1911 static int bput_one(handle_t *handle, struct buffer_head *bh)
1912 {
1913         put_bh(bh);
1914         return 0;
1915 }
1916 
1917 static int __ext4_journalled_writepage(struct page *page,
1918                                        unsigned int len)
1919 {
1920         struct address_space *mapping = page->mapping;
1921         struct inode *inode = mapping->host;
1922         struct buffer_head *page_bufs;
1923         handle_t *handle = NULL;
1924         int ret = 0;
1925         int err;
1926 
1927         ClearPageChecked(page);
1928         page_bufs = page_buffers(page);
1929         BUG_ON(!page_bufs);
1930         walk_page_buffers(handle, page_bufs, 0, len, NULL, bget_one);
1931         /* As soon as we unlock the page, it can go away, but we have
1932          * references to buffers so we are safe */
1933         unlock_page(page);
1934 
1935         handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
1936         if (IS_ERR(handle)) {
1937                 ret = PTR_ERR(handle);
1938                 goto out;
1939         }
1940 
1941         BUG_ON(!ext4_handle_valid(handle));
1942 
1943         ret = walk_page_buffers(handle, page_bufs, 0, len, NULL,
1944                                 do_journal_get_write_access);
1945 
1946         err = walk_page_buffers(handle, page_bufs, 0, len, NULL,
1947                                 write_end_fn);
1948         if (ret == 0)
1949                 ret = err;
1950         EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1951         err = ext4_journal_stop(handle);
1952         if (!ret)
1953                 ret = err;
1954 
1955         walk_page_buffers(handle, page_bufs, 0, len, NULL, bput_one);
1956         ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1957 out:
1958         return ret;
1959 }
1960 
1961 /*
1962  * Note that we don't need to start a transaction unless we're journaling data
1963  * because we should have holes filled from ext4_page_mkwrite(). We even don't
1964  * need to file the inode to the transaction's list in ordered mode because if
1965  * we are writing back data added by write(), the inode is already there and if
1966  * we are writing back data modified via mmap(), no one guarantees in which
1967  * transaction the data will hit the disk. In case we are journaling data, we
1968  * cannot start transaction directly because transaction start ranks above page
1969  * lock so we have to do some magic.
1970  *
1971  * This function can get called via...
1972  *   - ext4_da_writepages after taking page lock (have journal handle)
1973  *   - journal_submit_inode_data_buffers (no journal handle)
1974  *   - shrink_page_list via the kswapd/direct reclaim (no journal handle)
1975  *   - grab_page_cache when doing write_begin (have journal handle)
1976  *
1977  * We don't do any block allocation in this function. If we have page with
1978  * multiple blocks we need to write those buffer_heads that are mapped. This
1979  * is important for mmaped based write. So if we do with blocksize 1K
1980  * truncate(f, 1024);
1981  * a = mmap(f, 0, 4096);
1982  * a[0] = 'a';
1983  * truncate(f, 4096);
1984  * we have in the page first buffer_head mapped via page_mkwrite call back
1985  * but other buffer_heads would be unmapped but dirty (dirty done via the
1986  * do_wp_page). So writepage should write the first block. If we modify
1987  * the mmap area beyond 1024 we will again get a page_fault and the
1988  * page_mkwrite callback will do the block allocation and mark the
1989  * buffer_heads mapped.
1990  *
1991  * We redirty the page if we have any buffer_heads that is either delay or
1992  * unwritten in the page.
1993  *
1994  * We can get recursively called as show below.
1995  *
1996  *      ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1997  *              ext4_writepage()
1998  *
1999  * But since we don't do any block allocation we should not deadlock.
2000  * Page also have the dirty flag cleared so we don't get recurive page_lock.
2001  */
2002 static int ext4_writepage(struct page *page,
2003                           struct writeback_control *wbc)
2004 {
2005         int ret = 0, commit_write = 0;
2006         loff_t size;
2007         unsigned int len;
2008         struct buffer_head *page_bufs = NULL;
2009         struct inode *inode = page->mapping->host;
2010 
2011         trace_ext4_writepage(page);
2012         size = i_size_read(inode);
2013         if (page->index == size >> PAGE_CACHE_SHIFT)
2014                 len = size & ~PAGE_CACHE_MASK;
2015         else
2016                 len = PAGE_CACHE_SIZE;
2017 
2018         /*
2019          * If the page does not have buffers (for whatever reason),
2020          * try to create them using __block_write_begin.  If this
2021          * fails, redirty the page and move on.
2022          */
2023         if (!page_has_buffers(page)) {
2024                 if (__block_write_begin(page, 0, len,
2025                                         noalloc_get_block_write)) {
2026                 redirty_page:
2027                         redirty_page_for_writepage(wbc, page);
2028                         unlock_page(page);
2029                         return 0;
2030                 }
2031                 commit_write = 1;
2032         }
2033         page_bufs = page_buffers(page);
2034         if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
2035                               ext4_bh_delay_or_unwritten)) {
2036                 /*
2037                  * We don't want to do block allocation, so redirty
2038                  * the page and return.  We may reach here when we do
2039                  * a journal commit via journal_submit_inode_data_buffers.
2040                  * We can also reach here via shrink_page_list but it
2041                  * should never be for direct reclaim so warn if that
2042                  * happens
2043                  */
2044                 WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
2045                                                                 PF_MEMALLOC);
2046                 goto redirty_page;
2047         }
2048         if (commit_write)
2049                 /* now mark the buffer_heads as dirty and uptodate */
2050                 block_commit_write(page, 0, len);
2051 
2052         if (PageChecked(page) && ext4_should_journal_data(inode))
2053                 /*
2054                  * It's mmapped pagecache.  Add buffers and journal it.  There
2055                  * doesn't seem much point in redirtying the page here.
2056                  */
2057                 return __ext4_journalled_writepage(page, len);
2058 
2059         if (buffer_uninit(page_bufs)) {
2060                 ext4_set_bh_endio(page_bufs, inode);
2061                 ret = block_write_full_page_endio(page, noalloc_get_block_write,
2062                                             wbc, ext4_end_io_buffer_write);
2063         } else
2064                 ret = block_write_full_page(page, noalloc_get_block_write,
2065                                             wbc);
2066 
2067         return ret;
2068 }
2069 
2070 /*
2071  * This is called via ext4_da_writepages() to
2072  * calculate the total number of credits to reserve to fit
2073  * a single extent allocation into a single transaction,
2074  * ext4_da_writpeages() will loop calling this before
2075  * the block allocation.
2076  */
2077 
2078 static int ext4_da_writepages_trans_blocks(struct inode *inode)
2079 {
2080         int max_blocks = EXT4_I(inode)->i_reserved_data_blocks;
2081 
2082         /*
2083          * With non-extent format the journal credit needed to
2084          * insert nrblocks contiguous block is dependent on
2085          * number of contiguous block. So we will limit
2086          * number of contiguous block to a sane value
2087          */
2088         if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) &&
2089             (max_blocks > EXT4_MAX_TRANS_DATA))
2090                 max_blocks = EXT4_MAX_TRANS_DATA;
2091 
2092         return ext4_chunk_trans_blocks(inode, max_blocks);
2093 }
2094 
2095 /*
2096  * write_cache_pages_da - walk the list of dirty pages of the given
2097  * address space and accumulate pages that need writing, and call
2098  * mpage_da_map_and_submit to map a single contiguous memory region
2099  * and then write them.
2100  */
2101 static int write_cache_pages_da(struct address_space *mapping,
2102                                 struct writeback_control *wbc,
2103                                 struct mpage_da_data *mpd,
2104                                 pgoff_t *done_index)
2105 {
2106         struct buffer_head      *bh, *head;
2107         struct inode            *inode = mapping->host;
2108         struct pagevec          pvec;
2109         unsigned int            nr_pages;
2110         sector_t                logical;
2111         pgoff_t                 index, end;
2112         long                    nr_to_write = wbc->nr_to_write;
2113         int                     i, tag, ret = 0;
2114 
2115         memset(mpd, 0, sizeof(struct mpage_da_data));
2116         mpd->wbc = wbc;
2117         mpd->inode = inode;
2118         pagevec_init(&pvec, 0);
2119         index = wbc->range_start >> PAGE_CACHE_SHIFT;
2120         end = wbc->range_end >> PAGE_CACHE_SHIFT;
2121 
2122         if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
2123                 tag = PAGECACHE_TAG_TOWRITE;
2124         else
2125                 tag = PAGECACHE_TAG_DIRTY;
2126 
2127         *done_index = index;
2128         while (index <= end) {
2129                 nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
2130                               min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
2131                 if (nr_pages == 0)
2132                         return 0;
2133 
2134                 for (i = 0; i < nr_pages; i++) {
2135                         struct page *page = pvec.pages[i];
2136 
2137                         /*
2138                          * At this point, the page may be truncated or
2139                          * invalidated (changing page->mapping to NULL), or
2140                          * even swizzled back from swapper_space to tmpfs file
2141                          * mapping. However, page->index will not change
2142                          * because we have a reference on the page.
2143                          */
2144                         if (page->index > end)
2145                                 goto out;
2146 
2147                         *done_index = page->index + 1;
2148 
2149                         /*
2150                          * If we can't merge this page, and we have
2151                          * accumulated an contiguous region, write it
2152                          */
2153                         if ((mpd->next_page != page->index) &&
2154                             (mpd->next_page != mpd->first_page)) {
2155                                 mpage_da_map_and_submit(mpd);
2156                                 goto ret_extent_tail;
2157                         }
2158 
2159                         lock_page(page);
2160 
2161                         /*
2162                          * If the page is no longer dirty, or its
2163                          * mapping no longer corresponds to inode we
2164                          * are writing (which means it has been
2165                          * truncated or invalidated), or the page is
2166                          * already under writeback and we are not
2167                          * doing a data integrity writeback, skip the page
2168                          */
2169                         if (!PageDirty(page) ||
2170                             (PageWriteback(page) &&
2171                              (wbc->sync_mode == WB_SYNC_NONE)) ||
2172                             unlikely(page->mapping != mapping)) {
2173                                 unlock_page(page);
2174                                 continue;
2175                         }
2176 
2177                         wait_on_page_writeback(page);
2178                         BUG_ON(PageWriteback(page));
2179 
2180                         if (mpd->next_page != page->index)
2181                                 mpd->first_page = page->index;
2182                         mpd->next_page = page->index + 1;
2183                         logical = (sector_t) page->index <<
2184                                 (PAGE_CACHE_SHIFT - inode->i_blkbits);
2185 
2186                         if (!page_has_buffers(page)) {
2187                                 mpage_add_bh_to_extent(mpd, logical,
2188                                                        PAGE_CACHE_SIZE,
2189                                                        (1 << BH_Dirty) | (1 << BH_Uptodate));
2190                                 if (mpd->io_done)
2191                                         goto ret_extent_tail;
2192                         } else {
2193                                 /*
2194                                  * Page with regular buffer heads,
2195                                  * just add all dirty ones
2196                                  */
2197                                 head = page_buffers(page);
2198                                 bh = head;
2199                                 do {
2200                                         BUG_ON(buffer_locked(bh));
2201                                         /*
2202                                          * We need to try to allocate
2203                                          * unmapped blocks in the same page.
2204                                          * Otherwise we won't make progress
2205                                          * with the page in ext4_writepage
2206                                          */
2207                                         if (ext4_bh_delay_or_unwritten(NULL, bh)) {
2208                                                 mpage_add_bh_to_extent(mpd, logical,
2209                                                                        bh->b_size,
2210                                                                        bh->b_state);
2211                                                 if (mpd->io_done)
2212                                                         goto ret_extent_tail;
2213                                         } else if (buffer_dirty(bh) && (buffer_mapped(bh))) {
2214                                                 /*
2215                                                  * mapped dirty buffer. We need
2216                                                  * to update the b_state
2217                                                  * because we look at b_state
2218                                                  * in mpage_da_map_blocks.  We
2219                                                  * don't update b_size because
2220                                                  * if we find an unmapped
2221                                                  * buffer_head later we need to
2222                                                  * use the b_state flag of that
2223                                                  * buffer_head.
2224                                                  */
2225                                                 if (mpd->b_size == 0)
2226                                                         mpd->b_state = bh->b_state & BH_FLAGS;
2227                                         }
2228                                         logical++;
2229                                 } while ((bh = bh->b_this_page) != head);
2230                         }
2231 
2232                         if (nr_to_write > 0) {
2233                                 nr_to_write--;
2234                                 if (nr_to_write == 0 &&
2235                                     wbc->sync_mode == WB_SYNC_NONE)
2236                                         /*
2237                                          * We stop writing back only if we are
2238                                          * not doing integrity sync. In case of
2239                                          * integrity sync we have to keep going
2240                                          * because someone may be concurrently
2241                                          * dirtying pages, and we might have
2242                                          * synced a lot of newly appeared dirty
2243                                          * pages, but have not synced all of the
2244                                          * old dirty pages.
2245                                          */
2246                                         goto out;
2247                         }
2248                 }
2249                 pagevec_release(&pvec);
2250                 cond_resched();
2251         }
2252         return 0;
2253 ret_extent_tail:
2254         ret = MPAGE_DA_EXTENT_TAIL;
2255 out:
2256         pagevec_release(&pvec);
2257         cond_resched();
2258         return ret;
2259 }
2260 
2261 
2262 static int ext4_da_writepages(struct address_space *mapping,
2263                               struct writeback_control *wbc)
2264 {
2265         pgoff_t index;
2266         int range_whole = 0;
2267         handle_t *handle = NULL;
2268         struct mpage_da_data mpd;
2269         struct inode *inode = mapping->host;
2270         int pages_written = 0;
2271         unsigned int max_pages;
2272         int range_cyclic, cycled = 1, io_done = 0;
2273         int needed_blocks, ret = 0;
2274         long desired_nr_to_write, nr_to_writebump = 0;
2275         loff_t range_start = wbc->range_start;
2276         struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
2277         pgoff_t done_index = 0;
2278         pgoff_t end;
2279         struct blk_plug plug;
2280 
2281         trace_ext4_da_writepages(inode, wbc);
2282 
2283         /*
2284          * No pages to write? This is mainly a kludge to avoid starting
2285          * a transaction for special inodes like journal inode on last iput()
2286          * because that could violate lock ordering on umount
2287          */
2288         if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2289                 return 0;
2290 
2291         /*
2292          * If the filesystem has aborted, it is read-only, so return
2293          * right away instead of dumping stack traces later on that
2294          * will obscure the real source of the problem.  We test
2295          * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2296          * the latter could be true if the filesystem is mounted
2297          * read-only, and in that case, ext4_da_writepages should
2298          * *never* be called, so if that ever happens, we would want
2299          * the stack trace.
2300          */
2301         if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED))
2302                 return -EROFS;
2303 
2304         if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2305                 range_whole = 1;
2306 
2307         range_cyclic = wbc->range_cyclic;
2308         if (wbc->range_cyclic) {
2309                 index = mapping->writeback_index;
2310                 if (index)
2311                         cycled = 0;
2312                 wbc->range_start = index << PAGE_CACHE_SHIFT;
2313                 wbc->range_end  = LLONG_MAX;
2314                 wbc->range_cyclic = 0;
2315                 end = -1;
2316         } else {
2317                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
2318                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
2319         }
2320 
2321         /*
2322          * This works around two forms of stupidity.  The first is in
2323          * the writeback code, which caps the maximum number of pages
2324          * written to be 1024 pages.  This is wrong on multiple
2325          * levels; different architectues have a different page size,
2326          * which changes the maximum amount of data which gets
2327          * written.  Secondly, 4 megabytes is way too small.  XFS
2328          * forces this value to be 16 megabytes by multiplying
2329          * nr_to_write parameter by four, and then relies on its
2330          * allocator to allocate larger extents to make them
2331          * contiguous.  Unfortunately this brings us to the second
2332          * stupidity, which is that ext4's mballoc code only allocates
2333          * at most 2048 blocks.  So we force contiguous writes up to
2334          * the number of dirty blocks in the inode, or
2335          * sbi->max_writeback_mb_bump whichever is smaller.
2336          */
2337         max_pages = sbi->s_max_writeback_mb_bump << (20 - PAGE_CACHE_SHIFT);
2338         if (!range_cyclic && range_whole) {
2339                 if (wbc->nr_to_write == LONG_MAX)
2340                         desired_nr_to_write = wbc->nr_to_write;
2341                 else
2342                         desired_nr_to_write = wbc->nr_to_write * 8;
2343         } else
2344                 desired_nr_to_write = ext4_num_dirty_pages(inode, index,
2345                                                            max_pages);
2346         if (desired_nr_to_write > max_pages)
2347                 desired_nr_to_write = max_pages;
2348 
2349         if (wbc->nr_to_write < desired_nr_to_write) {
2350                 nr_to_writebump = desired_nr_to_write - wbc->nr_to_write;
2351                 wbc->nr_to_write = desired_nr_to_write;
2352         }
2353 
2354 retry:
2355         if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
2356                 tag_pages_for_writeback(mapping, index, end);
2357 
2358         blk_start_plug(&plug);
2359         while (!ret && wbc->nr_to_write > 0) {
2360 
2361                 /*
2362                  * we  insert one extent at a time. So we need
2363                  * credit needed for single extent allocation.
2364                  * journalled mode is currently not supported
2365                  * by delalloc
2366                  */
2367                 BUG_ON(ext4_should_journal_data(inode));
2368                 needed_blocks = ext4_da_writepages_trans_blocks(inode);
2369 
2370                 /* start a new transaction*/
2371                 handle = ext4_journal_start(inode, needed_blocks);
2372                 if (IS_ERR(handle)) {
2373                         ret = PTR_ERR(handle);
2374                         ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2375                                "%ld pages, ino %lu; err %d", __func__,
2376                                 wbc->nr_to_write, inode->i_ino, ret);
2377                         blk_finish_plug(&plug);
2378                         goto out_writepages;
2379                 }
2380 
2381                 /*
2382                  * Now call write_cache_pages_da() to find the next
2383                  * contiguous region of logical blocks that need
2384                  * blocks to be allocated by ext4 and submit them.
2385                  */
2386                 ret = write_cache_pages_da(mapping, wbc, &mpd, &done_index);
2387                 /*
2388                  * If we have a contiguous extent of pages and we
2389                  * haven't done the I/O yet, map the blocks and submit
2390                  * them for I/O.
2391                  */
2392                 if (!mpd.io_done && mpd.next_page != mpd.first_page) {
2393                         mpage_da_map_and_submit(&mpd);
2394                         ret = MPAGE_DA_EXTENT_TAIL;
2395                 }
2396                 trace_ext4_da_write_pages(inode, &mpd);
2397                 wbc->nr_to_write -= mpd.pages_written;
2398 
2399                 ext4_journal_stop(handle);
2400 
2401                 if ((mpd.retval == -ENOSPC) && sbi->s_journal) {
2402                         /* commit the transaction which would
2403                          * free blocks released in the transaction
2404                          * and try again
2405                          */
2406                         jbd2_journal_force_commit_nested(sbi->s_journal);
2407                         ret = 0;
2408                 } else if (ret == MPAGE_DA_EXTENT_TAIL) {
2409                         /*
2410                          * Got one extent now try with rest of the pages.
2411                          * If mpd.retval is set -EIO, journal is aborted.
2412                          * So we don't need to write any more.
2413                          */
2414                         pages_written += mpd.pages_written;
2415                         ret = mpd.retval;
2416                         io_done = 1;
2417                 } else if (wbc->nr_to_write)
2418                         /*
2419                          * There is no more writeout needed
2420                          * or we requested for a noblocking writeout
2421                          * and we found the device congested
2422                          */
2423                         break;
2424         }
2425         blk_finish_plug(&plug);
2426         if (!io_done && !cycled) {
2427                 cycled = 1;
2428                 index = 0;
2429                 wbc->range_start = index << PAGE_CACHE_SHIFT;
2430                 wbc->range_end  = mapping->writeback_index - 1;
2431                 goto retry;
2432         }
2433 
2434         /* Update index */
2435         wbc->range_cyclic = range_cyclic;
2436         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2437                 /*
2438                  * set the writeback_index so that range_cyclic
2439                  * mode will write it back later
2440                  */
2441                 mapping->writeback_index = done_index;
2442 
2443 out_writepages:
2444         wbc->nr_to_write -= nr_to_writebump;
2445         wbc->range_start = range_start;
2446         trace_ext4_da_writepages_result(inode, wbc, ret, pages_written);
2447         return ret;
2448 }
2449 
2450 #define FALL_BACK_TO_NONDELALLOC 1
2451 static int ext4_nonda_switch(struct super_block *sb)
2452 {
2453         s64 free_blocks, dirty_blocks;
2454         struct ext4_sb_info *sbi = EXT4_SB(sb);
2455 
2456         /*
2457          * switch to non delalloc mode if we are running low
2458          * on free block. The free block accounting via percpu
2459          * counters can get slightly wrong with percpu_counter_batch getting
2460          * accumulated on each CPU without updating global counters
2461          * Delalloc need an accurate free block accounting. So switch
2462          * to non delalloc when we are near to error range.
2463          */
2464         free_blocks  = EXT4_C2B(sbi,
2465                 percpu_counter_read_positive(&sbi->s_freeclusters_counter));
2466         dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
2467         /*
2468          * Start pushing delalloc when 1/2 of free blocks are dirty.
2469          */
2470         if (dirty_blocks && (free_blocks < 2 * dirty_blocks) &&
2471             !writeback_in_progress(sb->s_bdi) &&
2472             down_read_trylock(&sb->s_umount)) {
2473                 writeback_inodes_sb(sb, WB_REASON_FS_FREE_SPACE);
2474                 up_read(&sb->s_umount);
2475         }
2476 
2477         if (2 * free_blocks < 3 * dirty_blocks ||
2478                 free_blocks < (dirty_blocks + EXT4_FREECLUSTERS_WATERMARK)) {
2479                 /*
2480                  * free block count is less than 150% of dirty blocks
2481                  * or free blocks is less than watermark
2482                  */
2483                 return 1;
2484         }
2485         return 0;
2486 }
2487 
2488 static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
2489                                loff_t pos, unsigned len, unsigned flags,
2490                                struct page **pagep, void **fsdata)
2491 {
2492         int ret, retries = 0;
2493         struct page *page;
2494         pgoff_t index;
2495         struct inode *inode = mapping->host;
2496         handle_t *handle;
2497 
2498         index = pos >> PAGE_CACHE_SHIFT;
2499 
2500         if (ext4_nonda_switch(inode->i_sb)) {
2501                 *fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
2502                 return ext4_write_begin(file, mapping, pos,
2503                                         len, flags, pagep, fsdata);
2504         }
2505         *fsdata = (void *)0;
2506         trace_ext4_da_write_begin(inode, pos, len, flags);
2507 retry:
2508         /*
2509          * With delayed allocation, we don't log the i_disksize update
2510          * if there is delayed block allocation. But we still need
2511          * to journalling the i_disksize update if writes to the end
2512          * of file which has an already mapped buffer.
2513          */
2514         handle = ext4_journal_start(inode, 1);
2515         if (IS_ERR(handle)) {
2516                 ret = PTR_ERR(handle);
2517                 goto out;
2518         }
2519         /* We cannot recurse into the filesystem as the transaction is already
2520          * started */
2521         flags |= AOP_FLAG_NOFS;
2522 
2523         page = grab_cache_page_write_begin(mapping, index, flags);
2524         if (!page) {
2525                 ext4_journal_stop(handle);
2526                 ret = -ENOMEM;
2527                 goto out;
2528         }
2529         *pagep = page;
2530 
2531         ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
2532         if (ret < 0) {
2533                 unlock_page(page);
2534                 ext4_journal_stop(handle);
2535                 page_cache_release(page);
2536                 /*
2537                  * block_write_begin may have instantiated a few blocks
2538                  * outside i_size.  Trim these off again. Don't need
2539                  * i_size_read because we hold i_mutex.
2540                  */
2541                 if (pos + len > inode->i_size)
2542                         ext4_truncate_failed_write(inode);
2543         }
2544 
2545         if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
2546                 goto retry;
2547 out:
2548         return ret;
2549 }
2550 
2551 /*
2552  * Check if we should update i_disksize
2553  * when write to the end of file but not require block allocation
2554  */
2555 static int ext4_da_should_update_i_disksize(struct page *page,
2556                                             unsigned long offset)
2557 {
2558         struct buffer_head *bh;
2559         struct inode *inode = page->mapping->host;
2560         unsigned int idx;
2561         int i;
2562 
2563         bh = page_buffers(page);
2564         idx = offset >> inode->i_blkbits;
2565 
2566         for (i = 0; i < idx; i++)
2567                 bh = bh->b_this_page;
2568 
2569         if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
2570                 return 0;
2571         return 1;
2572 }
2573 
2574 static int ext4_da_write_end(struct file *file,
2575                              struct address_space *mapping,
2576                              loff_t pos, unsigned len, unsigned copied,
2577                              struct page *page, void *fsdata)
2578 {
2579         struct inode *inode = mapping->host;
2580         int ret = 0, ret2;
2581         handle_t *handle = ext4_journal_current_handle();
2582         loff_t new_i_size;
2583         unsigned long start, end;
2584         int write_mode = (int)(unsigned long)fsdata;
2585 
2586         if (write_mode == FALL_BACK_TO_NONDELALLOC) {
2587                 switch (ext4_inode_journal_mode(inode)) {
2588                 case EXT4_INODE_ORDERED_DATA_MODE:
2589                         return ext4_ordered_write_end(file, mapping, pos,
2590                                         len, copied, page, fsdata);
2591                 case EXT4_INODE_WRITEBACK_DATA_MODE:
2592                         return ext4_writeback_write_end(file, mapping, pos,
2593                                         len, copied, page, fsdata);
2594                 default:
2595                         BUG();
2596                 }
2597         }
2598 
2599         trace_ext4_da_write_end(inode, pos, len, copied);
2600         start = pos & (PAGE_CACHE_SIZE - 1);
2601         end = start + copied - 1;
2602 
2603         /*
2604          * generic_write_end() will run mark_inode_dirty() if i_size
2605          * changes.  So let's piggyback the i_disksize mark_inode_dirty
2606          * into that.
2607          */
2608 
2609         new_i_size = pos + copied;
2610         if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
2611                 if (ext4_da_should_update_i_disksize(page, end)) {
2612                         down_write(&EXT4_I(inode)->i_data_sem);
2613                         if (new_i_size > EXT4_I(inode)->i_disksize) {
2614                                 /*
2615                                  * Updating i_disksize when extending file
2616                                  * without needing block allocation
2617                                  */
2618                                 if (ext4_should_order_data(inode))
2619                                         ret = ext4_jbd2_file_inode(handle,
2620                                                                    inode);
2621 
2622                                 EXT4_I(inode)->i_disksize = new_i_size;
2623                         }
2624                         up_write(&EXT4_I(inode)->i_data_sem);
2625                         /* We need to mark inode dirty even if
2626                          * new_i_size is less that inode->i_size
2627                          * bu greater than i_disksize.(hint delalloc)
2628                          */
2629                         ext4_mark_inode_dirty(handle, inode);
2630                 }
2631         }
2632         ret2 = generic_write_end(file, mapping, pos, len, copied,
2633                                                         page, fsdata);
2634         copied = ret2;
2635         if (ret2 < 0)
2636                 ret = ret2;
2637         ret2 = ext4_journal_stop(handle);
2638         if (!ret)
2639                 ret = ret2;
2640 
2641         return ret ? ret : copied;
2642 }
2643 
2644 static void ext4_da_invalidatepage(struct page *page, unsigned long offset)
2645 {
2646         /*
2647          * Drop reserved blocks
2648          */
2649         BUG_ON(!PageLocked(page));
2650         if (!page_has_buffers(page))
2651                 goto out;
2652 
2653         ext4_da_page_release_reservation(page, offset);
2654 
2655 out:
2656         ext4_invalidatepage(page, offset);
2657 
2658         return;
2659 }
2660 
2661 /*
2662  * Force all delayed allocation blocks to be allocated for a given inode.
2663  */
2664 int ext4_alloc_da_blocks(struct inode *inode)
2665 {
2666         trace_ext4_alloc_da_blocks(inode);
2667 
2668         if (!EXT4_I(inode)->i_reserved_data_blocks &&
2669             !EXT4_I(inode)->i_reserved_meta_blocks)
2670                 return 0;
2671 
2672         /*
2673          * We do something simple for now.  The filemap_flush() will
2674          * also start triggering a write of the data blocks, which is
2675          * not strictly speaking necessary (and for users of
2676          * laptop_mode, not even desirable).  However, to do otherwise
2677          * would require replicating code paths in:
2678          *
2679          * ext4_da_writepages() ->
2680          *    write_cache_pages() ---> (via passed in callback function)
2681          *        __mpage_da_writepage() -->
2682          *           mpage_add_bh_to_extent()
2683          *           mpage_da_map_blocks()
2684          *
2685          * The problem is that write_cache_pages(), located in
2686          * mm/page-writeback.c, marks pages clean in preparation for
2687          * doing I/O, which is not desirable if we're not planning on
2688          * doing I/O at all.
2689          *
2690          * We could call write_cache_pages(), and then redirty all of
2691          * the pages by calling redirty_page_for_writepage() but that
2692          * would be ugly in the extreme.  So instead we would need to
2693          * replicate parts of the code in the above functions,
2694          * simplifying them because we wouldn't actually intend to
2695          * write out the pages, but rather only collect contiguous
2696          * logical block extents, call the multi-block allocator, and
2697          * then update the buffer heads with the block allocations.
2698          *
2699          * For now, though, we'll cheat by calling filemap_flush(),
2700          * which will map the blocks, and start the I/O, but not
2701          * actually wait for the I/O to complete.
2702          */
2703         return filemap_flush(inode->i_mapping);
2704 }
2705 
2706 /*
2707  * bmap() is special.  It gets used by applications such as lilo and by
2708  * the swapper to find the on-disk block of a specific piece of data.
2709  *
2710  * Naturally, this is dangerous if the block concerned is still in the
2711  * journal.  If somebody makes a swapfile on an ext4 data-journaling
2712  * filesystem and enables swap, then they may get a nasty shock when the
2713  * data getting swapped to that swapfile suddenly gets overwritten by
2714  * the original zero's written out previously to the journal and
2715  * awaiting writeback in the kernel's buffer cache.
2716  *
2717  * So, if we see any bmap calls here on a modified, data-journaled file,
2718  * take extra steps to flush any blocks which might be in the cache.
2719  */
2720 static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
2721 {
2722         struct inode *inode = mapping->host;
2723         journal_t *journal;
2724         int err;
2725 
2726         if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) &&
2727                         test_opt(inode->i_sb, DELALLOC)) {
2728                 /*
2729                  * With delalloc we want to sync the file
2730                  * so that we can make sure we allocate
2731                  * blocks for file
2732                  */
2733                 filemap_write_and_wait(mapping);
2734         }
2735 
2736         if (EXT4_JOURNAL(inode) &&
2737             ext4_test_inode_state(inode, EXT4_STATE_JDATA)) {
2738                 /*
2739                  * This is a REALLY heavyweight approach, but the use of
2740                  * bmap on dirty files is expected to be extremely rare:
2741                  * only if we run lilo or swapon on a freshly made file
2742                  * do we expect this to happen.
2743                  *
2744                  * (bmap requires CAP_SYS_RAWIO so this does not
2745                  * represent an unprivileged user DOS attack --- we'd be
2746                  * in trouble if mortal users could trigger this path at
2747                  * will.)
2748                  *
2749                  * NB. EXT4_STATE_JDATA is not set on files other than
2750                  * regular files.  If somebody wants to bmap a directory
2751                  * or symlink and gets confused because the buffer
2752                  * hasn't yet been flushed to disk, they deserve
2753                  * everything they get.
2754                  */
2755 
2756                 ext4_clear_inode_state(inode, EXT4_STATE_JDATA);
2757                 journal = EXT4_JOURNAL(inode);
2758                 jbd2_journal_lock_updates(journal);
2759                 err = jbd2_journal_flush(journal);
2760                 jbd2_journal_unlock_updates(journal);
2761 
2762                 if (err)
2763                         return 0;
2764         }
2765 
2766         return generic_block_bmap(mapping, block, ext4_get_block);
2767 }
2768 
2769 static int ext4_readpage(struct file *file, struct page *page)
2770 {
2771         trace_ext4_readpage(page);
2772         return mpage_readpage(page, ext4_get_block);
2773 }
2774 
2775 static int
2776 ext4_readpages(struct file *file, struct address_space *mapping,
2777                 struct list_head *pages, unsigned nr_pages)
2778 {
2779         return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
2780 }
2781 
2782 static void ext4_invalidatepage_free_endio(struct page *page, unsigned long offset)
2783 {
2784         struct buffer_head *head, *bh;
2785         unsigned int curr_off = 0;
2786 
2787         if (!page_has_buffers(page))
2788                 return;
2789         head = bh = page_buffers(page);
2790         do {
2791                 if (offset <= curr_off && test_clear_buffer_uninit(bh)
2792                                         && bh->b_private) {
2793                         ext4_free_io_end(bh->b_private);
2794                         bh->b_private = NULL;
2795                         bh->b_end_io = NULL;
2796                 }
2797                 curr_off = curr_off + bh->b_size;
2798                 bh = bh->b_this_page;
2799         } while (bh != head);
2800 }
2801 
2802 static void ext4_invalidatepage(struct page *page, unsigned long offset)
2803 {
2804         journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2805 
2806         trace_ext4_invalidatepage(page, offset);
2807 
2808         /*
2809          * free any io_end structure allocated for buffers to be discarded
2810          */
2811         if (ext4_should_dioread_nolock(page->mapping->host))
2812                 ext4_invalidatepage_free_endio(page, offset);
2813         /*
2814          * If it's a full truncate we just forget about the pending dirtying
2815          */
2816         if (offset == 0)
2817                 ClearPageChecked(page);
2818 
2819         if (journal)
2820                 jbd2_journal_invalidatepage(journal, page, offset);
2821         else
2822                 block_invalidatepage(page, offset);
2823 }
2824 
2825 static int ext4_releasepage(struct page *page, gfp_t wait)
2826 {
2827         journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2828 
2829         trace_ext4_releasepage(page);
2830 
2831         WARN_ON(PageChecked(page));
2832         if (!page_has_buffers(page))
2833                 return 0;
2834         if (journal)
2835                 return jbd2_journal_try_to_free_buffers(journal, page, wait);
2836         else
2837                 return try_to_free_buffers(page);
2838 }
2839 
2840 /*
2841  * ext4_get_block used when preparing for a DIO write or buffer write.
2842  * We allocate an uinitialized extent if blocks haven't been allocated.
2843  * The extent will be converted to initialized after the IO is complete.
2844  */
2845 static int ext4_get_block_write(struct inode *inode, sector_t iblock,
2846                    struct buffer_head *bh_result, int create)
2847 {
2848         ext4_debug("ext4_get_block_write: inode %lu, create flag %d\n",
2849                    inode->i_ino, create);
2850         return _ext4_get_block(inode, iblock, bh_result,
2851                                EXT4_GET_BLOCKS_IO_CREATE_EXT);
2852 }
2853 
2854 static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
2855                    struct buffer_head *bh_result, int flags)
2856 {
2857         handle_t *handle = ext4_journal_current_handle();
2858         struct ext4_map_blocks map;
2859         int ret = 0;
2860 
2861         ext4_debug("ext4_get_block_write_nolock: inode %lu, flag %d\n",
2862                    inode->i_ino, flags);
2863 
2864         flags = EXT4_GET_BLOCKS_NO_LOCK;
2865 
2866         map.m_lblk = iblock;
2867         map.m_len = bh_result->b_size >> inode->i_blkbits;
2868 
2869         ret = ext4_map_blocks(handle, inode, &map, flags);
2870         if (ret > 0) {
2871                 map_bh(bh_result, inode->i_sb, map.m_pblk);
2872                 bh_result->b_state = (bh_result->b_state & ~EXT4_MAP_FLAGS) |
2873                                         map.m_flags;
2874                 bh_result->b_size = inode->i_sb->s_blocksize * map.m_len;
2875                 ret = 0;
2876         }
2877         return ret;
2878 }
2879 
2880 static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
2881                             ssize_t size, void *private, int ret,
2882                             bool is_async)
2883 {
2884         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2885         ext4_io_end_t *io_end = iocb->private;
2886 
2887         /* if not async direct IO or dio with 0 bytes write, just return */
2888         if (!io_end || !size)
2889                 goto out;
2890 
2891         ext_debug("ext4_end_io_dio(): io_end 0x%p "
2892                   "for inode %lu, iocb 0x%p, offset %llu, size %zd\n",
2893                   iocb->private, io_end->inode->i_ino, iocb, offset,
2894                   size);
2895 
2896         iocb->private = NULL;
2897 
2898         /* if not aio dio with unwritten extents, just free io and return */
2899         if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
2900                 ext4_free_io_end(io_end);
2901 out:
2902                 if (is_async)
2903                         aio_complete(iocb, ret, 0);
2904                 inode_dio_done(inode);
2905                 return;
2906         }
2907 
2908         io_end->offset = offset;
2909         io_end->size = size;
2910         if (is_async) {
2911                 io_end->iocb = iocb;
2912                 io_end->result = ret;
2913         }
2914 
2915         ext4_add_complete_io(io_end);
2916 }
2917 
2918 static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate)
2919 {
2920         ext4_io_end_t *io_end = bh->b_private;
2921         struct inode *inode;
2922 
2923         if (!test_clear_buffer_uninit(bh) || !io_end)
2924                 goto out;
2925 
2926         if (!(io_end->inode->i_sb->s_flags & MS_ACTIVE)) {
2927                 ext4_msg(io_end->inode->i_sb, KERN_INFO,
2928                          "sb umounted, discard end_io request for inode %lu",
2929                          io_end->inode->i_ino);
2930                 ext4_free_io_end(io_end);
2931                 goto out;
2932         }
2933 
2934         /*
2935          * It may be over-defensive here to check EXT4_IO_END_UNWRITTEN now,
2936          * but being more careful is always safe for the future change.
2937          */
2938         inode = io_end->inode;
2939         ext4_set_io_unwritten_flag(inode, io_end);
2940         ext4_add_complete_io(io_end);
2941 out:
2942         bh->b_private = NULL;
2943         bh->b_end_io = NULL;
2944         clear_buffer_uninit(bh);
2945         end_buffer_async_write(bh, uptodate);
2946 }
2947 
2948 static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode)
2949 {
2950         ext4_io_end_t *io_end;
2951         struct page *page = bh->b_page;
2952         loff_t offset = (sector_t)page->index << PAGE_CACHE_SHIFT;
2953         size_t size = bh->b_size;
2954 
2955 retry:
2956         io_end = ext4_init_io_end(inode, GFP_ATOMIC);
2957         if (!io_end) {
2958                 pr_warn_ratelimited("%s: allocation fail\n", __func__);
2959                 schedule();
2960                 goto retry;
2961         }
2962         io_end->offset = offset;
2963         io_end->size = size;
2964         /*
2965          * We need to hold a reference to the page to make sure it
2966          * doesn't get evicted before ext4_end_io_work() has a chance
2967          * to convert the extent from written to unwritten.
2968          */
2969         io_end->page = page;
2970         get_page(io_end->page);
2971 
2972         bh->b_private = io_end;
2973         bh->b_end_io = ext4_end_io_buffer_write;
2974         return 0;
2975 }
2976 
2977 /*
2978  * For ext4 extent files, ext4 will do direct-io write to holes,
2979  * preallocated extents, and those write extend the file, no need to
2980  * fall back to buffered IO.
2981  *
2982  * For holes, we fallocate those blocks, mark them as uninitialized
2983  * If those blocks were preallocated, we mark sure they are splited, but
2984  * still keep the range to write as uninitialized.
2985  *
2986  * The unwrritten extents will be converted to written when DIO is completed.
2987  * For async direct IO, since the IO may still pending when return, we
2988  * set up an end_io call back function, which will do the conversion
2989  * when async direct IO completed.
2990  *
2991  * If the O_DIRECT write will extend the file then add this inode to the
2992  * orphan list.  So recovery will truncate it back to the original size
2993  * if the machine crashes during the write.
2994  *
2995  */
2996 static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
2997                               const struct iovec *iov, loff_t offset,
2998                               unsigned long nr_segs)
2999 {
3000         struct file *file = iocb->ki_filp;
3001         struct inode *inode = file->f_mapping->host;
3002         ssize_t ret;
3003         size_t count = iov_length(iov, nr_segs);
3004 
3005         loff_t final_size = offset + count;
3006         if (rw == WRITE && final_size <= inode->i_size) {
3007                 int overwrite = 0;
3008 
3009                 BUG_ON(iocb->private == NULL);
3010 
3011                 /* If we do a overwrite dio, i_mutex locking can be released */
3012                 overwrite = *((int *)iocb->private);
3013 
3014                 if (overwrite) {
3015                         atomic_inc(&inode->i_dio_count);
3016                         down_read(&EXT4_I(inode)->i_data_sem);
3017                         mutex_unlock(&inode->i_mutex);
3018                 }
3019 
3020                 /*
3021                  * We could direct write to holes and fallocate.
3022                  *
3023                  * Allocated blocks to fill the hole are marked as uninitialized
3024                  * to prevent parallel buffered read to expose the stale data
3025                  * before DIO complete the data IO.
3026                  *
3027                  * As to previously fallocated extents, ext4 get_block
3028                  * will just simply mark the buffer mapped but still
3029                  * keep the extents uninitialized.
3030                  *
3031                  * for non AIO case, we will convert those unwritten extents
3032                  * to written after return back from blockdev_direct_IO.
3033                  *
3034                  * for async DIO, the conversion needs to be defered when
3035                  * the IO is completed. The ext4 end_io callback function
3036                  * will be called to take care of the conversion work.
3037                  * Here for async case, we allocate an io_end structure to
3038                  * hook to the iocb.
3039                  */
3040                 iocb->private = NULL;
3041                 ext4_inode_aio_set(inode, NULL);
3042                 if (!is_sync_kiocb(iocb)) {
3043                         ext4_io_end_t *io_end =
3044                                 ext4_init_io_end(inode, GFP_NOFS);
3045                         if (!io_end) {
3046                                 ret = -ENOMEM;
3047                                 goto retake_lock;
3048                         }
3049                         io_end->flag |= EXT4_IO_END_DIRECT;
3050                         iocb->private = io_end;
3051                         /*
3052                          * we save the io structure for current async
3053                          * direct IO, so that later ext4_map_blocks()
3054                          * could flag the io structure whether there
3055                          * is a unwritten extents needs to be converted
3056                          * when IO is completed.
3057                          */
3058                         ext4_inode_aio_set(inode, io_end);
3059                 }
3060 
3061                 if (overwrite)
3062                         ret = __blockdev_direct_IO(rw, iocb, inode,
3063                                                  inode->i_sb->s_bdev, iov,
3064                                                  offset, nr_segs,
3065                                                  ext4_get_block_write_nolock,
3066                                                  ext4_end_io_dio,
3067                                                  NULL,
3068                                                  0);
3069                 else
3070                         ret = __blockdev_direct_IO(rw, iocb, inode,
3071                                                  inode->i_sb->s_bdev, iov,
3072                                                  offset, nr_segs,
3073                                                  ext4_get_block_write,
3074                                                  ext4_end_io_dio,
3075                                                  NULL,
3076                                                  DIO_LOCKING);
3077                 if (iocb->private)
3078                         ext4_inode_aio_set(inode, NULL);
3079                 /*
3080                  * The io_end structure takes a reference to the inode,
3081                  * that structure needs to be destroyed and the
3082                  * reference to the inode need to be dropped, when IO is
3083                  * complete, even with 0 byte write, or failed.
3084                  *
3085                  * In the successful AIO DIO case, the io_end structure will be
3086                  * desctroyed and the reference to the inode will be dropped
3087                  * after the end_io call back function is called.
3088                  *
3089                  * In the case there is 0 byte write, or error case, since
3090                  * VFS direct IO won't invoke the end_io call back function,
3091                  * we need to free the end_io structure here.
3092                  */
3093                 if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) {
3094                         ext4_free_io_end(iocb->private);
3095                         iocb->private = NULL;
3096                 } else if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
3097                                                 EXT4_STATE_DIO_UNWRITTEN)) {
3098                         int err;
3099                         /*
3100                          * for non AIO case, since the IO is already
3101                          * completed, we could do the conversion right here
3102                          */
3103                         err = ext4_convert_unwritten_extents(inode,
3104                                                              offset, ret);
3105                         if (err < 0)
3106                                 ret = err;
3107                         ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
3108                 }
3109 
3110         retake_lock:
3111                 /* take i_mutex locking again if we do a ovewrite dio */
3112                 if (overwrite) {
3113                         inode_dio_done(inode);
3114                         up_read(&EXT4_I(inode)->i_data_sem);
3115                         mutex_lock(&inode->i_mutex);
3116                 }
3117 
3118                 return ret;
3119         }
3120 
3121         /* for write the the end of file case, we fall back to old way */
3122         return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
3123 }
3124 
3125 static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
3126                               const struct iovec *iov, loff_t offset,
3127                               unsigned long nr_segs)
3128 {
3129         struct file *file = iocb->ki_filp;
3130         struct inode *inode = file->f_mapping->host;
3131         ssize_t ret;
3132 
3133         /*
3134          * If we are doing data journalling we don't support O_DIRECT
3135          */
3136         if (ext4_should_journal_data(inode))
3137                 return 0;
3138 
3139         trace_ext4_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw);
3140         if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3141                 ret = ext4_ext_direct_IO(rw, iocb, iov, offset, nr_segs);
3142         else
3143                 ret = ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
3144         trace_ext4_direct_IO_exit(inode, offset,
3145                                 iov_length(iov, nr_segs), rw, ret);
3146         return ret;
3147 }
3148 
3149 /*
3150  * Pages can be marked dirty completely asynchronously from ext4's journalling
3151  * activity.  By filemap_sync_pte(), try_to_unmap_one(), etc.  We cannot do
3152  * much here because ->set_page_dirty is called under VFS locks.  The page is
3153  * not necessarily locked.
3154  *
3155  * We cannot just dirty the page and leave attached buffers clean, because the
3156  * buffers' dirty state is "definitive".  We cannot just set the buffers dirty
3157  * or jbddirty because all the journalling code will explode.
3158  *
3159  * So what we do is to mark the page "pending dirty" and next time writepage
3160  * is called, propagate that into the buffers appropriately.
3161  */
3162 static int ext4_journalled_set_page_dirty(struct page *page)
3163 {
3164         SetPageChecked(page);
3165         return __set_page_dirty_nobuffers(page);
3166 }
3167 
3168 static const struct address_space_operations ext4_ordered_aops = {
3169         .readpage               = ext4_readpage,
3170         .readpages              = ext4_readpages,
3171         .writepage              = ext4_writepage,
3172         .write_begin            = ext4_write_begin,
3173         .write_end              = ext4_ordered_write_end,
3174         .bmap                   = ext4_bmap,
3175         .invalidatepage         = ext4_invalidatepage,
3176         .releasepage            = ext4_releasepage,
3177         .direct_IO              = ext4_direct_IO,
3178         .migratepage            = buffer_migrate_page,
3179         .is_partially_uptodate  = block_is_partially_uptodate,
3180         .error_remove_page      = generic_error_remove_page,
3181 };
3182 
3183 static const struct address_space_operations ext4_writeback_aops = {
3184         .readpage               = ext4_readpage,
3185         .readpages              = ext4_readpages,
3186         .writepage              = ext4_writepage,
3187         .write_begin            = ext4_write_begin,
3188         .write_end              = ext4_writeback_write_end,
3189         .bmap                   = ext4_bmap,
3190         .invalidatepage         = ext4_invalidatepage,
3191         .releasepage            = ext4_releasepage,
3192         .direct_IO              = ext4_direct_IO,
3193         .migratepage            = buffer_migrate_page,
3194         .is_partially_uptodate  = block_is_partially_uptodate,
3195         .error_remove_page      = generic_error_remove_page,
3196 };
3197 
3198 static const struct address_space_operations ext4_journalled_aops = {
3199         .readpage               = ext4_readpage,
3200         .readpages              = ext4_readpages,
3201         .writepage              = ext4_writepage,
3202         .write_begin            = ext4_write_begin,
3203         .write_end              = ext4_journalled_write_end,
3204         .set_page_dirty         = ext4_journalled_set_page_dirty,
3205         .bmap                   = ext4_bmap,
3206         .invalidatepage         = ext4_invalidatepage,
3207         .releasepage            = ext4_releasepage,
3208         .direct_IO              = ext4_direct_IO,
3209         .is_partially_uptodate  = block_is_partially_uptodate,
3210         .error_remove_page      = generic_error_remove_page,
3211 };
3212 
3213 static const struct address_space_operations ext4_da_aops = {
3214         .readpage               = ext4_readpage,
3215         .readpages              = ext4_readpages,
3216         .writepage              = ext4_writepage,
3217         .writepages             = ext4_da_writepages,
3218         .write_begin            = ext4_da_write_begin,
3219         .write_end              = ext4_da_write_end,
3220         .bmap                   = ext4_bmap,
3221         .invalidatepage         = ext4_da_invalidatepage,
3222         .releasepage            = ext4_releasepage,
3223         .direct_IO              = ext4_direct_IO,
3224         .migratepage            = buffer_migrate_page,
3225         .is_partially_uptodate  = block_is_partially_uptodate,
3226         .error_remove_page      = generic_error_remove_page,
3227 };
3228 
3229 void ext4_set_aops(struct inode *inode)
3230 {
3231         switch (ext4_inode_journal_mode(inode)) {
3232         case EXT4_INODE_ORDERED_DATA_MODE:
3233                 if (test_opt(inode->i_sb, DELALLOC))
3234                         inode->i_mapping->a_ops = &ext4_da_aops;
3235                 else
3236                         inode->i_mapping->a_ops = &ext4_ordered_aops;
3237                 break;
3238         case EXT4_INODE_WRITEBACK_DATA_MODE:
3239                 if (test_opt(inode->i_sb, DELALLOC))
3240                         inode->i_mapping->a_ops = &ext4_da_aops;
3241                 else
3242                         inode->i_mapping->a_ops = &ext4_writeback_aops;
3243                 break;
3244         case EXT4_INODE_JOURNAL_DATA_MODE:
3245                 inode->i_mapping->a_ops = &ext4_journalled_aops;
3246                 break;
3247         default:
3248                 BUG();
3249         }
3250 }
3251 
3252 
3253 /*
3254  * ext4_discard_partial_page_buffers()
3255  * Wrapper function for ext4_discard_partial_page_buffers_no_lock.
3256  * This function finds and locks the page containing the offset
3257  * "from" and passes it to ext4_discard_partial_page_buffers_no_lock.
3258  * Calling functions that already have the page locked should call
3259  * ext4_discard_partial_page_buffers_no_lock directly.
3260  */
3261 int ext4_discard_partial_page_buffers(handle_t *handle,
3262                 struct address_space *mapping, loff_t from,
3263                 loff_t length, int flags)
3264 {
3265         struct inode *inode = mapping->host;
3266         struct page *page;
3267         int err = 0;
3268 
3269         page = find_or_create_page(mapping, from >> PAGE_CACHE_SHIFT,
3270                                    mapping_gfp_mask(mapping) & ~__GFP_FS);
3271         if (!page)
3272                 return -ENOMEM;
3273 
3274         err = ext4_discard_partial_page_buffers_no_lock(handle, inode, page,
3275                 from, length, flags);
3276 
3277         unlock_page(page);
3278         page_cache_release(page);
3279         return err;
3280 }
3281 
3282 /*
3283  * ext4_discard_partial_page_buffers_no_lock()
3284  * Zeros a page range of length 'length' starting from offset 'from'.
3285  * Buffer heads that correspond to the block aligned regions of the
3286  * zeroed range will be unmapped.  Unblock aligned regions
3287  * will have the corresponding buffer head mapped if needed so that
3288  * that region of the page can be updated with the partial zero out.
3289  *
3290  * This function assumes that the page has already been  locked.  The
3291  * The range to be discarded must be contained with in the given page.
3292  * If the specified range exceeds the end of the page it will be shortened
3293  * to the end of the page that corresponds to 'from'.  This function is
3294  * appropriate for updating a page and it buffer heads to be unmapped and
3295  * zeroed for blocks that have been either released, or are going to be
3296  * released.
3297  *
3298  * handle: The journal handle
3299  * inode:  The files inode
3300  * page:   A locked page that contains the offset "from"
3301  * from:   The starting byte offset (from the beginning of the file)
3302  *         to begin discarding
3303  * len:    The length of bytes to discard
3304  * flags:  Optional flags that may be used:
3305  *
3306  *         EXT4_DISCARD_PARTIAL_PG_ZERO_UNMAPPED
3307  *         Only zero the regions of the page whose buffer heads
3308  *         have already been unmapped.  This flag is appropriate
3309  *         for updating the contents of a page whose blocks may
3310  *         have already been released, and we only want to zero
3311  *         out the regions that correspond to those released blocks.
3312  *
3313  * Returns zero on success or negative on failure.
3314  */
3315 static int ext4_discard_partial_page_buffers_no_lock(handle_t *handle,
3316                 struct inode *inode, struct page *page, loff_t from,
3317                 loff_t length, int flags)
3318 {
3319         ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT;
3320         unsigned int offset = from & (PAGE_CACHE_SIZE-1);
3321         unsigned int blocksize, max, pos;
3322         ext4_lblk_t iblock;
3323         struct buffer_head *bh;
3324         int err = 0;
3325 
3326         blocksize = inode->i_sb->s_blocksize;
3327         max = PAGE_CACHE_SIZE - offset;
3328 
3329         if (index != page->index)
3330                 return -EINVAL;
3331 
3332         /*
3333          * correct length if it does not fall between
3334          * 'from' and the end of the page
3335          */
3336         if (length > max || length < 0)
3337                 length = max;
3338 
3339         iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
3340 
3341         if (!page_has_buffers(page))
3342                 create_empty_buffers(page, blocksize, 0);
3343 
3344         /* Find the buffer that contains "offset" */
3345         bh = page_buffers(page);
3346         pos = blocksize;
3347         while (offset >= pos) {
3348                 bh = bh->b_this_page;
3349                 iblock++;
3350                 pos += blocksize;
3351         }
3352 
3353         pos = offset;
3354         while (pos < offset + length) {
3355                 unsigned int end_of_block, range_to_discard;
3356 
3357                 err = 0;
3358 
3359                 /* The length of space left to zero and unmap */
3360                 range_to_discard = offset + length - pos;
3361 
3362                 /* The length of space until the end of the block */
3363                 end_of_block = blocksize - (pos & (blocksize-1));
3364 
3365                 /*
3366                  * Do not unmap or zero past end of block
3367                  * for this buffer head
3368                  */
3369                 if (range_to_discard > end_of_block)
3370                         range_to_discard = end_of_block;
3371 
3372 
3373                 /*
3374                  * Skip this buffer head if we are only zeroing unampped
3375                  * regions of the page
3376                  */
3377                 if (flags & EXT4_DISCARD_PARTIAL_PG_ZERO_UNMAPPED &&
3378                         buffer_mapped(bh))
3379                                 goto next;
3380 
3381                 /* If the range is block aligned, unmap */
3382                 if (range_to_discard == blocksize) {
3383                         clear_buffer_dirty(bh);
3384                         bh->b_bdev = NULL;
3385                         clear_buffer_mapped(bh);
3386                         clear_buffer_req(bh);
3387                         clear_buffer_new(bh);
3388                         clear_buffer_delay(bh);
3389                         clear_buffer_unwritten(bh);
3390                         clear_buffer_uptodate(bh);
3391                         zero_user(page, pos, range_to_discard);
3392                         BUFFER_TRACE(bh, "Buffer discarded");
3393                         goto next;
3394                 }
3395 
3396                 /*
3397                  * If this block is not completely contained in the range
3398                  * to be discarded, then it is not going to be released. Because
3399                  * we need to keep this block, we need to make sure this part
3400                  * of the page is uptodate before we modify it by writeing
3401                  * partial zeros on it.
3402                  */
3403                 if (!buffer_mapped(bh)) {
3404                         /*
3405                          * Buffer head must be mapped before we can read
3406                          * from the block
3407                          */
3408                         BUFFER_TRACE(bh, "unmapped");
3409                         ext4_get_block(inode, iblock, bh, 0);
3410                         /* unmapped? It's a hole - nothing to do */
3411                         if (!buffer_mapped(bh)) {
3412                                 BUFFER_TRACE(bh, "still unmapped");
3413                                 goto next;
3414                         }
3415                 }
3416 
3417                 /* Ok, it's mapped. Make sure it's up-to-date */
3418                 if (PageUptodate(page))
3419                         set_buffer_uptodate(bh);
3420 
3421                 if (!buffer_uptodate(bh)) {
3422                         err = -EIO;
3423                         ll_rw_block(READ, 1, &bh);
3424                         wait_on_buffer(bh);
3425                         /* Uhhuh. Read error. Complain and punt.*/
3426                         if (!buffer_uptodate(bh))
3427                                 goto next;
3428                 }
3429 
3430                 if (ext4_should_journal_data(inode)) {
3431                         BUFFER_TRACE(bh, "get write access");
3432                         err = ext4_journal_get_write_access(handle, bh);
3433                         if (err)
3434                                 goto next;
3435                 }
3436 
3437                 zero_user(page, pos, range_to_discard);
3438 
3439                 err = 0;
3440                 if (ext4_should_journal_data(inode)) {
3441                         err = ext4_handle_dirty_metadata(handle, inode, bh);
3442                 } else
3443                         mark_buffer_dirty(bh);
3444 
3445                 BUFFER_TRACE(bh, "Partial buffer zeroed");
3446 next:
3447                 bh = bh->b_this_page;
3448                 iblock++;
3449                 pos += range_to_discard;
3450         }
3451 
3452         return err;
3453 }
3454 
3455 int ext4_can_truncate(struct inode *inode)
3456 {
3457         if (S_ISREG(inode->i_mode))
3458                 return 1;
3459         if (S_ISDIR(inode->i_mode))
3460                 return 1;
3461         if (S_ISLNK(inode->i_mode))
3462                 return !ext4_inode_is_fast_symlink(inode);
3463         return 0;
3464 }
3465 
3466 /*
3467  * ext4_punch_hole: punches a hole in a file by releaseing the blocks
3468  * associated with the given offset and length
3469  *
3470  * @inode:  File inode
3471  * @offset: The offset where the hole will begin
3472  * @len:    The length of the hole
3473  *
3474  * Returns: 0 on success or negative on failure
3475  */
3476 
3477 int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)
3478 {
3479         struct inode *inode = file->f_path.dentry->d_inode;
3480         if (!S_ISREG(inode->i_mode))
3481                 return -EOPNOTSUPP;
3482 
3483         if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
3484                 /* TODO: Add support for non extent hole punching */
3485                 return -EOPNOTSUPP;
3486         }
3487 
3488         if (EXT4_SB(inode->i_sb)->s_cluster_ratio > 1) {
3489                 /* TODO: Add support for bigalloc file systems */
3490                 return -EOPNOTSUPP;
3491         }
3492 
3493         return ext4_ext_punch_hole(file, offset, length);
3494 }
3495 
3496 /*
3497  * ext4_truncate()
3498  *
3499  * We block out ext4_get_block() block instantiations across the entire
3500  * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3501  * simultaneously on behalf of the same inode.
3502  *
3503  * As we work through the truncate and commit bits of it to the journal there
3504  * is one core, guiding principle: the file's tree must always be consistent on
3505  * disk.  We must be able to restart the truncate after a crash.
3506  *
3507  * The file's tree may be transiently inconsistent in memory (although it
3508  * probably isn't), but whenever we close off and commit a journal transaction,
3509  * the contents of (the filesystem + the journal) must be consistent and
3510  * restartable.  It's pretty simple, really: bottom up, right to left (although
3511  * left-to-right works OK too).
3512  *
3513  * Note that at recovery time, journal replay occurs *before* the restart of
3514  * truncate against the orphan inode list.
3515  *
3516  * The committed inode has the new, desired i_size (which is the same as
3517  * i_disksize in this case).  After a crash, ext4_orphan_cleanup() will see
3518  * that this inode's truncate did not complete and it will again call
3519  * ext4_truncate() to have another go.  So there will be instantiated blocks
3520  * to the right of the truncation point in a crashed ext4 filesystem.  But
3521  * that's fine - as long as they are linked from the inode, the post-crash
3522  * ext4_truncate() run will find them and release them.
3523  */
3524 void ext4_truncate(struct inode *inode)
3525 {
3526         trace_ext4_truncate_enter(inode);
3527 
3528         if (!ext4_can_truncate(inode))
3529                 return;
3530 
3531         ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
3532 
3533         if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
3534                 ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
3535 
3536         if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3537                 ext4_ext_truncate(inode);
3538         else
3539                 ext4_ind_truncate(inode);
3540 
3541         trace_ext4_truncate_exit(inode);
3542 }
3543 
3544 /*
3545  * ext4_get_inode_loc returns with an extra refcount against the inode's
3546  * underlying buffer_head on success. If 'in_mem' is true, we have all
3547  * data in memory that is needed to recreate the on-disk version of this
3548  * inode.
3549  */
3550 static int __ext4_get_inode_loc(struct inode *inode,
3551                                 struct ext4_iloc *iloc, int in_mem)
3552 {
3553         struct ext4_group_desc  *gdp;
3554         struct buffer_head      *bh;
3555         struct super_block      *sb = inode->i_sb;
3556         ext4_fsblk_t            block;
3557         int                     inodes_per_block, inode_offset;
3558 
3559         iloc->bh = NULL;
3560         if (!ext4_valid_inum(sb, inode->i_ino))
3561                 return -EIO;
3562 
3563         iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
3564         gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
3565         if (!gdp)
3566                 return -EIO;
3567 
3568         /*
3569          * Figure out the offset within the block group inode table
3570          */
3571         inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
3572         inode_offset = ((inode->i_ino - 1) %
3573                         EXT4_INODES_PER_GROUP(sb));
3574         block = ext4_inode_table(sb, gdp) + (inode_offset / inodes_per_block);
3575         iloc->offset = (inode_offset % inodes_per_block) * EXT4_INODE_SIZE(sb);
3576 
3577         bh = sb_getblk(sb, block);
3578         if (!bh) {
3579                 EXT4_ERROR_INODE_BLOCK(inode, block,
3580                                        "unable to read itable block");
3581                 return -EIO;
3582         }
3583         if (!buffer_uptodate(bh)) {
3584                 lock_buffer(bh);
3585 
3586                 /*
3587                  * If the buffer has the write error flag, we have failed
3588                  * to write out another inode in the same block.  In this
3589                  * case, we don't have to read the block because we may
3590                  * read the old inode data successfully.
3591                  */
3592                 if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
3593                         set_buffer_uptodate(bh);
3594 
3595                 if (buffer_uptodate(bh)) {
3596                         /* someone brought it uptodate while we waited */
3597                         unlock_buffer(bh);
3598                         goto has_buffer;
3599                 }
3600 
3601                 /*
3602                  * If we have all information of the inode in memory and this
3603                  * is the only valid inode in the block, we need not read the
3604                  * block.
3605                  */
3606                 if (in_mem) {
3607                         struct buffer_head *bitmap_bh;
3608                         int i, start;
3609 
3610                         start = inode_offset & ~(inodes_per_block - 1);
3611 
3612                         /* Is the inode bitmap in cache? */
3613                         bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
3614                         if (!bitmap_bh)
3615                                 goto make_io;
3616 
3617                         /*
3618                          * If the inode bitmap isn't in cache then the
3619                          * optimisation may end up performing two reads instead
3620                          * of one, so skip it.
3621                          */
3622                         if (!buffer_uptodate(bitmap_bh)) {
3623                                 brelse(bitmap_bh);
3624                                 goto make_io;
3625                         }
3626                         for (i = start; i < start + inodes_per_block; i++) {
3627                                 if (i == inode_offset)
3628                                         continue;
3629                                 if (ext4_test_bit(i, bitmap_bh->b_data))
3630                                         break;
3631                         }
3632                         brelse(bitmap_bh);
3633                         if (i == start + inodes_per_block) {
3634                                 /* all other inodes are free, so skip I/O */
3635                                 memset(bh->b_data, 0, bh->b_size);
3636                                 set_buffer_uptodate(bh);
3637                                 unlock_buffer(bh);
3638                                 goto has_buffer;
3639                         }
3640                 }
3641 
3642 make_io:
3643                 /*
3644                  * If we need to do any I/O, try to pre-readahead extra
3645                  * blocks from the inode table.
3646                  */
3647                 if (EXT4_SB(sb)->s_inode_readahead_blks) {
3648                         ext4_fsblk_t b, end, table;
3649                         unsigned num;
3650 
3651                         table = ext4_inode_table(sb, gdp);
3652                         /* s_inode_readahead_blks is always a power of 2 */
3653                         b = block & ~(EXT4_SB(sb)->s_inode_readahead_blks-1);
3654                         if (table > b)
3655                                 b = table;
3656                         end = b + EXT4_SB(sb)->s_inode_readahead_blks;
3657                         num = EXT4_INODES_PER_GROUP(sb);
3658                         if (ext4_has_group_desc_csum(sb))
3659                                 num -= ext4_itable_unused_count(sb, gdp);
3660                         table += num / inodes_per_block;
3661                         if (end > table)
3662                                 end = table;
3663                         while (b <= end)
3664                                 sb_breadahead(sb, b++);
3665                 }
3666 
3667                 /*
3668                  * There are other valid inodes in the buffer, this inode
3669                  * has in-inode xattrs, or we don't have this inode in memory.
3670                  * Read the block from disk.
3671                  */
3672                 trace_ext4_load_inode(inode);
3673                 get_bh(bh);
3674                 bh->b_end_io = end_buffer_read_sync;
3675                 submit_bh(READ | REQ_META | REQ_PRIO, bh);
3676                 wait_on_buffer(bh);
3677                 if (!buffer_uptodate(bh)) {
3678                         EXT4_ERROR_INODE_BLOCK(inode, block,
3679                                                "unable to read itable block");
3680                         brelse(bh);
3681                         return -EIO;
3682                 }
3683         }
3684 has_buffer:
3685         iloc->bh = bh;
3686         return 0;
3687 }
3688 
3689 int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
3690 {
3691         /* We have all inode data except xattrs in memory here. */
3692         return __ext4_get_inode_loc(inode, iloc,
3693                 !ext4_test_inode_state(inode, EXT4_STATE_XATTR));
3694 }
3695 
3696 void ext4_set_inode_flags(struct inode *inode)
3697 {
3698         unsigned int flags = EXT4_I(inode)->i_flags;
3699 
3700         inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
3701         if (flags & EXT4_SYNC_FL)
3702                 inode->i_flags |= S_SYNC;
3703         if (flags & EXT4_APPEND_FL)
3704                 inode->i_flags |= S_APPEND;
3705         if (flags & EXT4_IMMUTABLE_FL)
3706                 inode->i_flags |= S_IMMUTABLE;
3707         if (flags & EXT4_NOATIME_FL)
3708                 inode->i_flags |= S_NOATIME;
3709         if (flags & EXT4_DIRSYNC_FL)
3710                 inode->i_flags |= S_DIRSYNC;
3711 }
3712 
3713 /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
3714 void ext4_get_inode_flags(struct ext4_inode_info *ei)
3715 {
3716         unsigned int vfs_fl;
3717         unsigned long old_fl, new_fl;
3718 
3719         do {
3720                 vfs_fl = ei->vfs_inode.i_flags;
3721                 old_fl = ei->i_flags;
3722                 new_fl = old_fl & ~(EXT4_SYNC_FL|EXT4_APPEND_FL|
3723                                 EXT4_IMMUTABLE_FL|EXT4_NOATIME_FL|
3724                                 EXT4_DIRSYNC_FL);
3725                 if (vfs_fl & S_SYNC)
3726                         new_fl |= EXT4_SYNC_FL;
3727                 if (vfs_fl & S_APPEND)
3728                         new_fl |= EXT4_APPEND_FL;
3729                 if (vfs_fl & S_IMMUTABLE)
3730                         new_fl |= EXT4_IMMUTABLE_FL;
3731                 if (vfs_fl & S_NOATIME)
3732                         new_fl |= EXT4_NOATIME_FL;
3733                 if (vfs_fl & S_DIRSYNC)
3734                         new_fl |= EXT4_DIRSYNC_FL;
3735         } while (cmpxchg(&ei->i_flags, old_fl, new_fl) != old_fl);
3736 }
3737 
3738 static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
3739                                   struct ext4_inode_info *ei)
3740 {
3741         blkcnt_t i_blocks ;
3742         struct inode *inode = &(ei->vfs_inode);
3743         struct super_block *sb = inode->i_sb;
3744 
3745         if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
3746                                 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
3747                 /* we are using combined 48 bit field */
3748                 i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
3749                                         le32_to_cpu(raw_inode->i_blocks_lo);
3750                 if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) {
3751                         /* i_blocks represent file system block size */
3752                         return i_blocks  << (inode->i_blkbits - 9);
3753                 } else {
3754                         return i_blocks;
3755                 }
3756         } else {
3757                 return le32_to_cpu(raw_inode->i_blocks_lo);
3758         }
3759 }
3760 
3761 struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
3762 {
3763         struct ext4_iloc iloc;
3764         struct ext4_inode *raw_inode;
3765         struct ext4_inode_info *ei;
3766         struct inode *inode;
3767         journal_t *journal = EXT4_SB(sb)->s_journal;
3768         long ret;
3769         int block;
3770         uid_t i_uid;
3771         gid_t i_gid;
3772 
3773         inode = iget_locked(sb, ino);
3774         if (!inode)
3775                 return ERR_PTR(-ENOMEM);
3776         if (!(inode->i_state & I_NEW))
3777                 return inode;
3778 
3779         ei = EXT4_I(inode);
3780         iloc.bh = NULL;
3781 
3782         ret = __ext4_get_inode_loc(inode, &iloc, 0);
3783         if (ret < 0)
3784                 goto bad_inode;
3785         raw_inode = ext4_raw_inode(&iloc);
3786 
3787         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3788                 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
3789                 if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
3790                     EXT4_INODE_SIZE(inode->i_sb)) {
3791                         EXT4_ERROR_INODE(inode, "bad extra_isize (%u != %u)",
3792                                 EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize,
3793                                 EXT4_INODE_SIZE(inode->i_sb));
3794                         ret = -EIO;
3795                         goto bad_inode;
3796                 }
3797         } else
3798                 ei->i_extra_isize = 0;
3799 
3800         /* Precompute checksum seed for inode metadata */
3801         if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
3802                         EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
3803                 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
3804                 __u32 csum;
3805                 __le32 inum = cpu_to_le32(inode->i_ino);
3806                 __le32 gen = raw_inode->i_generation;
3807                 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum,
3808                                    sizeof(inum));
3809                 ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen,
3810                                               sizeof(gen));
3811         }
3812 
3813         if (!ext4_inode_csum_verify(inode, raw_inode, ei)) {
3814                 EXT4_ERROR_INODE(inode, "checksum invalid");
3815                 ret = -EIO;
3816                 goto bad_inode;
3817         }
3818 
3819         inode->i_mode = le16_to_cpu(raw_inode->i_mode);
3820         i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
3821         i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
3822         if (!(test_opt(inode->i_sb, NO_UID32))) {
3823                 i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
3824                 i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
3825         }
3826         i_uid_write(inode, i_uid);
3827         i_gid_write(inode, i_gid);
3828         set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
3829 
3830         ext4_clear_state_flags(ei);     /* Only relevant on 32-bit archs */
3831         ei->i_dir_start_lookup = 0;
3832         ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
3833         /* We now have enough fields to check if the inode was active or not.
3834          * This is needed because nfsd might try to access dead inodes
3835          * the test is that same one that e2fsck uses
3836          * NeilBrown 1999oct15
3837          */
3838         if (inode->i_nlink == 0) {
3839                 if (inode->i_mode == 0 ||
3840                     !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
3841                         /* this inode is deleted */
3842                         ret = -ESTALE;
3843                         goto bad_inode;
3844                 }
3845                 /* The only unlinked inodes we let through here have
3846                  * valid i_mode and are being read by the orphan
3847                  * recovery code: that's fine, we're about to complete
3848                  * the process of deleting those. */
3849         }
3850         ei->i_flags = le32_to_cpu(raw_inode->i_flags);
3851         inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
3852         ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
3853         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT))
3854                 ei->i_file_acl |=
3855                         ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
3856         inode->i_size = ext4_isize(raw_inode);
3857         ei->i_disksize = inode->i_size;
3858 #ifdef CONFIG_QUOTA
3859         ei->i_reserved_quota = 0;
3860 #endif
3861         inode->i_generation = le32_to_cpu(raw_inode->i_generation);
3862         ei->i_block_group = iloc.block_group;
3863         ei->i_last_alloc_group = ~0;
3864         /*
3865          * NOTE! The in-memory inode i_data array is in little-endian order
3866          * even on big-endian machines: we do NOT byteswap the block numbers!
3867          */
3868         for (block = 0; block < EXT4_N_BLOCKS; block++)
3869                 ei->i_data[block] = raw_inode->i_block[block];
3870         INIT_LIST_HEAD(&ei->i_orphan);
3871 
3872         /*
3873          * Set transaction id's of transactions that have to be committed
3874          * to finish f[data]sync. We set them to currently running transaction
3875          * as we cannot be sure that the inode or some of its metadata isn't
3876          * part of the transaction - the inode could have been reclaimed and
3877          * now it is reread from disk.
3878          */
3879         if (journal) {
3880                 transaction_t *transaction;
3881                 tid_t tid;
3882 
3883                 read_lock(&journal->j_state_lock);
3884                 if (journal->j_running_transaction)
3885                         transaction = journal->j_running_transaction;
3886                 else
3887                         transaction = journal->j_committing_transaction;
3888                 if (transaction)
3889                         tid = transaction->t_tid;
3890                 else
3891                         tid = journal->j_commit_sequence;
3892                 read_unlock(&journal->j_state_lock);
3893                 ei->i_sync_tid = tid;
3894                 ei->i_datasync_tid = tid;
3895         }
3896 
3897         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3898                 if (ei->i_extra_isize == 0) {
3899                         /* The extra space is currently unused. Use it. */
3900                         ei->i_extra_isize = sizeof(struct ext4_inode) -
3901                                             EXT4_GOOD_OLD_INODE_SIZE;
3902                 } else {
3903                         __le32 *magic = (void *)raw_inode +
3904                                         EXT4_GOOD_OLD_INODE_SIZE +
3905                                         ei->i_extra_isize;
3906                         if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC))
3907                                 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
3908                 }
3909         }
3910 
3911         EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode);
3912         EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode);
3913         EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
3914         EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
3915 
3916         inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
3917         if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3918                 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
3919                         inode->i_version |=
3920                         (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
3921         }
3922 
3923         ret = 0;
3924         if (ei->i_file_acl &&
3925             !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
3926                 EXT4_ERROR_INODE(inode, "bad extended attribute block %llu",
3927                                  ei->i_file_acl);
3928                 ret = -EIO;
3929                 goto bad_inode;
3930         } else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
3931                 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
3932                     (S_ISLNK(inode->i_mode) &&
3933                      !ext4_inode_is_fast_symlink(inode)))
3934                         /* Validate extent which is part of inode */
3935                         ret = ext4_ext_check_inode(inode);
3936         } else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
3937                    (S_ISLNK(inode->i_mode) &&
3938                     !ext4_inode_is_fast_symlink(inode))) {
3939                 /* Validate block references which are part of inode */
3940                 ret = ext4_ind_check_inode(inode);
3941         }
3942         if (ret)
3943                 goto bad_inode;
3944 
3945         if (S_ISREG(inode->i_mode)) {
3946                 inode->i_op = &ext4_file_inode_operations;
3947                 inode->i_fop = &ext4_file_operations;
3948                 ext4_set_aops(inode);
3949         } else if (S_ISDIR(inode->i_mode)) {
3950                 inode->i_op = &ext4_dir_inode_operations;
3951                 inode->i_fop = &ext4_dir_operations;
3952         } else if (S_ISLNK(inode->i_mode)) {
3953                 if (ext4_inode_is_fast_symlink(inode)) {
3954                         inode->i_op = &ext4_fast_symlink_inode_operations;
3955                         nd_terminate_link(ei->i_data, inode->i_size,
3956                                 sizeof(ei->i_data) - 1);
3957                 } else {
3958                         inode->i_op = &ext4_symlink_inode_operations;
3959                         ext4_set_aops(inode);
3960                 }
3961         } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
3962               S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
3963                 inode->i_op = &ext4_special_inode_operations;
3964                 if (raw_inode->i_block[0])
3965                         init_special_inode(inode, inode->i_mode,
3966                            old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
3967                 else
3968                         init_special_inode(inode, inode->i_mode,
3969                            new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
3970         } else {
3971                 ret = -EIO;
3972                 EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode);
3973                 goto bad_inode;
3974         }
3975         brelse(iloc.bh);
3976         ext4_set_inode_flags(inode);
3977         unlock_new_inode(inode);
3978         return inode;
3979 
3980 bad_inode:
3981         brelse(iloc.bh);
3982         iget_failed(inode);
3983         return ERR_PTR(ret);
3984 }
3985 
3986 static int ext4_inode_blocks_set(handle_t *handle,
3987                                 struct ext4_inode *raw_inode,
3988                                 struct ext4_inode_info *ei)
3989 {
3990         struct inode *inode = &(ei->vfs_inode);
3991         u64 i_blocks = inode->i_blocks;
3992         struct super_block *sb = inode->i_sb;
3993 
3994         if (i_blocks <= ~0U) {
3995                 /*
3996                  * i_blocks can be represented in a 32 bit variable
3997                  * as multiple of 512 bytes
3998                  */
3999                 raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
4000                 raw_inode->i_blocks_high = 0;
4001                 ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4002                 return 0;
4003         }
4004         if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE))
4005                 return -EFBIG;
4006 
4007         if (i_blocks <= 0xffffffffffffULL) {
4008                 /*
4009                  * i_blocks can be represented in a 48 bit variable
4010                  * as multiple of 512 bytes
4011                  */
4012                 raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
4013                 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
4014                 ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4015         } else {
4016                 ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4017                 /* i_block is stored in file system block size */
4018                 i_blocks = i_blocks >> (inode->i_blkbits - 9);
4019                 raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
4020                 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
4021         }
4022         return 0;
4023 }
4024 
4025 /*
4026  * Post the struct inode info into an on-disk inode location in the
4027  * buffer-cache.  This gobbles the caller's reference to the
4028  * buffer_head in the inode location struct.
4029  *
4030  * The caller must have write access to iloc->bh.
4031  */
4032 static int ext4_do_update_inode(handle_t *handle,
4033                                 struct inode *inode,
4034                                 struct ext4_iloc *iloc)
4035 {
4036         struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
4037         struct ext4_inode_info *ei = EXT4_I(inode);
4038         struct buffer_head *bh = iloc->bh;
4039         int err = 0, rc, block;
4040         int need_datasync = 0;
4041         uid_t i_uid;
4042         gid_t i_gid;
4043 
4044         /* For fields not not tracking in the in-memory inode,
4045          * initialise them to zero for new inodes. */
4046         if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
4047                 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
4048 
4049         ext4_get_inode_flags(ei);
4050         raw_inode->i_mode = cpu_to_le16(inode->i_mode);
4051         i_uid = i_uid_read(inode);
4052         i_gid = i_gid_read(inode);
4053         if (!(test_opt(inode->i_sb, NO_UID32))) {
4054                 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(i_uid));
4055                 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(i_gid));
4056 /*
4057  * Fix up interoperability with old kernels. Otherwise, old inodes get
4058  * re-used with the upper 16 bits of the uid/gid intact
4059  */
4060                 if (!ei->i_dtime) {
4061                         raw_inode->i_uid_high =
4062                                 cpu_to_le16(high_16_bits(i_uid));
4063                         raw_inode->i_gid_high =
4064                                 cpu_to_le16(high_16_bits(i_gid));
4065                 } else {
4066                         raw_inode->i_uid_high = 0;
4067                         raw_inode->i_gid_high = 0;
4068                 }
4069         } else {
4070                 raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid));
4071                 raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid));
4072                 raw_inode->i_uid_high = 0;
4073                 raw_inode->i_gid_high = 0;
4074         }
4075         raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
4076 
4077         EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
4078         EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
4079         EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
4080         EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
4081 
4082         if (ext4_inode_blocks_set(handle, raw_inode, ei))
4083                 goto out_brelse;
4084         raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
4085         raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF);
4086         if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
4087             cpu_to_le32(EXT4_OS_HURD))
4088                 raw_inode->i_file_acl_high =
4089                         cpu_to_le16(ei->i_file_acl >> 32);
4090         raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
4091         if (ei->i_disksize != ext4_isize(raw_inode)) {
4092                 ext4_isize_set(raw_inode, ei->i_disksize);
4093                 need_datasync = 1;
4094         }
4095         if (ei->i_disksize > 0x7fffffffULL) {
4096                 struct super_block *sb = inode->i_sb;
4097                 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
4098                                 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
4099                                 EXT4_SB(sb)->s_es->s_rev_level ==
4100                                 cpu_to_le32(EXT4_GOOD_OLD_REV)) {
4101                         /* If this is the first large file
4102                          * created, add a flag to the superblock.
4103                          */
4104                         err = ext4_journal_get_write_access(handle,
4105                                         EXT4_SB(sb)->s_sbh);
4106                         if (err)
4107                                 goto out_brelse;
4108                         ext4_update_dynamic_rev(sb);
4109                         EXT4_SET_RO_COMPAT_FEATURE(sb,
4110                                         EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4111                         ext4_handle_sync(handle);
4112                         err = ext4_handle_dirty_super(handle, sb);
4113                 }
4114         }
4115         raw_inode->i_generation = cpu_to_le32(inode->i_generation);
4116         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
4117                 if (old_valid_dev(inode->i_rdev)) {
4118                         raw_inode->i_block[0] =
4119                                 cpu_to_le32(old_encode_dev(inode->i_rdev));
4120                         raw_inode->i_block[1] = 0;
4121                 } else {
4122                         raw_inode->i_block[0] = 0;
4123                         raw_inode->i_block[1] =
4124                                 cpu_to_le32(new_encode_dev(inode->i_rdev));
4125                         raw_inode->i_block[2] = 0;
4126                 }
4127         } else
4128                 for (block = 0; block < EXT4_N_BLOCKS; block++)
4129                         raw_inode->i_block[block] = ei->i_data[block];
4130 
4131         raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
4132         if (ei->i_extra_isize) {
4133                 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
4134                         raw_inode->i_version_hi =
4135                         cpu_to_le32(inode->i_version >> 32);
4136                 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
4137         }
4138 
4139         ext4_inode_csum_set(inode, raw_inode, ei);
4140 
4141         BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
4142         rc = ext4_handle_dirty_metadata(handle, NULL, bh);
4143         if (!err)
4144                 err = rc;
4145         ext4_clear_inode_state(inode, EXT4_STATE_NEW);
4146 
4147         ext4_update_inode_fsync_trans(handle, inode, need_datasync);
4148 out_brelse:
4149         brelse(bh);
4150         ext4_std_error(inode->i_sb, err);
4151         return err;
4152 }
4153 
4154 /*
4155  * ext4_write_inode()
4156  *
4157  * We are called from a few places:
4158  *
4159  * - Within generic_file_write() for O_SYNC files.
4160  *   Here, there will be no transaction running. We wait for any running
4161  *   transaction to commit.
4162  *
4163  * - Within sys_sync(), kupdate and such.
4164  *   We wait on commit, if tol to.
4165  *
4166  * - Within prune_icache() (PF_MEMALLOC == true)
4167  *   Here we simply return.  We can't afford to block kswapd on the
4168  *   journal commit.
4169  *
4170  * In all cases it is actually safe for us to return without doing anything,
4171  * because the inode has been copied into a raw inode buffer in
4172  * ext4_mark_inode_dirty().  This is a correctness thing for O_SYNC and for
4173  * knfsd.
4174  *
4175  * Note that we are absolutely dependent upon all inode dirtiers doing the
4176  * right thing: they *must* call mark_inode_dirty() after dirtying info in
4177  * which we are interested.
4178  *
4179  * It would be a bug for them to not do this.  The code:
4180  *
4181  *      mark_inode_dirty(inode)
4182  *      stuff();
4183  *      inode->i_size = expr;
4184  *
4185  * is in error because a kswapd-driven write_inode() could occur while
4186  * `stuff()' is running, and the new i_size will be lost.  Plus the inode
4187  * will no longer be on the superblock's dirty inode list.
4188  */
4189 int ext4_write_inode(struct inode *inode, struct writeback_control *wbc)
4190 {
4191         int err;
4192 
4193         if (current->flags & PF_MEMALLOC)
4194                 return 0;
4195 
4196         if (EXT4_SB(inode->i_sb)->s_journal) {
4197                 if (ext4_journal_current_handle()) {
4198                         jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
4199                         dump_stack();
4200                         return -EIO;
4201                 }
4202 
4203                 if (wbc->sync_mode != WB_SYNC_ALL)
4204                         return 0;
4205 
4206                 err = ext4_force_commit(inode->i_sb);
4207         } else {
4208                 struct ext4_iloc iloc;
4209 
4210                 err = __ext4_get_inode_loc(inode, &iloc, 0);
4211                 if (err)
4212                         return err;
4213                 if (wbc->sync_mode == WB_SYNC_ALL)
4214                         sync_dirty_buffer(iloc.bh);
4215                 if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
4216                         EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr,
4217                                          "IO error syncing inode");
4218                         err = -EIO;
4219                 }
4220                 brelse(iloc.bh);
4221         }
4222         return err;
4223 }
4224 
4225 /*
4226  * ext4_setattr()
4227  *
4228  * Called from notify_change.
4229  *
4230  * We want to trap VFS attempts to truncate the file as soon as
4231  * possible.  In particular, we want to make sure that when the VFS
4232  * shrinks i_size, we put the inode on the orphan list and modify
4233  * i_disksize immediately, so that during the subsequent flushing of
4234  * dirty pages and freeing of disk blocks, we can guarantee that any
4235  * commit will leave the blocks being flushed in an unused state on
4236  * disk.  (On recovery, the inode will get truncated and the blocks will
4237  * be freed, so we have a strong guarantee that no future commit will
4238  * leave these blocks visible to the user.)
4239  *
4240  * Another thing we have to assure is that if we are in ordered mode
4241  * and inode is still attached to the committing transaction, we must
4242  * we start writeout of all the dirty pages which are being truncated.
4243  * This way we are sure that all the data written in the previous
4244  * transaction are already on disk (truncate waits for pages under
4245  * writeback).
4246  *
4247  * Called with inode->i_mutex down.
4248  */
4249 int ext4_setattr(struct dentry *dentry, struct iattr *attr)
4250 {
4251         struct inode *inode = dentry->d_inode;
4252         int error, rc = 0;
4253         int orphan = 0;
4254         const unsigned int ia_valid = attr->ia_valid;
4255 
4256         error = inode_change_ok(inode, attr);
4257         if (error)
4258                 return error;
4259 
4260         if (is_quota_modification(inode, attr))
4261                 dquot_initialize(inode);
4262         if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
4263             (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) {
4264                 handle_t *handle;
4265 
4266                 /* (user+group)*(old+new) structure, inode write (sb,
4267                  * inode block, ? - but truncate inode update has it) */
4268                 handle = ext4_journal_start(inode, (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
4269                                         EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb))+3);
4270                 if (IS_ERR(handle)) {
4271                         error = PTR_ERR(handle);
4272                         goto err_out;
4273                 }
4274                 error = dquot_transfer(inode, attr);
4275                 if (error) {
4276                         ext4_journal_stop(handle);
4277                         return error;
4278                 }
4279                 /* Update corresponding info in inode so that everything is in
4280                  * one transaction */
4281                 if (attr->ia_valid & ATTR_UID)
4282                         inode->i_uid = attr->ia_uid;
4283                 if (attr->ia_valid & ATTR_GID)
4284                         inode->i_gid = attr->ia_gid;
4285                 error = ext4_mark_inode_dirty(handle, inode);
4286                 ext4_journal_stop(handle);
4287         }
4288 
4289         if (attr->ia_valid & ATTR_SIZE) {
4290 
4291                 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4292                         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4293 
4294                         if (attr->ia_size > sbi->s_bitmap_maxbytes)
4295                                 return -EFBIG;
4296                 }
4297         }
4298 
4299         if (S_ISREG(inode->i_mode) &&
4300             attr->ia_valid & ATTR_SIZE &&
4301             (attr->ia_size < inode->i_size)) {
4302                 handle_t *handle;
4303 
4304                 handle = ext4_journal_start(inode, 3);
4305                 if (IS_ERR(handle)) {
4306                         error = PTR_ERR(handle);
4307                         goto err_out;
4308                 }
4309                 if (ext4_handle_valid(handle)) {
4310                         error = ext4_orphan_add(handle, inode);
4311                         orphan = 1;
4312                 }
4313                 EXT4_I(inode)->i_disksize = attr->ia_size;
4314                 rc = ext4_mark_inode_dirty(handle, inode);
4315                 if (!error)
4316                         error = rc;
4317                 ext4_journal_stop(handle);
4318 
4319                 if (ext4_should_order_data(inode)) {
4320                         error = ext4_begin_ordered_truncate(inode,
4321                                                             attr->ia_size);
4322                         if (error) {
4323                                 /* Do as much error cleanup as possible */
4324                                 handle = ext4_journal_start(inode, 3);
4325                                 if (IS_ERR(handle)) {
4326                                         ext4_orphan_del(NULL, inode);
4327                                         goto err_out;
4328                                 }
4329                                 ext4_orphan_del(handle, inode);
4330                                 orphan = 0;
4331                                 ext4_journal_stop(handle);
4332                                 goto err_out;
4333                         }
4334                 }
4335         }
4336 
4337         if (attr->ia_valid & ATTR_SIZE) {
4338                 if (attr->ia_size != i_size_read(inode)) {
4339                         truncate_setsize(inode, attr->ia_size);
4340                         /* Inode size will be reduced, wait for dio in flight.
4341                          * Temporarily disable dioread_nolock to prevent
4342                          * livelock. */
4343                         if (orphan) {
4344                                 ext4_inode_block_unlocked_dio(inode);
4345                                 inode_dio_wait(inode);
4346                                 ext4_inode_resume_unlocked_dio(inode);
4347                         }
4348                 }
4349                 ext4_truncate(inode);
4350         }
4351 
4352         if (!rc) {
4353                 setattr_copy(inode, attr);
4354                 mark_inode_dirty(inode);
4355         }
4356 
4357         /*
4358          * If the call to ext4_truncate failed to get a transaction handle at
4359          * all, we need to clean up the in-core orphan list manually.
4360          */
4361         if (orphan && inode->i_nlink)
4362                 ext4_orphan_del(NULL, inode);
4363 
4364         if (!rc && (ia_valid & ATTR_MODE))
4365                 rc = ext4_acl_chmod(inode);
4366 
4367 err_out:
4368         ext4_std_error(inode->i_sb, error);
4369         if (!error)
4370                 error = rc;
4371         return error;
4372 }
4373 
4374 int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
4375                  struct kstat *stat)
4376 {
4377         struct inode *inode;
4378         unsigned long delalloc_blocks;
4379 
4380         inode = dentry->d_inode;
4381         generic_fillattr(inode, stat);
4382 
4383         /*
4384          * We can't update i_blocks if the block allocation is delayed
4385          * otherwise in the case of system crash before the real block
4386          * allocation is done, we will have i_blocks inconsistent with
4387          * on-disk file blocks.
4388          * We always keep i_blocks updated together with real
4389          * allocation. But to not confuse with user, stat
4390          * will return the blocks that include the delayed allocation
4391          * blocks for this file.
4392          */
4393         delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb),
4394                                 EXT4_I(inode)->i_reserved_data_blocks);
4395 
4396         stat->blocks += (delalloc_blocks << inode->i_sb->s_blocksize_bits)>>9;
4397         return 0;
4398 }
4399 
4400 static int ext4_index_trans_blocks(struct inode *inode, int nrblocks, int chunk)
4401 {
4402         if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
4403                 return ext4_ind_trans_blocks(inode, nrblocks, chunk);
4404         return ext4_ext_index_trans_blocks(inode, nrblocks, chunk);
4405 }
4406 
4407 /*
4408  * Account for index blocks, block groups bitmaps and block group
4409  * descriptor blocks if modify datablocks and index blocks
4410  * worse case, the indexs blocks spread over different block groups
4411  *
4412  * If datablocks are discontiguous, they are possible to spread over
4413  * different block groups too. If they are contiguous, with flexbg,
4414  * they could still across block group boundary.
4415  *
4416  * Also account for superblock, inode, quota and xattr blocks
4417  */
4418 static int ext4_meta_trans_blocks(struct inode *inode, int nrblocks, int chunk)
4419 {
4420         ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
4421         int gdpblocks;
4422         int idxblocks;
4423         int ret = 0;
4424 
4425         /*
4426          * How many index blocks need to touch to modify nrblocks?
4427          * The "Chunk" flag indicating whether the nrblocks is
4428          * physically contiguous on disk
4429          *
4430          * For Direct IO and fallocate, they calls get_block to allocate
4431          * one single extent at a time, so they could set the "Chunk" flag
4432          */
4433         idxblocks = ext4_index_trans_blocks(inode, nrblocks, chunk);
4434 
4435         ret = idxblocks;
4436 
4437         /*
4438          * Now let's see how many group bitmaps and group descriptors need
4439          * to account
4440          */
4441         groups = idxblocks;
4442         if (chunk)
4443                 groups += 1;
4444         else
4445                 groups += nrblocks;
4446 
4447         gdpblocks = groups;
4448         if (groups > ngroups)
4449                 groups = ngroups;
4450         if (groups > EXT4_SB(inode->i_sb)->s_gdb_count)
4451                 gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count;
4452 
4453         /* bitmaps and block group descriptor blocks */
4454         ret += groups + gdpblocks;
4455 
4456         /* Blocks for super block, inode, quota and xattr blocks */
4457         ret += EXT4_META_TRANS_BLOCKS(inode->i_sb);
4458 
4459         return ret;
4460 }
4461 
4462 /*
4463  * Calculate the total number of credits to reserve to fit
4464  * the modification of a single pages into a single transaction,
4465  * which may include multiple chunks of block allocations.
4466  *
4467  * This could be called via ext4_write_begin()
4468  *
4469  * We need to consider the worse case, when
4470  * one new block per extent.
4471  */
4472 int ext4_writepage_trans_blocks(struct inode *inode)
4473 {
4474         int bpp = ext4_journal_blocks_per_page(inode);
4475         int ret;
4476 
4477         ret = ext4_meta_trans_blocks(inode, bpp, 0);
4478 
4479         /* Account for data blocks for journalled mode */
4480         if (ext4_should_journal_data(inode))
4481                 ret += bpp;
4482         return ret;
4483 }
4484 
4485 /*
4486  * Calculate the journal credits for a chunk of data modification.
4487  *
4488  * This is called from DIO, fallocate or whoever calling
4489  * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
4490  *
4491  * journal buffers for data blocks are not included here, as DIO
4492  * and fallocate do no need to journal data buffers.
4493  */
4494 int ext4_chunk_trans_blocks(struct inode *inode, int nrblocks)
4495 {
4496         return ext4_meta_trans_blocks(inode, nrblocks, 1);
4497 }
4498 
4499 /*
4500  * The caller must have previously called ext4_reserve_inode_write().
4501  * Give this, we know that the caller already has write access to iloc->bh.
4502  */
4503 int ext4_mark_iloc_dirty(handle_t *handle,
4504                          struct inode *inode, struct ext4_iloc *iloc)
4505 {
4506         int err = 0;
4507 
4508         if (IS_I_VERSION(inode))
4509                 inode_inc_iversion(inode);
4510 
4511         /* the do_update_inode consumes one bh->b_count */
4512         get_bh(iloc->bh);
4513 
4514         /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4515         err = ext4_do_update_inode(handle, inode, iloc);
4516         put_bh(iloc->bh);
4517         return err;
4518 }
4519 
4520 /*
4521  * On success, We end up with an outstanding reference count against
4522  * iloc->bh.  This _must_ be cleaned up later.
4523  */
4524 
4525 int
4526 ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
4527                          struct ext4_iloc *iloc)
4528 {
4529         int err;
4530 
4531         err = ext4_get_inode_loc(inode, iloc);
4532         if (!err) {
4533                 BUFFER_TRACE(iloc->bh, "get_write_access");
4534                 err = ext4_journal_get_write_access(handle, iloc->bh);
4535                 if (err) {
4536                         brelse(iloc->bh);
4537                         iloc->bh = NULL;
4538                 }
4539         }
4540         ext4_std_error(inode->i_sb, err);
4541         return err;
4542 }
4543 
4544 /*
4545  * Expand an inode by new_extra_isize bytes.
4546  * Returns 0 on success or negative error number on failure.
4547  */
4548 static int ext4_expand_extra_isize(struct inode *inode,
4549                                    unsigned int new_extra_isize,
4550                                    struct ext4_iloc iloc,
4551                                    handle_t *handle)
4552 {
4553         struct ext4_inode *raw_inode;
4554         struct ext4_xattr_ibody_header *header;
4555 
4556         if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
4557                 return 0;
4558 
4559         raw_inode = ext4_raw_inode(&iloc);
4560 
4561         header = IHDR(inode, raw_inode);
4562 
4563         /* No extended attributes present */
4564         if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
4565             header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
4566                 memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0,
4567                         new_extra_isize);
4568                 EXT4_I(inode)->i_extra_isize = new_extra_isize;
4569                 return 0;
4570         }
4571 
4572         /* try to expand with EAs present */
4573         return ext4_expand_extra_isize_ea(inode, new_extra_isize,
4574                                           raw_inode, handle);
4575 }
4576 
4577 /*
4578  * What we do here is to mark the in-core inode as clean with respect to inode
4579  * dirtiness (it may still be data-dirty).
4580  * This means that the in-core inode may be reaped by prune_icache
4581  * without having to perform any I/O.  This is a very good thing,
4582  * because *any* task may call prune_icache - even ones which
4583  * have a transaction open against a different journal.
4584  *
4585  * Is this cheating?  Not really.  Sure, we haven't written the
4586  * inode out, but prune_icache isn't a user-visible syncing function.
4587  * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
4588  * we start and wait on commits.
4589  */
4590 int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
4591 {
4592         struct ext4_iloc iloc;
4593         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4594         static unsigned int mnt_count;
4595         int err, ret;
4596 
4597         might_sleep();
4598         trace_ext4_mark_inode_dirty(inode, _RET_IP_);
4599         err = ext4_reserve_inode_write(handle, inode, &iloc);
4600         if (ext4_handle_valid(handle) &&
4601             EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize &&
4602             !ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND)) {
4603                 /*
4604                  * We need extra buffer credits since we may write into EA block
4605                  * with this same handle. If journal_extend fails, then it will
4606                  * only result in a minor loss of functionality for that inode.
4607                  * If this is felt to be critical, then e2fsck should be run to
4608                  * force a large enough s_min_extra_isize.
4609                  */
4610                 if ((jbd2_journal_extend(handle,
4611                              EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
4612                         ret = ext4_expand_extra_isize(inode,
4613                                                       sbi->s_want_extra_isize,
4614                                                       iloc, handle);
4615                         if (ret) {
4616                                 ext4_set_inode_state(inode,
4617                                                      EXT4_STATE_NO_EXPAND);
4618                                 if (mnt_count !=
4619                                         le16_to_cpu(sbi->s_es->s_mnt_count)) {
4620                                         ext4_warning(inode->i_sb,
4621                                         "Unable to expand inode %lu. Delete"
4622                                         " some EAs or run e2fsck.",
4623                                         inode->i_ino);
4624                                         mnt_count =
4625                                           le16_to_cpu(sbi->s_es->s_mnt_count);
4626                                 }
4627                         }
4628                 }
4629         }
4630         if (!err)
4631                 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
4632         return err;
4633 }
4634 
4635 /*
4636  * ext4_dirty_inode() is called from __mark_inode_dirty()
4637  *
4638  * We're really interested in the case where a file is being extended.
4639  * i_size has been changed by generic_commit_write() and we thus need
4640  * to include the updated inode in the current transaction.
4641  *
4642  * Also, dquot_alloc_block() will always dirty the inode when blocks
4643  * are allocated to the file.
4644  *
4645  * If the inode is marked synchronous, we don't honour that here - doing
4646  * so would cause a commit on atime updates, which we don't bother doing.
4647  * We handle synchronous inodes at the highest possible level.
4648  */
4649 void ext4_dirty_inode(struct inode *inode, int flags)
4650 {
4651         handle_t *handle;
4652 
4653         handle = ext4_journal_start(inode, 2);
4654         if (IS_ERR(handle))
4655                 goto out;
4656 
4657         ext4_mark_inode_dirty(handle, inode);
4658 
4659         ext4_journal_stop(handle);
4660 out:
4661         return;
4662 }
4663 
4664 #if 0
4665 /*
4666  * Bind an inode's backing buffer_head into this transaction, to prevent
4667  * it from being flushed to disk early.  Unlike
4668  * ext4_reserve_inode_write, this leaves behind no bh reference and
4669  * returns no iloc structure, so the caller needs to repeat the iloc
4670  * lookup to mark the inode dirty later.
4671  */
4672 static int ext4_pin_inode(handle_t *handle, struct inode *inode)
4673 {
4674         struct ext4_iloc iloc;
4675 
4676         int err = 0;
4677         if (handle) {
4678                 err = ext4_get_inode_loc(inode, &iloc);
4679                 if (!err) {
4680                         BUFFER_TRACE(iloc.bh, "get_write_access");
4681                         err = jbd2_journal_get_write_access(handle, iloc.bh);
4682                         if (!err)
4683                                 err = ext4_handle_dirty_metadata(handle,
4684                                                                  NULL,
4685                                                                  iloc.bh);
4686                         brelse(iloc.bh);
4687                 }
4688         }
4689         ext4_std_error(inode->i_sb, err);
4690         return err;
4691 }
4692 #endif
4693 
4694 int ext4_change_inode_journal_flag(struct inode *inode, int val)
4695 {
4696         journal_t *journal;
4697         handle_t *handle;
4698         int err;
4699 
4700         /*
4701          * We have to be very careful here: changing a data block's
4702          * journaling status dynamically is dangerous.  If we write a
4703          * data block to the journal, change the status and then delete
4704          * that block, we risk forgetting to revoke the old log record
4705          * from the journal and so a subsequent replay can corrupt data.
4706          * So, first we make sure that the journal is empty and that
4707          * nobody is changing anything.
4708          */
4709 
4710         journal = EXT4_JOURNAL(inode);
4711         if (!journal)
4712                 return 0;
4713         if (is_journal_aborted(journal))
4714                 return -EROFS;
4715         /* We have to allocate physical blocks for delalloc blocks
4716          * before flushing journal. otherwise delalloc blocks can not
4717          * be allocated any more. even more truncate on delalloc blocks
4718          * could trigger BUG by flushing delalloc blocks in journal.
4719          * There is no delalloc block in non-journal data mode.
4720          */
4721         if (val && test_opt(inode->i_sb, DELALLOC)) {
4722                 err = ext4_alloc_da_blocks(inode);
4723                 if (err < 0)
4724                         return err;
4725         }
4726 
4727         /* Wait for all existing dio workers */
4728         ext4_inode_block_unlocked_dio(inode);
4729         inode_dio_wait(inode);
4730 
4731         jbd2_journal_lock_updates(journal);
4732 
4733         /*
4734          * OK, there are no updates running now, and all cached data is
4735          * synced to disk.  We are now in a completely consistent state
4736          * which doesn't have anything in the journal, and we know that
4737          * no filesystem updates are running, so it is safe to modify
4738          * the inode's in-core data-journaling state flag now.
4739          */
4740 
4741         if (val)
4742                 ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
4743         else {
4744                 jbd2_journal_flush(journal);
4745                 ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
4746         }
4747         ext4_set_aops(inode);
4748 
4749         jbd2_journal_unlock_updates(journal);
4750         ext4_inode_resume_unlocked_dio(inode);
4751 
4752         /* Finally we can mark the inode as dirty. */
4753 
4754         handle = ext4_journal_start(inode, 1);
4755         if (IS_ERR(handle))
4756                 return PTR_ERR(handle);
4757 
4758         err = ext4_mark_inode_dirty(handle, inode);
4759         ext4_handle_sync(handle);
4760         ext4_journal_stop(handle);
4761         ext4_std_error(inode->i_sb, err);
4762 
4763         return err;
4764 }
4765 
4766 static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh)
4767 {
4768         return !buffer_mapped(bh);
4769 }
4770 
4771 int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
4772 {
4773         struct page *page = vmf->page;
4774         loff_t size;
4775         unsigned long len;
4776         int ret;
4777         struct file *file = vma->vm_file;
4778         struct inode *inode = file->f_path.dentry->d_inode;
4779         struct address_space *mapping = inode->i_mapping;
4780         handle_t *handle;
4781         get_block_t *get_block;
4782         int retries = 0;
4783 
4784         sb_start_pagefault(inode->i_sb);
4785         file_update_time(vma->vm_file);
4786         /* Delalloc case is easy... */
4787         if (test_opt(inode->i_sb, DELALLOC) &&
4788             !ext4_should_journal_data(inode) &&
4789             !ext4_nonda_switch(inode->i_sb)) {
4790                 do {
4791                         ret = __block_page_mkwrite(vma, vmf,
4792                                                    ext4_da_get_block_prep);
4793                 } while (ret == -ENOSPC &&
4794                        ext4_should_retry_alloc(inode->i_sb, &retries));
4795                 goto out_ret;
4796         }
4797 
4798         lock_page(page);
4799         size = i_size_read(inode);
4800         /* Page got truncated from under us? */
4801         if (page->mapping != mapping || page_offset(page) > size) {
4802                 unlock_page(page);
4803                 ret = VM_FAULT_NOPAGE;
4804                 goto out;
4805         }
4806 
4807         if (page->index == size >> PAGE_CACHE_SHIFT)
4808                 len = size & ~PAGE_CACHE_MASK;
4809         else
4810                 len = PAGE_CACHE_SIZE;
4811         /*
4812          * Return if we have all the buffers mapped. This avoids the need to do
4813          * journal_start/journal_stop which can block and take a long time
4814          */
4815         if (page_has_buffers(page)) {
4816                 if (!walk_page_buffers(NULL, page_buffers(page), 0, len, NULL,
4817                                         ext4_bh_unmapped)) {
4818                         /* Wait so that we don't change page under IO */
4819                         wait_on_page_writeback(page);
4820                         ret = VM_FAULT_LOCKED;
4821                         goto out;
4822                 }
4823         }
4824         unlock_page(page);
4825         /* OK, we need to fill the hole... */
4826         if (ext4_should_dioread_nolock(inode))
4827                 get_block = ext4_get_block_write;
4828         else
4829                 get_block = ext4_get_block;
4830 retry_alloc:
4831         handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
4832         if (IS_ERR(handle)) {
4833                 ret = VM_FAULT_SIGBUS;
4834                 goto out;
4835         }
4836         ret = __block_page_mkwrite(vma, vmf, get_block);
4837         if (!ret && ext4_should_journal_data(inode)) {
4838                 if (walk_page_buffers(handle, page_buffers(page), 0,
4839                           PAGE_CACHE_SIZE, NULL, do_journal_get_write_access)) {
4840                         unlock_page(page);
4841                         ret = VM_FAULT_SIGBUS;
4842                         ext4_journal_stop(handle);
4843                         goto out;
4844                 }
4845                 ext4_set_inode_state(inode, EXT4_STATE_JDATA);
4846         }
4847         ext4_journal_stop(handle);
4848         if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
4849                 goto retry_alloc;
4850 out_ret:
4851         ret = block_page_mkwrite_return(ret);
4852 out:
4853         sb_end_pagefault(inode->i_sb);
4854         return ret;
4855 }
4856 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp