Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso...
authorLinus Torvalds <torvalds@linux-foundation.org>
Tue, 26 Feb 2013 22:52:45 +0000 (14:52 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 26 Feb 2013 22:52:45 +0000 (14:52 -0800)
Pull ext4 updates from Theodore Ts'o:
 "The one new feature added in this patch series is the ability to use
  the "punch hole" functionality for inodes that are not using extent
  maps.

  In the bug fix category, we fixed some races in the AIO and fstrim
  code, and some potential NULL pointer dereferences and memory leaks in
  error handling code paths.

  In the optimization category, we fixed a performance regression in the
  jbd2 layer introduced by commit d9b01934d56a ("jbd: fix fsync() tid
  wraparound bug", introduced in v3.0) which shows up in the AIM7
  benchmark.  We also further optimized jbd2 by minimize the amount of
  time that transaction handles are held active.

  This patch series also features some additional enhancement of the
  extent status tree, which is now used to cache extent information in a
  more efficient/compact form than what we use on-disk."

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (65 commits)
  ext4: fix free clusters calculation in bigalloc filesystem
  ext4: no need to remove extent if len is 0 in ext4_es_remove_extent()
  ext4: fix xattr block allocation/release with bigalloc
  ext4: reclaim extents from extent status tree
  ext4: adjust some functions for reclaiming extents from extent status tree
  ext4: remove single extent cache
  ext4: lookup block mapping in extent status tree
  ext4: track all extent status in extent status tree
  ext4: let ext4_ext_map_blocks return EXT4_MAP_UNWRITTEN flag
  ext4: rename and improbe ext4_es_find_extent()
  ext4: add physical block and status member into extent status tree
  ext4: refine extent status tree
  ext4: use ERR_PTR() abstraction for ext4_append()
  ext4: refactor code to read directory blocks into ext4_read_dirblock()
  ext4: add debugging context for warning in ext4_da_update_reserve_space()
  ext4: use KERN_WARNING for warning messages
  jbd2: use module parameters instead of debugfs for jbd_debug
  ext4: use module parameters instead of debugfs for mballoc_debug
  ext4: start handle at the last possible moment when creating inodes
  ext4: fix the number of credits needed for acl ops with inline data
  ...

35 files changed:
fs/ext4/acl.c
fs/ext4/balloc.c
fs/ext4/dir.c
fs/ext4/ext4.h
fs/ext4/ext4_extents.h
fs/ext4/ext4_jbd2.c
fs/ext4/ext4_jbd2.h
fs/ext4/extents.c
fs/ext4/extents_status.c
fs/ext4/extents_status.h
fs/ext4/file.c
fs/ext4/hash.c
fs/ext4/ialloc.c
fs/ext4/indirect.c
fs/ext4/inline.c
fs/ext4/inode.c
fs/ext4/ioctl.c
fs/ext4/mballoc.c
fs/ext4/mballoc.h
fs/ext4/migrate.c
fs/ext4/mmp.c
fs/ext4/move_extent.c
fs/ext4/namei.c
fs/ext4/page-io.c
fs/ext4/resize.c
fs/ext4/super.c
fs/ext4/xattr.c
fs/ext4/xattr.h
fs/jbd2/commit.c
fs/jbd2/journal.c
fs/jbd2/transaction.c
include/linux/jbd2.h
include/linux/quota.h
include/trace/events/ext4.h
include/trace/events/jbd2.h

index e6e0d98..39a54a0 100644 (file)
@@ -324,8 +324,8 @@ ext4_acl_chmod(struct inode *inode)
        if (error)
                return error;
 retry:
-       handle = ext4_journal_start(inode,
-                       EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
+       handle = ext4_journal_start(inode, EXT4_HT_XATTR,
+                                   ext4_jbd2_credits_xattr(inode));
        if (IS_ERR(handle)) {
                error = PTR_ERR(handle);
                ext4_std_error(inode->i_sb, error);
@@ -422,7 +422,8 @@ ext4_xattr_set_acl(struct dentry *dentry, const char *name, const void *value,
                acl = NULL;
 
 retry:
-       handle = ext4_journal_start(inode, EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
+       handle = ext4_journal_start(inode, EXT4_HT_XATTR,
+                                   ext4_jbd2_credits_xattr(inode));
        if (IS_ERR(handle)) {
                error = PTR_ERR(handle);
                goto release_and_out;
index cf18217..2f2e0da 100644 (file)
@@ -358,7 +358,7 @@ void ext4_validate_block_bitmap(struct super_block *sb,
 }
 
 /**
- * ext4_read_block_bitmap()
+ * ext4_read_block_bitmap_nowait()
  * @sb:                        super block
  * @block_group:       given block group
  *
@@ -457,6 +457,8 @@ ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
        struct buffer_head *bh;
 
        bh = ext4_read_block_bitmap_nowait(sb, block_group);
+       if (!bh)
+               return NULL;
        if (ext4_wait_block_bitmap(sb, block_group, bh)) {
                put_bh(bh);
                return NULL;
@@ -482,11 +484,16 @@ static int ext4_has_free_clusters(struct ext4_sb_info *sbi,
 
        free_clusters  = percpu_counter_read_positive(fcc);
        dirty_clusters = percpu_counter_read_positive(dcc);
-       root_clusters = EXT4_B2C(sbi, ext4_r_blocks_count(sbi->s_es));
+
+       /*
+        * r_blocks_count should always be multiple of the cluster ratio so
+        * we are safe to do a plane bit shift only.
+        */
+       root_clusters = ext4_r_blocks_count(sbi->s_es) >> sbi->s_cluster_bits;
 
        if (free_clusters - (nclusters + root_clusters + dirty_clusters) <
                                        EXT4_FREECLUSTERS_WATERMARK) {
-               free_clusters  = EXT4_C2B(sbi, percpu_counter_sum_positive(fcc));
+               free_clusters  = percpu_counter_sum_positive(fcc);
                dirty_clusters = percpu_counter_sum_positive(dcc);
        }
        /* Check whether we have space after accounting for current
index 80a28b2..3882fbc 100644 (file)
@@ -185,6 +185,7 @@ static int ext4_readdir(struct file *filp,
                                        "at offset %llu",
                                        (unsigned long long)filp->f_pos);
                        filp->f_pos += sb->s_blocksize - offset;
+                       brelse(bh);
                        continue;
                }
                set_buffer_verified(bh);
index 8462eb3..6e16c18 100644 (file)
@@ -194,8 +194,7 @@ struct mpage_da_data {
  */
 #define        EXT4_IO_END_UNWRITTEN   0x0001
 #define EXT4_IO_END_ERROR      0x0002
-#define EXT4_IO_END_QUEUED     0x0004
-#define EXT4_IO_END_DIRECT     0x0008
+#define EXT4_IO_END_DIRECT     0x0004
 
 struct ext4_io_page {
        struct page     *p_page;
@@ -215,10 +214,8 @@ typedef struct ext4_io_end {
        struct list_head        list;           /* per-file finished IO list */
        struct inode            *inode;         /* file being written to */
        unsigned int            flag;           /* unwritten or not */
-       struct page             *page;          /* for writepage() path */
        loff_t                  offset;         /* offset in the file */
        ssize_t                 size;           /* size of the extent */
-       struct work_struct      work;           /* data work queue */
        struct kiocb            *iocb;          /* iocb struct for AIO */
        int                     result;         /* error value for AIO */
        int                     num_io_pages;   /* for writepages() */
@@ -582,6 +579,8 @@ enum {
 #define EXT4_GET_BLOCKS_KEEP_SIZE              0x0080
        /* Do not take i_data_sem locking in ext4_map_blocks */
 #define EXT4_GET_BLOCKS_NO_LOCK                        0x0100
+       /* Do not put hole in extent cache */
+#define EXT4_GET_BLOCKS_NO_PUT_HOLE            0x0200
 
 /*
  * Flags used by ext4_free_blocks
@@ -810,17 +809,6 @@ do {                                                                              \
 
 #endif /* defined(__KERNEL__) || defined(__linux__) */
 
-/*
- * storage for cached extent
- * If ec_len == 0, then the cache is invalid.
- * If ec_start == 0, then the cache represents a gap (null mapping)
- */
-struct ext4_ext_cache {
-       ext4_fsblk_t    ec_start;
-       ext4_lblk_t     ec_block;
-       __u32           ec_len; /* must be 32bit to return holes */
-};
-
 #include "extents_status.h"
 
 /*
@@ -887,7 +875,6 @@ struct ext4_inode_info {
        struct inode vfs_inode;
        struct jbd2_inode *jinode;
 
-       struct ext4_ext_cache i_cached_extent;
        /*
         * File creation time. Its function is same as that of
         * struct timespec i_{a,c,m}time in the generic inode.
@@ -901,6 +888,8 @@ struct ext4_inode_info {
        /* extents status tree */
        struct ext4_es_tree i_es_tree;
        rwlock_t i_es_lock;
+       struct list_head i_es_lru;
+       unsigned int i_es_lru_nr;       /* protected by i_es_lock */
 
        /* ialloc */
        ext4_group_t    i_last_alloc_group;
@@ -930,6 +919,7 @@ struct ext4_inode_info {
        spinlock_t i_completed_io_lock;
        atomic_t i_ioend_count; /* Number of outstanding io_end structs */
        atomic_t i_unwritten; /* Nr. of inflight conversions pending */
+       struct work_struct i_unwritten_work;    /* deferred extent conversion */
 
        spinlock_t i_block_reservation_lock;
 
@@ -985,7 +975,6 @@ struct ext4_inode_info {
 #define EXT4_MOUNT_DIOREAD_NOLOCK      0x400000 /* Enable support for dio read nolocking */
 #define EXT4_MOUNT_JOURNAL_CHECKSUM    0x800000 /* Journal checksums */
 #define EXT4_MOUNT_JOURNAL_ASYNC_COMMIT        0x1000000 /* Journal Async Commit */
-#define EXT4_MOUNT_MBLK_IO_SUBMIT      0x4000000 /* multi-block io submits */
 #define EXT4_MOUNT_DELALLOC            0x8000000 /* Delalloc support */
 #define EXT4_MOUNT_DATA_ERR_ABORT      0x10000000 /* Abort on file data write */
 #define EXT4_MOUNT_BLOCK_VALIDITY      0x20000000 /* Block validity checking */
@@ -1316,6 +1305,11 @@ struct ext4_sb_info {
 
        /* Precomputed FS UUID checksum for seeding other checksums */
        __u32 s_csum_seed;
+
+       /* Reclaim extents from extent status tree */
+       struct shrinker s_es_shrinker;
+       struct list_head s_es_lru;
+       spinlock_t s_es_lru_lock ____cacheline_aligned_in_smp;
 };
 
 static inline struct ext4_sb_info *EXT4_SB(struct super_block *sb)
@@ -2007,9 +2001,20 @@ extern int ext4fs_dirhash(const char *name, int len, struct
                          dx_hash_info *hinfo);
 
 /* ialloc.c */
-extern struct inode *ext4_new_inode(handle_t *, struct inode *, umode_t,
-                                   const struct qstr *qstr, __u32 goal,
-                                   uid_t *owner);
+extern struct inode *__ext4_new_inode(handle_t *, struct inode *, umode_t,
+                                     const struct qstr *qstr, __u32 goal,
+                                     uid_t *owner, int handle_type,
+                                     unsigned int line_no, int nblocks);
+
+#define ext4_new_inode(handle, dir, mode, qstr, goal, owner) \
+       __ext4_new_inode((handle), (dir), (mode), (qstr), (goal), (owner), \
+                        0, 0, 0)
+#define ext4_new_inode_start_handle(dir, mode, qstr, goal, owner, \
+                                   type, nblocks)                  \
+       __ext4_new_inode(NULL, (dir), (mode), (qstr), (goal), (owner), \
+                        (type), __LINE__, (nblocks))
+
+
 extern void ext4_free_inode(handle_t *, struct inode *);
 extern struct inode * ext4_orphan_get(struct super_block *, unsigned long);
 extern unsigned long ext4_count_free_inodes(struct super_block *);
@@ -2103,6 +2108,7 @@ extern ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb,
 extern int ext4_ind_calc_metadata_amount(struct inode *inode, sector_t lblock);
 extern int ext4_ind_trans_blocks(struct inode *inode, int nrblocks, int chunk);
 extern void ext4_ind_truncate(struct inode *inode);
+extern int ext4_ind_punch_hole(struct file *file, loff_t offset, loff_t length);
 
 /* ioctl.c */
 extern long ext4_ioctl(struct file *, unsigned int, unsigned long);
@@ -2151,6 +2157,8 @@ extern void *ext4_kvzalloc(size_t size, gfp_t flags);
 extern void ext4_kvfree(void *ptr);
 extern int ext4_alloc_flex_bg_array(struct super_block *sb,
                                    ext4_group_t ngroup);
+extern const char *ext4_decode_error(struct super_block *sb, int errno,
+                                    char nbuf[16]);
 extern __printf(4, 5)
 void __ext4_error(struct super_block *, const char *, unsigned int,
                  const char *, ...);
@@ -2227,6 +2235,8 @@ extern int ext4_group_desc_csum_verify(struct super_block *sb, __u32 group,
                                       struct ext4_group_desc *gdp);
 extern void ext4_group_desc_csum_set(struct super_block *sb, __u32 group,
                                     struct ext4_group_desc *gdp);
+extern int ext4_register_li_request(struct super_block *sb,
+                                   ext4_group_t first_not_zeroed);
 
 static inline int ext4_has_group_desc_csum(struct super_block *sb)
 {
@@ -2454,6 +2464,75 @@ extern const struct file_operations ext4_file_operations;
 extern loff_t ext4_llseek(struct file *file, loff_t offset, int origin);
 extern void ext4_unwritten_wait(struct inode *inode);
 
+/* inline.c */
+extern int ext4_has_inline_data(struct inode *inode);
+extern int ext4_get_inline_size(struct inode *inode);
+extern int ext4_get_max_inline_size(struct inode *inode);
+extern int ext4_find_inline_data_nolock(struct inode *inode);
+extern void ext4_write_inline_data(struct inode *inode,
+                                  struct ext4_iloc *iloc,
+                                  void *buffer, loff_t pos,
+                                  unsigned int len);
+extern int ext4_prepare_inline_data(handle_t *handle, struct inode *inode,
+                                   unsigned int len);
+extern int ext4_init_inline_data(handle_t *handle, struct inode *inode,
+                                unsigned int len);
+extern int ext4_destroy_inline_data(handle_t *handle, struct inode *inode);
+
+extern int ext4_readpage_inline(struct inode *inode, struct page *page);
+extern int ext4_try_to_write_inline_data(struct address_space *mapping,
+                                        struct inode *inode,
+                                        loff_t pos, unsigned len,
+                                        unsigned flags,
+                                        struct page **pagep);
+extern int ext4_write_inline_data_end(struct inode *inode,
+                                     loff_t pos, unsigned len,
+                                     unsigned copied,
+                                     struct page *page);
+extern struct buffer_head *
+ext4_journalled_write_inline_data(struct inode *inode,
+                                 unsigned len,
+                                 struct page *page);
+extern int ext4_da_write_inline_data_begin(struct address_space *mapping,
+                                          struct inode *inode,
+                                          loff_t pos, unsigned len,
+                                          unsigned flags,
+                                          struct page **pagep,
+                                          void **fsdata);
+extern int ext4_da_write_inline_data_end(struct inode *inode, loff_t pos,
+                                        unsigned len, unsigned copied,
+                                        struct page *page);
+extern int ext4_try_add_inline_entry(handle_t *handle, struct dentry *dentry,
+                                    struct inode *inode);
+extern int ext4_try_create_inline_dir(handle_t *handle,
+                                     struct inode *parent,
+                                     struct inode *inode);
+extern int ext4_read_inline_dir(struct file *filp,
+                               void *dirent, filldir_t filldir,
+                               int *has_inline_data);
+extern struct buffer_head *ext4_find_inline_entry(struct inode *dir,
+                                       const struct qstr *d_name,
+                                       struct ext4_dir_entry_2 **res_dir,
+                                       int *has_inline_data);
+extern int ext4_delete_inline_entry(handle_t *handle,
+                                   struct inode *dir,
+                                   struct ext4_dir_entry_2 *de_del,
+                                   struct buffer_head *bh,
+                                   int *has_inline_data);
+extern int empty_inline_dir(struct inode *dir, int *has_inline_data);
+extern struct buffer_head *ext4_get_first_inline_block(struct inode *inode,
+                                       struct ext4_dir_entry_2 **parent_de,
+                                       int *retval);
+extern int ext4_inline_data_fiemap(struct inode *inode,
+                                  struct fiemap_extent_info *fieinfo,
+                                  int *has_inline);
+extern int ext4_try_to_evict_inline_data(handle_t *handle,
+                                        struct inode *inode,
+                                        int needed);
+extern void ext4_inline_data_truncate(struct inode *inode, int *has_inline);
+
+extern int ext4_convert_inline_data(struct inode *inode);
+
 /* namei.c */
 extern const struct inode_operations ext4_dir_inode_operations;
 extern const struct inode_operations ext4_special_inode_operations;
@@ -2520,6 +2599,9 @@ extern struct ext4_ext_path *ext4_ext_find_extent(struct inode *, ext4_lblk_t,
                                                  struct ext4_ext_path *);
 extern void ext4_ext_drop_refs(struct ext4_ext_path *);
 extern int ext4_ext_check_inode(struct inode *inode);
+extern int ext4_find_delalloc_range(struct inode *inode,
+                                   ext4_lblk_t lblk_start,
+                                   ext4_lblk_t lblk_end);
 extern int ext4_find_delalloc_cluster(struct inode *inode, ext4_lblk_t lblk);
 extern int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                        __u64 start, __u64 len);
@@ -2537,6 +2619,7 @@ extern void ext4_exit_pageio(void);
 extern void ext4_ioend_wait(struct inode *);
 extern void ext4_free_io_end(ext4_io_end_t *io);
 extern ext4_io_end_t *ext4_init_io_end(struct inode *inode, gfp_t flags);
+extern void ext4_end_io_work(struct work_struct *work);
 extern void ext4_io_submit(struct ext4_io_submit *io);
 extern int ext4_bio_write_page(struct ext4_io_submit *io,
                               struct page *page,
index 487fda1..8643ff5 100644 (file)
@@ -193,12 +193,6 @@ static inline unsigned short ext_depth(struct inode *inode)
        return le16_to_cpu(ext_inode_hdr(inode)->eh_depth);
 }
 
-static inline void
-ext4_ext_invalidate_cache(struct inode *inode)
-{
-       EXT4_I(inode)->i_cached_extent.ec_len = 0;
-}
-
 static inline void ext4_ext_mark_uninitialized(struct ext4_extent *ext)
 {
        /* We can not have an uninitialized extent of zero length! */
index b4323ba..7058975 100644 (file)
@@ -6,6 +6,108 @@
 
 #include <trace/events/ext4.h>
 
+/* Just increment the non-pointer handle value */
+static handle_t *ext4_get_nojournal(void)
+{
+       handle_t *handle = current->journal_info;
+       unsigned long ref_cnt = (unsigned long)handle;
+
+       BUG_ON(ref_cnt >= EXT4_NOJOURNAL_MAX_REF_COUNT);
+
+       ref_cnt++;
+       handle = (handle_t *)ref_cnt;
+
+       current->journal_info = handle;
+       return handle;
+}
+
+
+/* Decrement the non-pointer handle value */
+static void ext4_put_nojournal(handle_t *handle)
+{
+       unsigned long ref_cnt = (unsigned long)handle;
+
+       BUG_ON(ref_cnt == 0);
+
+       ref_cnt--;
+       handle = (handle_t *)ref_cnt;
+
+       current->journal_info = handle;
+}
+
+/*
+ * Wrappers for jbd2_journal_start/end.
+ */
+handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,
+                                 int type, int nblocks)
+{
+       journal_t *journal;
+
+       trace_ext4_journal_start(sb, nblocks, _RET_IP_);
+       if (sb->s_flags & MS_RDONLY)
+               return ERR_PTR(-EROFS);
+
+       WARN_ON(sb->s_writers.frozen == SB_FREEZE_COMPLETE);
+       journal = EXT4_SB(sb)->s_journal;
+       if (!journal)
+               return ext4_get_nojournal();
+       /*
+        * Special case here: if the journal has aborted behind our
+        * backs (eg. EIO in the commit thread), then we still need to
+        * take the FS itself readonly cleanly.
+        */
+       if (is_journal_aborted(journal)) {
+               ext4_abort(sb, "Detected aborted journal");
+               return ERR_PTR(-EROFS);
+       }
+       return jbd2__journal_start(journal, nblocks, GFP_NOFS, type, line);
+}
+
+int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle)
+{
+       struct super_block *sb;
+       int err;
+       int rc;
+
+       if (!ext4_handle_valid(handle)) {
+               ext4_put_nojournal(handle);
+               return 0;
+       }
+       sb = handle->h_transaction->t_journal->j_private;
+       err = handle->h_err;
+       rc = jbd2_journal_stop(handle);
+
+       if (!err)
+               err = rc;
+       if (err)
+               __ext4_std_error(sb, where, line, err);
+       return err;
+}
+
+void ext4_journal_abort_handle(const char *caller, unsigned int line,
+                              const char *err_fn, struct buffer_head *bh,
+                              handle_t *handle, int err)
+{
+       char nbuf[16];
+       const char *errstr = ext4_decode_error(NULL, err, nbuf);
+
+       BUG_ON(!ext4_handle_valid(handle));
+
+       if (bh)
+               BUFFER_TRACE(bh, "abort");
+
+       if (!handle->h_err)
+               handle->h_err = err;
+
+       if (is_handle_aborted(handle))
+               return;
+
+       printk(KERN_ERR "EXT4-fs: %s:%d: aborting transaction: %s in %s\n",
+              caller, line, errstr, err_fn);
+
+       jbd2_journal_abort_handle(handle);
+}
+
 int __ext4_journal_get_write_access(const char *where, unsigned int line,
                                    handle_t *handle, struct buffer_head *bh)
 {
index 7177f9b..4c216b1 100644 (file)
 #define EXT4_META_TRANS_BLOCKS(sb)     (EXT4_XATTR_TRANS_BLOCKS + \
                                        EXT4_MAXQUOTAS_TRANS_BLOCKS(sb))
 
-/* Delete operations potentially hit one directory's namespace plus an
- * entire inode, plus arbitrary amounts of bitmap/indirection data.  Be
- * generous.  We can grow the delete transaction later if necessary. */
-
-#define EXT4_DELETE_TRANS_BLOCKS(sb)   (2 * EXT4_DATA_TRANS_BLOCKS(sb) + 64)
-
 /* Define an arbitrary limit for the amount of data we will anticipate
  * writing to any given transaction.  For unbounded transactions such as
  * write(2) and truncate(2) we can write more than this, but we always
 #define EXT4_MAXQUOTAS_INIT_BLOCKS(sb) (MAXQUOTAS*EXT4_QUOTA_INIT_BLOCKS(sb))
 #define EXT4_MAXQUOTAS_DEL_BLOCKS(sb) (MAXQUOTAS*EXT4_QUOTA_DEL_BLOCKS(sb))
 
+static inline int ext4_jbd2_credits_xattr(struct inode *inode)
+{
+       int credits = EXT4_DATA_TRANS_BLOCKS(inode->i_sb);
+
+       /*
+        * In case of inline data, we may push out the data to a block,
+        * so we need to reserve credits for this eventuality
+        */
+       if (ext4_has_inline_data(inode))
+               credits += ext4_writepage_trans_blocks(inode) + 1;
+       return credits;
+}
+
+
+/*
+ * Ext4 handle operation types -- for logging purposes
+ */
+#define EXT4_HT_MISC             0
+#define EXT4_HT_INODE            1
+#define EXT4_HT_WRITE_PAGE       2
+#define EXT4_HT_MAP_BLOCKS       3
+#define EXT4_HT_DIR              4
+#define EXT4_HT_TRUNCATE         5
+#define EXT4_HT_QUOTA            6
+#define EXT4_HT_RESIZE           7
+#define EXT4_HT_MIGRATE          8
+#define EXT4_HT_MOVE_EXTENTS     9
+#define EXT4_HT_XATTR           10
+#define EXT4_HT_MAX             11
+
 /**
  *   struct ext4_journal_cb_entry - Base structure for callback information.
  *
@@ -234,7 +258,8 @@ int __ext4_handle_dirty_super(const char *where, unsigned int line,
 #define ext4_handle_dirty_super(handle, sb) \
        __ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb))
 
-handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks);
+handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,
+                                 int type, int nblocks);
 int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle);
 
 #define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096)
@@ -268,9 +293,17 @@ static inline int ext4_handle_has_enough_credits(handle_t *handle, int needed)
        return 1;
 }
 
-static inline handle_t *ext4_journal_start(struct inode *inode, int nblocks)
+#define ext4_journal_start_sb(sb, type, nblocks)                       \
+       __ext4_journal_start_sb((sb), __LINE__, (type), (nblocks))
+
+#define ext4_journal_start(inode, type, nblocks)                       \
+       __ext4_journal_start((inode), __LINE__, (type), (nblocks))
+
+static inline handle_t *__ext4_journal_start(struct inode *inode,
+                                            unsigned int line, int type,
+                                            int nblocks)
 {
-       return ext4_journal_start_sb(inode->i_sb, nblocks);
+       return __ext4_journal_start_sb(inode->i_sb, line, type, nblocks);
 }
 
 #define ext4_journal_stop(handle) \
index 5ae1674..372b2cb 100644 (file)
@@ -112,7 +112,7 @@ static int ext4_split_extent_at(handle_t *handle,
                             int flags);
 
 static int ext4_find_delayed_extent(struct inode *inode,
-                                   struct ext4_ext_cache *newex);
+                                   struct extent_status *newes);
 
 static int ext4_ext_truncate_extend_restart(handle_t *handle,
                                            struct inode *inode,
@@ -714,7 +714,6 @@ int ext4_ext_tree_init(handle_t *handle, struct inode *inode)
        eh->eh_magic = EXT4_EXT_MAGIC;
        eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0));
        ext4_mark_inode_dirty(handle, inode);
-       ext4_ext_invalidate_cache(inode);
        return 0;
 }
 
@@ -725,6 +724,7 @@ ext4_ext_find_extent(struct inode *inode, ext4_lblk_t block,
        struct ext4_extent_header *eh;
        struct buffer_head *bh;
        short int depth, i, ppos = 0, alloc = 0;
+       int ret;
 
        eh = ext_inode_hdr(inode);
        depth = ext_depth(inode);
@@ -752,12 +752,15 @@ ext4_ext_find_extent(struct inode *inode, ext4_lblk_t block,
                path[ppos].p_ext = NULL;
 
                bh = sb_getblk(inode->i_sb, path[ppos].p_block);
-               if (unlikely(!bh))
+               if (unlikely(!bh)) {
+                       ret = -ENOMEM;
                        goto err;
+               }
                if (!bh_uptodate_or_lock(bh)) {
                        trace_ext4_ext_load_extent(inode, block,
                                                path[ppos].p_block);
-                       if (bh_submit_read(bh) < 0) {
+                       ret = bh_submit_read(bh);
+                       if (ret < 0) {
                                put_bh(bh);
                                goto err;
                        }
@@ -768,13 +771,15 @@ ext4_ext_find_extent(struct inode *inode, ext4_lblk_t block,
                        put_bh(bh);
                        EXT4_ERROR_INODE(inode,
                                         "ppos %d > depth %d", ppos, depth);
+                       ret = -EIO;
                        goto err;
                }
                path[ppos].p_bh = bh;
                path[ppos].p_hdr = eh;
                i--;
 
-               if (ext4_ext_check_block(inode, eh, i, bh))
+               ret = ext4_ext_check_block(inode, eh, i, bh);
+               if (ret < 0)
                        goto err;
        }
 
@@ -796,7 +801,7 @@ err:
        ext4_ext_drop_refs(path);
        if (alloc)
                kfree(path);
-       return ERR_PTR(-EIO);
+       return ERR_PTR(ret);
 }
 
 /*
@@ -950,8 +955,8 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
                goto cleanup;
        }
        bh = sb_getblk(inode->i_sb, newblock);
-       if (!bh) {
-               err = -EIO;
+       if (unlikely(!bh)) {
+               err = -ENOMEM;
                goto cleanup;
        }
        lock_buffer(bh);
@@ -1023,8 +1028,8 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
                oldblock = newblock;
                newblock = ablocks[--a];
                bh = sb_getblk(inode->i_sb, newblock);
-               if (!bh) {
-                       err = -EIO;
+               if (unlikely(!bh)) {
+                       err = -ENOMEM;
                        goto cleanup;
                }
                lock_buffer(bh);
@@ -1136,11 +1141,8 @@ static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
                return err;
 
        bh = sb_getblk(inode->i_sb, newblock);
-       if (!bh) {
-               err = -EIO;
-               ext4_std_error(inode->i_sb, err);
-               return err;
-       }
+       if (unlikely(!bh))
+               return -ENOMEM;
        lock_buffer(bh);
 
        err = ext4_journal_get_create_access(handle, bh);
@@ -1960,7 +1962,6 @@ cleanup:
                ext4_ext_drop_refs(npath);
                kfree(npath);
        }
-       ext4_ext_invalidate_cache(inode);
        return err;
 }
 
@@ -1969,8 +1970,8 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
                                    struct fiemap_extent_info *fieinfo)
 {
        struct ext4_ext_path *path = NULL;
-       struct ext4_ext_cache newex;
        struct ext4_extent *ex;
+       struct extent_status es;
        ext4_lblk_t next, next_del, start = 0, end = 0;
        ext4_lblk_t last = block + num;
        int exists, depth = 0, err = 0;
@@ -2044,37 +2045,47 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
                BUG_ON(end <= start);
 
                if (!exists) {
-                       newex.ec_block = start;
-                       newex.ec_len = end - start;
-                       newex.ec_start = 0;
+                       es.es_lblk = start;
+                       es.es_len = end - start;
+                       es.es_pblk = 0;
                } else {
-                       newex.ec_block = le32_to_cpu(ex->ee_block);
-                       newex.ec_len = ext4_ext_get_actual_len(ex);
-                       newex.ec_start = ext4_ext_pblock(ex);
+                       es.es_lblk = le32_to_cpu(ex->ee_block);
+                       es.es_len = ext4_ext_get_actual_len(ex);
+                       es.es_pblk = ext4_ext_pblock(ex);
                        if (ext4_ext_is_uninitialized(ex))
                                flags |= FIEMAP_EXTENT_UNWRITTEN;
                }
 
                /*
-                * Find delayed extent and update newex accordingly. We call
-                * it even in !exists case to find out whether newex is the
+                * Find delayed extent and update es accordingly. We call
+                * it even in !exists case to find out whether es is the
                 * last existing extent or not.
                 */
-               next_del = ext4_find_delayed_extent(inode, &newex);
+               next_del = ext4_find_delayed_extent(inode, &es);
                if (!exists && next_del) {
                        exists = 1;
                        flags |= FIEMAP_EXTENT_DELALLOC;
                }
                up_read(&EXT4_I(inode)->i_data_sem);
 
-               if (unlikely(newex.ec_len == 0)) {
-                       EXT4_ERROR_INODE(inode, "newex.ec_len == 0");
+               if (unlikely(es.es_len == 0)) {
+                       EXT4_ERROR_INODE(inode, "es.es_len == 0");
                        err = -EIO;
                        break;
                }
 
-               /* This is possible iff next == next_del == EXT_MAX_BLOCKS */
-               if (next == next_del) {
+               /*
+                * This is possible iff next == next_del == EXT_MAX_BLOCKS.
+                * we need to check next == EXT_MAX_BLOCKS because it is
+                * possible that an extent is with unwritten and delayed
+                * status due to when an extent is delayed allocated and
+                * is allocated by fallocate status tree will track both of
+                * them in a extent.
+                *
+                * So we could return a unwritten and delayed extent, and
+                * its block is equal to 'next'.
+                */
+               if (next == next_del && next == EXT_MAX_BLOCKS) {
                        flags |= FIEMAP_EXTENT_LAST;
                        if (unlikely(next_del != EXT_MAX_BLOCKS ||
                                     next != EXT_MAX_BLOCKS)) {
@@ -2089,9 +2100,9 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
 
                if (exists) {
                        err = fiemap_fill_next_extent(fieinfo,
-                               (__u64)newex.ec_block << blksize_bits,
-                               (__u64)newex.ec_start << blksize_bits,
-                               (__u64)newex.ec_len << blksize_bits,
+                               (__u64)es.es_lblk << blksize_bits,
+                               (__u64)es.es_pblk << blksize_bits,
+                               (__u64)es.es_len << blksize_bits,
                                flags);
                        if (err < 0)
                                break;
@@ -2101,7 +2112,7 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
                        }
                }
 
-               block = newex.ec_block + newex.ec_len;
+               block = es.es_lblk + es.es_len;
        }
 
        if (path) {
@@ -2112,21 +2123,6 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
        return err;
 }
 
-static void
-ext4_ext_put_in_cache(struct inode *inode, ext4_lblk_t block,
-                       __u32 len, ext4_fsblk_t start)
-{
-       struct ext4_ext_cache *cex;
-       BUG_ON(len == 0);
-       spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
-       trace_ext4_ext_put_in_cache(inode, block, len, start);
-       cex = &EXT4_I(inode)->i_cached_extent;
-       cex->ec_block = block;
-       cex->ec_len = len;
-       cex->ec_start = start;
-       spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
-}
-
 /*
  * ext4_ext_put_gap_in_cache:
  * calculate boundaries of the gap that the requested block fits into
@@ -2143,9 +2139,10 @@ ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,
 
        ex = path[depth].p_ext;
        if (ex == NULL) {
-               /* there is no extent yet, so gap is [0;-] */
-               lblock = 0;
-               len = EXT_MAX_BLOCKS;
+               /*
+                * there is no extent yet, so gap is [0;-] and we
+                * don't cache it
+                */
                ext_debug("cache gap(whole file):");
        } else if (block < le32_to_cpu(ex->ee_block)) {
                lblock = block;
@@ -2154,6 +2151,9 @@ ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,
                                block,
                                le32_to_cpu(ex->ee_block),
                                 ext4_ext_get_actual_len(ex));
+               if (!ext4_find_delalloc_range(inode, lblock, lblock + len - 1))
+                       ext4_es_insert_extent(inode, lblock, len, ~0,
+                                             EXTENT_STATUS_HOLE);
        } else if (block >= le32_to_cpu(ex->ee_block)
                        + ext4_ext_get_actual_len(ex)) {
                ext4_lblk_t next;
@@ -2167,58 +2167,15 @@ ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,
                                block);
                BUG_ON(next == lblock);
                len = next - lblock;
+               if (!ext4_find_delalloc_range(inode, lblock, lblock + len - 1))
+                       ext4_es_insert_extent(inode, lblock, len, ~0,
+                                             EXTENT_STATUS_HOLE);
        } else {
                lblock = len = 0;
                BUG();
        }
 
        ext_debug(" -> %u:%lu\n", lblock, len);
-       ext4_ext_put_in_cache(inode, lblock, len, 0);
-}
-
-/*
- * ext4_ext_in_cache()
- * Checks to see if the given block is in the cache.
- * If it is, the cached extent is stored in the given
- * cache extent pointer.
- *
- * @inode: The files inode
- * @block: The block to look for in the cache
- * @ex:    Pointer where the cached extent will be stored
- *         if it contains block
- *
- * Return 0 if cache is invalid; 1 if the cache is valid
- */
-static int
-ext4_ext_in_cache(struct inode *inode, ext4_lblk_t block,
-                 struct ext4_extent *ex)
-{
-       struct ext4_ext_cache *cex;
-       int ret = 0;
-
-       /*
-        * We borrow i_block_reservation_lock to protect i_cached_extent
-        */
-       spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
-       cex = &EXT4_I(inode)->i_cached_extent;
-
-       /* has cache valid data? */
-       if (cex->ec_len == 0)
-               goto errout;
-
-       if (in_range(block, cex->ec_block, cex->ec_len)) {
-               ex->ee_block = cpu_to_le32(cex->ec_block);
-               ext4_ext_store_pblock(ex, cex->ec_start);
-               ex->ee_len = cpu_to_le16(cex->ec_len);
-               ext_debug("%u cached by %u:%u:%llu\n",
-                               block,
-                               cex->ec_block, cex->ec_len, cex->ec_start);
-               ret = 1;
-       }
-errout:
-       trace_ext4_ext_in_cache(inode, block, ret);
-       spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
-       return ret;
 }
 
 /*
@@ -2653,13 +2610,11 @@ static int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
        ext_debug("truncate since %u to %u\n", start, end);
 
        /* probably first extent we're gonna free will be last in block */
-       handle = ext4_journal_start(inode, depth + 1);
+       handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, depth + 1);
        if (IS_ERR(handle))
                return PTR_ERR(handle);
 
 again:
-       ext4_ext_invalidate_cache(inode);
-
        trace_ext4_ext_remove_space(inode, start, depth);
 
        /*
@@ -3519,19 +3474,19 @@ out:
  *
  * Return 1 if there is a delalloc block in the range, otherwise 0.
  */
-static int ext4_find_delalloc_range(struct inode *inode,
-                                   ext4_lblk_t lblk_start,
-                                   ext4_lblk_t lblk_end)
+int ext4_find_delalloc_range(struct inode *inode,
+                            ext4_lblk_t lblk_start,
+                            ext4_lblk_t lblk_end)
 {
        struct extent_status es;
 
-       es.start = lblk_start;
-       ext4_es_find_extent(inode, &es);
-       if (es.len == 0)
+       ext4_es_find_delayed_extent(inode, lblk_start, &es);
+       if (es.es_len == 0)
                return 0; /* there is no delay extent in this tree */
-       else if (es.start <= lblk_start && lblk_start < es.start + es.len)
+       else if (es.es_lblk <= lblk_start &&
+                lblk_start < es.es_lblk + es.es_len)
                return 1;
-       else if (lblk_start <= es.start && es.start <= lblk_end)
+       else if (lblk_start <= es.es_lblk && es.es_lblk <= lblk_end)
                return 1;
        else
                return 0;
@@ -3656,6 +3611,7 @@ ext4_ext_handle_uninitialized_extents(handle_t *handle, struct inode *inode,
                        ext4_set_io_unwritten_flag(inode, io);
                else
                        ext4_set_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
+               map->m_flags |= EXT4_MAP_UNWRITTEN;
                if (ext4_should_dioread_nolock(inode))
                        map->m_flags |= EXT4_MAP_UNINIT;
                goto out;
@@ -3677,8 +3633,10 @@ ext4_ext_handle_uninitialized_extents(handle_t *handle, struct inode *inode,
         * repeat fallocate creation request
         * we already have an unwritten extent
         */
-       if (flags & EXT4_GET_BLOCKS_UNINIT_EXT)
+       if (flags & EXT4_GET_BLOCKS_UNINIT_EXT) {
+               map->m_flags |= EXT4_MAP_UNWRITTEN;
                goto map_out;
+       }
 
        /* buffered READ or buffered write_begin() lookup */
        if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
@@ -3898,35 +3856,6 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
                  map->m_lblk, map->m_len, inode->i_ino);
        trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags);
 
-       /* check in cache */
-       if (ext4_ext_in_cache(inode, map->m_lblk, &newex)) {
-               if (!newex.ee_start_lo && !newex.ee_start_hi) {
-                       if ((sbi->s_cluster_ratio > 1) &&
-                           ext4_find_delalloc_cluster(inode, map->m_lblk))
-                               map->m_flags |= EXT4_MAP_FROM_CLUSTER;
-
-                       if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
-                               /*
-                                * block isn't allocated yet and
-                                * user doesn't want to allocate it
-                                */
-                               goto out2;
-                       }
-                       /* we should allocate requested block */
-               } else {
-                       /* block is already allocated */
-                       if (sbi->s_cluster_ratio > 1)
-                               map->m_flags |= EXT4_MAP_FROM_CLUSTER;
-                       newblock = map->m_lblk
-                                  - le32_to_cpu(newex.ee_block)
-                                  + ext4_ext_pblock(&newex);
-                       /* number of remaining blocks in the extent */
-                       allocated = ext4_ext_get_actual_len(&newex) -
-                               (map->m_lblk - le32_to_cpu(newex.ee_block));
-                       goto out;
-               }
-       }
-
        /* find extent for this block */
        path = ext4_ext_find_extent(inode, map->m_lblk, NULL);
        if (IS_ERR(path)) {
@@ -3973,15 +3902,9 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
                        ext_debug("%u fit into %u:%d -> %llu\n", map->m_lblk,
                                  ee_block, ee_len, newblock);
 
-                       /*
-                        * Do not put uninitialized extent
-                        * in the cache
-                        */
-                       if (!ext4_ext_is_uninitialized(ex)) {
-                               ext4_ext_put_in_cache(inode, ee_block,
-                                       ee_len, ee_start);
+                       if (!ext4_ext_is_uninitialized(ex))
                                goto out;
-                       }
+
                        allocated = ext4_ext_handle_uninitialized_extents(
                                handle, inode, map, path, flags,
                                allocated, newblock);
@@ -4002,7 +3925,8 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
                 * put just found gap into cache to speed up
                 * subsequent requests
                 */
-               ext4_ext_put_gap_in_cache(inode, path, map->m_lblk);
+               if ((flags & EXT4_GET_BLOCKS_NO_PUT_HOLE) == 0)
+                       ext4_ext_put_gap_in_cache(inode, path, map->m_lblk);
                goto out2;
        }
 
@@ -4108,6 +4032,7 @@ got_allocated_blocks:
        /* Mark uninitialized */
        if (flags & EXT4_GET_BLOCKS_UNINIT_EXT){
                ext4_ext_mark_uninitialized(&newex);
+               map->m_flags |= EXT4_MAP_UNWRITTEN;
                /*
                 * io_end structure was created for every IO write to an
                 * uninitialized extent. To avoid unnecessary conversion,
@@ -4241,10 +4166,9 @@ got_allocated_blocks:
         * Cache the extent and update transaction to commit on fdatasync only
         * when it is _not_ an uninitialized extent.
         */
-       if ((flags & EXT4_GET_BLOCKS_UNINIT_EXT) == 0) {
-               ext4_ext_put_in_cache(inode, map->m_lblk, allocated, newblock);
+       if ((flags & EXT4_GET_BLOCKS_UNINIT_EXT) == 0)
                ext4_update_inode_fsync_trans(handle, inode, 1);
-       else
+       else
                ext4_update_inode_fsync_trans(handle, inode, 0);
 out:
        if (allocated > map->m_len)
@@ -4284,7 +4208,7 @@ void ext4_ext_truncate(struct inode *inode)
         * probably first extent we're gonna free will be last in block
         */
        err = ext4_writepage_trans_blocks(inode);
-       handle = ext4_journal_start(inode, err);
+       handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, err);
        if (IS_ERR(handle))
                return;
 
@@ -4303,7 +4227,6 @@ void ext4_ext_truncate(struct inode *inode)
                goto out_stop;
 
        down_write(&EXT4_I(inode)->i_data_sem);
-       ext4_ext_invalidate_cache(inode);
 
        ext4_discard_preallocations(inode);
 
@@ -4397,13 +4320,6 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
        struct ext4_map_blocks map;
        unsigned int credits, blkbits = inode->i_blkbits;
 
-       /*
-        * currently supporting (pre)allocate mode for extent-based
-        * files _only_
-        */
-       if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
-               return -EOPNOTSUPP;
-
        /* Return error if mode is not supported */
        if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
                return -EOPNOTSUPP;
@@ -4415,6 +4331,13 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
        if (ret)
                return ret;
 
+       /*
+        * currently supporting (pre)allocate mode for extent-based
+        * files _only_
+        */
+       if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
+               return -EOPNOTSUPP;
+
        trace_ext4_fallocate_enter(inode, offset, len, mode);
        map.m_lblk = offset >> blkbits;
        /*
@@ -4451,7 +4374,8 @@ retry:
        while (ret >= 0 && ret < max_blocks) {
                map.m_lblk = map.m_lblk + ret;
                map.m_len = max_blocks = max_blocks - ret;
-               handle = ext4_journal_start(inode, credits);
+               handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
+                                           credits);
                if (IS_ERR(handle)) {
                        ret = PTR_ERR(handle);
                        break;
@@ -4459,11 +4383,11 @@ retry:
                ret = ext4_map_blocks(handle, inode, &map, flags);
                if (ret <= 0) {
 #ifdef EXT4FS_DEBUG
-                       WARN_ON(ret <= 0);
-                       printk(KERN_ERR "%s: ext4_ext_map_blocks "
-                                   "returned error inode#%lu, block=%u, "
-                                   "max_blocks=%u", __func__,
-                                   inode->i_ino, map.m_lblk, max_blocks);
+                       ext4_warning(inode->i_sb,
+                                    "inode #%lu: block %u: len %u: "
+                                    "ext4_ext_map_blocks returned %d",
+                                    inode->i_ino, map.m_lblk,
+                                    map.m_len, ret);
 #endif
                        ext4_mark_inode_dirty(handle, inode);
                        ret2 = ext4_journal_stop(handle);
@@ -4529,21 +4453,19 @@ int ext4_convert_unwritten_extents(struct inode *inode, loff_t offset,
        while (ret >= 0 && ret < max_blocks) {
                map.m_lblk += ret;
                map.m_len = (max_blocks -= ret);
-               handle = ext4_journal_start(inode, credits);
+               handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, credits);
                if (IS_ERR(handle)) {
                        ret = PTR_ERR(handle);
                        break;
                }
                ret = ext4_map_blocks(handle, inode, &map,
                                      EXT4_GET_BLOCKS_IO_CONVERT_EXT);
-               if (ret <= 0) {
-                       WARN_ON(ret <= 0);
-                       ext4_msg(inode->i_sb, KERN_ERR,
-                                "%s:%d: inode #%lu: block %u: len %u: "
-                                "ext4_ext_map_blocks returned %d",
-                                __func__, __LINE__, inode->i_ino, map.m_lblk,
-                                map.m_len, ret);
-               }
+               if (ret <= 0)
+                       ext4_warning(inode->i_sb,
+                                    "inode #%lu: block %u: len %u: "
+                                    "ext4_ext_map_blocks returned %d",
+                                    inode->i_ino, map.m_lblk,
+                                    map.m_len, ret);
                ext4_mark_inode_dirty(handle, inode);
                ret2 = ext4_journal_stop(handle);
                if (ret <= 0 || ret2 )
@@ -4553,42 +4475,48 @@ int ext4_convert_unwritten_extents(struct inode *inode, loff_t offset,
 }
 
 /*
- * If newex is not existing extent (newex->ec_start equals zero) find
- * delayed extent at start of newex and update newex accordingly and
+ * If newes is not existing extent (newes->ec_pblk equals zero) find
+ * delayed extent at start of newes and update newes accordingly and
  * return start of the next delayed extent.
  *
- * If newex is existing extent (newex->ec_start is not equal zero)
+ * If newes is existing extent (newes->ec_pblk is not equal zero)
  * return start of next delayed extent or EXT_MAX_BLOCKS if no delayed
- * extent found. Leave newex unmodified.
+ * extent found. Leave newes unmodified.
  */
 static int ext4_find_delayed_extent(struct inode *inode,
-                                   struct ext4_ext_cache *newex)
+                                   struct extent_status *newes)
 {
        struct extent_status es;
-       ext4_lblk_t next_del;
+       ext4_lblk_t block, next_del;
 
-       es.start = newex->ec_block;
-       next_del = ext4_es_find_extent(inode, &es);
+       ext4_es_find_delayed_extent(inode, newes->es_lblk, &es);
 
-       if (newex->ec_start == 0) {
+       if (newes->es_pblk == 0) {
                /*
-                * No extent in extent-tree contains block @newex->ec_start,
+                * No extent in extent-tree contains block @newes->es_pblk,
                 * then the block may stay in 1)a hole or 2)delayed-extent.
                 */
-               if (es.len == 0)
+               if (es.es_len == 0)
                        /* A hole found. */
                        return 0;
 
-               if (es.start > newex->ec_block) {
+               if (es.es_lblk > newes->es_lblk) {
                        /* A hole found. */
-                       newex->ec_len = min(es.start - newex->ec_block,
-                                           newex->ec_len);
+                       newes->es_len = min(es.es_lblk - newes->es_lblk,
+                                           newes->es_len);
                        return 0;
                }
 
-               newex->ec_len = es.start + es.len - newex->ec_block;
+               newes->es_len = es.es_lblk + es.es_len - newes->es_lblk;
        }
 
+       block = newes->es_lblk + newes->es_len;
+       ext4_es_find_delayed_extent(inode, block, &es);
+       if (es.es_len == 0)
+               next_del = EXT_MAX_BLOCKS;
+       else
+               next_del = es.es_lblk;
+
        return next_del;
 }
 /* fiemap flags we can handle specified here */
@@ -4709,7 +4637,7 @@ int ext4_ext_punch_hole(struct file *file, loff_t offset, loff_t length)
        inode_dio_wait(inode);
 
        credits = ext4_writepage_trans_blocks(inode);
-       handle = ext4_journal_start(inode, credits);
+       handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
        if (IS_ERR(handle)) {
                err = PTR_ERR(handle);
                goto out_dio;
@@ -4786,14 +4714,12 @@ int ext4_ext_punch_hole(struct file *file, loff_t offset, loff_t length)
                goto out;
 
        down_write(&EXT4_I(inode)->i_data_sem);
-       ext4_ext_invalidate_cache(inode);
        ext4_discard_preallocations(inode);
 
        err = ext4_es_remove_extent(inode, first_block,
                                    stop_block - first_block);
        err = ext4_ext_remove_space(inode, first_block, stop_block - 1);
 
-       ext4_ext_invalidate_cache(inode);
        ext4_discard_preallocations(inode);
 
        if (IS_SYNC(inode))
index 564d981..f768f4a 100644 (file)
  * (e.g. Reservation space warning), and provide extent-level locking.
  * Delay extent tree is the first step to achieve this goal.  It is
  * original built by Yongqiang Yang.  At that time it is called delay
- * extent tree, whose goal is only track delay extent in memory to
+ * extent tree, whose goal is only track delayed extents in memory to
  * simplify the implementation of fiemap and bigalloc, and introduce
  * lseek SEEK_DATA/SEEK_HOLE support.  That is why it is still called
- * delay extent tree at the following comment.  But for better
- * understand what it does, it has been rename to extent status tree.
+ * delay extent tree at the first commit.  But for better understand
+ * what it does, it has been rename to extent status tree.
  *
- * Currently the first step has been done.  All delay extents are
- * tracked in the tree.  It maintains the delay extent when a delay
- * allocation is issued, and the delay extent is written out or
+ * Step1:
+ * Currently the first step has been done.  All delayed extents are
+ * tracked in the tree.  It maintains the delayed extent when a delayed
+ * allocation is issued, and the delayed extent is written out or
  * invalidated.  Therefore the implementation of fiemap and bigalloc
  * are simplified, and SEEK_DATA/SEEK_HOLE are introduced.
  *
  * The following comment describes the implemenmtation of extent
  * status tree and future works.
+ *
+ * Step2:
+ * In this step all extent status are tracked by extent status tree.
+ * Thus, we can first try to lookup a block mapping in this tree before
+ * finding it in extent tree.  Hence, single extent cache can be removed
+ * because extent status tree can do a better job.  Extents in status
+ * tree are loaded on-demand.  Therefore, the extent status tree may not
+ * contain all of the extents in a file.  Meanwhile we define a shrinker
+ * to reclaim memory from extent status tree because fragmented extent
+ * tree will make status tree cost too much memory.  written/unwritten/-
+ * hole extents in the tree will be reclaimed by this shrinker when we
+ * are under high memory pressure.  Delayed extents will not be
+ * reclimed because fiemap, bigalloc, and seek_data/hole need it.
  */
 
 /*
- * extents status tree implementation for ext4.
+ * Extent status tree implementation for ext4.
  *
  *
  * ==========================================================================
- * Extents status encompass delayed extents and extent locks
+ * Extent status tree tracks all extent status.
  *
- * 1. Why delayed extent implementation ?
+ * 1. Why we need to implement extent status tree?
  *
- * Without delayed extent, ext4 identifies a delayed extent by looking
+ * Without extent status tree, ext4 identifies a delayed extent by looking
  * up page cache, this has several deficiencies - complicated, buggy,
  * and inefficient code.
  *
- * FIEMAP, SEEK_HOLE/DATA, bigalloc, punch hole and writeout all need
- * to know if a block or a range of blocks are belonged to a delayed
- * extent.
+ * FIEMAP, SEEK_HOLE/DATA, bigalloc, and writeout all need to know if a
+ * block or a range of blocks are belonged to a delayed extent.
  *
- * Let us have a look at how they do without delayed extents implementation.
+ * Let us have a look at how they do without extent status tree.
  *   --        FIEMAP
  *     FIEMAP looks up page cache to identify delayed allocations from holes.
  *
  *     already under delayed allocation or not to determine whether
  *     quota reserving is needed for the cluster.
  *
- *   -- punch hole
- *     punch hole looks up page cache to identify a delayed extent.
- *
  *   --        writeout
  *     Writeout looks up whole page cache to see if a buffer is
  *     mapped, If there are not very many delayed buffers, then it is
  *     time comsuming.
  *
- * With delayed extents implementation, FIEMAP, SEEK_HOLE/DATA,
+ * With extent status tree implementation, FIEMAP, SEEK_HOLE/DATA,
  * bigalloc and writeout can figure out if a block or a range of
  * blocks is under delayed allocation(belonged to a delayed extent) or
- * not by searching the delayed extent tree.
+ * not by searching the extent tree.
  *
  *
  * ==========================================================================
- * 2. ext4 delayed extents impelmentation
+ * 2. Ext4 extent status tree impelmentation
+ *
+ *   --        extent
+ *     A extent is a range of blocks which are contiguous logically and
+ *     physically.  Unlike extent in extent tree, this extent in ext4 is
+ *     a in-memory struct, there is no corresponding on-disk data.  There
+ *     is no limit on length of extent, so an extent can contain as many
+ *     blocks as they are contiguous logically and physically.
  *
- *   --        delayed extent
- *     A delayed extent is a range of blocks which are contiguous
- *     logically and under delayed allocation.  Unlike extent in
- *     ext4, delayed extent in ext4 is a in-memory struct, there is
- *     no corresponding on-disk data.  There is no limit on length of
- *     delayed extent, so a delayed extent can contain as many blocks
- *     as they are contiguous logically.
+ *   --        extent status tree
+ *     Every inode has an extent status tree and all allocation blocks
+ *     are added to the tree with different status.  The extent in the
+ *     tree are ordered by logical block no.
  *
- *   --        delayed extent tree
- *     Every inode has a delayed extent tree and all under delayed
- *     allocation blocks are added to the tree as delayed extents.
- *     Delayed extents in the tree are ordered by logical block no.
+ *   --        operations on a extent status tree
+ *     There are three important operations on a delayed extent tree: find
+ *     next extent, adding a extent(a range of blocks) and removing a extent.
  *
- *   --        operations on a delayed extent tree
- *     There are three operations on a delayed extent tree: find next
- *     delayed extent, adding a space(a range of blocks) and removing
- *     a space.
+ *   --        race on a extent status tree
+ *     Extent status tree is protected by inode->i_es_lock.
  *
- *   --        race on a delayed extent tree
- *     Delayed extent tree is protected inode->i_es_lock.
+ *   --        memory consumption
+ *      Fragmented extent tree will make extent status tree cost too much
+ *      memory.  Hence, we will reclaim written/unwritten/hole extents from
+ *      the tree under a heavy memory pressure.
  *
  *
  * ==========================================================================
- * 3. performance analysis
+ * 3. Performance analysis
+ *
  *   --        overhead
  *     1. There is a cache extent for write access, so if writes are
  *     not very random, adding space operaions are in O(1) time.
  *
  * ==========================================================================
  * 4. TODO list
- *   -- Track all extent status
  *
- *   -- Improve get block process
+ *   -- Refactor delayed space reservation
  *
  *   -- Extent-level locking
  */
 
 static struct kmem_cache *ext4_es_cachep;
 
+static int __es_insert_extent(struct inode *inode, struct extent_status *newes);
+static int __es_remove_extent(struct inode *inode, ext4_lblk_t lblk,
+                             ext4_lblk_t end);
+static int __es_try_to_reclaim_extents(struct ext4_inode_info *ei,
+                                      int nr_to_scan);
+static int ext4_es_reclaim_extents_count(struct super_block *sb);
+
 int __init ext4_init_es(void)
 {
        ext4_es_cachep = KMEM_CACHE(extent_status, SLAB_RECLAIM_ACCOUNT);
@@ -161,7 +181,9 @@ static void ext4_es_print_tree(struct inode *inode)
        while (node) {
                struct extent_status *es;
                es = rb_entry(node, struct extent_status, rb_node);
-               printk(KERN_DEBUG " [%u/%u)", es->start, es->len);
+               printk(KERN_DEBUG " [%u/%u) %llu %llx",
+                      es->es_lblk, es->es_len,
+                      ext4_es_pblock(es), ext4_es_status(es));
                node = rb_next(node);
        }
        printk(KERN_DEBUG "\n");
@@ -170,10 +192,10 @@ static void ext4_es_print_tree(struct inode *inode)
 #define ext4_es_print_tree(inode)
 #endif
 
-static inline ext4_lblk_t extent_status_end(struct extent_status *es)
+static inline ext4_lblk_t ext4_es_end(struct extent_status *es)
 {
-       BUG_ON(es->start + es->len < es->start);
-       return es->start + es->len - 1;
+       BUG_ON(es->es_lblk + es->es_len < es->es_lblk);
+       return es->es_lblk + es->es_len - 1;
 }
 
 /*
@@ -181,25 +203,25 @@ static inline ext4_lblk_t extent_status_end(struct extent_status *es)
  * it can't be found, try to find next extent.
  */
 static struct extent_status *__es_tree_search(struct rb_root *root,
-                                             ext4_lblk_t offset)
+                                             ext4_lblk_t lblk)
 {
        struct rb_node *node = root->rb_node;
        struct extent_status *es = NULL;
 
        while (node) {
                es = rb_entry(node, struct extent_status, rb_node);
-               if (offset < es->start)
+               if (lblk < es->es_lblk)
                        node = node->rb_left;
-               else if (offset > extent_status_end(es))
+               else if (lblk > ext4_es_end(es))
                        node = node->rb_right;
                else
                        return es;
        }
 
-       if (es && offset < es->start)
+       if (es && lblk < es->es_lblk)
                return es;
 
-       if (es && offset > extent_status_end(es)) {
+       if (es && lblk > ext4_es_end(es)) {
                node = rb_next(&es->rb_node);
                return node ? rb_entry(node, struct extent_status, rb_node) :
                              NULL;
@@ -209,79 +231,121 @@ static struct extent_status *__es_tree_search(struct rb_root *root,
 }
 
 /*
- * ext4_es_find_extent: find the 1st delayed extent covering @es->start
- * if it exists, otherwise, the next extent after @es->start.
+ * ext4_es_find_delayed_extent: find the 1st delayed extent covering @es->lblk
+ * if it exists, otherwise, the next extent after @es->lblk.
  *
  * @inode: the inode which owns delayed extents
+ * @lblk: the offset where we start to search
  * @es: delayed extent that we found
- *
- * Returns the first block of the next extent after es, otherwise
- * EXT_MAX_BLOCKS if no delay extent is found.
- * Delayed extent is returned via @es.
  */
-ext4_lblk_t ext4_es_find_extent(struct inode *inode, struct extent_status *es)
+void ext4_es_find_delayed_extent(struct inode *inode, ext4_lblk_t lblk,
+                                struct extent_status *es)
 {
        struct ext4_es_tree *tree = NULL;
        struct extent_status *es1 = NULL;
        struct rb_node *node;
-       ext4_lblk_t ret = EXT_MAX_BLOCKS;
 
-       trace_ext4_es_find_extent_enter(inode, es->start);
+       BUG_ON(es == NULL);
+       trace_ext4_es_find_delayed_extent_enter(inode, lblk);
 
        read_lock(&EXT4_I(inode)->i_es_lock);
        tree = &EXT4_I(inode)->i_es_tree;
 
-       /* find delay extent in cache firstly */
+       /* find extent in cache firstly */
+       es->es_lblk = es->es_len = es->es_pblk = 0;
        if (tree->cache_es) {
                es1 = tree->cache_es;
-               if (in_range(es->start, es1->start, es1->len)) {
-                       es_debug("%u cached by [%u/%u)\n",
-                                es->start, es1->start, es1->len);
+               if (in_range(lblk, es1->es_lblk, es1->es_len)) {
+                       es_debug("%u cached by [%u/%u) %llu %llx\n",
+                                lblk, es1->es_lblk, es1->es_len,
+                                ext4_es_pblock(es1), ext4_es_status(es1));
                        goto out;
                }
        }
 
-       es->len = 0;
-       es1 = __es_tree_search(&tree->root, es->start);
+       es1 = __es_tree_search(&tree->root, lblk);
 
 out:
-       if (es1) {
-               tree->cache_es = es1;
-               es->start = es1->start;
-               es->len = es1->len;
-               node = rb_next(&es1->rb_node);
-               if (node) {
+       if (es1 && !ext4_es_is_delayed(es1)) {
+               while ((node = rb_next(&es1->rb_node)) != NULL) {
                        es1 = rb_entry(node, struct extent_status, rb_node);
-                       ret = es1->start;
+                       if (ext4_es_is_delayed(es1))
+                               break;
                }
        }
 
+       if (es1 && ext4_es_is_delayed(es1)) {
+               tree->cache_es = es1;
+               es->es_lblk = es1->es_lblk;
+               es->es_len = es1->es_len;
+               es->es_pblk = es1->es_pblk;
+       }
+
        read_unlock(&EXT4_I(inode)->i_es_lock);
 
-       trace_ext4_es_find_extent_exit(inode, es, ret);
-       return ret;
+       ext4_es_lru_add(inode);
+       trace_ext4_es_find_delayed_extent_exit(inode, es);
 }
 
 static struct extent_status *
-ext4_es_alloc_extent(ext4_lblk_t start, ext4_lblk_t len)
+ext4_es_alloc_extent(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len,
+                    ext4_fsblk_t pblk)
 {
        struct extent_status *es;
        es = kmem_cache_alloc(ext4_es_cachep, GFP_ATOMIC);
        if (es == NULL)
                return NULL;
-       es->start = start;
-       es->len = len;
+       es->es_lblk = lblk;
+       es->es_len = len;
+       es->es_pblk = pblk;
+
+       /*
+        * We don't count delayed extent because we never try to reclaim them
+        */
+       if (!ext4_es_is_delayed(es))
+               EXT4_I(inode)->i_es_lru_nr++;
+
        return es;
 }
 
-static void ext4_es_free_extent(struct extent_status *es)
+static void ext4_es_free_extent(struct inode *inode, struct extent_status *es)
 {
+       /* Decrease the lru counter when this es is not delayed */
+       if (!ext4_es_is_delayed(es)) {
+               BUG_ON(EXT4_I(inode)->i_es_lru_nr == 0);
+               EXT4_I(inode)->i_es_lru_nr--;
+       }
+
        kmem_cache_free(ext4_es_cachep, es);
 }
 
+/*
+ * Check whether or not two extents can be merged
+ * Condition:
+ *  - logical block number is contiguous
+ *  - physical block number is contiguous
+ *  - status is equal
+ */
+static int ext4_es_can_be_merged(struct extent_status *es1,
+                                struct extent_status *es2)
+{
+       if (es1->es_lblk + es1->es_len != es2->es_lblk)
+               return 0;
+
+       if (ext4_es_status(es1) != ext4_es_status(es2))
+               return 0;
+
+       if ((ext4_es_is_written(es1) || ext4_es_is_unwritten(es1)) &&
+           (ext4_es_pblock(es1) + es1->es_len != ext4_es_pblock(es2)))
+               return 0;
+
+       return 1;
+}
+
 static struct extent_status *
-ext4_es_try_to_merge_left(struct ext4_es_tree *tree, struct extent_status *es)
+ext4_es_try_to_merge_left(struct inode *inode, struct extent_status *es)
 {
+       struct ext4_es_tree *tree = &EXT4_I(inode)->i_es_tree;
        struct extent_status *es1;
        struct rb_node *node;
 
@@ -290,10 +354,10 @@ ext4_es_try_to_merge_left(struct ext4_es_tree *tree, struct extent_status *es)
                return es;
 
        es1 = rb_entry(node, struct extent_status, rb_node);
-       if (es->start == extent_status_end(es1) + 1) {
-               es1->len += es->len;
+       if (ext4_es_can_be_merged(es1, es)) {
+               es1->es_len += es->es_len;
                rb_erase(&es->rb_node, &tree->root);
-               ext4_es_free_extent(es);
+               ext4_es_free_extent(inode, es);
                es = es1;
        }
 
@@ -301,8 +365,9 @@ ext4_es_try_to_merge_left(struct ext4_es_tree *tree, struct extent_status *es)
 }
 
 static struct extent_status *
-ext4_es_try_to_merge_right(struct ext4_es_tree *tree, struct extent_status *es)
+ext4_es_try_to_merge_right(struct inode *inode, struct extent_status *es)
 {
+       struct ext4_es_tree *tree = &EXT4_I(inode)->i_es_tree;
        struct extent_status *es1;
        struct rb_node *node;
 
@@ -311,69 +376,57 @@ ext4_es_try_to_merge_right(struct ext4_es_tree *tree, struct extent_status *es)
                return es;
 
        es1 = rb_entry(node, struct extent_status, rb_node);
-       if (es1->start == extent_status_end(es) + 1) {
-               es->len += es1->len;
+       if (ext4_es_can_be_merged(es, es1)) {
+               es->es_len += es1->es_len;
                rb_erase(node, &tree->root);
-               ext4_es_free_extent(es1);
+               ext4_es_free_extent(inode, es1);
        }
 
        return es;
 }
 
-static int __es_insert_extent(struct ext4_es_tree *tree, ext4_lblk_t offset,
-                             ext4_lblk_t len)
+static int __es_insert_extent(struct inode *inode, struct extent_status *newes)
 {
+       struct ext4_es_tree *tree = &EXT4_I(inode)->i_es_tree;
        struct rb_node **p = &tree->root.rb_node;
        struct rb_node *parent = NULL;
        struct extent_status *es;
-       ext4_lblk_t end = offset + len - 1;
-
-       BUG_ON(end < offset);
-       es = tree->cache_es;
-       if (es && offset == (extent_status_end(es) + 1)) {
-               es_debug("cached by [%u/%u)\n", es->start, es->len);
-               es->len += len;
-               es = ext4_es_try_to_merge_right(tree, es);
-               goto out;
-       } else if (es && es->start == end + 1) {
-               es_debug("cached by [%u/%u)\n", es->start, es->len);
-               es->start = offset;
-               es->len += len;
-               es = ext4_es_try_to_merge_left(tree, es);
-               goto out;
-       } else if (es && es->start <= offset &&
-                  end <= extent_status_end(es)) {
-               es_debug("cached by [%u/%u)\n", es->start, es->len);
-               goto out;
-       }
 
        while (*p) {
                parent = *p;
                es = rb_entry(parent, struct extent_status, rb_node);
 
-               if (offset < es->start) {
-                       if (es->start == end + 1) {
-                               es->start = offset;
-                               es->len += len;
-                               es = ext4_es_try_to_merge_left(tree, es);
+               if (newes->es_lblk < es->es_lblk) {
+                       if (ext4_es_can_be_merged(newes, es)) {
+                               /*
+                                * Here we can modify es_lblk directly
+                                * because it isn't overlapped.
+                                */
+                               es->es_lblk = newes->es_lblk;
+                               es->es_len += newes->es_len;
+                               if (ext4_es_is_written(es) ||
+                                   ext4_es_is_unwritten(es))
+                                       ext4_es_store_pblock(es,
+                                                            newes->es_pblk);
+                               es = ext4_es_try_to_merge_left(inode, es);
                                goto out;
                        }
                        p = &(*p)->rb_left;
-               } else if (offset > extent_status_end(es)) {
-                       if (offset == extent_status_end(es) + 1) {
-                               es->len += len;
-                               es = ext4_es_try_to_merge_right(tree, es);
+               } else if (newes->es_lblk > ext4_es_end(es)) {
+                       if (ext4_es_can_be_merged(es, newes)) {
+                               es->es_len += newes->es_len;
+                               es = ext4_es_try_to_merge_right(inode, es);
                                goto out;
                        }
                        p = &(*p)->rb_right;
                } else {
-                       if (extent_status_end(es) <= end)
-                               es->len = offset - es->start + len;
-                       goto out;
+                       BUG_ON(1);
+                       return -EINVAL;
                }
        }
 
-       es = ext4_es_alloc_extent(offset, len);
+       es = ext4_es_alloc_extent(inode, newes->es_lblk, newes->es_len,
+                                 newes->es_pblk);
        if (!es)
                return -ENOMEM;
        rb_link_node(&es->rb_node, parent, p);
@@ -385,85 +438,166 @@ out:
 }
 
 /*
- * ext4_es_insert_extent() adds a space to a delayed extent tree.
- * Caller holds inode->i_es_lock.
+ * ext4_es_insert_extent() adds a space to a extent status tree.
  *
  * ext4_es_insert_extent is called by ext4_da_write_begin and
  * ext4_es_remove_extent.
  *
  * Return 0 on success, error code on failure.
  */
-int ext4_es_insert_extent(struct inode *inode, ext4_lblk_t offset,
-                         ext4_lblk_t len)
+int ext4_es_insert_extent(struct inode *inode, ext4_lblk_t lblk,
+                         ext4_lblk_t len, ext4_fsblk_t pblk,
+                         unsigned long long status)
 {
-       struct ext4_es_tree *tree;
+       struct extent_status newes;
+       ext4_lblk_t end = lblk + len - 1;
        int err = 0;
 
-       trace_ext4_es_insert_extent(inode, offset, len);
-       es_debug("add [%u/%u) to extent status tree of inode %lu\n",
-                offset, len, inode->i_ino);
+       es_debug("add [%u/%u) %llu %llx to extent status tree of inode %lu\n",
+                lblk, len, pblk, status, inode->i_ino);
+
+       if (!len)
+               return 0;
+
+       BUG_ON(end < lblk);
+
+       newes.es_lblk = lblk;
+       newes.es_len = len;
+       ext4_es_store_pblock(&newes, pblk);
+       ext4_es_store_status(&newes, status);
+       trace_ext4_es_insert_extent(inode, &newes);
 
        write_lock(&EXT4_I(inode)->i_es_lock);
-       tree = &EXT4_I(inode)->i_es_tree;
-       err = __es_insert_extent(tree, offset, len);
+       err = __es_remove_extent(inode, lblk, end);
+       if (err != 0)
+               goto error;
+       err = __es_insert_extent(inode, &newes);
+
+error:
        write_unlock(&EXT4_I(inode)->i_es_lock);
 
+       ext4_es_lru_add(inode);
        ext4_es_print_tree(inode);
 
        return err;
 }
 
 /*
- * ext4_es_remove_extent() removes a space from a delayed extent tree.
- * Caller holds inode->i_es_lock.
+ * ext4_es_lookup_extent() looks up an extent in extent status tree.
  *
- * Return 0 on success, error code on failure.
+ * ext4_es_lookup_extent is called by ext4_map_blocks/ext4_da_map_blocks.
+ *
+ * Return: 1 on found, 0 on not
  */
-int ext4_es_remove_extent(struct inode *inode, ext4_lblk_t offset,
-                         ext4_lblk_t len)
+int ext4_es_lookup_extent(struct inode *inode, ext4_lblk_t lblk,
+                         struct extent_status *es)
 {
-       struct rb_node *node;
        struct ext4_es_tree *tree;
+       struct extent_status *es1 = NULL;
+       struct rb_node *node;
+       int found = 0;
+
+       trace_ext4_es_lookup_extent_enter(inode, lblk);
+       es_debug("lookup extent in block %u\n", lblk);
+
+       tree = &EXT4_I(inode)->i_es_tree;
+       read_lock(&EXT4_I(inode)->i_es_lock);
+
+       /* find extent in cache firstly */
+       es->es_lblk = es->es_len = es->es_pblk = 0;
+       if (tree->cache_es) {
+               es1 = tree->cache_es;
+               if (in_range(lblk, es1->es_lblk, es1->es_len)) {
+                       es_debug("%u cached by [%u/%u)\n",
+                                lblk, es1->es_lblk, es1->es_len);
+                       found = 1;
+                       goto out;
+               }
+       }
+
+       node = tree->root.rb_node;
+       while (node) {
+               es1 = rb_entry(node, struct extent_status, rb_node);
+               if (lblk < es1->es_lblk)
+                       node = node->rb_left;
+               else if (lblk > ext4_es_end(es1))
+                       node = node->rb_right;
+               else {
+                       found = 1;
+                       break;
+               }
+       }
+
+out:
+       if (found) {
+               BUG_ON(!es1);
+               es->es_lblk = es1->es_lblk;
+               es->es_len = es1->es_len;
+               es->es_pblk = es1->es_pblk;
+       }
+
+       read_unlock(&EXT4_I(inode)->i_es_lock);
+
+       ext4_es_lru_add(inode);
+       trace_ext4_es_lookup_extent_exit(inode, es, found);
+       return found;
+}
+
+static int __es_remove_extent(struct inode *inode, ext4_lblk_t lblk,
+                             ext4_lblk_t end)
+{
+       struct ext4_es_tree *tree = &EXT4_I(inode)->i_es_tree;
+       struct rb_node *node;
        struct extent_status *es;
        struct extent_status orig_es;
-       ext4_lblk_t len1, len2, end;
+       ext4_lblk_t len1, len2;
+       ext4_fsblk_t block;
        int err = 0;
 
-       trace_ext4_es_remove_extent(inode, offset, len);
-       es_debug("remove [%u/%u) from extent status tree of inode %lu\n",
-                offset, len, inode->i_ino);
-
-       end = offset + len - 1;
-       BUG_ON(end < offset);
-       write_lock(&EXT4_I(inode)->i_es_lock);
-       tree = &EXT4_I(inode)->i_es_tree;
-       es = __es_tree_search(&tree->root, offset);
+       es = __es_tree_search(&tree->root, lblk);
        if (!es)
                goto out;
-       if (es->start > end)
+       if (es->es_lblk > end)
                goto out;
 
        /* Simply invalidate cache_es. */
        tree->cache_es = NULL;
 
-       orig_es.start = es->start;
-       orig_es.len = es->len;
-       len1 = offset > es->start ? offset - es->start : 0;
-       len2 = extent_status_end(es) > end ?
-              extent_status_end(es) - end : 0;
+       orig_es.es_lblk = es->es_lblk;
+       orig_es.es_len = es->es_len;
+       orig_es.es_pblk = es->es_pblk;
+
+       len1 = lblk > es->es_lblk ? lblk - es->es_lblk : 0;
+       len2 = ext4_es_end(es) > end ? ext4_es_end(es) - end : 0;
        if (len1 > 0)
-               es->len = len1;
+               es->es_len = len1;
        if (len2 > 0) {
                if (len1 > 0) {
-                       err = __es_insert_extent(tree, end + 1, len2);
+                       struct extent_status newes;
+
+                       newes.es_lblk = end + 1;
+                       newes.es_len = len2;
+                       if (ext4_es_is_written(&orig_es) ||
+                           ext4_es_is_unwritten(&orig_es)) {
+                               block = ext4_es_pblock(&orig_es) +
+                                       orig_es.es_len - len2;
+                               ext4_es_store_pblock(&newes, block);
+                       }
+                       ext4_es_store_status(&newes, ext4_es_status(&orig_es));
+                       err = __es_insert_extent(inode, &newes);
                        if (err) {
-                               es->start = orig_es.start;
-                               es->len = orig_es.len;
+                               es->es_lblk = orig_es.es_lblk;
+                               es->es_len = orig_es.es_len;
                                goto out;
                        }
                } else {
-                       es->start = end + 1;
-                       es->len = len2;
+                       es->es_lblk = end + 1;
+                       es->es_len = len2;
+                       if (ext4_es_is_written(es) ||
+                           ext4_es_is_unwritten(es)) {
+                               block = orig_es.es_pblk + orig_es.es_len - len2;
+                               ext4_es_store_pblock(es, block);
+                       }
                }
                goto out;
        }
@@ -476,10 +610,10 @@ int ext4_es_remove_extent(struct inode *inode, ext4_lblk_t offset,
                        es = NULL;
        }
 
-       while (es && extent_status_end(es) <= end) {
+       while (es && ext4_es_end(es) <= end) {
                node = rb_next(&es->rb_node);
                rb_erase(&es->rb_node, &tree->root);
-               ext4_es_free_extent(es);
+               ext4_es_free_extent(inode, es);
                if (!node) {
                        es = NULL;
                        break;
@@ -487,14 +621,183 @@ int ext4_es_remove_extent(struct inode *inode, ext4_lblk_t offset,
                es = rb_entry(node, struct extent_status, rb_node);
        }
 
-       if (es && es->start < end + 1) {
-               len1 = extent_status_end(es) - end;
-               es->start = end + 1;
-               es->len = len1;
+       if (es && es->es_lblk < end + 1) {
+               ext4_lblk_t orig_len = es->es_len;
+
+               len1 = ext4_es_end(es) - end;
+               es->es_lblk = end + 1;
+               es->es_len = len1;
+               if (ext4_es_is_written(es) || ext4_es_is_unwritten(es)) {
+                       block = es->es_pblk + orig_len - len1;
+                       ext4_es_store_pblock(es, block);
+               }
        }
 
 out:
+       return err;
+}
+
+/*
+ * ext4_es_remove_extent() removes a space from a extent status tree.
+ *
+ * Return 0 on success, error code on failure.
+ */
+int ext4_es_remove_extent(struct inode *inode, ext4_lblk_t lblk,
+                         ext4_lblk_t len)
+{
+       ext4_lblk_t end;
+       int err = 0;
+
+       trace_ext4_es_remove_extent(inode, lblk, len);
+       es_debug("remove [%u/%u) from extent status tree of inode %lu\n",
+                lblk, len, inode->i_ino);
+
+       if (!len)
+               return err;
+
+       end = lblk + len - 1;
+       BUG_ON(end < lblk);
+
+       write_lock(&EXT4_I(inode)->i_es_lock);
+       err = __es_remove_extent(inode, lblk, end);
        write_unlock(&EXT4_I(inode)->i_es_lock);
        ext4_es_print_tree(inode);
        return err;
 }
+
+static int ext4_es_shrink(struct shrinker *shrink, struct shrink_control *sc)
+{
+       struct ext4_sb_info *sbi = container_of(shrink,
+                                       struct ext4_sb_info, s_es_shrinker);
+       struct ext4_inode_info *ei;
+       struct list_head *cur, *tmp, scanned;
+       int nr_to_scan = sc->nr_to_scan;
+       int ret, nr_shrunk = 0;
+
+       trace_ext4_es_shrink_enter(sbi->s_sb, nr_to_scan);
+
+       if (!nr_to_scan)
+               return ext4_es_reclaim_extents_count(sbi->s_sb);
+
+       INIT_LIST_HEAD(&scanned);
+
+       spin_lock(&sbi->s_es_lru_lock);
+       list_for_each_safe(cur, tmp, &sbi->s_es_lru) {
+               list_move_tail(cur, &scanned);
+
+               ei = list_entry(cur, struct ext4_inode_info, i_es_lru);
+
+               read_lock(&ei->i_es_lock);
+               if (ei->i_es_lru_nr == 0) {
+                       read_unlock(&ei->i_es_lock);
+                       continue;
+               }
+               read_unlock(&ei->i_es_lock);
+
+               write_lock(&ei->i_es_lock);
+               ret = __es_try_to_reclaim_extents(ei, nr_to_scan);
+               write_unlock(&ei->i_es_lock);
+
+               nr_shrunk += ret;
+               nr_to_scan -= ret;
+               if (nr_to_scan == 0)
+                       break;
+       }
+       list_splice_tail(&scanned, &sbi->s_es_lru);
+       spin_unlock(&sbi->s_es_lru_lock);
+       trace_ext4_es_shrink_exit(sbi->s_sb, nr_shrunk);
+
+       return ext4_es_reclaim_extents_count(sbi->s_sb);
+}
+
+void ext4_es_register_shrinker(struct super_block *sb)
+{
+       struct ext4_sb_info *sbi;
+
+       sbi = EXT4_SB(sb);
+       INIT_LIST_HEAD(&sbi->s_es_lru);
+       spin_lock_init(&sbi->s_es_lru_lock);
+       sbi->s_es_shrinker.shrink = ext4_es_shrink;
+       sbi->s_es_shrinker.seeks = DEFAULT_SEEKS;
+       register_shrinker(&sbi->s_es_shrinker);
+}
+
+void ext4_es_unregister_shrinker(struct super_block *sb)
+{
+       unregister_shrinker(&EXT4_SB(sb)->s_es_shrinker);
+}
+
+void ext4_es_lru_add(struct inode *inode)
+{
+       struct ext4_inode_info *ei = EXT4_I(inode);
+       struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
+
+       spin_lock(&sbi->s_es_lru_lock);
+       if (list_empty(&ei->i_es_lru))
+               list_add_tail(&ei->i_es_lru, &sbi->s_es_lru);
+       else
+               list_move_tail(&ei->i_es_lru, &sbi->s_es_lru);
+       spin_unlock(&sbi->s_es_lru_lock);
+}
+
+void ext4_es_lru_del(struct inode *inode)
+{
+       struct ext4_inode_info *ei = EXT4_I(inode);
+       struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
+
+       spin_lock(&sbi->s_es_lru_lock);
+       if (!list_empty(&ei->i_es_lru))
+               list_del_init(&ei->i_es_lru);
+       spin_unlock(&sbi->s_es_lru_lock);
+}
+
+static int ext4_es_reclaim_extents_count(struct super_block *sb)
+{
+       struct ext4_sb_info *sbi = EXT4_SB(sb);
+       struct ext4_inode_info *ei;
+       struct list_head *cur;
+       int nr_cached = 0;
+
+       spin_lock(&sbi->s_es_lru_lock);
+       list_for_each(cur, &sbi->s_es_lru) {
+               ei = list_entry(cur, struct ext4_inode_info, i_es_lru);
+               read_lock(&ei->i_es_lock);
+               nr_cached += ei->i_es_lru_nr;
+               read_unlock(&ei->i_es_lock);
+       }
+       spin_unlock(&sbi->s_es_lru_lock);
+       trace_ext4_es_reclaim_extents_count(sb, nr_cached);
+       return nr_cached;
+}
+
+static int __es_try_to_reclaim_extents(struct ext4_inode_info *ei,
+                                      int nr_to_scan)
+{
+       struct inode *inode = &ei->vfs_inode;
+       struct ext4_es_tree *tree = &ei->i_es_tree;
+       struct rb_node *node;
+       struct extent_status *es;
+       int nr_shrunk = 0;
+
+       if (ei->i_es_lru_nr == 0)
+               return 0;
+
+       node = rb_first(&tree->root);
+       while (node != NULL) {
+               es = rb_entry(node, struct extent_status, rb_node);
+               node = rb_next(&es->rb_node);
+               /*
+                * We can't reclaim delayed extent from status tree because
+                * fiemap, bigallic, and seek_data/hole need to use it.
+                */
+               if (!ext4_es_is_delayed(es)) {
+                       rb_erase(&es->rb_node, &tree->root);
+                       ext4_es_free_extent(inode, es);
+                       nr_shrunk++;
+                       if (--nr_to_scan == 0)
+                               break;
+               }
+       }
+       tree->cache_es = NULL;
+       return nr_shrunk;
+}
index 077f82d..cf83e77 100644 (file)
 #define es_debug(fmt, ...)     no_printk(fmt, ##__VA_ARGS__)
 #endif
 
+#define EXTENT_STATUS_WRITTEN  0x80000000      /* written extent */
+#define EXTENT_STATUS_UNWRITTEN        0x40000000      /* unwritten extent */
+#define EXTENT_STATUS_DELAYED  0x20000000      /* delayed extent */
+#define EXTENT_STATUS_HOLE     0x10000000      /* hole */
+
+#define EXTENT_STATUS_FLAGS    (EXTENT_STATUS_WRITTEN | \
+                                EXTENT_STATUS_UNWRITTEN | \
+                                EXTENT_STATUS_DELAYED | \
+                                EXTENT_STATUS_HOLE)
+
 struct extent_status {
        struct rb_node rb_node;
-       ext4_lblk_t start;      /* first block extent covers */
-       ext4_lblk_t len;        /* length of extent in block */
+       ext4_lblk_t es_lblk;    /* first logical block extent covers */
+       ext4_lblk_t es_len;     /* length of extent in block */
+       ext4_fsblk_t es_pblk;   /* first physical block */
 };
 
 struct ext4_es_tree {
@@ -35,11 +46,69 @@ extern int __init ext4_init_es(void);
 extern void ext4_exit_es(void);
 extern void ext4_es_init_tree(struct ext4_es_tree *tree);
 
-extern int ext4_es_insert_extent(struct inode *inode, ext4_lblk_t start,
+extern int ext4_es_insert_extent(struct inode *inode, ext4_lblk_t lblk,
+                                ext4_lblk_t len, ext4_fsblk_t pblk,
+                                unsigned long long status);
+extern int ext4_es_remove_extent(struct inode *inode, ext4_lblk_t lblk,
                                 ext4_lblk_t len);
-extern int ext4_es_remove_extent(struct inode *inode, ext4_lblk_t start,
-                                ext4_lblk_t len);
-extern ext4_lblk_t ext4_es_find_extent(struct inode *inode,
-                               struct extent_status *es);
+extern void ext4_es_find_delayed_extent(struct inode *inode, ext4_lblk_t lblk,
+                                       struct extent_status *es);
+extern int ext4_es_lookup_extent(struct inode *inode, ext4_lblk_t lblk,
+                                struct extent_status *es);
+
+static inline int ext4_es_is_written(struct extent_status *es)
+{
+       return (es->es_pblk & EXTENT_STATUS_WRITTEN);
+}
+
+static inline int ext4_es_is_unwritten(struct extent_status *es)
+{
+       return (es->es_pblk & EXTENT_STATUS_UNWRITTEN);
+}
+
+static inline int ext4_es_is_delayed(struct extent_status *es)
+{
+       return (es->es_pblk & EXTENT_STATUS_DELAYED);
+}
+
+static inline int ext4_es_is_hole(struct extent_status *es)
+{
+       return (es->es_pblk & EXTENT_STATUS_HOLE);
+}
+
+static inline ext4_fsblk_t ext4_es_status(struct extent_status *es)
+{
+       return (es->es_pblk & EXTENT_STATUS_FLAGS);
+}
+
+static inline ext4_fsblk_t ext4_es_pblock(struct extent_status *es)
+{
+       return (es->es_pblk & ~EXTENT_STATUS_FLAGS);
+}
+
+static inline void ext4_es_store_pblock(struct extent_status *es,
+                                       ext4_fsblk_t pb)
+{
+       ext4_fsblk_t block;
+
+       block = (pb & ~EXTENT_STATUS_FLAGS) |
+               (es->es_pblk & EXTENT_STATUS_FLAGS);
+       es->es_pblk = block;
+}
+
+static inline void ext4_es_store_status(struct extent_status *es,
+                                       unsigned long long status)
+{
+       ext4_fsblk_t block;
+
+       block = (status & EXTENT_STATUS_FLAGS) |
+               (es->es_pblk & ~EXTENT_STATUS_FLAGS);
+       es->es_pblk = block;
+}
+
+extern void ext4_es_register_shrinker(struct super_block *sb);
+extern void ext4_es_unregister_shrinker(struct super_block *sb);
+extern void ext4_es_lru_add(struct inode *inode);
+extern void ext4_es_lru_del(struct inode *inode);
 
 #endif /* _EXT4_EXTENTS_STATUS_H */
index 405565a..7e85a10 100644 (file)
@@ -240,7 +240,7 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
                        handle_t *handle;
                        int err;
 
-                       handle = ext4_journal_start_sb(sb, 1);
+                       handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
                        if (IS_ERR(handle))
                                return PTR_ERR(handle);
                        err = ext4_journal_get_write_access(handle, sbi->s_sbh);
@@ -464,10 +464,8 @@ static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize)
                 * If there is a delay extent at this offset,
                 * it will be as a data.
                 */
-               es.start = last;
-               (void)ext4_es_find_extent(inode, &es);
-               if (last >= es.start &&
-                   last < es.start + es.len) {
+               ext4_es_find_delayed_extent(inode, last, &es);
+               if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
                        if (last != start)
                                dataoff = last << blkbits;
                        break;
@@ -549,11 +547,9 @@ static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
                 * If there is a delay extent at this offset,
                 * we will skip this extent.
                 */
-               es.start = last;
-               (void)ext4_es_find_extent(inode, &es);
-               if (last >= es.start &&
-                   last < es.start + es.len) {
-                       last = es.start + es.len;
+               ext4_es_find_delayed_extent(inode, last, &es);
+               if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
+                       last = es.es_lblk + es.es_len;
                        holeoff = last << blkbits;
                        continue;
                }
index fa8e491..3d586f0 100644 (file)
@@ -155,11 +155,11 @@ int ext4fs_dirhash(const char *name, int len, struct dx_hash_info *hinfo)
        /* Check to see if the seed is all zero's */
        if (hinfo->seed) {
                for (i = 0; i < 4; i++) {
-                       if (hinfo->seed[i])
+                       if (hinfo->seed[i]) {
+                               memcpy(buf, hinfo->seed, sizeof(buf));
                                break;
+                       }
                }
-               if (i < 4)
-                       memcpy(buf, hinfo->seed, sizeof(buf));
        }
 
        switch (hinfo->hash_version) {
index 3f32c80..32fd2b9 100644 (file)
@@ -634,8 +634,10 @@ static int find_group_other(struct super_block *sb, struct inode *parent,
  * For other inodes, search forward from the parent directory's block
  * group to find a free inode.
  */
-struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, umode_t mode,
-                            const struct qstr *qstr, __u32 goal, uid_t *owner)
+struct inode *__ext4_new_inode(handle_t *handle, struct inode *dir,
+                              umode_t mode, const struct qstr *qstr,
+                              __u32 goal, uid_t *owner, int handle_type,
+                              unsigned int line_no, int nblocks)
 {
        struct super_block *sb;
        struct buffer_head *inode_bitmap_bh = NULL;
@@ -725,6 +727,15 @@ repeat_in_this_group:
                                   "inode=%lu", ino + 1);
                        continue;
                }
+               if (!handle) {
+                       BUG_ON(nblocks <= 0);
+                       handle = __ext4_journal_start_sb(dir->i_sb, line_no,
+                                                        handle_type, nblocks);
+                       if (IS_ERR(handle)) {
+                               err = PTR_ERR(handle);
+                               goto fail;
+                       }
+               }
                BUFFER_TRACE(inode_bitmap_bh, "get_write_access");
                err = ext4_journal_get_write_access(handle, inode_bitmap_bh);
                if (err)
@@ -1017,17 +1028,17 @@ iget_failed:
        inode = NULL;
 bad_orphan:
        ext4_warning(sb, "bad orphan inode %lu!  e2fsck was run?", ino);
-       printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n",
+       printk(KERN_WARNING "ext4_test_bit(bit=%d, block=%llu) = %d\n",
               bit, (unsigned long long)bitmap_bh->b_blocknr,
               ext4_test_bit(bit, bitmap_bh->b_data));
-       printk(KERN_NOTICE "inode=%p\n", inode);
+       printk(KERN_WARNING "inode=%p\n", inode);
        if (inode) {
-               printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
+               printk(KERN_WARNING "is_bad_inode(inode)=%d\n",
                       is_bad_inode(inode));
-               printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
+               printk(KERN_WARNING "NEXT_ORPHAN(inode)=%u\n",
                       NEXT_ORPHAN(inode));
-               printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
-               printk(KERN_NOTICE "i_nlink=%u\n", inode->i_nlink);
+               printk(KERN_WARNING "max_ino=%lu\n", max_ino);
+               printk(KERN_WARNING "i_nlink=%u\n", inode->i_nlink);
                /* Avoid freeing blocks if we got a bad deleted inode */
                if (inode->i_nlink == 0)
                        inode->i_blocks = 0;
@@ -1137,7 +1148,7 @@ int ext4_init_inode_table(struct super_block *sb, ext4_group_t group,
        if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED))
                goto out;
 
-       handle = ext4_journal_start_sb(sb, 1);
+       handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
        if (IS_ERR(handle)) {
                ret = PTR_ERR(handle);
                goto out;
index 20862f9..c541ab8 100644 (file)
@@ -146,6 +146,7 @@ static Indirect *ext4_get_branch(struct inode *inode, int depth,
        struct super_block *sb = inode->i_sb;
        Indirect *p = chain;
        struct buffer_head *bh;
+       int ret = -EIO;
 
        *err = 0;
        /* i_data is not going away, no lock needed */
@@ -154,8 +155,10 @@ static Indirect *ext4_get_branch(struct inode *inode, int depth,
                goto no_block;
        while (--depth) {
                bh = sb_getblk(sb, le32_to_cpu(p->key));
-               if (unlikely(!bh))
+               if (unlikely(!bh)) {
+                       ret = -ENOMEM;
                        goto failure;
+               }
 
                if (!bh_uptodate_or_lock(bh)) {
                        if (bh_submit_read(bh) < 0) {
@@ -177,7 +180,7 @@ static Indirect *ext4_get_branch(struct inode *inode, int depth,
        return NULL;
 
 failure:
-       *err = -EIO;
+       *err = ret;
 no_block:
        return p;
 }
@@ -355,9 +358,8 @@ static int ext4_alloc_blocks(handle_t *handle, struct inode *inode,
                         * for the first direct block
                         */
                        new_blocks[index] = current_block;
-                       printk(KERN_INFO "%s returned more blocks than "
+                       WARN(1, KERN_INFO "%s returned more blocks than "
                                                "requested\n", __func__);
-                       WARN_ON(1);
                        break;
                }
        }
@@ -471,7 +473,7 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
                 */
                bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
                if (unlikely(!bh)) {
-                       err = -EIO;
+                       err = -ENOMEM;
                        goto failed;
                }
 
@@ -789,7 +791,7 @@ ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb,
 
                if (final_size > inode->i_size) {
                        /* Credits for sb + inode write */
-                       handle = ext4_journal_start(inode, 2);
+                       handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
                        if (IS_ERR(handle)) {
                                ret = PTR_ERR(handle);
                                goto out;
@@ -849,7 +851,7 @@ locked:
                int err;
 
                /* Credits for sb + inode write */
-               handle = ext4_journal_start(inode, 2);
+               handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
                if (IS_ERR(handle)) {
                        /* This is really bad luck. We've written the data
                         * but cannot extend i_size. Bail out and pretend
@@ -948,7 +950,8 @@ static handle_t *start_transaction(struct inode *inode)
 {
        handle_t *result;
 
-       result = ext4_journal_start(inode, ext4_blocks_for_truncate(inode));
+       result = ext4_journal_start(inode, EXT4_HT_TRUNCATE,
+                                   ext4_blocks_for_truncate(inode));
        if (!IS_ERR(result))
                return result;
 
@@ -1515,3 +1518,243 @@ out_stop:
        trace_ext4_truncate_exit(inode);
 }
 
+static int free_hole_blocks(handle_t *handle, struct inode *inode,
+                           struct buffer_head *parent_bh, __le32 *i_data,
+                           int level, ext4_lblk_t first,
+                           ext4_lblk_t count, int max)
+{
+       struct buffer_head *bh = NULL;
+       int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb);
+       int ret = 0;
+       int i, inc;
+       ext4_lblk_t offset;
+       __le32 blk;
+
+       inc = 1 << ((EXT4_BLOCK_SIZE_BITS(inode->i_sb) - 2) * level);
+       for (i = 0, offset = 0; i < max; i++, i_data++, offset += inc) {
+               if (offset >= count + first)
+                       break;
+               if (*i_data == 0 || (offset + inc) <= first)
+                       continue;
+               blk = *i_data;
+               if (level > 0) {
+                       ext4_lblk_t first2;
+                       bh = sb_bread(inode->i_sb, blk);
+                       if (!bh) {
+                               EXT4_ERROR_INODE_BLOCK(inode, blk,
+                                                      "Read failure");
+                               return -EIO;
+                       }
+                       first2 = (first > offset) ? first - offset : 0;
+                       ret = free_hole_blocks(handle, inode, bh,
+                                              (__le32 *)bh->b_data, level - 1,
+                                              first2, count - offset,
+                                              inode->i_sb->s_blocksize >> 2);
+                       if (ret) {
+                               brelse(bh);
+                               goto err;
+                       }
+               }
+               if (level == 0 ||
+                   (bh && all_zeroes((__le32 *)bh->b_data,
+                                     (__le32 *)bh->b_data + addr_per_block))) {
+                       ext4_free_data(handle, inode, parent_bh, &blk, &blk+1);
+                       *i_data = 0;
+               }
+               brelse(bh);
+               bh = NULL;
+       }
+
+err:
+       return ret;
+}
+
+static int ext4_free_hole_blocks(handle_t *handle, struct inode *inode,
+                                ext4_lblk_t first, ext4_lblk_t stop)
+{
+       int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb);
+       int level, ret = 0;
+       int num = EXT4_NDIR_BLOCKS;
+       ext4_lblk_t count, max = EXT4_NDIR_BLOCKS;
+       __le32 *i_data = EXT4_I(inode)->i_data;
+
+       count = stop - first;
+       for (level = 0; level < 4; level++, max *= addr_per_block) {
+               if (first < max) {
+                       ret = free_hole_blocks(handle, inode, NULL, i_data,
+                                              level, first, count, num);
+                       if (ret)
+                               goto err;
+                       if (count > max - first)
+                               count -= max - first;
+                       else
+                               break;
+                       first = 0;
+               } else {
+                       first -= max;
+               }
+               i_data += num;
+               if (level == 0) {
+                       num = 1;
+                       max = 1;
+               }
+       }
+
+err:
+       return ret;
+}
+
+int ext4_ind_punch_hole(struct file *file, loff_t offset, loff_t length)
+{
+       struct inode *inode = file->f_path.dentry->d_inode;
+       struct super_block *sb = inode->i_sb;
+       ext4_lblk_t first_block, stop_block;
+       struct address_space *mapping = inode->i_mapping;
+       handle_t *handle = NULL;
+       loff_t first_page, last_page, page_len;
+       loff_t first_page_offset, last_page_offset;
+       int err = 0;
+
+       /*
+        * Write out all dirty pages to avoid race conditions
+        * Then release them.
+        */
+       if (mapping->nrpages && mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
+               err = filemap_write_and_wait_range(mapping,
+                       offset, offset + length - 1);
+               if (err)
+                       return err;
+       }
+
+       mutex_lock(&inode->i_mutex);
+       /* It's not possible punch hole on append only file */
+       if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) {
+               err = -EPERM;
+               goto out_mutex;
+       }
+       if (IS_SWAPFILE(inode)) {
+               err = -ETXTBSY;
+               goto out_mutex;
+       }
+
+       /* No need to punch hole beyond i_size */
+       if (offset >= inode->i_size)
+               goto out_mutex;
+
+       /*
+        * If the hole extents beyond i_size, set the hole
+        * to end after the page that contains i_size
+        */
+       if (offset + length > inode->i_size) {
+               length = inode->i_size +
+                   PAGE_CACHE_SIZE - (inode->i_size & (PAGE_CACHE_SIZE - 1)) -
+                   offset;
+       }
+
+       first_page = (offset + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+       last_page = (offset + length) >> PAGE_CACHE_SHIFT;
+
+       first_page_offset = first_page << PAGE_CACHE_SHIFT;
+       last_page_offset = last_page << PAGE_CACHE_SHIFT;
+
+       /* Now release the pages */
+       if (last_page_offset > first_page_offset) {
+               truncate_pagecache_range(inode, first_page_offset,
+                                        last_page_offset - 1);
+       }
+
+       /* Wait all existing dio works, newcomers will block on i_mutex */
+       inode_dio_wait(inode);
+
+       handle = start_transaction(inode);
+       if (IS_ERR(handle))
+               goto out_mutex;
+
+       /*
+        * Now we need to zero out the non-page-aligned data in the
+        * pages at the start and tail of the hole, and unmap the buffer
+        * heads for the block aligned regions of the page that were
+        * completely zerod.
+        */
+       if (first_page > last_page) {
+               /*
+                * If the file space being truncated is contained within a page
+                * just zero out and unmap the middle of that page
+                */
+               err = ext4_discard_partial_page_buffers(handle,
+                       mapping, offset, length, 0);
+               if (err)
+                       goto out;
+       } else {
+               /*
+                * Zero out and unmap the paritial page that contains
+                * the start of the hole
+                */
+               page_len = first_page_offset - offset;
+               if (page_len > 0) {
+                       err = ext4_discard_partial_page_buffers(handle, mapping,
+                                                       offset, page_len, 0);
+                       if (err)
+                               goto out;
+               }
+
+               /*
+                * Zero out and unmap the partial page that contains
+                * the end of the hole
+                */
+               page_len = offset + length - last_page_offset;
+               if (page_len > 0) {
+                       err = ext4_discard_partial_page_buffers(handle, mapping,
+                                               last_page_offset, page_len, 0);
+                       if (err)
+                               goto out;
+               }
+       }
+
+       /*
+        * If i_size contained in the last page, we need to
+        * unmap and zero the paritial page after i_size
+        */
+       if (inode->i_size >> PAGE_CACHE_SHIFT == last_page &&
+           inode->i_size % PAGE_CACHE_SIZE != 0) {
+               page_len = PAGE_CACHE_SIZE -
+                       (inode->i_size & (PAGE_CACHE_SIZE - 1));
+               if (page_len > 0) {
+                       err = ext4_discard_partial_page_buffers(handle,
+                               mapping, inode->i_size, page_len, 0);
+                       if (err)
+                               goto out;
+               }
+       }
+
+       first_block = (offset + sb->s_blocksize - 1) >>
+               EXT4_BLOCK_SIZE_BITS(sb);
+       stop_block = (offset + length) >> EXT4_BLOCK_SIZE_BITS(sb);
+
+       if (first_block >= stop_block)
+               goto out;
+
+       down_write(&EXT4_I(inode)->i_data_sem);
+       ext4_discard_preallocations(inode);
+
+       err = ext4_es_remove_extent(inode, first_block,
+                                   stop_block - first_block);
+       err = ext4_free_hole_blocks(handle, inode, first_block, stop_block);
+
+       ext4_discard_preallocations(inode);
+
+       if (IS_SYNC(inode))
+               ext4_handle_sync(handle);
+
+       up_write(&EXT4_I(inode)->i_data_sem);
+
+out:
+       inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
+       ext4_mark_inode_dirty(handle, inode);
+       ext4_journal_stop(handle);
+
+out_mutex:
+       mutex_unlock(&inode->i_mutex);
+
+       return err;
+}
index 387c47c..bc5f871 100644 (file)
@@ -545,7 +545,7 @@ static int ext4_convert_inline_data_to_extent(struct address_space *mapping,
                return ret;
 
 retry:
-       handle = ext4_journal_start(inode, needed_blocks);
+       handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
        if (IS_ERR(handle)) {
                ret = PTR_ERR(handle);
                handle = NULL;
@@ -657,7 +657,7 @@ int ext4_try_to_write_inline_data(struct address_space *mapping,
         * The possible write could happen in the inode,
         * so try to reserve the space in inode first.
         */
-       handle = ext4_journal_start(inode, 1);
+       handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
        if (IS_ERR(handle)) {
                ret = PTR_ERR(handle);
                handle = NULL;
@@ -853,7 +853,7 @@ int ext4_da_write_inline_data_begin(struct address_space *mapping,
        if (ret)
                return ret;
 
-       handle = ext4_journal_start(inode, 1);
+       handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
        if (IS_ERR(handle)) {
                ret = PTR_ERR(handle);
                handle = NULL;
@@ -1188,7 +1188,7 @@ static int ext4_convert_inline_data_nolock(handle_t *handle,
 
        data_bh = sb_getblk(inode->i_sb, map.m_pblk);
        if (!data_bh) {
-               error = -EIO;
+               error = -ENOMEM;
                goto out_restore;
        }
 
@@ -1770,7 +1770,7 @@ void ext4_inline_data_truncate(struct inode *inode, int *has_inline)
 
 
        needed_blocks = ext4_writepage_trans_blocks(inode);
-       handle = ext4_journal_start(inode, needed_blocks);
+       handle = ext4_journal_start(inode, EXT4_HT_INODE, needed_blocks);
        if (IS_ERR(handle))
                return;
 
@@ -1862,7 +1862,7 @@ int ext4_convert_inline_data(struct inode *inode)
        if (error)
                return error;
 
-       handle = ext4_journal_start(inode, needed_blocks);
+       handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
        if (IS_ERR(handle)) {
                error = PTR_ERR(handle);
                goto out_free;
index cd818d8..88049d8 100644 (file)
@@ -132,10 +132,6 @@ static inline int ext4_begin_ordered_truncate(struct inode *inode,
 }
 
 static void ext4_invalidatepage(struct page *page, unsigned long offset);
-static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
-                                  struct buffer_head *bh_result, int create);
-static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode);
-static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate);
 static int __ext4_journalled_writepage(struct page *page, unsigned int len);
 static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh);
 static int ext4_discard_partial_page_buffers_no_lock(handle_t *handle,
@@ -238,7 +234,8 @@ void ext4_evict_inode(struct inode *inode)
         * protection against it
         */
        sb_start_intwrite(inode->i_sb);
-       handle = ext4_journal_start(inode, ext4_blocks_for_truncate(inode)+3);
+       handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE,
+                                   ext4_blocks_for_truncate(inode)+3);
        if (IS_ERR(handle)) {
                ext4_std_error(inode->i_sb, PTR_ERR(handle));
                /*
@@ -346,7 +343,7 @@ void ext4_da_update_reserve_space(struct inode *inode,
        spin_lock(&ei->i_block_reservation_lock);
        trace_ext4_da_update_reserve_space(inode, used, quota_claim);
        if (unlikely(used > ei->i_reserved_data_blocks)) {
-               ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, used %d "
+               ext4_warning(inode->i_sb, "%s: ino %lu, used %d "
                         "with only %d reserved data blocks",
                         __func__, inode->i_ino, used,
                         ei->i_reserved_data_blocks);
@@ -355,10 +352,12 @@ void ext4_da_update_reserve_space(struct inode *inode,
        }
 
        if (unlikely(ei->i_allocated_meta_blocks > ei->i_reserved_meta_blocks)) {
-               ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, allocated %d "
-                        "with only %d reserved metadata blocks\n", __func__,
-                        inode->i_ino, ei->i_allocated_meta_blocks,
-                        ei->i_reserved_meta_blocks);
+               ext4_warning(inode->i_sb, "ino %lu, allocated %d "
+                       "with only %d reserved metadata blocks "
+                       "(releasing %d blocks with reserved %d data blocks)",
+                       inode->i_ino, ei->i_allocated_meta_blocks,
+                            ei->i_reserved_meta_blocks, used,
+                            ei->i_reserved_data_blocks);
                WARN_ON(1);
                ei->i_allocated_meta_blocks = ei->i_reserved_meta_blocks;
        }
@@ -508,12 +507,33 @@ static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx,
 int ext4_map_blocks(handle_t *handle, struct inode *inode,
                    struct ext4_map_blocks *map, int flags)
 {
+       struct extent_status es;
        int retval;
 
        map->m_flags = 0;
        ext_debug("ext4_map_blocks(): inode %lu, flag %d, max_blocks %u,"
                  "logical block %lu\n", inode->i_ino, flags, map->m_len,
                  (unsigned long) map->m_lblk);
+
+       /* Lookup extent status tree firstly */
+       if (ext4_es_lookup_extent(inode, map->m_lblk, &es)) {
+               if (ext4_es_is_written(&es) || ext4_es_is_unwritten(&es)) {
+                       map->m_pblk = ext4_es_pblock(&es) +
+                                       map->m_lblk - es.es_lblk;
+                       map->m_flags |= ext4_es_is_written(&es) ?
+                                       EXT4_MAP_MAPPED : EXT4_MAP_UNWRITTEN;
+                       retval = es.es_len - (map->m_lblk - es.es_lblk);
+                       if (retval > map->m_len)
+                               retval = map->m_len;
+                       map->m_len = retval;
+               } else if (ext4_es_is_delayed(&es) || ext4_es_is_hole(&es)) {
+                       retval = 0;
+               } else {
+                       BUG_ON(1);
+               }
+               goto found;
+       }
+
        /*
         * Try to see if we can get the block without requesting a new
         * file system block.
@@ -527,20 +547,27 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
                retval = ext4_ind_map_blocks(handle, inode, map, flags &
                                             EXT4_GET_BLOCKS_KEEP_SIZE);
        }
+       if (retval > 0) {
+               int ret;
+               unsigned long long status;
+
+               status = map->m_flags & EXT4_MAP_UNWRITTEN ?
+                               EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
+               if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) &&
+                   ext4_find_delalloc_range(inode, map->m_lblk,
+                                            map->m_lblk + map->m_len - 1))
+                       status |= EXTENT_STATUS_DELAYED;
+               ret = ext4_es_insert_extent(inode, map->m_lblk,
+                                           map->m_len, map->m_pblk, status);
+               if (ret < 0)
+                       retval = ret;
+       }
        if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
                up_read((&EXT4_I(inode)->i_data_sem));
 
+found:
        if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
-               int ret;
-               if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
-                       /* delayed alloc may be allocated by fallocate and
-                        * coverted to initialized by directIO.
-                        * we need to handle delayed extent here.
-                        */
-                       down_write((&EXT4_I(inode)->i_data_sem));
-                       goto delayed_mapped;
-               }
-               ret = check_block_validity(inode, map);
+               int ret = check_block_validity(inode, map);
                if (ret != 0)
                        return ret;
        }
@@ -560,16 +587,10 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
                return retval;
 
        /*
-        * When we call get_blocks without the create flag, the
-        * BH_Unwritten flag could have gotten set if the blocks
-        * requested were part of a uninitialized extent.  We need to
-        * clear this flag now that we are committed to convert all or
-        * part of the uninitialized extent to be an initialized
-        * extent.  This is because we need to avoid the combination
-        * of BH_Unwritten and BH_Mapped flags being simultaneously
-        * set on the buffer_head.
+        * Here we clear m_flags because after allocating an new extent,
+        * it will be set again.
         */
-       map->m_flags &= ~EXT4_MAP_UNWRITTEN;
+       map->m_flags &= ~EXT4_MAP_FLAGS;
 
        /*
         * New blocks allocate and/or writing to uninitialized extent
@@ -615,18 +636,23 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
                        (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE))
                        ext4_da_update_reserve_space(inode, retval, 1);
        }
-       if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
+       if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
                ext4_clear_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
 
-               if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
-                       int ret;
-delayed_mapped:
-                       /* delayed allocation blocks has been allocated */
-                       ret = ext4_es_remove_extent(inode, map->m_lblk,
-                                                   map->m_len);
-                       if (ret < 0)
-                               retval = ret;
-               }
+       if (retval > 0) {
+               int ret;
+               unsigned long long status;
+
+               status = map->m_flags & EXT4_MAP_UNWRITTEN ?
+                               EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
+               if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) &&
+                   ext4_find_delalloc_range(inode, map->m_lblk,
+                                            map->m_lblk + map->m_len - 1))
+                       status |= EXTENT_STATUS_DELAYED;
+               ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
+                                           map->m_pblk, status);
+               if (ret < 0)
+                       retval = ret;
        }
 
        up_write((&EXT4_I(inode)->i_data_sem));
@@ -660,7 +686,8 @@ static int _ext4_get_block(struct inode *inode, sector_t iblock,
                if (map.m_len > DIO_MAX_BLOCKS)
                        map.m_len = DIO_MAX_BLOCKS;
                dio_credits = ext4_chunk_trans_blocks(inode, map.m_len);
-               handle = ext4_journal_start(inode, dio_credits);
+               handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
+                                           dio_credits);
                if (IS_ERR(handle)) {
                        ret = PTR_ERR(handle);
                        return ret;
@@ -707,14 +734,16 @@ struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
        /* ensure we send some value back into *errp */
        *errp = 0;
 
+       if (create && err == 0)
+               err = -ENOSPC;  /* should never happen */
        if (err < 0)
                *errp = err;
        if (err <= 0)
                return NULL;
 
        bh = sb_getblk(inode->i_sb, map.m_pblk);
-       if (!bh) {
-               *errp = -EIO;
+       if (unlikely(!bh)) {
+               *errp = -ENOMEM;
                return NULL;
        }
        if (map.m_flags & EXT4_MAP_NEW) {
@@ -808,11 +837,10 @@ int ext4_walk_page_buffers(handle_t *handle,
  * and the commit_write().  So doing the jbd2_journal_start at the start of
  * prepare_write() is the right place.
  *
- * Also, this function can nest inside ext4_writepage() ->
- * block_write_full_page(). In that case, we *know* that ext4_writepage()
- * has generated enough buffer credits to do the whole page.  So we won't
- * block on the journal in that case, which is good, because the caller may
- * be PF_MEMALLOC.
+ * Also, this function can nest inside ext4_writepage().  In that case, we
+ * *know* that ext4_writepage() has generated enough buffer credits to do the
+ * whole page.  So we won't block on the journal in that case, which is good,
+ * because the caller may be PF_MEMALLOC.
  *
  * By accident, ext4 can be reentered when a transaction is open via
  * quota file writes.  If we were to commit the transaction while thus
@@ -878,32 +906,40 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping,
                ret = ext4_try_to_write_inline_data(mapping, inode, pos, len,
                                                    flags, pagep);
                if (ret < 0)
-                       goto out;
-               if (ret == 1) {
-                       ret = 0;
-                       goto out;
-               }
+                       return ret;
+               if (ret == 1)
+                       return 0;
        }
 
-retry:
-       handle = ext4_journal_start(inode, needed_blocks);
+       /*
+        * grab_cache_page_write_begin() can take a long time if the
+        * system is thrashing due to memory pressure, or if the page
+        * is being written back.  So grab it first before we start
+        * the transaction handle.  This also allows us to allocate
+        * the page (if needed) without using GFP_NOFS.
+        */
+retry_grab:
+       page = grab_cache_page_write_begin(mapping, index, flags);
+       if (!page)
+               return -ENOMEM;
+       unlock_page(page);
+
+retry_journal:
+       handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
        if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               goto out;
+               page_cache_release(page);
+               return PTR_ERR(handle);
        }
 
-       /* We cannot recurse into the filesystem as the transaction is already
-        * started */
-       flags |= AOP_FLAG_NOFS;
-
-       page = grab_cache_page_write_begin(mapping, index, flags);
-       if (!page) {
+       lock_page(page);
+       if (page->mapping != mapping) {
+               /* The page got truncated from under us */
+               unlock_page(page);
+               page_cache_release(page);
                ext4_journal_stop(handle);
-               ret = -ENOMEM;
-               goto out;
+               goto retry_grab;
        }
-
-       *pagep = page;
+       wait_on_page_writeback(page);
 
        if (ext4_should_dioread_nolock(inode))
                ret = __block_write_begin(page, pos, len, ext4_get_block_write);
@@ -918,7 +954,6 @@ retry:
 
        if (ret) {
                unlock_page(page);
-               page_cache_release(page);
                /*
                 * __block_write_begin may have instantiated a few blocks
                 * outside i_size.  Trim these off again. Don't need
@@ -942,11 +977,14 @@ retry:
                        if (inode->i_nlink)
                                ext4_orphan_del(NULL, inode);
                }
-       }
 
-       if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
-               goto retry;
-out:
+               if (ret == -ENOSPC &&
+                   ext4_should_retry_alloc(inode->i_sb, &retries))
+                       goto retry_journal;
+               page_cache_release(page);
+               return ret;
+       }
+       *pagep = page;
        return ret;
 }
 
@@ -1256,7 +1294,7 @@ static void ext4_da_release_space(struct inode *inode, int to_free)
                 * function is called from invalidate page, it's
                 * harmless to return without any action.
                 */
-               ext4_msg(inode->i_sb, KERN_NOTICE, "ext4_da_release_space: "
+               ext4_warning(inode->i_sb, "ext4_da_release_space: "
                         "ino %lu, to_free %d with only %d reserved "
                         "data blocks", inode->i_ino, to_free,
                         ei->i_reserved_data_blocks);
@@ -1357,7 +1395,6 @@ static int mpage_da_submit_io(struct mpage_da_data *mpd,
        loff_t size = i_size_read(inode);
        unsigned int len, block_start;
        struct buffer_head *bh, *page_bufs = NULL;
-       int journal_data = ext4_should_journal_data(inode);
        sector_t pblock = 0, cur_logical = 0;
        struct ext4_io_submit io_submit;
 
@@ -1378,7 +1415,7 @@ static int mpage_da_submit_io(struct mpage_da_data *mpd,
                if (nr_pages == 0)
                        break;
                for (i = 0; i < nr_pages; i++) {
-                       int commit_write = 0, skip_page = 0;
+                       int skip_page = 0;
                        struct page *page = pvec.pages[i];
 
                        index = page->index;
@@ -1400,27 +1437,9 @@ static int mpage_da_submit_io(struct mpage_da_data *mpd,
                        BUG_ON(!PageLocked(page));
                        BUG_ON(PageWriteback(page));
 
-                       /*
-                        * If the page does not have buffers (for
-                        * whatever reason), try to create them using
-                        * __block_write_begin.  If this fails,
-                        * skip the page and move on.
-                        */
-                       if (!page_has_buffers(page)) {
-                               if (__block_write_begin(page, 0, len,
-                                               noalloc_get_block_write)) {
-                               skip_page:
-                                       unlock_page(page);
-                                       continue;
-                               }
-                               commit_write = 1;
-                       }
-
                        bh = page_bufs = page_buffers(page);
                        block_start = 0;
                        do {
-                               if (!bh)
-                                       goto skip_page;
                                if (map && (cur_logical >= map->m_lblk) &&
                                    (cur_logical <= (map->m_lblk +
                                                     (map->m_len - 1)))) {
@@ -1448,33 +1467,14 @@ static int mpage_da_submit_io(struct mpage_da_data *mpd,
                                pblock++;
                        } while (bh != page_bufs);
 
-                       if (skip_page)
-                               goto skip_page;
-
-                       if (commit_write)
-                               /* mark the buffer_heads as dirty & uptodate */
-                               block_commit_write(page, 0, len);
+                       if (skip_page) {
+                               unlock_page(page);
+                               continue;
+                       }
 
                        clear_page_dirty_for_io(page);
-                       /*
-                        * Delalloc doesn't support data journalling,
-                        * but eventually maybe we'll lift this
-                        * restriction.
-                        */
-                       if (unlikely(journal_data && PageChecked(page)))
-                               err = __ext4_journalled_writepage(page, len);
-                       else if (test_opt(inode->i_sb, MBLK_IO_SUBMIT))
-                               err = ext4_bio_write_page(&io_submit, page,
-                                                         len, mpd->wbc);
-                       else if (buffer_uninit(page_bufs)) {
-                               ext4_set_bh_endio(page_bufs, inode);
-                               err = block_write_full_page_endio(page,
-                                       noalloc_get_block_write,
-                                       mpd->wbc, ext4_end_io_buffer_write);
-                       } else
-                               err = block_write_full_page(page,
-                                       noalloc_get_block_write, mpd->wbc);
-
+                       err = ext4_bio_write_page(&io_submit, page, len,
+                                                 mpd->wbc);
                        if (!err)
                                mpd->pages_written++;
                        /*
@@ -1640,7 +1640,7 @@ static void mpage_da_map_and_submit(struct mpage_da_data *mpd)
                                 (unsigned long long) next,
                                 mpd->b_size >> mpd->inode->i_blkbits, err);
                        ext4_msg(sb, KERN_CRIT,
-                               "This should not happen!! Data will be lost\n");
+                               "This should not happen!! Data will be lost");
                        if (err == -ENOSPC)
                                ext4_print_free_blocks(mpd->inode);
                }
@@ -1690,16 +1690,16 @@ submit_io:
  *
  * @mpd->lbh - extent of blocks
  * @logical - logical number of the block in the file
- * @bh - bh of the block (used to access block's state)
+ * @b_state - b_state of the buffer head added
  *
  * the function is used to collect contig. blocks in same state
  */
-static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
-                                  sector_t logical, size_t b_size,
+static void mpage_add_bh_to_extent(struct mpage_da_data *mpd, sector_t logical,
                                   unsigned long b_state)
 {
        sector_t next;
-       int nrblocks = mpd->b_size >> mpd->inode->i_blkbits;
+       int blkbits = mpd->inode->i_blkbits;
+       int nrblocks = mpd->b_size >> blkbits;
 
        /*
         * XXX Don't go larger than mballoc is willing to allocate
@@ -1707,11 +1707,11 @@ static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
         * mpage_da_submit_io() into this function and then call
         * ext4_map_blocks() multiple times in a loop
         */
-       if (nrblocks >= 8*1024*1024/mpd->inode->i_sb->s_blocksize)
+       if (nrblocks >= (8*1024*1024 >> blkbits))
                goto flush_it;
 
-       /* check if thereserved journal credits might overflow */
-       if (!(ext4_test_inode_flag(mpd->inode, EXT4_INODE_EXTENTS))) {
+       /* check if the reserved journal credits might overflow */
+       if (!ext4_test_inode_flag(mpd->inode, EXT4_INODE_EXTENTS)) {
                if (nrblocks >= EXT4_MAX_TRANS_DATA) {
                        /*
                         * With non-extent format we are limited by the journal
@@ -1720,16 +1720,6 @@ static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
                         * nrblocks.  So limit nrblocks.
                         */
                        goto flush_it;
-               } else if ((nrblocks + (b_size >> mpd->inode->i_blkbits)) >
-                               EXT4_MAX_TRANS_DATA) {
-                       /*
-                        * Adding the new buffer_head would make it cross the
-                        * allowed limit for which we have journal credit
-                        * reserved. So limit the new bh->b_size
-                        */
-                       b_size = (EXT4_MAX_TRANS_DATA - nrblocks) <<
-                                               mpd->inode->i_blkbits;
-                       /* we will do mpage_da_submit_io in the next loop */
                }
        }
        /*
@@ -1737,7 +1727,7 @@ static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
         */
        if (mpd->b_size == 0) {
                mpd->b_blocknr = logical;
-               mpd->b_size = b_size;
+               mpd->b_size = 1 << blkbits;
                mpd->b_state = b_state & BH_FLAGS;
                return;
        }
@@ -1747,7 +1737,7 @@ static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
         * Can we merge the block to our big extent?
         */
        if (logical == next && (b_state & BH_FLAGS) == mpd->b_state) {
-               mpd->b_size += b_size;
+               mpd->b_size += 1 << blkbits;
                return;
        }
 
@@ -1775,6 +1765,7 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
                              struct ext4_map_blocks *map,
                              struct buffer_head *bh)
 {
+       struct extent_status es;
        int retval;
        sector_t invalid_block = ~((sector_t) 0xffff);
 
@@ -1785,6 +1776,42 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
        ext_debug("ext4_da_map_blocks(): inode %lu, max_blocks %u,"
                  "logical block %lu\n", inode->i_ino, map->m_len,
                  (unsigned long) map->m_lblk);
+
+       /* Lookup extent status tree firstly */
+       if (ext4_es_lookup_extent(inode, iblock, &es)) {
+
+               if (ext4_es_is_hole(&es)) {
+                       retval = 0;
+                       down_read((&EXT4_I(inode)->i_data_sem));
+                       goto add_delayed;
+               }
+
+               /*
+                * Delayed extent could be allocated by fallocate.
+                * So we need to check it.
+                */
+               if (ext4_es_is_delayed(&es) && !ext4_es_is_unwritten(&es)) {
+                       map_bh(bh, inode->i_sb, invalid_block);
+                       set_buffer_new(bh);
+                       set_buffer_delay(bh);
+                       return 0;
+               }
+
+               map->m_pblk = ext4_es_pblock(&es) + iblock - es.es_lblk;
+               retval = es.es_len - (iblock - es.es_lblk);
+               if (retval > map->m_len)
+                       retval = map->m_len;
+               map->m_len = retval;
+               if (ext4_es_is_written(&es))
+                       map->m_flags |= EXT4_MAP_MAPPED;
+               else if (ext4_es_is_unwritten(&es))
+                       map->m_flags |= EXT4_MAP_UNWRITTEN;
+               else
+                       BUG_ON(1);
+
+               return retval;
+       }
+
        /*
         * Try to see if we can get the block without requesting a new
         * file system block.
@@ -1803,11 +1830,15 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
                        map->m_flags |= EXT4_MAP_FROM_CLUSTER;
                retval = 0;
        } else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
-               retval = ext4_ext_map_blocks(NULL, inode, map, 0);
+               retval = ext4_ext_map_blocks(NULL, inode, map,
+                                            EXT4_GET_BLOCKS_NO_PUT_HOLE);
        else
-               retval = ext4_ind_map_blocks(NULL, inode, map, 0);
+               retval = ext4_ind_map_blocks(NULL, inode, map,
+                                            EXT4_GET_BLOCKS_NO_PUT_HOLE);
 
+add_delayed:
        if (retval == 0) {
+               int ret;
                /*
                 * XXX: __block_prepare_write() unmaps passed block,
                 * is it OK?
@@ -1815,15 +1846,20 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
                /* If the block was allocated from previously allocated cluster,
                 * then we dont need to reserve it again. */
                if (!(map->m_flags & EXT4_MAP_FROM_CLUSTER)) {
-                       retval = ext4_da_reserve_space(inode, iblock);
-                       if (retval)
+                       ret = ext4_da_reserve_space(inode, iblock);
+                       if (ret) {
                                /* not enough space to reserve */
+                               retval = ret;
                                goto out_unlock;
+                       }
                }
 
-               retval = ext4_es_insert_extent(inode, map->m_lblk, map->m_len);
-               if (retval)
+               ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
+                                           ~0, EXTENT_STATUS_DELAYED);
+               if (ret) {
+                       retval = ret;
                        goto out_unlock;
+               }
 
                /* Clear EXT4_MAP_FROM_CLUSTER flag since its purpose is served
                 * and it should not appear on the bh->b_state.
@@ -1833,6 +1869,16 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
                map_bh(bh, inode->i_sb, invalid_block);
                set_buffer_new(bh);
                set_buffer_delay(bh);
+       } else if (retval > 0) {
+               int ret;
+               unsigned long long status;
+
+               status = map->m_flags & EXT4_MAP_UNWRITTEN ?
+                               EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
+               ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
+                                           map->m_pblk, status);
+               if (ret != 0)
+                       retval = ret;
        }
 
 out_unlock:
@@ -1890,27 +1936,6 @@ int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
        return 0;
 }
 
-/*
- * This function is used as a standard get_block_t calback function
- * when there is no desire to allocate any blocks.  It is used as a
- * callback function for block_write_begin() and block_write_full_page().
- * These functions should only try to map a single block at a time.
- *
- * Since this function doesn't do block allocations even if the caller
- * requests it by passing in create=1, it is critically important that
- * any caller checks to make sure that any buffer heads are returned
- * by this function are either all already mapped or marked for
- * delayed allocation before calling  block_write_full_page().  Otherwise,
- * b_blocknr could be left unitialized, and the page write functions will
- * be taken by surprise.
- */
-static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
-                                  struct buffer_head *bh_result, int create)
-{
-       BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
-       return _ext4_get_block(inode, iblock, bh_result, 0);
-}
-
 static int bget_one(handle_t *handle, struct buffer_head *bh)
 {
        get_bh(bh);
@@ -1955,7 +1980,8 @@ static int __ext4_journalled_writepage(struct page *page,
         * references to buffers so we are safe */
        unlock_page(page);
 
-       handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
+       handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
+                                   ext4_writepage_trans_blocks(inode));
        if (IS_ERR(handle)) {
                ret = PTR_ERR(handle);
                goto out;
@@ -2035,11 +2061,12 @@ out:
 static int ext4_writepage(struct page *page,
                          struct writeback_control *wbc)
 {
-       int ret = 0, commit_write = 0;
+       int ret = 0;
        loff_t size;
        unsigned int len;
        struct buffer_head *page_bufs = NULL;
        struct inode *inode = page->mapping->host;
+       struct ext4_io_submit io_submit;
 
        trace_ext4_writepage(page);
        size = i_size_read(inode);
@@ -2048,39 +2075,29 @@ static int ext4_writepage(struct page *page,
        else
                len = PAGE_CACHE_SIZE;
 
+       page_bufs = page_buffers(page);
        /*
-        * If the page does not have buffers (for whatever reason),
-        * try to create them using __block_write_begin.  If this
-        * fails, redirty the page and move on.
+        * We cannot do block allocation or other extent handling in this
+        * function. If there are buffers needing that, we have to redirty
+        * the page. But we may reach here when we do a journal commit via
+        * journal_submit_inode_data_buffers() and in that case we must write
+        * allocated buffers to achieve data=ordered mode guarantees.
         */
-       if (!page_has_buffers(page)) {
-               if (__block_write_begin(page, 0, len,
-                                       noalloc_get_block_write)) {
-               redirty_page:
-                       redirty_page_for_writepage(wbc, page);
+       if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
+                                  ext4_bh_delay_or_unwritten)) {
+               redirty_page_for_writepage(wbc, page);
+               if (current->flags & PF_MEMALLOC) {
+                       /*
+                        * For memory cleaning there's no point in writing only
+                        * some buffers. So just bail out. Warn if we came here
+                        * from direct reclaim.
+                        */
+                       WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD))
+                                                       == PF_MEMALLOC);
                        unlock_page(page);
                        return 0;
                }
-               commit_write = 1;
        }
-       page_bufs = page_buffers(page);
-       if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
-                                  ext4_bh_delay_or_unwritten)) {
-               /*
-                * We don't want to do block allocation, so redirty
-                * the page and return.  We may reach here when we do
-                * a journal commit via journal_submit_inode_data_buffers.
-                * We can also reach here via shrink_page_list but it
-                * should never be for direct reclaim so warn if that
-                * happens
-                */
-               WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
-                                                               PF_MEMALLOC);
-               goto redirty_page;
-       }
-       if (commit_write)
-               /* now mark the buffer_heads as dirty and uptodate */
-               block_commit_write(page, 0, len);
 
        if (PageChecked(page) && ext4_should_journal_data(inode))
                /*
@@ -2089,14 +2106,9 @@ static int ext4_writepage(struct page *page,
                 */
                return __ext4_journalled_writepage(page, len);
 
-       if (buffer_uninit(page_bufs)) {
-               ext4_set_bh_endio(page_bufs, inode);
-               ret = block_write_full_page_endio(page, noalloc_get_block_write,
-                                           wbc, ext4_end_io_buffer_write);
-       } else
-               ret = block_write_full_page(page, noalloc_get_block_write,
-                                           wbc);
-
+       memset(&io_submit, 0, sizeof(io_submit));
+       ret = ext4_bio_write_page(&io_submit, page, len, wbc);
+       ext4_io_submit(&io_submit);
        return ret;
 }
 
@@ -2228,51 +2240,38 @@ static int write_cache_pages_da(handle_t *handle,
                        logical = (sector_t) page->index <<
                                (PAGE_CACHE_SHIFT - inode->i_blkbits);
 
-                       if (!page_has_buffers(page)) {
-                               mpage_add_bh_to_extent(mpd, logical,
-                                                      PAGE_CACHE_SIZE,
-                                                      (1 << BH_Dirty) | (1 << BH_Uptodate));
-                               if (mpd->io_done)
-                                       goto ret_extent_tail;
-                       } else {
+                       /* Add all dirty buffers to mpd */
+                       head = page_buffers(page);
+                       bh = head;
+                       do {
+                               BUG_ON(buffer_locked(bh));
                                /*
-                                * Page with regular buffer heads,
-                                * just add all dirty ones
+                                * We need to try to allocate unmapped blocks
+                                * in the same page.  Otherwise we won't make
+                                * progress with the page in ext4_writepage
                                 */
-                               head = page_buffers(page);
-                               bh = head;
-                               do {
-                                       BUG_ON(buffer_locked(bh));
+                               if (ext4_bh_delay_or_unwritten(NULL, bh)) {
+                                       mpage_add_bh_to_extent(mpd, logical,
+                                                              bh->b_state);
+                                       if (mpd->io_done)
+                                               goto ret_extent_tail;
+                               } else if (buffer_dirty(bh) &&
+                                          buffer_mapped(bh)) {
                                        /*
-                                        * We need to try to allocate
-                                        * unmapped blocks in the same page.
-                                        * Otherwise we won't make progress
-                                        * with the page in ext4_writepage
+                                        * mapped dirty buffer. We need to
+                                        * update the b_state because we look
+                                        * at b_state in mpage_da_map_blocks.
+                                        * We don't update b_size because if we
+                                        * find an unmapped buffer_head later
+                                        * we need to use the b_state flag of
+                                        * that buffer_head.
                                         */
-                                       if (ext4_bh_delay_or_unwritten(NULL, bh)) {
-                                               mpage_add_bh_to_extent(mpd, logical,
-                                                                      bh->b_size,
-                                                                      bh->b_state);
-                                               if (mpd->io_done)
-                                                       goto ret_extent_tail;
-                                       } else if (buffer_dirty(bh) && (buffer_mapped(bh))) {
-                                               /*
-                                                * mapped dirty buffer. We need
-                                                * to update the b_state
-                                                * because we look at b_state
-                                                * in mpage_da_map_blocks.  We
-                                                * don't update b_size because
-                                                * if we find an unmapped
-                                                * buffer_head later we need to
-                                                * use the b_state flag of that
-                                                * buffer_head.
-                                                */
-                                               if (mpd->b_size == 0)
-                                                       mpd->b_state = bh->b_state & BH_FLAGS;
-                                       }
-                                       logical++;
-                               } while ((bh = bh->b_this_page) != head);
-                       }
+                                       if (mpd->b_size == 0)
+                                               mpd->b_state =
+                                                       bh->b_state & BH_FLAGS;
+                               }
+                               logical++;
+                       } while ((bh = bh->b_this_page) != head);
 
                        if (nr_to_write > 0) {
                                nr_to_write--;
@@ -2413,7 +2412,8 @@ retry:
                needed_blocks = ext4_da_writepages_trans_blocks(inode);
 
                /* start a new transaction*/
-               handle = ext4_journal_start(inode, needed_blocks);
+               handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
+                                           needed_blocks);
                if (IS_ERR(handle)) {
                        ret = PTR_ERR(handle);
                        ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
@@ -2555,42 +2555,52 @@ static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
                                                      pos, len, flags,
                                                      pagep, fsdata);
                if (ret < 0)
-                       goto out;
-               if (ret == 1) {
-                       ret = 0;
-                       goto out;
-               }
+                       return ret;
+               if (ret == 1)
+                       return 0;
        }
 
-retry:
+       /*
+        * grab_cache_page_write_begin() can take a long time if the
+        * system is thrashing due to memory pressure, or if the page
+        * is being written back.  So grab it first before we start
+        * the transaction handle.  This also allows us to allocate
+        * the page (if needed) without using GFP_NOFS.
+        */
+retry_grab:
+       page = grab_cache_page_write_begin(mapping, index, flags);
+       if (!page)
+               return -ENOMEM;
+       unlock_page(page);
+
        /*
         * With delayed allocation, we don't log the i_disksize update
         * if there is delayed block allocation. But we still need
         * to journalling the i_disksize update if writes to the end
         * of file which has an already mapped buffer.
         */
-       handle = ext4_journal_start(inode, 1);
+retry_journal:
+       handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, 1);
        if (IS_ERR(handle)) {
-               ret = PTR_ERR(handle);
-               goto out;
+               page_cache_release(page);
+               return PTR_ERR(handle);
        }
-       /* We cannot recurse into the filesystem as the transaction is already
-        * started */
-       flags |= AOP_FLAG_NOFS;
 
-       page = grab_cache_page_write_begin(mapping, index, flags);
-       if (!page) {
+       lock_page(page);
+       if (page->mapping != mapping) {
+               /* The page got truncated from under us */
+               unlock_page(page);
+               page_cache_release(page);
                ext4_journal_stop(handle);
-               ret = -ENOMEM;
-               goto out;
+               goto retry_grab;
        }
-       *pagep = page;
+       /* In case writeback began while the page was unlocked */
+       wait_on_page_writeback(page);
 
        ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
        if (ret < 0) {
                unlock_page(page);
                ext4_journal_stop(handle);
-               page_cache_release(page);
                /*
                 * block_write_begin may have instantiated a few blocks
                 * outside i_size.  Trim these off again. Don't need
@@ -2598,11 +2608,16 @@ retry:
                 */
                if (pos + len > inode->i_size)
                        ext4_truncate_failed_write(inode);
+
+               if (ret == -ENOSPC &&
+                   ext4_should_retry_alloc(inode->i_sb, &retries))
+                       goto retry_journal;
+
+               page_cache_release(page);
+               return ret;
        }
 
-       if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
-               goto retry;
-out:
+       *pagep = page;
        return ret;
 }
 
@@ -2858,36 +2873,10 @@ ext4_readpages(struct file *file, struct address_space *mapping,
        return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
 }
 
-static void ext4_invalidatepage_free_endio(struct page *page, unsigned long offset)
-{
-       struct buffer_head *head, *bh;
-       unsigned int curr_off = 0;
-
-       if (!page_has_buffers(page))
-               return;
-       head = bh = page_buffers(page);
-       do {
-               if (offset <= curr_off && test_clear_buffer_uninit(bh)
-                                       && bh->b_private) {
-                       ext4_free_io_end(bh->b_private);
-                       bh->b_private = NULL;
-                       bh->b_end_io = NULL;
-               }
-               curr_off = curr_off + bh->b_size;
-               bh = bh->b_this_page;
-       } while (bh != head);
-}
-
 static void ext4_invalidatepage(struct page *page, unsigned long offset)
 {
        trace_ext4_invalidatepage(page, offset);
 
-       /*
-        * free any io_end structure allocated for buffers to be discarded
-        */
-       if (ext4_should_dioread_nolock(page->mapping->host))
-               ext4_invalidatepage_free_endio(page, offset);
-
        /* No journalling happens on data buffers when this function is used */
        WARN_ON(page_has_buffers(page) && buffer_jbd(page_buffers(page)));
 
@@ -2977,9 +2966,9 @@ static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
        if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
                ext4_free_io_end(io_end);
 out:
+               inode_dio_done(inode);
                if (is_async)
                        aio_complete(iocb, ret, 0);
-               inode_dio_done(inode);
                return;
        }
 
@@ -2993,65 +2982,6 @@ out:
        ext4_add_complete_io(io_end);
 }
 
-static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate)
-{
-       ext4_io_end_t *io_end = bh->b_private;
-       struct inode *inode;
-
-       if (!test_clear_buffer_uninit(bh) || !io_end)
-               goto out;
-
-       if (!(io_end->inode->i_sb->s_flags & MS_ACTIVE)) {
-               ext4_msg(io_end->inode->i_sb, KERN_INFO,
-                        "sb umounted, discard end_io request for inode %lu",
-                        io_end->inode->i_ino);
-               ext4_free_io_end(io_end);
-               goto out;
-       }
-
-       /*
-        * It may be over-defensive here to check EXT4_IO_END_UNWRITTEN now,
-        * but being more careful is always safe for the future change.
-        */
-       inode = io_end->inode;
-       ext4_set_io_unwritten_flag(inode, io_end);
-       ext4_add_complete_io(io_end);
-out:
-       bh->b_private = NULL;
-       bh->b_end_io = NULL;
-       clear_buffer_uninit(bh);
-       end_buffer_async_write(bh, uptodate);
-}
-
-static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode)
-{
-       ext4_io_end_t *io_end;
-       struct page *page = bh->b_page;
-       loff_t offset = (sector_t)page->index << PAGE_CACHE_SHIFT;
-       size_t size = bh->b_size;
-
-retry:
-       io_end = ext4_init_io_end(inode, GFP_ATOMIC);
-       if (!io_end) {
-               pr_warn_ratelimited("%s: allocation fail\n", __func__);
-               schedule();
-               goto retry;
-       }
-       io_end->offset = offset;
-       io_end->size = size;
-       /*
-        * We need to hold a reference to the page to make sure it
-        * doesn't get evicted before ext4_end_io_work() has a chance
-        * to convert the extent from written to unwritten.
-        */
-       io_end->page = page;
-       get_page(io_end->page);
-
-       bh->b_private = io_end;
-       bh->b_end_io = ext4_end_io_buffer_write;
-       return 0;
-}
-
 /*
  * For ext4 extent files, ext4 will do direct-io write to holes,
  * preallocated extents, and those write extend the file, no need to
@@ -3557,16 +3487,16 @@ int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)
        if (!S_ISREG(inode->i_mode))
                return -EOPNOTSUPP;
 
-       if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
-               /* TODO: Add support for non extent hole punching */
-               return -EOPNOTSUPP;
-       }
+       if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
+               return ext4_ind_punch_hole(file, offset, length);
 
        if (EXT4_SB(inode->i_sb)->s_cluster_ratio > 1) {
                /* TODO: Add support for bigalloc file systems */
                return -EOPNOTSUPP;
        }
 
+       trace_ext4_punch_hole(inode, offset, length);
+
        return ext4_ext_punch_hole(file, offset, length);
 }
 
@@ -3660,11 +3590,8 @@ static int __ext4_get_inode_loc(struct inode *inode,
        iloc->offset = (inode_offset % inodes_per_block) * EXT4_INODE_SIZE(sb);
 
        bh = sb_getblk(sb, block);
-       if (!bh) {
-               EXT4_ERROR_INODE_BLOCK(inode, block,
-                                      "unable to read itable block");
-               return -EIO;
-       }
+       if (unlikely(!bh))
+               return -ENOMEM;
        if (!buffer_uptodate(bh)) {
                lock_buffer(bh);
 
@@ -3696,7 +3623,7 @@ static int __ext4_get_inode_loc(struct inode *inode,
 
                        /* Is the inode bitmap in cache? */
                        bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
-                       if (!bitmap_bh)
+                       if (unlikely(!bitmap_bh))
                                goto make_io;
 
                        /*
@@ -4404,8 +4331,9 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr)
 
                /* (user+group)*(old+new) structure, inode write (sb,
                 * inode block, ? - but truncate inode update has it) */
-               handle = ext4_journal_start(inode, (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
-                                       EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb))+3);
+               handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
+                       (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) +
+                        EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)) + 3);
                if (IS_ERR(handle)) {
                        error = PTR_ERR(handle);
                        goto err_out;
@@ -4440,7 +4368,7 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr)
            (attr->ia_size < inode->i_size)) {
                handle_t *handle;
 
-               handle = ext4_journal_start(inode, 3);
+               handle = ext4_journal_start(inode, EXT4_HT_INODE, 3);
                if (IS_ERR(handle)) {
                        error = PTR_ERR(handle);
                        goto err_out;
@@ -4460,7 +4388,8 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr)
                                                            attr->ia_size);
                        if (error) {
                                /* Do as much error cleanup as possible */
-                               handle = ext4_journal_start(inode, 3);
+                               handle = ext4_journal_start(inode,
+                                                           EXT4_HT_INODE, 3);
                                if (IS_ERR(handle)) {
                                        ext4_orphan_del(NULL, inode);
                                        goto err_out;
@@ -4801,7 +4730,7 @@ void ext4_dirty_inode(struct inode *inode, int flags)
 {
        handle_t *handle;
 
-       handle = ext4_journal_start(inode, 2);
+       handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
        if (IS_ERR(handle))
                goto out;
 
@@ -4902,7 +4831,7 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val)
 
        /* Finally we can mark the inode as dirty. */
 
-       handle = ext4_journal_start(inode, 1);
+       handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
        if (IS_ERR(handle))
                return PTR_ERR(handle);
 
@@ -4980,7 +4909,8 @@ int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
        else
                get_block = ext4_get_block;
 retry_alloc:
-       handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
+       handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
+                                   ext4_writepage_trans_blocks(inode));
        if (IS_ERR(handle)) {
                ret = VM_FAULT_SIGBUS;
                goto out;
index 5747f52..31f4f56 100644 (file)
@@ -104,7 +104,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                } else if (oldflags & EXT4_EOFBLOCKS_FL)
                        ext4_truncate(inode);
 
-               handle = ext4_journal_start(inode, 1);
+               handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
                if (IS_ERR(handle)) {
                        err = PTR_ERR(handle);
                        goto flags_out;
@@ -173,7 +173,7 @@ flags_out:
                }
 
                mutex_lock(&inode->i_mutex);
-               handle = ext4_journal_start(inode, 1);
+               handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
                if (IS_ERR(handle)) {
                        err = PTR_ERR(handle);
                        goto unlock_out;
@@ -313,6 +313,9 @@ mext_out:
                if (err == 0)
                        err = err2;
                mnt_drop_write_file(filp);
+               if (!err && ext4_has_group_desc_csum(sb) &&
+                   test_opt(sb, INIT_INODE_TABLE))
+                       err = ext4_register_li_request(sb, input.group);
 group_add_out:
                ext4_resize_end(sb);
                return err;
@@ -358,6 +361,7 @@ group_add_out:
                ext4_fsblk_t n_blocks_count;
                struct super_block *sb = inode->i_sb;
                int err = 0, err2 = 0;
+               ext4_group_t o_group = EXT4_SB(sb)->s_groups_count;
 
                if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
                               EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
@@ -388,6 +392,11 @@ group_add_out:
                if (err == 0)
                        err = err2;
                mnt_drop_write_file(filp);
+               if (!err && (o_group > EXT4_SB(sb)->s_groups_count) &&
+                   ext4_has_group_desc_csum(sb) &&
+                   test_opt(sb, INIT_INODE_TABLE))
+                       err = ext4_register_li_request(sb, o_group);
+
 resizefs_out:
                ext4_resize_end(sb);
                return err;
index 1bf6fe7..6540ebe 100644 (file)
 
 #include "ext4_jbd2.h"
 #include "mballoc.h"
-#include <linux/debugfs.h>
 #include <linux/log2.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <trace/events/ext4.h>
 
+#ifdef CONFIG_EXT4_DEBUG
+ushort ext4_mballoc_debug __read_mostly;
+
+module_param_named(mballoc_debug, ext4_mballoc_debug, ushort, 0644);
+MODULE_PARM_DESC(mballoc_debug, "Debugging level for ext4's mballoc");
+#endif
+
 /*
  * MUSTDO:
  *   - test ext4_ext_search_left() and ext4_ext_search_right()
@@ -1884,15 +1891,19 @@ static int ext4_mb_good_group(struct ext4_allocation_context *ac,
        case 0:
                BUG_ON(ac->ac_2order == 0);
 
-               if (grp->bb_largest_free_order < ac->ac_2order)
-                       return 0;
-
                /* Avoid using the first bg of a flexgroup for data files */
                if ((ac->ac_flags & EXT4_MB_HINT_DATA) &&
                    (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) &&
                    ((group % flex_size) == 0))
                        return 0;
 
+               if ((ac->ac_2order > ac->ac_sb->s_blocksize_bits+1) ||
+                   (free / fragments) >= ac->ac_g_ex.fe_len)
+                       return 1;
+
+               if (grp->bb_largest_free_order < ac->ac_2order)
+                       return 0;
+
                return 1;
        case 1:
                if ((free / fragments) >= ac->ac_g_ex.fe_len)
@@ -2007,7 +2018,7 @@ repeat:
                        }
 
                        ac->ac_groups_scanned++;
-                       if (cr == 0)
+                       if (cr == 0 && ac->ac_2order < sb->s_blocksize_bits+2)
                                ext4_mb_simple_scan_group(ac, &e4b);
                        else if (cr == 1 && sbi->s_stripe &&
                                        !(ac->ac_g_ex.fe_len % sbi->s_stripe))
@@ -2656,40 +2667,6 @@ static void ext4_free_data_callback(struct super_block *sb,
        mb_debug(1, "freed %u blocks in %u structures\n", count, count2);
 }
 
-#ifdef CONFIG_EXT4_DEBUG
-u8 mb_enable_debug __read_mostly;
-
-static struct dentry *debugfs_dir;
-static struct dentry *debugfs_debug;
-
-static void __init ext4_create_debugfs_entry(void)
-{
-       debugfs_dir = debugfs_create_dir("ext4", NULL);
-       if (debugfs_dir)
-               debugfs_debug = debugfs_create_u8("mballoc-debug",
-                                                 S_IRUGO | S_IWUSR,
-                                                 debugfs_dir,
-                                                 &mb_enable_debug);
-}
-
-static void ext4_remove_debugfs_entry(void)
-{
-       debugfs_remove(debugfs_debug);
-       debugfs_remove(debugfs_dir);
-}
-
-#else
-
-static void __init ext4_create_debugfs_entry(void)
-{
-}
-
-static void ext4_remove_debugfs_entry(void)
-{
-}
-
-#endif
-
 int __init ext4_init_mballoc(void)
 {
        ext4_pspace_cachep = KMEM_CACHE(ext4_prealloc_space,
@@ -2711,7 +2688,6 @@ int __init ext4_init_mballoc(void)
                kmem_cache_destroy(ext4_ac_cachep);
                return -ENOMEM;
        }
-       ext4_create_debugfs_entry();
        return 0;
 }
 
@@ -2726,7 +2702,6 @@ void ext4_exit_mballoc(void)
        kmem_cache_destroy(ext4_ac_cachep);
        kmem_cache_destroy(ext4_free_data_cachep);
        ext4_groupinfo_destroy_slabs();
-       ext4_remove_debugfs_entry();
 }
 
 
@@ -3872,7 +3847,7 @@ static void ext4_mb_show_ac(struct ext4_allocation_context *ac)
        struct super_block *sb = ac->ac_sb;
        ext4_group_t ngroups, i;
 
-       if (!mb_enable_debug ||
+       if (!ext4_mballoc_debug ||
            (EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED))
                return;
 
@@ -4005,8 +3980,8 @@ ext4_mb_initialize_context(struct ext4_allocation_context *ac,
        len = ar->len;
 
        /* just a dirty hack to filter too big requests  */
-       if (len >= EXT4_CLUSTERS_PER_GROUP(sb) - 10)
-               len = EXT4_CLUSTERS_PER_GROUP(sb) - 10;
+       if (len >= EXT4_CLUSTERS_PER_GROUP(sb))
+               len = EXT4_CLUSTERS_PER_GROUP(sb);
 
        /* start searching from the goal */
        goal = ar->goal;
@@ -4136,7 +4111,7 @@ static void ext4_mb_add_n_trim(struct ext4_allocation_context *ac)
                /* The max size of hash table is PREALLOC_TB_SIZE */
                order = PREALLOC_TB_SIZE - 1;
        /* Add the prealloc space to lg */
-       rcu_read_lock();
+       spin_lock(&lg->lg_prealloc_lock);
        list_for_each_entry_rcu(tmp_pa, &lg->lg_prealloc_list[order],
                                                pa_inode_list) {
                spin_lock(&tmp_pa->pa_lock);
@@ -4160,12 +4135,12 @@ static void ext4_mb_add_n_trim(struct ext4_allocation_context *ac)
        if (!added)
                list_add_tail_rcu(&pa->pa_inode_list,
                                        &lg->lg_prealloc_list[order]);
-       rcu_read_unlock();
+       spin_unlock(&lg->lg_prealloc_lock);
 
        /* Now trim the list to be not more than 8 elements */
        if (lg_prealloc_count > 8) {
                ext4_mb_discard_lg_preallocations(sb, lg,
-                                               order, lg_prealloc_count);
+                                                 order, lg_prealloc_count);
                return;
        }
        return ;
index 3ccd889..08481ee 100644 (file)
 /*
  */
 #ifdef CONFIG_EXT4_DEBUG
-extern u8 mb_enable_debug;
+extern ushort ext4_mballoc_debug;
 
 #define mb_debug(n, fmt, a...)                                         \
        do {                                                            \
-               if ((n) <= mb_enable_debug) {                           \
+               if ((n) <= ext4_mballoc_debug) {                        \
                        printk(KERN_DEBUG "(%s, %d): %s: ",             \
                               __FILE__, __LINE__, __func__);           \
                        printk(fmt, ## a);                              \
index db8226d..480acf4 100644 (file)
@@ -456,11 +456,14 @@ int ext4_ext_migrate(struct inode *inode)
                 */
                return retval;
 
-       handle = ext4_journal_start(inode,
-                                       EXT4_DATA_TRANS_BLOCKS(inode->i_sb) +
-                                       EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
-                                       EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)
-                                       + 1);
+       /*
+        * Worst case we can touch the allocation bitmaps, a bgd
+        * block, and a block to link in the orphan list.  We do need
+        * need to worry about credits for modifying the quota inode.
+        */
+       handle = ext4_journal_start(inode, EXT4_HT_MIGRATE,
+               4 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb));
+
        if (IS_ERR(handle)) {
                retval = PTR_ERR(handle);
                return retval;
@@ -507,7 +510,7 @@ int ext4_ext_migrate(struct inode *inode)
        ext4_set_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
        up_read((&EXT4_I(inode)->i_data_sem));
 
-       handle = ext4_journal_start(inode, 1);
+       handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, 1);
        if (IS_ERR(handle)) {
                /*
                 * It is impossible to update on-disk structures without
index fe7c63f..f9b5515 100644 (file)
@@ -80,6 +80,8 @@ static int read_mmp_block(struct super_block *sb, struct buffer_head **bh,
         * is not blocked in the elevator. */
        if (!*bh)
                *bh = sb_getblk(sb, mmp_block);
+       if (!*bh)
+               return -ENOMEM;
        if (*bh) {
                get_bh(*bh);
                lock_buffer(*bh);
@@ -91,7 +93,7 @@ static int read_mmp_block(struct super_block *sb, struct buffer_head **bh,
                        *bh = NULL;
                }
        }
-       if (!*bh) {
+       if (unlikely(!*bh)) {
                ext4_warning(sb, "Error while reading MMP block %llu",
                             mmp_block);
                return -EIO;
index d9cc5ee..d78c33e 100644 (file)
@@ -681,6 +681,8 @@ mext_replace_branches(handle_t *handle, struct inode *orig_inode,
 
        depth = ext_depth(donor_inode);
        dext = donor_path[depth].p_ext;
+       if (unlikely(!dext))
+               goto missing_donor_extent;
        tmp_dext = *dext;
 
        *err = mext_calc_swap_extents(&tmp_dext, &tmp_oext, orig_off,
@@ -691,7 +693,8 @@ mext_replace_branches(handle_t *handle, struct inode *orig_inode,
        /* Loop for the donor extents */
        while (1) {
                /* The extent for donor must be found. */
-               if (!dext) {
+               if (unlikely(!dext)) {
+               missing_donor_extent:
                        EXT4_ERROR_INODE(donor_inode,
                                   "The extent for donor must be found");
                        *err = -EIO;
@@ -761,9 +764,6 @@ out:
                kfree(donor_path);
        }
 
-       ext4_ext_invalidate_cache(orig_inode);
-       ext4_ext_invalidate_cache(donor_inode);
-
        return replaced_count;
 }
 
@@ -920,7 +920,7 @@ move_extent_per_page(struct file *o_filp, struct inode *donor_inode,
 again:
        *err = 0;
        jblocks = ext4_writepage_trans_blocks(orig_inode) * 2;
-       handle = ext4_journal_start(orig_inode, jblocks);
+       handle = ext4_journal_start(orig_inode, EXT4_HT_MOVE_EXTENTS, jblocks);
        if (IS_ERR(handle)) {
                *err = PTR_ERR(handle);
                return 0;
index cc9a512..2a7015d 100644 (file)
 
 static struct buffer_head *ext4_append(handle_t *handle,
                                        struct inode *inode,
-                                       ext4_lblk_t *block, int *err)
+                                       ext4_lblk_t *block)
 {
        struct buffer_head *bh;
+       int err = 0;
 
        if (unlikely(EXT4_SB(inode->i_sb)->s_max_dir_size_kb &&
                     ((inode->i_size >> 10) >=
-                     EXT4_SB(inode->i_sb)->s_max_dir_size_kb))) {
-               *err = -ENOSPC;
-               return NULL;
-       }
+                     EXT4_SB(inode->i_sb)->s_max_dir_size_kb)))
+               return ERR_PTR(-ENOSPC);
 
        *block = inode->i_size >> inode->i_sb->s_blocksize_bits;
 
-       bh = ext4_bread(handle, inode, *block, 1, err);
-       if (bh) {
-               inode->i_size += inode->i_sb->s_blocksize;
-               EXT4_I(inode)->i_disksize = inode->i_size;
-               *err = ext4_journal_get_write_access(handle, bh);
-               if (*err) {
+       bh = ext4_bread(handle, inode, *block, 1, &err);
+       if (!bh)
+               return ERR_PTR(err);
+       inode->i_size += inode->i_sb->s_blocksize;
+       EXT4_I(inode)->i_disksize = inode->i_size;
+       err = ext4_journal_get_write_access(handle, bh);
+       if (err) {
+               brelse(bh);
+               ext4_std_error(inode->i_sb, err);
+               return ERR_PTR(err);
+       }
+       return bh;
+}
+
+static int ext4_dx_csum_verify(struct inode *inode,
+                              struct ext4_dir_entry *dirent);
+
+typedef enum {
+       EITHER, INDEX, DIRENT
+} dirblock_type_t;
+
+#define ext4_read_dirblock(inode, block, type) \
+       __ext4_read_dirblock((inode), (block), (type), __LINE__)
+
+static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
+                                             ext4_lblk_t block,
+                                             dirblock_type_t type,
+                                             unsigned int line)
+{
+       struct buffer_head *bh;
+       struct ext4_dir_entry *dirent;
+       int err = 0, is_dx_block = 0;
+
+       bh = ext4_bread(NULL, inode, block, 0, &err);
+       if (!bh) {
+               if (err == 0) {
+                       ext4_error_inode(inode, __func__, line, block,
+                                              "Directory hole found");
+                       return ERR_PTR(-EIO);
+               }
+               __ext4_warning(inode->i_sb, __func__, line,
+                              "error reading directory block "
+                              "(ino %lu, block %lu)", inode->i_ino,
+                              (unsigned long) block);
+               return ERR_PTR(err);
+       }
+       dirent = (struct ext4_dir_entry *) bh->b_data;
+       /* Determine whether or not we have an index block */
+       if (is_dx(inode)) {
+               if (block == 0)
+                       is_dx_block = 1;
+               else if (ext4_rec_len_from_disk(dirent->rec_len,
+                                               inode->i_sb->s_blocksize) ==
+                        inode->i_sb->s_blocksize)
+                       is_dx_block = 1;
+       }
+       if (!is_dx_block && type == INDEX) {
+               ext4_error_inode(inode, __func__, line, block,
+                      "directory leaf block found instead of index block");
+               return ERR_PTR(-EIO);
+       }
+       if (!EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
+                                       EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) ||
+           buffer_verified(bh))
+               return bh;
+
+       /*
+        * An empty leaf block can get mistaken for a index block; for
+        * this reason, we can only check the index checksum when the
+        * caller is sure it should be an index block.
+        */
+       if (is_dx_block && type == INDEX) {
+               if (ext4_dx_csum_verify(inode, dirent))
+                       set_buffer_verified(bh);
+               else {
+                       ext4_error_inode(inode, __func__, line, block,
+                               "Directory index failed checksum");
                        brelse(bh);
-                       bh = NULL;
+                       return ERR_PTR(-EIO);
                }
        }
-       if (!bh && !(*err)) {
-               *err = -EIO;
-               ext4_error(inode->i_sb,
-                          "Directory hole detected on inode %lu\n",
-                          inode->i_ino);
+       if (!is_dx_block) {
+               if (ext4_dirent_csum_verify(inode, dirent))
+                       set_buffer_verified(bh);
+               else {
+                       ext4_error_inode(inode, __func__, line, block,
+                               "Directory block failed checksum");
+                       brelse(bh);
+                       return ERR_PTR(-EIO);
+               }
        }
        return bh;
 }
@@ -603,9 +677,9 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
        u32 hash;
 
        frame->bh = NULL;
-       if (!(bh = ext4_bread(NULL, dir, 0, 0, err))) {
-               if (*err == 0)
-                       *err = ERR_BAD_DX_DIR;
+       bh = ext4_read_dirblock(dir, 0, INDEX);
+       if (IS_ERR(bh)) {
+               *err = PTR_ERR(bh);
                goto fail;
        }
        root = (struct dx_root *) bh->b_data;
@@ -642,15 +716,6 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
                goto fail;
        }
 
-       if (!buffer_verified(bh) &&
-           !ext4_dx_csum_verify(dir, (struct ext4_dir_entry *)bh->b_data)) {
-               ext4_warning(dir->i_sb, "Root failed checksum");
-               brelse(bh);
-               *err = ERR_BAD_DX_DIR;
-               goto fail;
-       }
-       set_buffer_verified(bh);
-
        entries = (struct dx_entry *) (((char *)&root->info) +
                                       root->info.info_length);
 
@@ -708,22 +773,12 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
                frame->entries = entries;
                frame->at = at;
                if (!indirect--) return frame;
-               if (!(bh = ext4_bread(NULL, dir, dx_get_block(at), 0, err))) {
-                       if (!(*err))
-                               *err = ERR_BAD_DX_DIR;
-                       goto fail2;
-               }
-               at = entries = ((struct dx_node *) bh->b_data)->entries;
-
-               if (!buffer_verified(bh) &&
-                   !ext4_dx_csum_verify(dir,
-                                        (struct ext4_dir_entry *)bh->b_data)) {
-                       ext4_warning(dir->i_sb, "Node failed checksum");
-                       brelse(bh);
-                       *err = ERR_BAD_DX_DIR;
+               bh = ext4_read_dirblock(dir, dx_get_block(at), INDEX);
+               if (IS_ERR(bh)) {
+                       *err = PTR_ERR(bh);
                        goto fail2;
                }
-               set_buffer_verified(bh);
+               entries = ((struct dx_node *) bh->b_data)->entries;
 
                if (dx_get_limit(entries) != dx_node_limit (dir)) {
                        ext4_warning(dir->i_sb,
@@ -782,7 +837,7 @@ static int ext4_htree_next_block(struct inode *dir, __u32 hash,
 {
        struct dx_frame *p;
        struct buffer_head *bh;
-       int err, num_frames = 0;
+       int num_frames = 0;
        __u32 bhash;
 
        p = frame;
@@ -821,25 +876,9 @@ static int ext4_htree_next_block(struct inode *dir, __u32 hash,
         * block so no check is necessary
         */
        while (num_frames--) {
-               if (!(bh = ext4_bread(NULL, dir, dx_get_block(p->at),
-                                     0, &err))) {
-                       if (!err) {
-                               ext4_error(dir->i_sb,
-                                          "Directory hole detected on inode %lu\n",
-                                          dir->i_ino);
-                               return -EIO;
-                       }
-                       return err; /* Failure */
-               }
-
-               if (!buffer_verified(bh) &&
-                   !ext4_dx_csum_verify(dir,
-                                        (struct ext4_dir_entry *)bh->b_data)) {
-                       ext4_warning(dir->i_sb, "Node failed checksum");
-                       return -EIO;
-               }
-               set_buffer_verified(bh);
-
+               bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
+               if (IS_ERR(bh))
+                       return PTR_ERR(bh);
                p++;
                brelse(p->bh);
                p->bh = bh;
@@ -865,20 +904,9 @@ static int htree_dirblock_to_tree(struct file *dir_file,
 
        dxtrace(printk(KERN_INFO "In htree dirblock_to_tree: block %lu\n",
                                                        (unsigned long)block));
-       if (!(bh = ext4_bread(NULL, dir, block, 0, &err))) {
-               if (!err) {
-                       err = -EIO;
-                       ext4_error(dir->i_sb,
-                                  "Directory hole detected on inode %lu\n",
-                                  dir->i_ino);
-               }
-               return err;
-       }
-
-       if (!buffer_verified(bh) &&
-           !ext4_dirent_csum_verify(dir, (struct ext4_dir_entry *)bh->b_data))
-               return -EIO;
-       set_buffer_verified(bh);
+       bh = ext4_read_dirblock(dir, block, DIRENT);
+       if (IS_ERR(bh))
+               return PTR_ERR(bh);
 
        de = (struct ext4_dir_entry_2 *) bh->b_data;
        top = (struct ext4_dir_entry_2 *) ((char *) de +
@@ -1332,26 +1360,11 @@ static struct buffer_head * ext4_dx_find_entry(struct inode *dir, const struct q
                return NULL;
        do {
                block = dx_get_block(frame->at);
-               if (!(bh = ext4_bread(NULL, dir, block, 0, err))) {
-                       if (!(*err)) {
-                               *err = -EIO;
-                               ext4_error(dir->i_sb,
-                                          "Directory hole detected on inode %lu\n",
-                                          dir->i_ino);
-                       }
-                       goto errout;
-               }
-
-               if (!buffer_verified(bh) &&
-                   !ext4_dirent_csum_verify(dir,
-                               (struct ext4_dir_entry *)bh->b_data)) {
-                       EXT4_ERROR_INODE(dir, "checksumming directory "
-                                        "block %lu", (unsigned long)block);
-                       brelse(bh);
-                       *err = -EIO;
+               bh = ext4_read_dirblock(dir, block, DIRENT);
+               if (IS_ERR(bh)) {
+                       *err = PTR_ERR(bh);
                        goto errout;
                }
-               set_buffer_verified(bh);
                retval = search_dirblock(bh, dir, d_name,
                                         block << EXT4_BLOCK_SIZE_BITS(sb),
                                         res_dir);
@@ -1535,11 +1548,12 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
                                       EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
                csum_size = sizeof(struct ext4_dir_entry_tail);
 
-       bh2 = ext4_append (handle, dir, &newblock, &err);
-       if (!(bh2)) {
+       bh2 = ext4_append(handle, dir, &newblock);
+       if (IS_ERR(bh2)) {
                brelse(*bh);
                *bh = NULL;
-               goto errout;
+               *error = PTR_ERR(bh2);
+               return NULL;
        }
 
        BUFFER_TRACE(*bh, "get_write_access");
@@ -1620,7 +1634,6 @@ journal_error:
        brelse(bh2);
        *bh = NULL;
        ext4_std_error(dir->i_sb, err);
-errout:
        *error = err;
        return NULL;
 }
@@ -1698,7 +1711,6 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
        const char      *name = dentry->d_name.name;
        int             namelen = dentry->d_name.len;
        unsigned int    blocksize = dir->i_sb->s_blocksize;
-       unsigned short  reclen;
        int             csum_size = 0;
        int             err;
 
@@ -1706,7 +1718,6 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
                                       EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
                csum_size = sizeof(struct ext4_dir_entry_tail);
 
-       reclen = EXT4_DIR_REC_LEN(namelen);
        if (!de) {
                err = ext4_find_dest_de(dir, inode,
                                        bh, bh->b_data, blocksize - csum_size,
@@ -1797,10 +1808,10 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
        len = ((char *) root) + (blocksize - csum_size) - (char *) de;
 
        /* Allocate new block for the 0th block's dirents */
-       bh2 = ext4_append(handle, dir, &block, &retval);
-       if (!(bh2)) {
+       bh2 = ext4_append(handle, dir, &block);
+       if (IS_ERR(bh2)) {
                brelse(bh);
-               return retval;
+               return PTR_ERR(bh2);
        }
        ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
        data1 = bh2->b_data;
@@ -1917,20 +1928,10 @@ static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
        }
        blocks = dir->i_size >> sb->s_blocksize_bits;
        for (block = 0; block < blocks; block++) {
-               if (!(bh = ext4_bread(handle, dir, block, 0, &retval))) {
-                       if (!retval) {
-                               retval = -EIO;
-                               ext4_error(inode->i_sb,
-                                          "Directory hole detected on inode %lu\n",
-                                          inode->i_ino);
-                       }
-                       return retval;
-               }
-               if (!buffer_verified(bh) &&
-                   !ext4_dirent_csum_verify(dir,
-                               (struct ext4_dir_entry *)bh->b_data))
-                       return -EIO;
-               set_buffer_verified(bh);
+               bh = ext4_read_dirblock(dir, block, DIRENT);
+               if (IS_ERR(bh))
+                       return PTR_ERR(bh);
+
                retval = add_dirent_to_buf(handle, dentry, inode, NULL, bh);
                if (retval != -ENOSPC) {
                        brelse(bh);
@@ -1942,9 +1943,9 @@ static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
                        return make_indexed_dir(handle, dentry, inode, bh);
                brelse(bh);
        }
-       bh = ext4_append(handle, dir, &block, &retval);
-       if (!bh)
-               return retval;
+       bh = ext4_append(handle, dir, &block);
+       if (IS_ERR(bh))
+               return PTR_ERR(bh);
        de = (struct ext4_dir_entry_2 *) bh->b_data;
        de->inode = 0;
        de->rec_len = ext4_rec_len_to_disk(blocksize - csum_size, blocksize);
@@ -1981,22 +1982,13 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
                return err;
        entries = frame->entries;
        at = frame->at;
-
-       if (!(bh = ext4_bread(handle, dir, dx_get_block(frame->at), 0, &err))) {
-               if (!err) {
-                       err = -EIO;
-                       ext4_error(dir->i_sb,
-                                  "Directory hole detected on inode %lu\n",
-                                  dir->i_ino);
-               }
+       bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT);
+       if (IS_ERR(bh)) {
+               err = PTR_ERR(bh);
+               bh = NULL;
                goto cleanup;
        }
 
-       if (!buffer_verified(bh) &&
-           !ext4_dirent_csum_verify(dir, (struct ext4_dir_entry *)bh->b_data))
-               goto journal_error;
-       set_buffer_verified(bh);
-
        BUFFER_TRACE(bh, "get_write_access");
        err = ext4_journal_get_write_access(handle, bh);
        if (err)
@@ -2024,9 +2016,11 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
                        err = -ENOSPC;
                        goto cleanup;
                }
-               bh2 = ext4_append (handle, dir, &newblock, &err);
-               if (!(bh2))
+               bh2 = ext4_append(handle, dir, &newblock);
+               if (IS_ERR(bh2)) {
+                       err = PTR_ERR(bh2);
                        goto cleanup;
+               }
                node2 = (struct dx_node *)(bh2->b_data);
                entries2 = node2->entries;
                memset(&node2->fake, 0, sizeof(struct fake_dirent));
@@ -2105,8 +2099,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
 journal_error:
        ext4_std_error(dir->i_sb, err);
 cleanup:
-       if (bh)
-               brelse(bh);
+       brelse(bh);
        dx_release(frames);
        return err;
 }
@@ -2253,29 +2246,28 @@ static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 {
        handle_t *handle;
        struct inode *inode;
-       int err, retries = 0;
+       int err, credits, retries = 0;
 
        dquot_initialize(dir);
 
+       credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
+                  EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
+                  EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
 retry:
-       handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
-                                       EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
-                                       EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
-       if (IS_ERR(handle))
-               return PTR_ERR(handle);
-
-       if (IS_DIRSYNC(dir))
-               ext4_handle_sync(handle);
-
-       inode = ext4_new_inode(handle, dir, mode, &dentry->d_name, 0, NULL);
+       inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
+                                           NULL, EXT4_HT_DIR, credits);
+       handle = ext4_journal_current_handle();
        err = PTR_ERR(inode);
        if (!IS_ERR(inode)) {
                inode->i_op = &ext4_file_inode_operations;
                inode->i_fop = &ext4_file_operations;
                ext4_set_aops(inode);
                err = ext4_add_nondir(handle, dentry, inode);
+               if (!err && IS_DIRSYNC(dir))
+                       ext4_handle_sync(handle);
        }
-       ext4_journal_stop(handle);
+       if (handle)
+               ext4_journal_stop(handle);
        if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
                goto retry;
        return err;
@@ -2286,31 +2278,30 @@ static int ext4_mknod(struct inode *dir, struct dentry *dentry,
 {
        handle_t *handle;
        struct inode *inode;
-       int err, retries = 0;
+       int err, credits, retries = 0;
 
        if (!new_valid_dev(rdev))
                return -EINVAL;
 
        dquot_initialize(dir);
 
+       credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
+                  EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
+                  EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
 retry:
-       handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
-                                       EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
-                                       EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
-       if (IS_ERR(handle))
-               return PTR_ERR(handle);
-
-       if (IS_DIRSYNC(dir))
-               ext4_handle_sync(handle);
-
-       inode = ext4_new_inode(handle, dir, mode, &dentry->d_name, 0, NULL);
+       inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
+                                           NULL, EXT4_HT_DIR, credits);
+       handle = ext4_journal_current_handle();
        err = PTR_ERR(inode);
        if (!IS_ERR(inode)) {
                init_special_inode(inode, inode->i_mode, rdev);
                inode->i_op = &ext4_special_inode_operations;
                err = ext4_add_nondir(handle, dentry, inode);
+               if (!err && IS_DIRSYNC(dir))
+                       ext4_handle_sync(handle);
        }
-       ext4_journal_stop(handle);
+       if (handle)
+               ext4_journal_stop(handle);
        if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
                goto retry;
        return err;
@@ -2350,6 +2341,7 @@ static int ext4_init_new_dir(handle_t *handle, struct inode *dir,
        struct buffer_head *dir_block = NULL;
        struct ext4_dir_entry_2 *de;
        struct ext4_dir_entry_tail *t;
+       ext4_lblk_t block = 0;
        unsigned int blocksize = dir->i_sb->s_blocksize;
        int csum_size = 0;
        int err;
@@ -2366,16 +2358,10 @@ static int ext4_init_new_dir(handle_t *handle, struct inode *dir,
                        goto out;
        }
 
-       inode->i_size = EXT4_I(inode)->i_disksize = blocksize;
-       if (!(dir_block = ext4_bread(handle, inode, 0, 1, &err))) {
-               if (!err) {
-                       err = -EIO;
-                       ext4_error(inode->i_sb,
-                                  "Directory hole detected on inode %lu\n",
-                                  inode->i_ino);
-               }
-               goto out;
-       }
+       inode->i_size = 0;
+       dir_block = ext4_append(handle, inode, &block);
+       if (IS_ERR(dir_block))
+               return PTR_ERR(dir_block);
        BUFFER_TRACE(dir_block, "get_write_access");
        err = ext4_journal_get_write_access(handle, dir_block);
        if (err)
@@ -2402,25 +2388,21 @@ static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
        handle_t *handle;
        struct inode *inode;
-       int err, retries = 0;
+       int err, credits, retries = 0;
 
        if (EXT4_DIR_LINK_MAX(dir))
                return -EMLINK;
 
        dquot_initialize(dir);
 
+       credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
+                  EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
+                  EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
 retry:
-       handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
-                                       EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
-                                       EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
-       if (IS_ERR(handle))
-               return PTR_ERR(handle);
-
-       if (IS_DIRSYNC(dir))
-               ext4_handle_sync(handle);
-
-       inode = ext4_new_inode(handle, dir, S_IFDIR | mode,
-                              &dentry->d_name, 0, NULL);
+       inode = ext4_new_inode_start_handle(dir, S_IFDIR | mode,
+                                           &dentry->d_name,
+                                           0, NULL, EXT4_HT_DIR, credits);
+       handle = ext4_journal_current_handle();
        err = PTR_ERR(inode);
        if (IS_ERR(inode))
                goto out_stop;
@@ -2448,8 +2430,12 @@ out_clear_inode:
                goto out_clear_inode;
        unlock_new_inode(inode);
        d_instantiate(dentry, inode);
+       if (IS_DIRSYNC(dir))
+               ext4_handle_sync(handle);
+
 out_stop:
-       ext4_journal_stop(handle);
+       if (handle)
+               ext4_journal_stop(handle);
        if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
                goto retry;
        return err;
@@ -2475,25 +2461,14 @@ static int empty_dir(struct inode *inode)
        }
 
        sb = inode->i_sb;
-       if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2) ||
-           !(bh = ext4_bread(NULL, inode, 0, 0, &err))) {
-               if (err)
-                       EXT4_ERROR_INODE(inode,
-                               "error %d reading directory lblock 0", err);
-               else
-                       ext4_warning(inode->i_sb,
-                                    "bad directory (dir #%lu) - no data block",
-                                    inode->i_ino);
+       if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2)) {
+               EXT4_ERROR_INODE(inode, "invalid size");
                return 1;
        }
-       if (!buffer_verified(bh) &&
-           !ext4_dirent_csum_verify(inode,
-                       (struct ext4_dir_entry *)bh->b_data)) {
-               EXT4_ERROR_INODE(inode, "checksum error reading directory "
-                                "lblock 0");
-               return -EIO;
-       }
-       set_buffer_verified(bh);
+       bh = ext4_read_dirblock(inode, 0, EITHER);
+       if (IS_ERR(bh))
+               return 1;
+
        de = (struct ext4_dir_entry_2 *) bh->b_data;
        de1 = ext4_next_entry(de, sb->s_blocksize);
        if (le32_to_cpu(de->inode) != inode->i_ino ||
@@ -2516,28 +2491,9 @@ static int empty_dir(struct inode *inode)
                        err = 0;
                        brelse(bh);
                        lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
-                       bh = ext4_bread(NULL, inode, lblock, 0, &err);
-                       if (!bh) {
-                               if (err)
-                                       EXT4_ERROR_INODE(inode,
-                                               "error %d reading directory "
-                                               "lblock %u", err, lblock);
-                               else
-                                       ext4_warning(inode->i_sb,
-                                               "bad directory (dir #%lu) - no data block",
-                                               inode->i_ino);
-
-                               offset += sb->s_blocksize;
-                               continue;
-                       }
-                       if (!buffer_verified(bh) &&
-                           !ext4_dirent_csum_verify(inode,
-                                       (struct ext4_dir_entry *)bh->b_data)) {
-                               EXT4_ERROR_INODE(inode, "checksum error "
-                                                "reading directory lblock 0");
-                               return -EIO;
-                       }
-                       set_buffer_verified(bh);
+                       bh = ext4_read_dirblock(inode, lblock, EITHER);
+                       if (IS_ERR(bh))
+                               return 1;
                        de = (struct ext4_dir_entry_2 *) bh->b_data;
                }
                if (ext4_check_dir_entry(inode, NULL, de, bh,
@@ -2716,25 +2672,18 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
        struct inode *inode;
        struct buffer_head *bh;
        struct ext4_dir_entry_2 *de;
-       handle_t *handle;
+       handle_t *handle = NULL;
 
        /* Initialize quotas before so that eventual writes go in
         * separate transaction */
        dquot_initialize(dir);
        dquot_initialize(dentry->d_inode);
 
-       handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb));
-       if (IS_ERR(handle))
-               return PTR_ERR(handle);
-
        retval = -ENOENT;
        bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
        if (!bh)
                goto end_rmdir;
 
-       if (IS_DIRSYNC(dir))
-               ext4_handle_sync(handle);
-
        inode = dentry->d_inode;
 
        retval = -EIO;
@@ -2745,6 +2694,17 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
        if (!empty_dir(inode))
                goto end_rmdir;
 
+       handle = ext4_journal_start(dir, EXT4_HT_DIR,
+                                   EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
+       if (IS_ERR(handle)) {
+               retval = PTR_ERR(handle);
+               handle = NULL;
+               goto end_rmdir;
+       }
+
+       if (IS_DIRSYNC(dir))
+               ext4_handle_sync(handle);
+
        retval = ext4_delete_entry(handle, dir, de, bh);
        if (retval)
                goto end_rmdir;
@@ -2766,8 +2726,9 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
        ext4_mark_inode_dirty(handle, dir);
 
 end_rmdir:
-       ext4_journal_stop(handle);
        brelse(bh);
+       if (handle)
+               ext4_journal_stop(handle);
        return retval;
 }
 
@@ -2777,7 +2738,7 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
        struct inode *inode;
        struct buffer_head *bh;
        struct ext4_dir_entry_2 *de;
-       handle_t *handle;
+       handle_t *handle = NULL;
 
        trace_ext4_unlink_enter(dir, dentry);
        /* Initialize quotas before so that eventual writes go
@@ -2785,13 +2746,6 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
        dquot_initialize(dir);
        dquot_initialize(dentry->d_inode);
 
-       handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb));
-       if (IS_ERR(handle))
-               return PTR_ERR(handle);
-
-       if (IS_DIRSYNC(dir))
-               ext4_handle_sync(handle);
-
        retval = -ENOENT;
        bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
        if (!bh)
@@ -2803,6 +2757,17 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
        if (le32_to_cpu(de->inode) != inode->i_ino)
                goto end_unlink;
 
+       handle = ext4_journal_start(dir, EXT4_HT_DIR,
+                                   EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
+       if (IS_ERR(handle)) {
+               retval = PTR_ERR(handle);
+               handle = NULL;
+               goto end_unlink;
+       }
+
+       if (IS_DIRSYNC(dir))
+               ext4_handle_sync(handle);
+
        if (!inode->i_nlink) {
                ext4_warning(inode->i_sb,
                             "Deleting nonexistent file (%lu), %d",
@@ -2823,8 +2788,9 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
        retval = 0;
 
 end_unlink:
-       ext4_journal_stop(handle);
        brelse(bh);
+       if (handle)
+               ext4_journal_stop(handle);
        trace_ext4_unlink_exit(dentry, retval);
        return retval;
 }
@@ -2864,15 +2830,10 @@ static int ext4_symlink(struct inode *dir,
                          EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb);
        }
 retry:
-       handle = ext4_journal_start(dir, credits);
-       if (IS_ERR(handle))
-               return PTR_ERR(handle);
-
-       if (IS_DIRSYNC(dir))
-               ext4_handle_sync(handle);
-
-       inode = ext4_new_inode(handle, dir, S_IFLNK|S_IRWXUGO,
-                              &dentry->d_name, 0, NULL);
+       inode = ext4_new_inode_start_handle(dir, S_IFLNK|S_IRWXUGO,
+                                           &dentry->d_name, 0, NULL,
+                                           EXT4_HT_DIR, credits);
+       handle = ext4_journal_current_handle();
        err = PTR_ERR(inode);
        if (IS_ERR(inode))
                goto out_stop;
@@ -2902,7 +2863,7 @@ retry:
                 * Now inode is being linked into dir (EXT4_DATA_TRANS_BLOCKS
                 * + EXT4_INDEX_EXTRA_TRANS_BLOCKS), inode is also modified
                 */
-               handle = ext4_journal_start(dir,
+               handle = ext4_journal_start(dir, EXT4_HT_DIR,
                                EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
                                EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1);
                if (IS_ERR(handle)) {
@@ -2925,8 +2886,12 @@ retry:
        }
        EXT4_I(inode)->i_disksize = inode->i_size;
        err = ext4_add_nondir(handle, dentry, inode);
+       if (!err && IS_DIRSYNC(dir))
+               ext4_handle_sync(handle);
+
 out_stop:
-       ext4_journal_stop(handle);
+       if (handle)
+               ext4_journal_stop(handle);
        if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
                goto retry;
        return err;
@@ -2949,8 +2914,9 @@ static int ext4_link(struct dentry *old_dentry,
        dquot_initialize(dir);
 
 retry:
-       handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
-                                       EXT4_INDEX_EXTRA_TRANS_BLOCKS);
+       handle = ext4_journal_start(dir, EXT4_HT_DIR,
+               (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
+                EXT4_INDEX_EXTRA_TRANS_BLOCKS));
        if (IS_ERR(handle))
                return PTR_ERR(handle);
 
@@ -2990,13 +2956,9 @@ static struct buffer_head *ext4_get_first_dir_block(handle_t *handle,
        struct buffer_head *bh;
 
        if (!ext4_has_inline_data(inode)) {
-               if (!(bh = ext4_bread(handle, inode, 0, 0, retval))) {
-                       if (!*retval) {
-                               *retval = -EIO;
-                               ext4_error(inode->i_sb,
-                                          "Directory hole detected on inode %lu\n",
-                                          inode->i_ino);
-                       }
+               bh = ext4_read_dirblock(inode, 0, EITHER);
+               if (IS_ERR(bh)) {
+                       *retval = PTR_ERR(bh);
                        return NULL;
                }
                *parent_de = ext4_next_entry(
@@ -3033,9 +2995,9 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
         * in separate transaction */
        if (new_dentry->d_inode)
                dquot_initialize(new_dentry->d_inode);
-       handle = ext4_journal_start(old_dir, 2 *
-                                       EXT4_DATA_TRANS_BLOCKS(old_dir->i_sb) +
-                                       EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2);
+       handle = ext4_journal_start(old_dir, EXT4_HT_DIR,
+               (2 * EXT4_DATA_TRANS_BLOCKS(old_dir->i_sb) +
+                EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2));
        if (IS_ERR(handle))
                return PTR_ERR(handle);
 
@@ -3075,11 +3037,6 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
                                                  &inlined);
                if (!dir_bh)
                        goto end_rename;
-               if (!inlined && !buffer_verified(dir_bh) &&
-                   !ext4_dirent_csum_verify(old_inode,
-                               (struct ext4_dir_entry *)dir_bh->b_data))
-                       goto end_rename;
-               set_buffer_verified(dir_bh);
                if (le32_to_cpu(parent_de->inode) != old_dir->i_ino)
                        goto end_rename;
                retval = -EMLINK;
index 0016fbc..809b310 100644 (file)
@@ -23,6 +23,7 @@
 #include <linux/workqueue.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
+#include <linux/mm.h>
 
 #include "ext4_jbd2.h"
 #include "xattr.h"
@@ -73,8 +74,6 @@ void ext4_free_io_end(ext4_io_end_t *io)
        BUG_ON(!list_empty(&io->list));
        BUG_ON(io->flag & EXT4_IO_END_UNWRITTEN);
 
-       if (io->page)
-               put_page(io->page);
        for (i = 0; i < io->num_io_pages; i++)
                put_io_page(io->pages[i]);
        io->num_io_pages = 0;
@@ -103,14 +102,13 @@ static int ext4_end_io(ext4_io_end_t *io)
                         "(inode %lu, offset %llu, size %zd, error %d)",
                         inode->i_ino, offset, size, ret);
        }
-       if (io->iocb)
-               aio_complete(io->iocb, io->result, 0);
-
-       if (io->flag & EXT4_IO_END_DIRECT)
-               inode_dio_done(inode);
        /* Wake up anyone waiting on unwritten extent conversion */
        if (atomic_dec_and_test(&EXT4_I(inode)->i_unwritten))
                wake_up_all(ext4_ioend_wq(inode));
+       if (io->flag & EXT4_IO_END_DIRECT)
+               inode_dio_done(inode);
+       if (io->iocb)
+               aio_complete(io->iocb, io->result, 0);
        return ret;
 }
 
@@ -119,7 +117,6 @@ static void dump_completed_IO(struct inode *inode)
 #ifdef EXT4FS_DEBUG
        struct list_head *cur, *before, *after;
        ext4_io_end_t *io, *io0, *io1;
-       unsigned long flags;
 
        if (list_empty(&EXT4_I(inode)->i_completed_io_list)) {
                ext4_debug("inode %lu completed_io list is empty\n",
@@ -152,26 +149,20 @@ void ext4_add_complete_io(ext4_io_end_t *io_end)
        wq = EXT4_SB(io_end->inode->i_sb)->dio_unwritten_wq;
 
        spin_lock_irqsave(&ei->i_completed_io_lock, flags);
-       if (list_empty(&ei->i_completed_io_list)) {
-               io_end->flag |= EXT4_IO_END_QUEUED;
-               queue_work(wq, &io_end->work);
-       }
+       if (list_empty(&ei->i_completed_io_list))
+               queue_work(wq, &ei->i_unwritten_work);
        list_add_tail(&io_end->list, &ei->i_completed_io_list);
        spin_unlock_irqrestore(&ei->i_completed_io_lock, flags);
 }
 
-static int ext4_do_flush_completed_IO(struct inode *inode,
-                                     ext4_io_end_t *work_io)
+static int ext4_do_flush_completed_IO(struct inode *inode)
 {
        ext4_io_end_t *io;
-       struct list_head unwritten, complete, to_free;
+       struct list_head unwritten;
        unsigned long flags;
        struct ext4_inode_info *ei = EXT4_I(inode);
        int err, ret = 0;
 
-       INIT_LIST_HEAD(&complete);
-       INIT_LIST_HEAD(&to_free);
-
        spin_lock_irqsave(&ei->i_completed_io_lock, flags);
        dump_completed_IO(inode);
        list_replace_init(&ei->i_completed_io_list, &unwritten);
@@ -185,32 +176,7 @@ static int ext4_do_flush_completed_IO(struct inode *inode,
                err = ext4_end_io(io);
                if (unlikely(!ret && err))
                        ret = err;
-
-               list_add_tail(&io->list, &complete);
-       }
-       spin_lock_irqsave(&ei->i_completed_io_lock, flags);
-       while (!list_empty(&complete)) {
-               io = list_entry(complete.next, ext4_io_end_t, list);
                io->flag &= ~EXT4_IO_END_UNWRITTEN;
-               /* end_io context can not be destroyed now because it still
-                * used by queued worker. Worker thread will destroy it later */
-               if (io->flag & EXT4_IO_END_QUEUED)
-                       list_del_init(&io->list);
-               else
-                       list_move(&io->list, &to_free);
-       }
-       /* If we are called from worker context, it is time to clear queued
-        * flag, and destroy it's end_io if it was converted already */
-       if (work_io) {
-               work_io->flag &= ~EXT4_IO_END_QUEUED;
-               if (!(work_io->flag & EXT4_IO_END_UNWRITTEN))
-                       list_add_tail(&work_io->list, &to_free);
-       }
-       spin_unlock_irqrestore(&ei->i_completed_io_lock, flags);
-
-       while (!list_empty(&to_free)) {
-               io = list_entry(to_free.next, ext4_io_end_t, list);
-               list_del_init(&io->list);
                ext4_free_io_end(io);
        }
        return ret;
@@ -219,10 +185,11 @@ static int ext4_do_flush_completed_IO(struct inode *inode,
 /*
  * work on completed aio dio IO, to convert unwritten extents to extents
  */
-static void ext4_end_io_work(struct work_struct *work)
+void ext4_end_io_work(struct work_struct *work)
 {
-       ext4_io_end_t *io = container_of(work, ext4_io_end_t, work);
-       ext4_do_flush_completed_IO(io->inode, io);
+       struct ext4_inode_info *ei = container_of(work, struct ext4_inode_info,
+                                                 i_unwritten_work);
+       ext4_do_flush_completed_IO(&ei->vfs_inode);
 }
 
 int ext4_flush_unwritten_io(struct inode *inode)
@@ -230,7 +197,7 @@ int ext4_flush_unwritten_io(struct inode *inode)
        int ret;
        WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex) &&
                     !(inode->i_state & I_FREEING));
-       ret = ext4_do_flush_completed_IO(inode, NULL);
+       ret = ext4_do_flush_completed_IO(inode);
        ext4_unwritten_wait(inode);
        return ret;
 }
@@ -241,7 +208,6 @@ ext4_io_end_t *ext4_init_io_end(struct inode *inode, gfp_t flags)
        if (io) {
                atomic_inc(&EXT4_I(inode)->i_ioend_count);
                io->inode = inode;
-               INIT_WORK(&io->work, ext4_end_io_work);
                INIT_LIST_HEAD(&io->list);
        }
        return io;
@@ -382,14 +348,6 @@ static int io_submit_add_bh(struct ext4_io_submit *io,
                unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr);
        }
 
-       if (!buffer_mapped(bh) || buffer_delay(bh)) {
-               if (!buffer_mapped(bh))
-                       clear_buffer_dirty(bh);
-               if (io->io_bio)
-                       ext4_io_submit(io);
-               return 0;
-       }
-
        if (io->io_bio && bh->b_blocknr != io->io_next_block) {
 submit_and_retry:
                ext4_io_submit(io);
@@ -436,7 +394,7 @@ int ext4_bio_write_page(struct ext4_io_submit *io,
 
        io_page = kmem_cache_alloc(io_page_cachep, GFP_NOFS);
        if (!io_page) {
-               set_page_dirty(page);
+               redirty_page_for_writepage(wbc, page);
                unlock_page(page);
                return -ENOMEM;
        }
@@ -468,7 +426,15 @@ int ext4_bio_write_page(struct ext4_io_submit *io,
                        set_buffer_uptodate(bh);
                        continue;
                }
-               clear_buffer_dirty(bh);
+               if (!buffer_dirty(bh) || buffer_delay(bh) ||
+                   !buffer_mapped(bh) || buffer_unwritten(bh)) {
+                       /* A hole? We can safely clear the dirty bit */
+                       if (!buffer_mapped(bh))
+                               clear_buffer_dirty(bh);
+                       if (io->io_bio)
+                               ext4_io_submit(io);
+                       continue;
+               }
                ret = io_submit_add_bh(io, io_page, inode, wbc, bh);
                if (ret) {
                        /*
@@ -476,9 +442,10 @@ int ext4_bio_write_page(struct ext4_io_submit *io,
                         * we can do but mark the page as dirty, and
                         * better luck next time.
                         */
-                       set_page_dirty(page);
+                       redirty_page_for_writepage(wbc, page);
                        break;
                }
+               clear_buffer_dirty(bh);
        }
        unlock_page(page);
        /*
index d99387b..c7f4d75 100644 (file)
@@ -333,8 +333,8 @@ static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,
        int err;
 
        bh = sb_getblk(sb, blk);
-       if (!bh)
-               return ERR_PTR(-EIO);
+       if (unlikely(!bh))
+               return ERR_PTR(-ENOMEM);
        if ((err = ext4_journal_get_write_access(handle, bh))) {
                brelse(bh);
                bh = ERR_PTR(err);
@@ -410,8 +410,8 @@ static int set_flexbg_block_bitmap(struct super_block *sb, handle_t *handle,
                        return err;
 
                bh = sb_getblk(sb, flex_gd->groups[group].block_bitmap);
-               if (!bh)
-                       return -EIO;
+               if (unlikely(!bh))
+                       return -ENOMEM;
 
                err = ext4_journal_get_write_access(handle, bh);
                if (err)
@@ -466,7 +466,7 @@ static int setup_new_flex_group_blocks(struct super_block *sb,
        meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG);
 
        /* This transaction may be extended/restarted along the way */
-       handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA);
+       handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA);
        if (IS_ERR(handle))
                return PTR_ERR(handle);
 
@@ -500,8 +500,8 @@ static int setup_new_flex_group_blocks(struct super_block *sb,
                                goto out;
 
                        gdb = sb_getblk(sb, block);
-                       if (!gdb) {
-                               err = -EIO;
+                       if (unlikely(!gdb)) {
+                               err = -ENOMEM;
                                goto out;
                        }
 
@@ -1031,7 +1031,7 @@ static void update_backups(struct super_block *sb, int blk_off, char *data,
        handle_t *handle;
        int err = 0, err2;
 
-       handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA);
+       handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA);
        if (IS_ERR(handle)) {
                group = 1;
                err = PTR_ERR(handle);
@@ -1064,8 +1064,8 @@ static void update_backups(struct super_block *sb, int blk_off, char *data,
                                        ext4_bg_has_super(sb, group));
 
                bh = sb_getblk(sb, backup_block);
-               if (!bh) {
-                       err = -EIO;
+               if (unlikely(!bh)) {
+                       err = -ENOMEM;
                        break;
                }
                ext4_debug("update metadata backup %llu(+%llu)\n",
@@ -1168,7 +1168,7 @@ static int ext4_add_new_descs(handle_t *handle, struct super_block *sb,
 static struct buffer_head *ext4_get_bitmap(struct super_block *sb, __u64 block)
 {
        struct buffer_head *bh = sb_getblk(sb, block);
-       if (!bh)
+       if (unlikely(!bh))
                return NULL;
        if (!bh_uptodate_or_lock(bh)) {
                if (bh_submit_read(bh) < 0) {
@@ -1412,7 +1412,7 @@ static int ext4_flex_group_add(struct super_block *sb,
         * modify each of the reserved GDT dindirect blocks.
         */
        credit = flex_gd->count * 4 + reserved_gdb;
-       handle = ext4_journal_start_sb(sb, credit);
+       handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, credit);
        if (IS_ERR(handle)) {
                err = PTR_ERR(handle);
                goto exit;
@@ -1506,10 +1506,12 @@ static int ext4_setup_next_flex_gd(struct super_block *sb,
                group_data[i].blocks_count = blocks_per_group;
                overhead = ext4_group_overhead_blocks(sb, group + i);
                group_data[i].free_blocks_count = blocks_per_group - overhead;
-               if (ext4_has_group_desc_csum(sb))
+               if (ext4_has_group_desc_csum(sb)) {
                        flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT |
                                               EXT4_BG_INODE_UNINIT;
-               else
+                       if (!test_opt(sb, INIT_INODE_TABLE))
+                               flex_gd->bg_flags[i] |= EXT4_BG_INODE_ZEROED;
+               } else
                        flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED;
        }
 
@@ -1594,7 +1596,7 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
 
        err = ext4_alloc_flex_bg_array(sb, input->group + 1);
        if (err)
-               return err;
+               goto out;
 
        err = ext4_mb_alloc_groupinfo(sb, input->group + 1);
        if (err)
@@ -1622,7 +1624,7 @@ static int ext4_group_extend_no_check(struct super_block *sb,
        /* We will update the superblock, one block bitmap, and
         * one group descriptor via ext4_group_add_blocks().
         */
-       handle = ext4_journal_start_sb(sb, 3);
+       handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, 3);
        if (IS_ERR(handle)) {
                err = PTR_ERR(handle);
                ext4_warning(sb, "error %d on journal start", err);
@@ -1786,7 +1788,7 @@ static int ext4_convert_meta_bg(struct super_block *sb, struct inode *inode)
                credits += 3;   /* block bitmap, bg descriptor, resize inode */
        }
 
-       handle = ext4_journal_start_sb(sb, credits);
+       handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, credits);
        if (IS_ERR(handle))
                return PTR_ERR(handle);
 
index 3d4fb81..373d46c 100644 (file)
@@ -69,8 +69,6 @@ static void ext4_mark_recovery_complete(struct super_block *sb,
 static void ext4_clear_journal_err(struct super_block *sb,
                                   struct ext4_super_block *es);
 static int ext4_sync_fs(struct super_block *sb, int wait);
-static const char *ext4_decode_error(struct super_block *sb, int errno,
-                                    char nbuf[16]);
 static int ext4_remount(struct super_block *sb, int *flags, char *data);
 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int ext4_unfreeze(struct super_block *sb);
@@ -296,107 +294,6 @@ void ext4_itable_unused_set(struct super_block *sb,
 }
 
 
-/* Just increment the non-pointer handle value */
-static handle_t *ext4_get_nojournal(void)
-{
-       handle_t *handle = current->journal_info;
-       unsigned long ref_cnt = (unsigned long)handle;
-
-       BUG_ON(ref_cnt >= EXT4_NOJOURNAL_MAX_REF_COUNT);
-
-       ref_cnt++;
-       handle = (handle_t *)ref_cnt;
-
-       current->journal_info = handle;
-       return handle;
-}
-
-
-/* Decrement the non-pointer handle value */
-static void ext4_put_nojournal(handle_t *handle)
-{
-       unsigned long ref_cnt = (unsigned long)handle;
-
-       BUG_ON(ref_cnt == 0);
-
-       ref_cnt--;
-       handle = (handle_t *)ref_cnt;
-
-       current->journal_info = handle;
-}
-
-/*
- * Wrappers for jbd2_journal_start/end.
- */
-handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks)
-{
-       journal_t *journal;
-
-       trace_ext4_journal_start(sb, nblocks, _RET_IP_);
-       if (sb->s_flags & MS_RDONLY)
-               return ERR_PTR(-EROFS);
-
-       WARN_ON(sb->s_writers.frozen == SB_FREEZE_COMPLETE);
-       journal = EXT4_SB(sb)->s_journal;
-       if (!journal)
-               return ext4_get_nojournal();
-       /*
-        * Special case here: if the journal has aborted behind our
-        * backs (eg. EIO in the commit thread), then we still need to
-        * take the FS itself readonly cleanly.
-        */
-       if (is_journal_aborted(journal)) {
-               ext4_abort(sb, "Detected aborted journal");
-               return ERR_PTR(-EROFS);
-       }
-       return jbd2_journal_start(journal, nblocks);
-}
-
-int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle)
-{
-       struct super_block *sb;
-       int err;
-       int rc;
-
-       if (!ext4_handle_valid(handle)) {
-               ext4_put_nojournal(handle);
-               return 0;
-       }
-       sb = handle->h_transaction->t_journal->j_private;
-       err = handle->h_err;
-       rc = jbd2_journal_stop(handle);
-
-       if (!err)
-               err = rc;
-       if (err)
-               __ext4_std_error(sb, where, line, err);
-       return err;
-}
-
-void ext4_journal_abort_handle(const char *caller, unsigned int line,
-                              const char *err_fn, struct buffer_head *bh,
-                              handle_t *handle, int err)
-{
-       char nbuf[16];
-       const char *errstr = ext4_decode_error(NULL, err, nbuf);
-
-       BUG_ON(!ext4_handle_valid(handle));
-
-       if (bh)
-               BUFFER_TRACE(bh, "abort");
-
-       if (!handle->h_err)
-               handle->h_err = err;
-
-       if (is_handle_aborted(handle))
-               return;
-
-       printk(KERN_ERR "EXT4-fs: %s:%d: aborting transaction: %s in %s\n",
-              caller, line, errstr, err_fn);
-
-       jbd2_journal_abort_handle(handle);
-}
-
 static void __save_error_info(struct super_block *sb, const char *func,
                            unsigned int line)
 {
@@ -582,8 +479,8 @@ void ext4_error_file(struct file *file, const char *function,
        ext4_handle_error(inode->i_sb);
 }
 
-static const char *ext4_decode_error(struct super_block *sb, int errno,
-                                    char nbuf[16])
+const char *ext4_decode_error(struct super_block *sb, int errno,
+                             char nbuf[16])
 {
        char *errstr = NULL;
 
@@ -858,6 +755,7 @@ static void ext4_put_super(struct super_block *sb)
                        ext4_abort(sb, "Couldn't clean up the journal");
        }
 
+       ext4_es_unregister_shrinker(sb);
        del_timer(&sbi->s_err_report);
        ext4_release_system_zone(sb);
        ext4_mb_release(sb);
@@ -939,11 +837,12 @@ static struct inode *ext4_alloc_inode(struct super_block *sb)
                return NULL;
 
        ei->vfs_inode.i_version = 1;
-       memset(&ei->i_cached_extent, 0, sizeof(struct ext4_ext_cache));
        INIT_LIST_HEAD(&ei->i_prealloc_list);
        spin_lock_init(&ei->i_prealloc_lock);
        ext4_es_init_tree(&ei->i_es_tree);
        rwlock_init(&ei->i_es_lock);
+       INIT_LIST_HEAD(&ei->i_es_lru);
+       ei->i_es_lru_nr = 0;
        ei->i_reserved_data_blocks = 0;
        ei->i_reserved_meta_blocks = 0;
        ei->i_allocated_meta_blocks = 0;
@@ -960,6 +859,7 @@ static struct inode *ext4_alloc_inode(struct super_block *sb)
        ei->i_datasync_tid = 0;
        atomic_set(&ei->i_ioend_count, 0);
        atomic_set(&ei->i_unwritten, 0);
+       INIT_WORK(&ei->i_unwritten_work, ext4_end_io_work);
 
        return &ei->vfs_inode;
 }
@@ -1031,6 +931,7 @@ void ext4_clear_inode(struct inode *inode)
        dquot_drop(inode);
        ext4_discard_preallocations(inode);
        ext4_es_remove_extent(inode, 0, EXT_MAX_BLOCKS);
+       ext4_es_lru_del(inode);
        if (EXT4_I(inode)->jinode) {
                jbd2_journal_release_jbd_inode(EXT4_JOURNAL(inode),
                                               EXT4_I(inode)->jinode);
@@ -1280,8 +1181,8 @@ static const match_table_t tokens = {
        {Opt_stripe, "stripe=%u"},
        {Opt_delalloc, "delalloc"},
        {Opt_nodelalloc, "nodelalloc"},
-       {Opt_mblk_io_submit, "mblk_io_submit"},
-       {Opt_nomblk_io_submit, "nomblk_io_submit"},
+       {Opt_removed, "mblk_io_submit"},
+       {Opt_removed, "nomblk_io_submit"},
        {Opt_block_validity, "block_validity"},
        {Opt_noblock_validity, "noblock_validity"},
        {Opt_inode_readahead_blks, "inode_readahead_blks=%u"},
@@ -1337,6 +1238,7 @@ static int set_qf_name(struct super_block *sb, int qtype, substring_t *args)
 {
        struct ext4_sb_info *sbi = EXT4_SB(sb);
        char *qname;
+       int ret = -1;
 
        if (sb_any_quota_loaded(sb) &&
                !sbi->s_qf_names[qtype]) {
@@ -1351,23 +1253,26 @@ static int set_qf_name(struct super_block *sb, int qtype, substring_t *args)
                        "Not enough memory for storing quotafile name");
                return -1;
        }
-       if (sbi->s_qf_names[qtype] &&
-               strcmp(sbi->s_qf_names[qtype], qname)) {
-               ext4_msg(sb, KERN_ERR,
-                       "%s quota file already specified", QTYPE2NAME(qtype));
-               kfree(qname);
-               return -1;
+       if (sbi->s_qf_names[qtype]) {
+               if (strcmp(sbi->s_qf_names[qtype], qname) == 0)
+                       ret = 1;
+               else
+                       ext4_msg(sb, KERN_ERR,
+                                "%s quota file already specified",
+                                QTYPE2NAME(qtype));
+               goto errout;
        }
-       sbi->s_qf_names[qtype] = qname;
-       if (strchr(sbi->s_qf_names[qtype], '/')) {
+       if (strchr(qname, '/')) {
                ext4_msg(sb, KERN_ERR,
                        "quotafile must be on filesystem root");
-               kfree(sbi->s_qf_names[qtype]);
-               sbi->s_qf_names[qtype] = NULL;
-               return -1;
+               goto errout;
        }
+       sbi->s_qf_names[qtype] = qname;
        set_opt(sb, QUOTA);
        return 1;
+errout:
+       kfree(qname);
+       return ret;
 }
 
 static int clear_qf_name(struct super_block *sb, int qtype)
@@ -1381,10 +1286,7 @@ static int clear_qf_name(struct super_block *sb, int qtype)
                        " when quota turned on");
                return -1;
        }
-       /*
-        * The space will be released later when all options are confirmed
-        * to be correct
-        */
+       kfree(sbi->s_qf_names[qtype]);
        sbi->s_qf_names[qtype] = NULL;
        return 1;
 }
@@ -1404,6 +1306,9 @@ static int clear_qf_name(struct super_block *sb, int qtype)
 #define MOPT_QFMT      MOPT_NOSUPPORT
 #endif
 #define MOPT_DATAJ     0x0080
+#define MOPT_NO_EXT2   0x0100
+#define MOPT_NO_EXT3   0x0200
+#define MOPT_EXT4_ONLY (MOPT_NO_EXT2 | MOPT_NO_EXT3)
 
 static const struct mount_opts {
        int     token;
@@ -1414,25 +1319,31 @@ static const struct mount_opts {
        {Opt_bsd_df, EXT4_MOUNT_MINIX_DF, MOPT_CLEAR},
        {Opt_grpid, EXT4_MOUNT_GRPID, MOPT_SET},
        {Opt_nogrpid, EXT4_MOUNT_GRPID, MOPT_CLEAR},
-       {Opt_mblk_io_submit, EXT4_MOUNT_MBLK_IO_SUBMIT, MOPT_SET},
-       {Opt_nomblk_io_submit, EXT4_MOUNT_MBLK_IO_SUBMIT, MOPT_CLEAR},
        {Opt_block_validity, EXT4_MOUNT_BLOCK_VALIDITY, MOPT_SET},
        {Opt_noblock_validity, EXT4_MOUNT_BLOCK_VALIDITY, MOPT_CLEAR},
-       {Opt_dioread_nolock, EXT4_MOUNT_DIOREAD_NOLOCK, MOPT_SET},
-       {Opt_dioread_lock, EXT4_MOUNT_DIOREAD_NOLOCK, MOPT_CLEAR},
+       {Opt_dioread_nolock, EXT4_MOUNT_DIOREAD_NOLOCK,
+        MOPT_EXT4_ONLY | MOPT_SET},
+       {Opt_dioread_lock, EXT4_MOUNT_DIOREAD_NOLOCK,
+        MOPT_EXT4_ONLY | MOPT_CLEAR},
        {Opt_discard, EXT4_MOUNT_DISCARD, MOPT_SET},
        {Opt_nodiscard, EXT4_MOUNT_DISCARD, MOPT_CLEAR},
-       {Opt_delalloc, EXT4_MOUNT_DELALLOC, MOPT_SET | MOPT_EXPLICIT},
-       {Opt_nodelalloc, EXT4_MOUNT_DELALLOC, MOPT_CLEAR | MOPT_EXPLICIT},
-       {Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM, MOPT_SET},
+       {Opt_delalloc, EXT4_MOUNT_DELALLOC,
+        MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
+       {Opt_nodelalloc, EXT4_MOUNT_DELALLOC,
+        MOPT_EXT4_ONLY | MOPT_CLEAR | MOPT_EXPLICIT},
+       {Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
+        MOPT_EXT4_ONLY | MOPT_SET},
        {Opt_journal_async_commit, (EXT4_MOUNT_JOURNAL_ASYNC_COMMIT |
-                                   EXT4_MOUNT_JOURNAL_CHECKSUM), MOPT_SET},
-       {Opt_noload, EXT4_MOUNT_NOLOAD, MOPT_SET},
+                                   EXT4_MOUNT_JOURNAL_CHECKSUM),
+        MOPT_EXT4_ONLY | MOPT_SET},
+       {Opt_noload, EXT4_MOUNT_NOLOAD, MOPT_NO_EXT2 | MOPT_SET},
        {Opt_err_panic, EXT4_MOUNT_ERRORS_PANIC, MOPT_SET | MOPT_CLEAR_ERR},
        {Opt_err_ro, EXT4_MOUNT_ERRORS_RO, MOPT_SET | MOPT_CLEAR_ERR},
        {Opt_err_cont, EXT4_MOUNT_ERRORS_CONT, MOPT_SET | MOPT_CLEAR_ERR},
-       {Opt_data_err_abort, EXT4_MOUNT_DATA_ERR_ABORT, MOPT_SET},
-       {Opt_data_err_ignore, EXT4_MOUNT_DATA_ERR_ABORT, MOPT_CLEAR},
+       {Opt_data_err_abort, EXT4_MOUNT_DATA_ERR_ABORT,
+        MOPT_NO_EXT2 | MOPT_SET},
+       {Opt_data_err_ignore, EXT4_MOUNT_DATA_ERR_ABORT,
+        MOPT_NO_EXT2 | MOPT_CLEAR},
        {Opt_barrier, EXT4_MOUNT_BARRIER, MOPT_SET},
        {Opt_nobarrier, EXT4_MOUNT_BARRIER, MOPT_CLEAR},
        {Opt_noauto_da_alloc, EXT4_MOUNT_NO_AUTO_DA_ALLOC, MOPT_SET},
@@ -1444,9 +1355,14 @@ static const struct mount_opts {
        {Opt_inode_readahead_blks, 0, MOPT_GTE0},
        {Opt_init_itable, 0, MOPT_GTE0},
        {Opt_stripe, 0, MOPT_GTE0},
-       {Opt_data_journal, EXT4_MOUNT_JOURNAL_DATA, MOPT_DATAJ},
-       {Opt_data_ordered, EXT4_MOUNT_ORDERED_DATA, MOPT_DATAJ},
-       {Opt_data_writeback, EXT4_MOUNT_WRITEBACK_DATA, MOPT_DATAJ},
+       {Opt_resuid, 0, MOPT_GTE0},
+       {Opt_resgid, 0, MOPT_GTE0},
+       {Opt_journal_dev, 0, MOPT_GTE0},
+       {Opt_journal_ioprio, 0, MOPT_GTE0},
+       {Opt_data_journal, EXT4_MOUNT_JOURNAL_DATA, MOPT_NO_EXT2 | MOPT_DATAJ},
+       {Opt_data_ordered, EXT4_MOUNT_ORDERED_DATA, MOPT_NO_EXT2 | MOPT_DATAJ},
+       {Opt_data_writeback, EXT4_MOUNT_WRITEBACK_DATA,
+        MOPT_NO_EXT2 | MOPT_DATAJ},
        {Opt_user_xattr, EXT4_MOUNT_XATTR_USER, MOPT_SET},
        {Opt_nouser_xattr, EXT4_MOUNT_XATTR_USER, MOPT_CLEAR},
 #ifdef CONFIG_EXT4_FS_POSIX_ACL
@@ -1496,8 +1412,6 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token,
        else if (token == Opt_offgrpjquota)
                return clear_qf_name(sb, GRPQUOTA);
 #endif
-       if (args->from && match_int(args, &arg))
-               return -1;
        switch (token) {
        case Opt_noacl:
        case Opt_nouser_xattr:
@@ -1506,138 +1420,149 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token,
        case Opt_sb:
                return 1;       /* handled by get_sb_block() */
        case Opt_removed:
-               ext4_msg(sb, KERN_WARNING,
-                        "Ignoring removed %s option", opt);
+               ext4_msg(sb, KERN_WARNING, "Ignoring removed %s option", opt);
+               return 1;
+       case Opt_abort:
+               sbi->s_mount_flags |= EXT4_MF_FS_ABORTED;
+               return 1;
+       case Opt_i_version:
+               sb->s_flags |= MS_I_VERSION;
                return 1;
-       case Opt_resuid:
+       }
+
+       for (m = ext4_mount_opts; m->token != Opt_err; m++)
+               if (token == m->token)
+                       break;
+
+       if (m->token == Opt_err) {
+               ext4_msg(sb, KERN_ERR, "Unrecognized mount option \"%s\" "
+                        "or missing value", opt);
+               return -1;
+       }
+
+       if ((m->flags & MOPT_NO_EXT2) && IS_EXT2_SB(sb)) {
+               ext4_msg(sb, KERN_ERR,
+                        "Mount option \"%s\" incompatible with ext2", opt);
+               return -1;
+       }
+       if ((m->flags & MOPT_NO_EXT3) && IS_EXT3_SB(sb)) {
+               ext4_msg(sb, KERN_ERR,
+                        "Mount option \"%s\" incompatible with ext3", opt);
+               return -1;
+       }
+
+       if (args->from && match_int(args, &arg))
+               return -1;
+       if (args->from && (m->flags & MOPT_GTE0) && (arg < 0))
+               return -1;
+       if (m->flags & MOPT_EXPLICIT)
+               set_opt2(sb, EXPLICIT_DELALLOC);
+       if (m->flags & MOPT_CLEAR_ERR)
+               clear_opt(sb, ERRORS_MASK);
+       if (token == Opt_noquota && sb_any_quota_loaded(sb)) {
+               ext4_msg(sb, KERN_ERR, "Cannot change quota "
+                        "options when quota turned on");
+               return -1;
+       }
+
+       if (m->flags & MOPT_NOSUPPORT) {
+               ext4_msg(sb, KERN_ERR, "%s option not supported", opt);
+       } else if (token == Opt_commit) {
+               if (arg == 0)
+                       arg = JBD2_DEFAULT_MAX_COMMIT_AGE;
+               sbi->s_commit_interval = HZ * arg;
+       } else if (token == Opt_max_batch_time) {
+               if (arg == 0)
+                       arg = EXT4_DEF_MAX_BATCH_TIME;
+               sbi->s_max_batch_time = arg;
+       } else if (token == Opt_min_batch_time) {
+               sbi->s_min_batch_time = arg;
+       } else if (token == Opt_inode_readahead_blks) {
+               if (arg && (arg > (1 << 30) || !is_power_of_2(arg))) {
+                       ext4_msg(sb, KERN_ERR,
+                                "EXT4-fs: inode_readahead_blks must be "
+                                "0 or a power of 2 smaller than 2^31");
+                       return -1;
+               }
+               sbi->s_inode_readahead_blks = arg;
+       } else if (token == Opt_init_itable) {
+               set_opt(sb, INIT_INODE_TABLE);
+               if (!args->from)
+                       arg = EXT4_DEF_LI_WAIT_MULT;
+               sbi->s_li_wait_mult = arg;
+       } else if (token == Opt_max_dir_size_kb) {
+               sbi->s_max_dir_size_kb = arg;
+       } else if (token == Opt_stripe) {
+               sbi->s_stripe = arg;
+       } else if (token == Opt_resuid) {
                uid = make_kuid(current_user_ns(), arg);
                if (!uid_valid(uid)) {
                        ext4_msg(sb, KERN_ERR, "Invalid uid value %d", arg);
                        return -1;
                }
                sbi->s_resuid = uid;
-               return 1;
-       case Opt_resgid:
+       } else if (token == Opt_resgid) {
                gid = make_kgid(current_user_ns(), arg);
                if (!gid_valid(gid)) {
                        ext4_msg(sb, KERN_ERR, "Invalid gid value %d", arg);
                        return -1;
                }
                sbi->s_resgid = gid;
-               return 1;
-       case Opt_abort:
-               sbi->s_mount_flags |= EXT4_MF_FS_ABORTED;
-               return 1;
-       case Opt_i_version:
-               sb->s_flags |= MS_I_VERSION;
-               return 1;
-       case Opt_journal_dev:
+       } else if (token == Opt_journal_dev) {
                if (is_remount) {
                        ext4_msg(sb, KERN_ERR,
                                 "Cannot specify journal on remount");
                        return -1;
                }
                *journal_devnum = arg;
-               return 1;
-       case Opt_journal_ioprio:
-               if (arg < 0 || arg > 7)
-                       return -1;
-               *journal_ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, arg);
-               return 1;
-       }
-
-       for (m = ext4_mount_opts; m->token != Opt_err; m++) {
-               if (token != m->token)
-                       continue;
-               if (args->from && (m->flags & MOPT_GTE0) && (arg < 0))
-                       return -1;
-               if (m->flags & MOPT_EXPLICIT)
-                       set_opt2(sb, EXPLICIT_DELALLOC);
-               if (m->flags & MOPT_CLEAR_ERR)
-                       clear_opt(sb, ERRORS_MASK);
-               if (token == Opt_noquota && sb_any_quota_loaded(sb)) {
-                       ext4_msg(sb, KERN_ERR, "Cannot change quota "
-                                "options when quota turned on");
+       } else if (token == Opt_journal_ioprio) {
+               if (arg > 7) {
+                       ext4_msg(sb, KERN_ERR, "Invalid journal IO priority"
+                                " (must be 0-7)");
                        return -1;
                }
-
-               if (m->flags & MOPT_NOSUPPORT) {
-                       ext4_msg(sb, KERN_ERR, "%s option not supported", opt);
-               } else if (token == Opt_commit) {
-                       if (arg == 0)
-                               arg = JBD2_DEFAULT_MAX_COMMIT_AGE;
-                       sbi->s_commit_interval = HZ * arg;
-               } else if (token == Opt_max_batch_time) {
-                       if (arg == 0)
-                               arg = EXT4_DEF_MAX_BATCH_TIME;
-                       sbi->s_max_batch_time = arg;
-               } else if (token == Opt_min_batch_time) {
-                       sbi->s_min_batch_time = arg;
-               } else if (token == Opt_inode_readahead_blks) {
-                       if (arg > (1 << 30))
-                               return -1;
-                       if (arg && !is_power_of_2(arg)) {
+               *journal_ioprio =
+                       IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, arg);
+       } else if (m->flags & MOPT_DATAJ) {
+               if (is_remount) {
+                       if (!sbi->s_journal)
+                               ext4_msg(sb, KERN_WARNING, "Remounting file system with no journal so ignoring journalled data option");
+                       else if (test_opt(sb, DATA_FLAGS) != m->mount_opt) {
                                ext4_msg(sb, KERN_ERR,
-                                        "EXT4-fs: inode_readahead_blks"
-                                        " must be a power of 2");
-                               return -1;
-                       }
-                       sbi->s_inode_readahead_blks = arg;
-               } else if (token == Opt_init_itable) {
-                       set_opt(sb, INIT_INODE_TABLE);
-                       if (!args->from)
-                               arg = EXT4_DEF_LI_WAIT_MULT;
-                       sbi->s_li_wait_mult = arg;
-               } else if (token == Opt_max_dir_size_kb) {
-                       sbi->s_max_dir_size_kb = arg;
-               } else if (token == Opt_stripe) {
-                       sbi->s_stripe = arg;
-               } else if (m->flags & MOPT_DATAJ) {
-                       if (is_remount) {
-                               if (!sbi->s_journal)
-                                       ext4_msg(sb, KERN_WARNING, "Remounting file system with no journal so ignoring journalled data option");
-                               else if (test_opt(sb, DATA_FLAGS) !=
-                                        m->mount_opt) {
-                                       ext4_msg(sb, KERN_ERR,
                                         "Cannot change data mode on remount");
-                                       return -1;
-                               }
-                       } else {
-                               clear_opt(sb, DATA_FLAGS);
-                               sbi->s_mount_opt |= m->mount_opt;
-                       }
-#ifdef CONFIG_QUOTA
-               } else if (m->flags & MOPT_QFMT) {
-                       if (sb_any_quota_loaded(sb) &&
-                           sbi->s_jquota_fmt != m->mount_opt) {
-                               ext4_msg(sb, KERN_ERR, "Cannot "
-                                        "change journaled quota options "
-                                        "when quota turned on");
                                return -1;
                        }
-                       sbi->s_jquota_fmt = m->mount_opt;
-#endif
                } else {
-                       if (!args->from)
-                               arg = 1;
-                       if (m->flags & MOPT_CLEAR)
-                               arg = !arg;
-                       else if (unlikely(!(m->flags & MOPT_SET))) {
-                               ext4_msg(sb, KERN_WARNING,
-                                        "buggy handling of option %s", opt);
-                               WARN_ON(1);
-                               return -1;
-                       }
-                       if (arg != 0)
-                               sbi->s_mount_opt |= m->mount_opt;
-                       else
-                               sbi->s_mount_opt &= ~m->mount_opt;
+                       clear_opt(sb, DATA_FLAGS);
+                       sbi->s_mount_opt |= m->mount_opt;
                }
-               return 1;
+#ifdef CONFIG_QUOTA
+       } else if (m->flags & MOPT_QFMT) {
+               if (sb_any_quota_loaded(sb) &&
+                   sbi->s_jquota_fmt != m->mount_opt) {
+                       ext4_msg(sb, KERN_ERR, "Cannot change journaled "
+                                "quota options when quota turned on");
+                       return -1;
+               }
+               sbi->s_jquota_fmt = m->mount_opt;
+#endif
+       } else {
+               if (!args->from)
+                       arg = 1;
+               if (m->flags & MOPT_CLEAR)
+                       arg = !arg;
+               else if (unlikely(!(m->flags & MOPT_SET))) {
+                       ext4_msg(sb, KERN_WARNING,
+                                "buggy handling of option %s", opt);
+                       WARN_ON(1);
+                       return -1;
+               }
+               if (arg != 0)
+                       sbi->s_mount_opt |= m->mount_opt;
+               else
+                       sbi->s_mount_opt &= ~m->mount_opt;
        }
-       ext4_msg(sb, KERN_ERR, "Unrecognized mount option \"%s\" "
-                "or missing value", opt);
-       return -1;
+       return 1;
 }
 
 static int parse_options(char *options, struct super_block *sb,
@@ -2776,7 +2701,7 @@ static int ext4_run_li_request(struct ext4_li_request *elr)
                        break;
        }
 
-       if (group == ngroups)
+       if (group >= ngroups)
                ret = 1;
 
        if (!ret) {
@@ -3016,33 +2941,34 @@ static struct ext4_li_request *ext4_li_request_new(struct super_block *sb,
        return elr;
 }
 
-static int ext4_register_li_request(struct super_block *sb,
-                                   ext4_group_t first_not_zeroed)
+int ext4_register_li_request(struct super_block *sb,
+                            ext4_group_t first_not_zeroed)
 {
        struct ext4_sb_info *sbi = EXT4_SB(sb);
-       struct ext4_li_request *elr;
+       struct ext4_li_request *elr = NULL;
        ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
        int ret = 0;
 
+       mutex_lock(&ext4_li_mtx);
        if (sbi->s_li_request != NULL) {
                /*
                 * Reset timeout so it can be computed again, because
                 * s_li_wait_mult might have changed.
                 */
                sbi->s_li_request->lr_timeout = 0;
-               return 0;
+               goto out;
        }
 
        if (first_not_zeroed == ngroups ||
            (sb->s_flags & MS_RDONLY) ||
            !test_opt(sb, INIT_INODE_TABLE))
-               return 0;
+               goto out;
 
        elr = ext4_li_request_new(sb, first_not_zeroed);
-       if (!elr)
-               return -ENOMEM;
-
-       mutex_lock(&ext4_li_mtx);
+       if (!elr) {
+               ret = -ENOMEM;
+               goto out;
+       }
 
        if (NULL == ext4_li_info) {
                ret = ext4_li_info_new();
@@ -3379,7 +3305,6 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 #ifdef CONFIG_EXT4_FS_POSIX_ACL
        set_opt(sb, POSIX_ACL);
 #endif
-       set_opt(sb, MBLK_IO_SUBMIT);
        if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
                set_opt(sb, JOURNAL_DATA);
        else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
@@ -3772,6 +3697,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
        sbi->s_max_writeback_mb_bump = 128;
        sbi->s_extent_max_zeroout_kb = 32;
 
+       /* Register extent status tree shrinker */
+       ext4_es_register_shrinker(sb);
+
        /*
         * set up enough so that it can read an inode
         */
@@ -4008,7 +3936,7 @@ no_journal:
            !(sb->s_flags & MS_RDONLY)) {
                err = ext4_enable_quotas(sb);
                if (err)
-                       goto failed_mount7;
+                       goto failed_mount8;
        }
 #endif  /* CONFIG_QUOTA */
 
@@ -4035,6 +3963,10 @@ cantfind_ext4:
                ext4_msg(sb, KERN_ERR, "VFS: Can't find ext4 filesystem");
        goto failed_mount;
 
+#ifdef CONFIG_QUOTA
+failed_mount8:
+       kobject_del(&sbi->s_kobj);
+#endif
 failed_mount7:
        ext4_unregister_li_request(sb);
 failed_mount6:
@@ -4476,16 +4408,12 @@ static void ext4_clear_journal_err(struct super_block *sb,
 int ext4_force_commit(struct super_block *sb)
 {
        journal_t *journal;
-       int ret = 0;
 
        if (sb->s_flags & MS_RDONLY)
                return 0;
 
        journal = EXT4_SB(sb)->s_journal;
-       if (journal)
-               ret = ext4_journal_force_commit(journal);
-
-       return ret;
+       return ext4_journal_force_commit(journal);
 }
 
 static int ext4_sync_fs(struct super_block *sb, int wait)
@@ -4588,7 +4516,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
        unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
        int err = 0;
 #ifdef CONFIG_QUOTA
-       int i;
+       int i, j;
 #endif
        char *orig_data = kstrdup(data, GFP_KERNEL);
 
@@ -4604,7 +4532,16 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
 #ifdef CONFIG_QUOTA
        old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
        for (i = 0; i < MAXQUOTAS; i++)
-               old_opts.s_qf_names[i] = sbi->s_qf_names[i];
+               if (sbi->s_qf_names[i]) {
+                       old_opts.s_qf_names[i] = kstrdup(sbi->s_qf_names[i],
+                                                        GFP_KERNEL);
+                       if (!old_opts.s_qf_names[i]) {
+                               for (j = 0; j < i; j++)
+                                       kfree(old_opts.s_qf_names[j]);
+                               return -ENOMEM;
+                       }
+               } else
+                       old_opts.s_qf_names[i] = NULL;
 #endif
        if (sbi->s_journal && sbi->s_journal->j_task->io_context)
                journal_ioprio = sbi->s_journal->j_task->io_context->ioprio;
@@ -4737,9 +4674,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
 #ifdef CONFIG_QUOTA
        /* Release old quota file names */
        for (i = 0; i < MAXQUOTAS; i++)
-               if (old_opts.s_qf_names[i] &&
-                   old_opts.s_qf_names[i] != sbi->s_qf_names[i])
-                       kfree(old_opts.s_qf_names[i]);
+               kfree(old_opts.s_qf_names[i]);
        if (enable_quota) {
                if (sb_any_quota_suspended(sb))
                        dquot_resume(sb, -1);
@@ -4768,9 +4703,7 @@ restore_opts:
 #ifdef CONFIG_QUOTA
        sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
        for (i = 0; i < MAXQUOTAS; i++) {
-               if (sbi->s_qf_names[i] &&
-                   old_opts.s_qf_names[i] != sbi->s_qf_names[i])
-                       kfree(sbi->s_qf_names[i]);
+               kfree(sbi->s_qf_names[i]);
                sbi->s_qf_names[i] = old_opts.s_qf_names[i];
        }
 #endif
@@ -4835,7 +4768,7 @@ static int ext4_write_dquot(struct dquot *dquot)
        struct inode *inode;
 
        inode = dquot_to_inode(dquot);
-       handle = ext4_journal_start(inode,
+       handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
                                    EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
        if (IS_ERR(handle))
                return PTR_ERR(handle);
@@ -4851,7 +4784,7 @@ static int ext4_acquire_dquot(struct dquot *dquot)
        int ret, err;
        handle_t *handle;
 
-       handle = ext4_journal_start(dquot_to_inode(dquot),
+       handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
                                    EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
        if (IS_ERR(handle))
                return PTR_ERR(handle);
@@ -4867,7 +4800,7 @@ static int ext4_release_dquot(struct dquot *dquot)
        int ret, err;
        handle_t *handle;
 
-       handle = ext4_journal_start(dquot_to_inode(dquot),
+       handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
                                    EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
        if (IS_ERR(handle)) {
                /* Release dquot anyway to avoid endless cycle in dqput() */
@@ -4899,7 +4832,7 @@ static int ext4_write_info(struct super_block *sb, int type)
        handle_t *handle;
 
        /* Data block + inode block */
-       handle = ext4_journal_start(sb->s_root->d_inode, 2);
+       handle = ext4_journal_start(sb->s_root->d_inode, EXT4_HT_QUOTA, 2);
        if (IS_ERR(handle))
                return PTR_ERR(handle);
        ret = dquot_commit_info(sb, type);
@@ -5005,9 +4938,9 @@ static int ext4_enable_quotas(struct super_block *sb)
                                                DQUOT_USAGE_ENABLED);
                        if (err) {
                                ext4_warning(sb,
-                                       "Failed to enable quota (type=%d) "
-                                       "tracking. Please run e2fsck to fix.",
-                                       type);
+                                       "Failed to enable quota tracking "
+                                       "(type=%d, err=%d). Please run "
+                                       "e2fsck to fix.", type, err);
                                return err;
                        }
                }
@@ -5045,7 +4978,7 @@ static int ext4_quota_off(struct super_block *sb, int type)
 
        /* Update modification times of quota files when userspace can
         * start looking at them */
-       handle = ext4_journal_start(inode, 1);
+       handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
        if (IS_ERR(handle))
                goto out;
        inode->i_mtime = inode->i_ctime = CURRENT_TIME;