1 files changed, 356 insertions, 175 deletions

diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 6d600a69fc9d..cac448282331 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -202,13 +202,8 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
                              struct inode *inode);
 
 /* checksumming functions */
-#define EXT4_DIRENT_TAIL(block, blocksize) \
-        ((struct ext4_dir_entry_tail *)(((void *)(block)) + \
-                                        ((blocksize) - \
-                                         sizeof(struct ext4_dir_entry_tail))))
-
-static void initialize_dirent_tail(struct ext4_dir_entry_tail *t,
-                                   unsigned int blocksize)
+void initialize_dirent_tail(struct ext4_dir_entry_tail *t,
+                            unsigned int blocksize)
 {
         memset(t, 0, sizeof(struct ext4_dir_entry_tail));
         t->det_rec_len = ext4_rec_len_to_disk(
@@ -261,6 +256,12 @@ static __le32 ext4_dirent_csum(struct inode *inode,
         return cpu_to_le32(csum);
 }
 
+static void warn_no_space_for_csum(struct inode *inode)
+{
+        ext4_warning(inode->i_sb, "no space in directory inode %lu leaf for "
+                     "checksum.  Please run e2fsck -D.", inode->i_ino);
+}
+
 int ext4_dirent_csum_verify(struct inode *inode, struct ext4_dir_entry *dirent)
 {
         struct ext4_dir_entry_tail *t;
@@ -271,8 +272,7 @@ int ext4_dirent_csum_verify(struct inode *inode, struct ext4_dir_entry *dirent)
 
         t = get_dirent_tail(inode, dirent);
         if (!t) {
-                EXT4_ERROR_INODE(inode, "metadata_csum set but no space in dir "
-                                 "leaf for checksum.  Please run e2fsck -D.");
+                warn_no_space_for_csum(inode);
                 return 0;
         }
 
@@ -294,8 +294,7 @@ static void ext4_dirent_csum_set(struct inode *inode,
 
         t = get_dirent_tail(inode, dirent);
         if (!t) {
-                EXT4_ERROR_INODE(inode, "metadata_csum set but no space in dir "
-                                 "leaf for checksum.  Please run e2fsck -D.");
+                warn_no_space_for_csum(inode);
                 return;
         }
 
@@ -303,9 +302,9 @@ static void ext4_dirent_csum_set(struct inode *inode,
                                            (void *)t - (void *)dirent);
 }
 
-static inline int ext4_handle_dirty_dirent_node(handle_t *handle,
-                                                struct inode *inode,
-                                                struct buffer_head *bh)
+int ext4_handle_dirty_dirent_node(handle_t *handle,
+                                  struct inode *inode,
+                                  struct buffer_head *bh)
 {
         ext4_dirent_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
         return ext4_handle_dirty_metadata(handle, inode, bh);
@@ -377,8 +376,7 @@ static int ext4_dx_csum_verify(struct inode *inode,
         count = le16_to_cpu(c->count);
         if (count_offset + (limit * sizeof(struct dx_entry)) >
             EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
-                EXT4_ERROR_INODE(inode, "metadata_csum set but no space for "
-                                 "tree checksum found.  Run e2fsck -D.");
+                warn_no_space_for_csum(inode);
                 return 1;
         }
         t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
@@ -408,8 +406,7 @@ static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent)
         count = le16_to_cpu(c->count);
         if (count_offset + (limit * sizeof(struct dx_entry)) >
             EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
-                EXT4_ERROR_INODE(inode, "metadata_csum set but no space for "
-                                 "tree checksum.  Run e2fsck -D.");
+                warn_no_space_for_csum(inode);
                 return;
         }
         t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
@@ -890,6 +887,7 @@ static int htree_dirblock_to_tree(struct file *dir_file,
                                            EXT4_DIR_REC_LEN(0));
         for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
                 if (ext4_check_dir_entry(dir, NULL, de, bh,
+                                bh->b_data, bh->b_size,
                                 (block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb))
                                          + ((char *)de - bh->b_data))) {
                         /* On error, skip the f_pos to the next block. */
@@ -1007,6 +1005,15 @@ errout:
         return (err);
 }
 
+static inline int search_dirblock(struct buffer_head *bh,
+                                  struct inode *dir,
+                                  const struct qstr *d_name,
+                                  unsigned int offset,
+                                  struct ext4_dir_entry_2 **res_dir)
+{
+        return search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
+                          d_name, offset, res_dir);
+}
 
 /*
  * Directory block splitting, compacting
@@ -1081,13 +1088,6 @@ static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
         dx_set_count(entries, count + 1);
 }
 
-static void ext4_update_dx_flag(struct inode *inode)
-{
-        if (!EXT4_HAS_COMPAT_FEATURE(inode->i_sb,
-                                     EXT4_FEATURE_COMPAT_DIR_INDEX))
-                ext4_clear_inode_flag(inode, EXT4_INODE_INDEX);
-}
-
 /*
  * NOTE! unlike strncmp, ext4_match returns 1 for success, 0 for failure.
  *
@@ -1107,11 +1107,13 @@ static inline int ext4_match (int len, const char * const name,
 /*
  * Returns 0 if not found, -1 on failure, and 1 on success
  */
-static inline int search_dirblock(struct buffer_head *bh,
-                                  struct inode *dir,
-                                  const struct qstr *d_name,
-                                  unsigned int offset,
-                                  struct ext4_dir_entry_2 ** res_dir)
+int search_dir(struct buffer_head *bh,
+               char *search_buf,
+               int buf_size,
+               struct inode *dir,
+               const struct qstr *d_name,
+               unsigned int offset,
+               struct ext4_dir_entry_2 **res_dir)
 {
         struct ext4_dir_entry_2 * de;
         char * dlimit;
@@ -1119,8 +1121,8 @@ static inline int search_dirblock(struct buffer_head *bh,
         const char *name = d_name->name;
         int namelen = d_name->len;
 
-        de = (struct ext4_dir_entry_2 *) bh->b_data;
-        dlimit = bh->b_data + dir->i_sb->s_blocksize;
+        de = (struct ext4_dir_entry_2 *)search_buf;
+        dlimit = search_buf + buf_size;
         while ((char *) de < dlimit) {
                 /* this code is executed quadratically often */
                 /* do minimal checking `by hand' */
@@ -1128,7 +1130,8 @@ static inline int search_dirblock(struct buffer_head *bh,
                 if ((char *) de + namelen <= dlimit &&
                     ext4_match (namelen, name, de)) {
                         /* found a match - just to be sure, do a full check */
-                        if (ext4_check_dir_entry(dir, NULL, de, bh, offset))
+                        if (ext4_check_dir_entry(dir, NULL, de, bh, bh->b_data,
+                                                 bh->b_size, offset))
                                 return -1;
                         *res_dir = de;
                         return 1;
@@ -1144,6 +1147,21 @@ static inline int search_dirblock(struct buffer_head *bh,
         return 0;
 }
 
+static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block,
+                               struct ext4_dir_entry *de)
+{
+        struct super_block *sb = dir->i_sb;
+
+        if (!is_dx(dir))
+                return 0;
+        if (block == 0)
+                return 1;
+        if (de->inode == 0 &&
+            ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize) ==
+                        sb->s_blocksize)
+                return 1;
+        return 0;
+}
 
 /*
  *      ext4_find_entry()
@@ -1158,7 +1176,8 @@ static inline int search_dirblock(struct buffer_head *bh,
  */
 static struct buffer_head * ext4_find_entry (struct inode *dir,
                                         const struct qstr *d_name,
-                                        struct ext4_dir_entry_2 ** res_dir)
+                                        struct ext4_dir_entry_2 **res_dir,
+                                        int *inlined)
 {
         struct super_block *sb;
         struct buffer_head *bh_use[NAMEI_RA_SIZE];
@@ -1179,6 +1198,18 @@ static struct buffer_head * ext4_find_entry (struct inode *dir,
         namelen = d_name->len;
         if (namelen > EXT4_NAME_LEN)
                 return NULL;
+
+        if (ext4_has_inline_data(dir)) {
+                int has_inline_data = 1;
+                ret = ext4_find_inline_entry(dir, d_name, res_dir,
+                                             &has_inline_data);
+                if (has_inline_data) {
+                        if (inlined)
+                                *inlined = 1;
+                        return ret;
+                }
+        }
+
         if ((namelen <= 2) && (name[0] == '.') &&
             (name[1] == '.' || name[1] == '\0')) {
                 /*
@@ -1244,6 +1275,8 @@ restart:
                         goto next;
                 }
                 if (!buffer_verified(bh) &&
+                    !is_dx_internal_node(dir, block,
+                                         (struct ext4_dir_entry *)bh->b_data) &&
                     !ext4_dirent_csum_verify(dir,
                                 (struct ext4_dir_entry *)bh->b_data)) {
                         EXT4_ERROR_INODE(dir, "checksumming directory "
@@ -1361,7 +1394,7 @@ static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsi
         if (dentry->d_name.len > EXT4_NAME_LEN)
                 return ERR_PTR(-ENAMETOOLONG);
 
-        bh = ext4_find_entry(dir, &dentry->d_name, &de);
+        bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
         inode = NULL;
         if (bh) {
                 __u32 ino = le32_to_cpu(de->inode);
@@ -1395,7 +1428,7 @@ struct dentry *ext4_get_parent(struct dentry *child)
         struct ext4_dir_entry_2 * de;
         struct buffer_head *bh;
 
-        bh = ext4_find_entry(child->d_inode, &dotdot, &de);
+        bh = ext4_find_entry(child->d_inode, &dotdot, &de, NULL);
         if (!bh)
                 return ERR_PTR(-ENOENT);
         ino = le32_to_cpu(de->inode);
@@ -1593,6 +1626,63 @@ errout:
         return NULL;
 }
 
+int ext4_find_dest_de(struct inode *dir, struct inode *inode,
+                      struct buffer_head *bh,
+                      void *buf, int buf_size,
+                      const char *name, int namelen,
+                      struct ext4_dir_entry_2 **dest_de)
+{
+        struct ext4_dir_entry_2 *de;
+        unsigned short reclen = EXT4_DIR_REC_LEN(namelen);
+        int nlen, rlen;
+        unsigned int offset = 0;
+        char *top;
+
+        de = (struct ext4_dir_entry_2 *)buf;
+        top = buf + buf_size - reclen;
+        while ((char *) de <= top) {
+                if (ext4_check_dir_entry(dir, NULL, de, bh,
+                                         buf, buf_size, offset))
+                        return -EIO;
+                if (ext4_match(namelen, name, de))
+                        return -EEXIST;
+                nlen = EXT4_DIR_REC_LEN(de->name_len);
+                rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
+                if ((de->inode ? rlen - nlen : rlen) >= reclen)
+                        break;
+                de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
+                offset += rlen;
+        }
+        if ((char *) de > top)
+                return -ENOSPC;
+
+        *dest_de = de;
+        return 0;
+}
+
+void ext4_insert_dentry(struct inode *inode,
+                        struct ext4_dir_entry_2 *de,
+                        int buf_size,
+                        const char *name, int namelen)
+{
+
+        int nlen, rlen;
+
+        nlen = EXT4_DIR_REC_LEN(de->name_len);
+        rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
+        if (de->inode) {
+                struct ext4_dir_entry_2 *de1 =
+                                (struct ext4_dir_entry_2 *)((char *)de + nlen);
+                de1->rec_len = ext4_rec_len_to_disk(rlen - nlen, buf_size);
+                de->rec_len = ext4_rec_len_to_disk(nlen, buf_size);
+                de = de1;
+        }
+        de->file_type = EXT4_FT_UNKNOWN;
+        de->inode = cpu_to_le32(inode->i_ino);
+        ext4_set_de_type(inode->i_sb, de, inode->i_mode);
+        de->name_len = namelen;
+        memcpy(de->name, name, namelen);
+}
 /*
  * Add a new entry into a directory (leaf) block.  If de is non-NULL,
  * it points to a directory entry which is guaranteed to be large
@@ -1608,12 +1698,10 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
         struct inode    *dir = dentry->d_parent->d_inode;
         const char      *name = dentry->d_name.name;
         int             namelen = dentry->d_name.len;
-        unsigned int    offset = 0;
         unsigned int    blocksize = dir->i_sb->s_blocksize;
         unsigned short  reclen;
-        int             nlen, rlen, err;
-        char            *top;
         int             csum_size = 0;
+        int             err;
 
         if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
                                        EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
@@ -1621,22 +1709,11 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
 
         reclen = EXT4_DIR_REC_LEN(namelen);
         if (!de) {
-                de = (struct ext4_dir_entry_2 *)bh->b_data;
-                top = bh->b_data + (blocksize - csum_size) - reclen;
-                while ((char *) de <= top) {
-                        if (ext4_check_dir_entry(dir, NULL, de, bh, offset))
-                                return -EIO;
-                        if (ext4_match(namelen, name, de))
-                                return -EEXIST;
-                        nlen = EXT4_DIR_REC_LEN(de->name_len);
-                        rlen = ext4_rec_len_from_disk(de->rec_len, blocksize);
-                        if ((de->inode? rlen - nlen: rlen) >= reclen)
-                                break;
-                        de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
-                        offset += rlen;
-                }
-                if ((char *) de > top)
-                        return -ENOSPC;
+                err = ext4_find_dest_de(dir, inode,
+                                        bh, bh->b_data, blocksize - csum_size,
+                                        name, namelen, &de);
+                if (err)
+                        return err;
         }
         BUFFER_TRACE(bh, "get_write_access");
         err = ext4_journal_get_write_access(handle, bh);
@@ -1646,19 +1723,8 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
         }
 
         /* By now the buffer is marked for journaling */
-        nlen = EXT4_DIR_REC_LEN(de->name_len);
-        rlen = ext4_rec_len_from_disk(de->rec_len, blocksize);
-        if (de->inode) {
-                struct ext4_dir_entry_2 *de1 = (struct ext4_dir_entry_2 *)((char *)de + nlen);
-                de1->rec_len = ext4_rec_len_to_disk(rlen - nlen, blocksize);
-                de->rec_len = ext4_rec_len_to_disk(nlen, blocksize);
-                de = de1;
-        }
-        de->file_type = EXT4_FT_UNKNOWN;
-        de->inode = cpu_to_le32(inode->i_ino);
-        ext4_set_de_type(dir->i_sb, de, inode->i_mode);
-        de->name_len = namelen;
-        memcpy(de->name, name, namelen);
+        ext4_insert_dentry(inode, de, blocksize, name, namelen);
+
         /*
          * XXX shouldn't update any times until successful
          * completion of syscall, but too many callers depend
@@ -1831,6 +1897,17 @@ static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
         blocksize = sb->s_blocksize;
         if (!dentry->d_name.len)
                 return -EINVAL;
+
+        if (ext4_has_inline_data(dir)) {
+                retval = ext4_try_add_inline_entry(handle, dentry, inode);
+                if (retval < 0)
+                        return retval;
+                if (retval == 1) {
+                        retval = 0;
+                        return retval;
+                }
+        }
+
         if (is_dx(dir)) {
                 retval = ext4_dx_add_entry(handle, dentry, inode);
                 if (!retval || (retval != ERR_BAD_DX_DIR))
@@ -2036,36 +2113,29 @@ cleanup:
 }
 
 /*
- * ext4_delete_entry deletes a directory entry by merging it with the
- * previous entry
+ * ext4_generic_delete_entry deletes a directory entry by merging it
+ * with the previous entry
  */
-static int ext4_delete_entry(handle_t *handle,
-                             struct inode *dir,
-                             struct ext4_dir_entry_2 *de_del,
-                             struct buffer_head *bh)
+int ext4_generic_delete_entry(handle_t *handle,
+                              struct inode *dir,
+                              struct ext4_dir_entry_2 *de_del,
+                              struct buffer_head *bh,
+                              void *entry_buf,
+                              int buf_size,
+                              int csum_size)
 {
         struct ext4_dir_entry_2 *de, *pde;
         unsigned int blocksize = dir->i_sb->s_blocksize;
-        int csum_size = 0;
-        int i, err;
-
-        if (EXT4_HAS_RO_COMPAT_FEATURE(dir->i_sb,
-                                       EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
-                csum_size = sizeof(struct ext4_dir_entry_tail);
+        int i;
 
         i = 0;
         pde = NULL;
-        de = (struct ext4_dir_entry_2 *) bh->b_data;
-        while (i < bh->b_size - csum_size) {
-                if (ext4_check_dir_entry(dir, NULL, de, bh, i))
+        de = (struct ext4_dir_entry_2 *)entry_buf;
+        while (i < buf_size - csum_size) {
+                if (ext4_check_dir_entry(dir, NULL, de, bh,
+                                         bh->b_data, bh->b_size, i))
                         return -EIO;
                 if (de == de_del)  {
-                        BUFFER_TRACE(bh, "get_write_access");
-                        err = ext4_journal_get_write_access(handle, bh);
-                        if (unlikely(err)) {
-                                ext4_std_error(dir->i_sb, err);
-                                return err;
-                        }
                         if (pde)
                                 pde->rec_len = ext4_rec_len_to_disk(
                                         ext4_rec_len_from_disk(pde->rec_len,
@@ -2076,12 +2146,6 @@ static int ext4_delete_entry(handle_t *handle,
                         else
                                 de->inode = 0;
                         dir->i_version++;
-                        BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
-                        err = ext4_handle_dirty_dirent_node(handle, dir, bh);
-                        if (unlikely(err)) {
-                                ext4_std_error(dir->i_sb, err);
-                                return err;
-                        }
                         return 0;
                 }
                 i += ext4_rec_len_from_disk(de->rec_len, blocksize);
@@ -2091,6 +2155,48 @@ static int ext4_delete_entry(handle_t *handle,
         return -ENOENT;
 }
 
+static int ext4_delete_entry(handle_t *handle,
+                             struct inode *dir,
+                             struct ext4_dir_entry_2 *de_del,
+                             struct buffer_head *bh)
+{
+        int err, csum_size = 0;
+
+        if (ext4_has_inline_data(dir)) {
+                int has_inline_data = 1;
+                err = ext4_delete_inline_entry(handle, dir, de_del, bh,
+                                               &has_inline_data);
+                if (has_inline_data)
+                        return err;
+        }
+
+        if (EXT4_HAS_RO_COMPAT_FEATURE(dir->i_sb,
+                                       EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
+                csum_size = sizeof(struct ext4_dir_entry_tail);
+
+        BUFFER_TRACE(bh, "get_write_access");
+        err = ext4_journal_get_write_access(handle, bh);
+        if (unlikely(err))
+                goto out;
+
+        err = ext4_generic_delete_entry(handle, dir, de_del,
+                                        bh, bh->b_data,
+                                        dir->i_sb->s_blocksize, csum_size);
+        if (err)
+                goto out;
+
+        BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
+        err = ext4_handle_dirty_dirent_node(handle, dir, bh);
+        if (unlikely(err))
+                goto out;
+
+        return 0;
+out:
+        if (err != -ENOENT)
+                ext4_std_error(dir->i_sb, err);
+        return err;
+}
+
 /*
  * DIR_NLINK feature is set if 1) nlinks > EXT4_LINK_MAX or 2) nlinks == 2,
  * since this indicates that nlinks count was previously 1.
@@ -2211,21 +2317,95 @@ retry:
         return err;
 }
 
-static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
+struct ext4_dir_entry_2 *ext4_init_dot_dotdot(struct inode *inode,
+                          struct ext4_dir_entry_2 *de,
+                          int blocksize, int csum_size,
+                          unsigned int parent_ino, int dotdot_real_len)
+{
+        de->inode = cpu_to_le32(inode->i_ino);
+        de->name_len = 1;
+        de->rec_len = ext4_rec_len_to_disk(EXT4_DIR_REC_LEN(de->name_len),
+                                           blocksize);
+        strcpy(de->name, ".");
+        ext4_set_de_type(inode->i_sb, de, S_IFDIR);
+
+        de = ext4_next_entry(de, blocksize);
+        de->inode = cpu_to_le32(parent_ino);
+        de->name_len = 2;
+        if (!dotdot_real_len)
+                de->rec_len = ext4_rec_len_to_disk(blocksize -
+                                        (csum_size + EXT4_DIR_REC_LEN(1)),
+                                        blocksize);
+        else
+                de->rec_len = ext4_rec_len_to_disk(
+                                EXT4_DIR_REC_LEN(de->name_len), blocksize);
+        strcpy(de->name, "..");
+        ext4_set_de_type(inode->i_sb, de, S_IFDIR);
+
+        return ext4_next_entry(de, blocksize);
+}
+
+static int ext4_init_new_dir(handle_t *handle, struct inode *dir,
+                             struct inode *inode)
 {
-        handle_t *handle;
-        struct inode *inode;
         struct buffer_head *dir_block = NULL;
         struct ext4_dir_entry_2 *de;
         struct ext4_dir_entry_tail *t;
         unsigned int blocksize = dir->i_sb->s_blocksize;
         int csum_size = 0;
-        int err, retries = 0;
+        int err;
 
         if (EXT4_HAS_RO_COMPAT_FEATURE(dir->i_sb,
                                        EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
                 csum_size = sizeof(struct ext4_dir_entry_tail);
 
+        if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
+                err = ext4_try_create_inline_dir(handle, dir, inode);
+                if (err < 0 && err != -ENOSPC)
+                        goto out;
+                if (!err)
+                        goto out;
+        }
+
+        inode->i_size = EXT4_I(inode)->i_disksize = blocksize;
+        dir_block = ext4_bread(handle, inode, 0, 1, &err);
+        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;
+        }
+        BUFFER_TRACE(dir_block, "get_write_access");
+        err = ext4_journal_get_write_access(handle, dir_block);
+        if (err)
+                goto out;
+        de = (struct ext4_dir_entry_2 *)dir_block->b_data;
+        ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0);
+        set_nlink(inode, 2);
+        if (csum_size) {
+                t = EXT4_DIRENT_TAIL(dir_block->b_data, blocksize);
+                initialize_dirent_tail(t, blocksize);
+        }
+
+        BUFFER_TRACE(dir_block, "call ext4_handle_dirty_metadata");
+        err = ext4_handle_dirty_dirent_node(handle, inode, dir_block);
+        if (err)
+                goto out;
+        set_buffer_verified(dir_block);
+out:
+        brelse(dir_block);
+        return err;
+}
+
+static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
+{
+        handle_t *handle;
+        struct inode *inode;
+        int err, retries = 0;
+
         if (EXT4_DIR_LINK_MAX(dir))
                 return -EMLINK;
 
@@ -2249,47 +2429,9 @@ retry:
 
         inode->i_op = &ext4_dir_inode_operations;
         inode->i_fop = &ext4_dir_operations;
-        inode->i_size = EXT4_I(inode)->i_disksize = inode->i_sb->s_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_clear_inode;
-        }
-        BUFFER_TRACE(dir_block, "get_write_access");
-        err = ext4_journal_get_write_access(handle, dir_block);
-        if (err)
-                goto out_clear_inode;
-        de = (struct ext4_dir_entry_2 *) dir_block->b_data;
-        de->inode = cpu_to_le32(inode->i_ino);
-        de->name_len = 1;
-        de->rec_len = ext4_rec_len_to_disk(EXT4_DIR_REC_LEN(de->name_len),
-                                           blocksize);
-        strcpy(de->name, ".");
-        ext4_set_de_type(dir->i_sb, de, S_IFDIR);
-        de = ext4_next_entry(de, blocksize);
-        de->inode = cpu_to_le32(dir->i_ino);
-        de->rec_len = ext4_rec_len_to_disk(blocksize -
-                                           (csum_size + EXT4_DIR_REC_LEN(1)),
-                                           blocksize);
-        de->name_len = 2;
-        strcpy(de->name, "..");
-        ext4_set_de_type(dir->i_sb, de, S_IFDIR);
-        set_nlink(inode, 2);
-
-        if (csum_size) {
-                t = EXT4_DIRENT_TAIL(dir_block->b_data, blocksize);
-                initialize_dirent_tail(t, blocksize);
-        }
-
-        BUFFER_TRACE(dir_block, "call ext4_handle_dirty_metadata");
-        err = ext4_handle_dirty_dirent_node(handle, inode, dir_block);
+        err = ext4_init_new_dir(handle, dir, inode);
         if (err)
                 goto out_clear_inode;
-        set_buffer_verified(dir_block);
         err = ext4_mark_inode_dirty(handle, inode);
         if (!err)
                 err = ext4_add_entry(handle, dentry, inode);
@@ -2309,7 +2451,6 @@ out_clear_inode:
         unlock_new_inode(inode);
         d_instantiate(dentry, inode);
 out_stop:
-        brelse(dir_block);
         ext4_journal_stop(handle);
         if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
                 goto retry;
@@ -2327,6 +2468,14 @@ static int empty_dir(struct inode *inode)
         struct super_block *sb;
         int err = 0;
 
+        if (ext4_has_inline_data(inode)) {
+                int has_inline_data = 1;
+
+                err = empty_inline_dir(inode, &has_inline_data);
+                if (has_inline_data)
+                        return err;
+        }
+
         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))) {
@@ -2393,7 +2542,8 @@ static int empty_dir(struct inode *inode)
                         set_buffer_verified(bh);
                         de = (struct ext4_dir_entry_2 *) bh->b_data;
                 }
-                if (ext4_check_dir_entry(inode, NULL, de, bh, offset)) {
+                if (ext4_check_dir_entry(inode, NULL, de, bh,
+                                         bh->b_data, bh->b_size, offset)) {
                         de = (struct ext4_dir_entry_2 *)(bh->b_data +
                                                          sb->s_blocksize);
                         offset = (offset | (sb->s_blocksize - 1)) + 1;
@@ -2579,7 +2729,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
                 return PTR_ERR(handle);
 
         retval = -ENOENT;
-        bh = ext4_find_entry(dir, &dentry->d_name, &de);
+        bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
         if (!bh)
                 goto end_rmdir;
 
@@ -2644,7 +2794,7 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
                 ext4_handle_sync(handle);
 
         retval = -ENOENT;
-        bh = ext4_find_entry(dir, &dentry->d_name, &de);
+        bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
         if (!bh)
                 goto end_unlink;
 
@@ -2826,8 +2976,39 @@ retry:
         return err;
 }
 
-#define PARENT_INO(buffer, size) \
-        (ext4_next_entry((struct ext4_dir_entry_2 *)(buffer), size)->inode)
+
+/*
+ * Try to find buffer head where contains the parent block.
+ * It should be the inode block if it is inlined or the 1st block
+ * if it is a normal dir.
+ */
+static struct buffer_head *ext4_get_first_dir_block(handle_t *handle,
+                                        struct inode *inode,
+                                        int *retval,
+                                        struct ext4_dir_entry_2 **parent_de,
+                                        int *inlined)
+{
+        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);
+                        }
+                        return NULL;
+                }
+                *parent_de = ext4_next_entry(
+                                        (struct ext4_dir_entry_2 *)bh->b_data,
+                                        inode->i_sb->s_blocksize);
+                return bh;
+        }
+
+        *inlined = 1;
+        return ext4_get_first_inline_block(inode, parent_de, retval);
+}
 
 /*
  * Anybody can rename anything with this: the permission checks are left to the
@@ -2841,6 +3022,8 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct buffer_head *old_bh, *new_bh, *dir_bh;
         struct ext4_dir_entry_2 *old_de, *new_de;
         int retval, force_da_alloc = 0;
+        int inlined = 0, new_inlined = 0;
+        struct ext4_dir_entry_2 *parent_de;
 
         dquot_initialize(old_dir);
         dquot_initialize(new_dir);
@@ -2860,7 +3043,7 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
                 ext4_handle_sync(handle);
 
-        old_bh = ext4_find_entry(old_dir, &old_dentry->d_name, &old_de);
+        old_bh = ext4_find_entry(old_dir, &old_dentry->d_name, &old_de, NULL);
         /*
          *  Check for inode number is _not_ due to possible IO errors.
          *  We might rmdir the source, keep it as pwd of some process
@@ -2873,7 +3056,8 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
                 goto end_rename;
 
         new_inode = new_dentry->d_inode;
-        new_bh = ext4_find_entry(new_dir, &new_dentry->d_name, &new_de);
+        new_bh = ext4_find_entry(new_dir, &new_dentry->d_name,
+                                 &new_de, &new_inlined);
         if (new_bh) {
                 if (!new_inode) {
                         brelse(new_bh);
@@ -2887,22 +3071,17 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
                                 goto end_rename;
                 }
                 retval = -EIO;
-                if (!(dir_bh = ext4_bread(handle, old_inode, 0, 0, &retval))) {
-                        if (!retval) {
-                                retval = -EIO;
-                                ext4_error(old_inode->i_sb,
-                                           "Directory hole detected on inode %lu\n",
-                                           old_inode->i_ino);
-                        }
+                dir_bh = ext4_get_first_dir_block(handle, old_inode,
+                                                  &retval, &parent_de,
+                                                  &inlined);
+                if (!dir_bh)
                         goto end_rename;
-                }
-                if (!buffer_verified(dir_bh) &&
+                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_INO(dir_bh->b_data,
-                                old_dir->i_sb->s_blocksize)) != old_dir->i_ino)
+                if (le32_to_cpu(parent_de->inode) != old_dir->i_ino)
                         goto end_rename;
                 retval = -EMLINK;
                 if (!new_inode && new_dir != old_dir &&
@@ -2931,10 +3110,13 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
                                         ext4_current_time(new_dir);
                 ext4_mark_inode_dirty(handle, new_dir);
                 BUFFER_TRACE(new_bh, "call ext4_handle_dirty_metadata");
-                retval = ext4_handle_dirty_dirent_node(handle, new_dir, new_bh);
-                if (unlikely(retval)) {
-                        ext4_std_error(new_dir->i_sb, retval);
-                        goto end_rename;
+                if (!new_inlined) {
+                        retval = ext4_handle_dirty_dirent_node(handle,
+                                                               new_dir, new_bh);
+                        if (unlikely(retval)) {
+                                ext4_std_error(new_dir->i_sb, retval);
+                                goto end_rename;
+                        }
                 }
                 brelse(new_bh);
                 new_bh = NULL;
@@ -2962,7 +3144,8 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
                 struct buffer_head *old_bh2;
                 struct ext4_dir_entry_2 *old_de2;
 
-                old_bh2 = ext4_find_entry(old_dir, &old_dentry->d_name, &old_de2);
+                old_bh2 = ext4_find_entry(old_dir, &old_dentry->d_name,
+                                          &old_de2, NULL);
                 if (old_bh2) {
                         retval = ext4_delete_entry(handle, old_dir,
                                                    old_de2, old_bh2);
@@ -2982,17 +3165,19 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
         old_dir->i_ctime = old_dir->i_mtime = ext4_current_time(old_dir);
         ext4_update_dx_flag(old_dir);
         if (dir_bh) {
-                PARENT_INO(dir_bh->b_data, new_dir->i_sb->s_blocksize) =
-                                                cpu_to_le32(new_dir->i_ino);
+                parent_de->inode = cpu_to_le32(new_dir->i_ino);
                 BUFFER_TRACE(dir_bh, "call ext4_handle_dirty_metadata");
-                if (is_dx(old_inode)) {
-                        retval = ext4_handle_dirty_dx_node(handle,
-                                                           old_inode,
-                                                           dir_bh);
+                if (!inlined) {
+                        if (is_dx(old_inode)) {
+                                retval = ext4_handle_dirty_dx_node(handle,
+                                                                   old_inode,
+                                                                   dir_bh);
+                        } else {
+                                retval = ext4_handle_dirty_dirent_node(handle,
+                                                        old_inode, dir_bh);
+                        }
                 } else {
-                        retval = ext4_handle_dirty_dirent_node(handle,
-                                                               old_inode,
-                                                               dir_bh);
+                        retval = ext4_mark_inode_dirty(handle, old_inode);
                 }
                 if (retval) {
                         ext4_std_error(old_dir->i_sb, retval);
@@ -3043,23 +3228,19 @@ const struct inode_operations ext4_dir_inode_operations = {
         .mknod          = ext4_mknod,
         .rename         = ext4_rename,
         .setattr        = ext4_setattr,
-#ifdef CONFIG_EXT4_FS_XATTR
         .setxattr       = generic_setxattr,
         .getxattr       = generic_getxattr,
         .listxattr      = ext4_listxattr,
         .removexattr    = generic_removexattr,
-#endif
         .get_acl        = ext4_get_acl,
         .fiemap         = ext4_fiemap,
 };
 
 const struct inode_operations ext4_special_inode_operations = {
         .setattr        = ext4_setattr,
-#ifdef CONFIG_EXT4_FS_XATTR
         .setxattr       = generic_setxattr,
         .getxattr       = generic_getxattr,
         .listxattr      = ext4_listxattr,
         .removexattr    = generic_removexattr,
-#endif
         .get_acl        = ext4_get_acl,
 };