From patchwork Fri Aug 2 09:49:34 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Zheng Liu X-Patchwork-Id: 264259 Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@ozlabs.org Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 143E02C0095 for ; Fri, 2 Aug 2013 19:51:10 +1000 (EST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1758588Ab3HBJum (ORCPT ); Fri, 2 Aug 2013 05:50:42 -0400 Received: from mail-pd0-f182.google.com ([209.85.192.182]:37202 "EHLO mail-pd0-f182.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1758500Ab3HBJuh (ORCPT ); Fri, 2 Aug 2013 05:50:37 -0400 Received: by mail-pd0-f182.google.com with SMTP id r10so486057pdi.27 for ; Fri, 02 Aug 2013 02:50:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=from:to:cc:subject:date:message-id:x-mailer:in-reply-to:references; bh=f9Pb+8uJySCfkNX4xzxcLNldcDCsXeGaqUlg8yMlG8M=; b=dM6bVBP1jlHIyDmehgKdDdlgPIdvnxA5HwDx0v39DaZC+GaLgfC8fWSHOnYt9puBVa RCqg5nixH8Pa2go8QYqe9b3766V6di1BnMTVRX7RfDw8YB3xyg4GfDnfpOxnvkYKjXTH hvIibA/9Hu+iFBhkckFPPheFfy0GafBBhMxZcN81LozM9nj4OPDrHszwn6dPQvFwP0NH TRHL+a2mPkGEER+At9YL7cjtqhL9sQr11zRN5hCCxAU4m0IRF1YCurnBEU+oW0h0sHbq 4RCRmXeWgwQQy7sSoX3Azt5TjNtm8Q7XsiK8zwu5CjZ6SSDAtzClnWz5VqzHxO9MD3yK qAIw== X-Received: by 10.68.234.72 with SMTP id uc8mr6870183pbc.35.1375437036748; Fri, 02 Aug 2013 02:50:36 -0700 (PDT) Received: from lz-devel.taobao.ali.com ([182.92.247.2]) by mx.google.com with ESMTPSA id il4sm5912193pbb.36.2013.08.02.02.50.31 for (version=TLSv1 cipher=RC4-SHA bits=128/128); Fri, 02 Aug 2013 02:50:36 -0700 (PDT) From: Zheng Liu To: linux-ext4@vger.kernel.org Cc: Theodore Ts'o , Zheng Liu Subject: [PATCH v1 07/22] debugfs: make mkdir and expanddir command support inline data Date: Fri, 2 Aug 2013 17:49:34 +0800 Message-Id: <1375436989-18948-8-git-send-email-wenqing.lz@taobao.com> X-Mailer: git-send-email 1.7.9.7 In-Reply-To: <1375436989-18948-1-git-send-email-wenqing.lz@taobao.com> References: <1375436989-18948-1-git-send-email-wenqing.lz@taobao.com> Sender: linux-ext4-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org From: Zheng Liu This commit tries to make mkdir and expanddir command support inline date feature. In ext2fs_expand_dir() function ext2fs_inline_data_convert() will be called to expand a directory with inline data. It tries to allocate a block and copy all directory entries into it. In ext2fs_mkdir() it calls ext2fs_new_dir_inline_data() function to create a new directory with inline data. Signed-off-by: Theodore Ts'o Signed-off-by: Zheng Liu --- lib/ext2fs/expanddir.c | 18 +-- lib/ext2fs/ext2fs.h | 5 + lib/ext2fs/ext2fsP.h | 13 +++ lib/ext2fs/inline_data.c | 280 ++++++++++++++++++++++++++++++++++++++++++++++ lib/ext2fs/mkdir.c | 102 +++++++++++++---- lib/ext2fs/newdir.c | 33 ++++++ 6 files changed, 420 insertions(+), 31 deletions(-) diff --git a/lib/ext2fs/expanddir.c b/lib/ext2fs/expanddir.c index 22558d6..9696b61 100644 --- a/lib/ext2fs/expanddir.c +++ b/lib/ext2fs/expanddir.c @@ -19,13 +19,7 @@ #include "ext2_fs.h" #include "ext2fs.h" -struct expand_dir_struct { - int done; - int newblocks; - blk64_t goal; - errcode_t err; - ext2_ino_t dir; -}; +#include "ext2fsP.h" static int expand_dir_proc(ext2_filsys fs, blk64_t *blocknr, @@ -114,6 +108,16 @@ errcode_t ext2fs_expand_dir(ext2_filsys fs, ext2_ino_t dir) es.newblocks = 0; es.dir = dir; + if (ext2fs_inode_has_inline_data(fs, dir)) { + retval = ext2fs_inline_data_convert(fs, dir, &es); + if (retval) + return retval; + if (!es.done) + return EXT2_ET_EXPAND_DIR_ERR; + + return 0; + } + retval = ext2fs_block_iterate3(fs, dir, BLOCK_FLAG_APPEND, 0, expand_dir_proc, &es); diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h index 6e3bf6e..934dbd0 100644 --- a/lib/ext2fs/ext2fs.h +++ b/lib/ext2fs/ext2fs.h @@ -1356,6 +1356,9 @@ extern errcode_t ext2fs_inline_data_iterate(ext2_filsys fs, struct ext2_inode_large *inode, void *priv_data), void *priv_data); +extern errcode_t ext2fs_inline_data_create(ext2_filsys fs, + struct ext2_inode_large *inode, + unsigned int len); /* inode.c */ extern void ext2fs_free_inode_cache(struct ext2_inode_cache *icache); @@ -1430,6 +1433,8 @@ int ext2fs_native_flag(void); /* newdir.c */ extern errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino, ext2_ino_t parent_ino, char **block); +extern errcode_t ext2fs_new_dir_inline_data(ext2_filsys fs, ext2_ino_t dir_ino, + ext2_ino_t parent_ino, struct ext2_inode *inode); /* mkdir.c */ extern errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum, diff --git a/lib/ext2fs/ext2fsP.h b/lib/ext2fs/ext2fsP.h index e86d452..ed89272 100644 --- a/lib/ext2fs/ext2fsP.h +++ b/lib/ext2fs/ext2fsP.h @@ -62,6 +62,17 @@ struct dir_context { }; /* + * For expanding directory + */ +struct expand_dir_struct { + int done; + int newblocks; + blk64_t goal; + errcode_t err; + ext2_ino_t dir; +}; + +/* * Inode cache structure */ struct ext2_inode_cache { @@ -97,6 +108,8 @@ extern int ext2fs_process_dir_inline_data(ext2_filsys fs, extern errcode_t ext2fs_inline_data_find(ext2_filsys fs, struct ext2_inode_large *inode, struct inline_data *data); +extern errcode_t ext2fs_inline_data_convert(ext2_filsys fs, ext2_ino_t ino, + void *priv_data); /* Generic numeric progress meter */ diff --git a/lib/ext2fs/inline_data.c b/lib/ext2fs/inline_data.c index 1220418..c936e28 100644 --- a/lib/ext2fs/inline_data.c +++ b/lib/ext2fs/inline_data.c @@ -21,6 +21,14 @@ static void *ext2fs_get_inline_xattr_pos(struct ext2_inode_large *inode, struct inline_data *data); +static void ext2fs_inline_data_finish_convert(ext2_filsys fs, ext2_ino_t ino, + char *target, char *buf, + int inline_size); +static void ext2fs_update_final_de(ext2_filsys fs, char *de_buf, + int old_size, int new_size); +static errcode_t ext2fs_inline_data_destory_data(ext2_filsys fs, ext2_ino_t ino, + struct ext2_inode_large *inode, + struct inline_data *data); errcode_t ext2fs_inline_data_find(ext2_filsys fs, struct ext2_inode_large *inode, @@ -68,6 +76,48 @@ static void *ext2fs_get_inline_xattr_pos(struct ext2_inode_large *inode, return (void *) (IFIRST(header) + entry->e_value_offs); } +static errcode_t ext2fs_inline_data_destory_data(ext2_filsys fs, ext2_ino_t ino, + struct ext2_inode_large *inode, + struct inline_data *data) +{ + struct ext2_ext_attr_ibody_header *header; + struct ext2_ext_attr_search s = { + .not_found = ENODATA, + }; + struct ext2_ext_attr_info i = { + .name_index = EXT4_EXT_ATTR_INDEX_SYSTEM, + .name = EXT4_EXT_ATTR_SYSTEM_DATA, + .value = "", + .value_len = 0, + }; + errcode_t retval; + + if (!data->inline_off) + return 0; + + if (inode->i_extra_isize > (EXT2_INODE_SIZE(fs->super) - + EXT2_GOOD_OLD_INODE_SIZE)) + return EXT2_ET_BAD_EXTRA_SIZE; + + header = IHDR(inode); + if (header->h_magic != EXT2_EXT_ATTR_MAGIC) + return EXT2_ET_BAD_EXT_ATTR_MAGIC; + + retval = ext2fs_ext_attr_ibody_find(fs, inode, &i, &s); + if (retval) + return retval; + + if (!s.not_found) { + retval = ext2fs_ext_attr_set_entry(&i, &s); + if (retval) + return retval; + } + + memset((void *)inode->i_block, 0, EXT4_MIN_INLINE_DATA_SIZE); + + return 0; +} + int ext2fs_inode_has_inline_data(ext2_filsys fs, ext2_ino_t ino) { struct ext2_inode inode; @@ -107,6 +157,83 @@ out: return size; } +static void ext2fs_update_final_de(ext2_filsys fs, char *de_buf, + int old_size, int new_size) +{ + struct ext2_dir_entry *de, *prev_de; + char *limit; + unsigned int de_len; + + de = (struct ext2_dir_entry *)de_buf; + if (old_size) { + limit = de_buf + old_size; + do { + prev_de = de; + ext2fs_get_rec_len(fs, de, &de_len); + de_buf += de_len; + de = (struct ext2_dir_entry *)de_buf; + } while (de_buf < limit); + + ext2fs_set_rec_len(fs, de_len + new_size - old_size, + prev_de); + } else { + de->inode = 0; + ext2fs_set_rec_len(fs, new_size, de); + } +} + +static void ext2fs_inline_data_finish_convert(ext2_filsys fs, ext2_ino_t ino, + char *target, char *buf, + int inline_size) +{ + struct ext2_dir_entry *de; + struct ext2_dir_entry_tail *t; + int header_size = 0; + int csum_size = 0; + int filetype = 0; + + if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) + csum_size = sizeof(struct ext2_dir_entry_tail); + + /* First create '.' and '..' */ + if (fs->super->s_feature_incompat & + EXT2_FEATURE_INCOMPAT_FILETYPE) + filetype = EXT2_FT_DIR << 8; + + de = (struct ext2_dir_entry *)target; + de->inode = ino; + de->name_len = 1 | filetype; + de->name[0] = '.'; + de->name[1] = '\0'; + de->rec_len = EXT2_DIR_REC_LEN(1); + + de = (struct ext2_dir_entry *)(target + de->rec_len); + de->rec_len = EXT2_DIR_REC_LEN(2); + de->inode = ((struct ext2_dir_entry *)buf)->inode; + de->name_len = 2 | filetype; + de->name[0] = '.'; + de->name[1] = '.'; + de->name[2] = '\0'; + + de = (struct ext2_dir_entry *)(target + + EXT2_DIR_REC_LEN(1) + + EXT2_DIR_REC_LEN(2)); + header_size = (char *)de - (char *)target; + + memcpy((void *)de, buf + EXT4_INLINE_DATA_DOTDOT_SIZE, + inline_size - EXT4_INLINE_DATA_DOTDOT_SIZE); + + ext2fs_update_final_de(fs, target, + inline_size - EXT4_INLINE_DATA_DOTDOT_SIZE + header_size, + fs->blocksize - csum_size); + + if (csum_size) { + t = EXT2_DIRENT_TAIL(target, fs->blocksize); + ext2fs_initialize_dirent_tail(fs, t); + } +} + errcode_t ext2fs_inline_data_iterate(ext2_filsys fs, ext2_ino_t ino, int flags, @@ -188,3 +315,156 @@ out: ext2fs_free_mem(&inode); return retval & BLOCK_ERROR ? ctx->errcode : 0; } + +errcode_t ext2fs_inline_data_convert(ext2_filsys fs, + ext2_ino_t ino, + void *priv_data) +{ + struct expand_dir_struct *es; + struct ext2_inode_large *inode; + struct inline_data data; + ext2_extent_handle_t handle; + errcode_t retval; + blk64_t blk; + char *backup_buf; + char *blk_buf; + unsigned int inline_size; + + EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); + + es = (struct expand_dir_struct *)priv_data; + retval = ext2fs_get_mem(EXT2_INODE_SIZE(fs->super), &inode); + if (retval) + return retval; + + retval = ext2fs_read_inode_full(fs, ino, (void *)inode, + EXT2_INODE_SIZE(fs->super)); + if (retval) + goto out; + + retval = ext2fs_inline_data_find(fs, inode, &data); + if (retval) + goto out; + + inline_size = data.inline_size; + retval = ext2fs_get_mem(inline_size, &backup_buf); + if (retval) + goto out; + + memcpy(backup_buf, (void *)inode->i_block, EXT4_MIN_INLINE_DATA_SIZE); + if (inline_size > EXT4_MIN_INLINE_DATA_SIZE) + memcpy(backup_buf + EXT4_MIN_INLINE_DATA_SIZE, + ext2fs_get_inline_xattr_pos(inode, &data), + inline_size - EXT4_MIN_INLINE_DATA_SIZE); + + /* clear the entry and the flag in dir now */ + retval = ext2fs_inline_data_destory_data(fs, ino, inode, &data); + if (retval) + goto out1; + + if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) { + if (LINUX_S_ISDIR(inode->i_mode) || + LINUX_S_ISREG(inode->i_mode) || + LINUX_S_ISLNK(inode->i_mode)) + inode->i_flags |= EXT4_EXTENTS_FL; + } + + inode->i_flags &= ~EXT4_INLINE_DATA_FL; + + retval = ext2fs_new_block2(fs, 0, 0, &blk); + if (retval) + goto out1; + + ext2fs_iblk_set(fs, (void*)inode, 1); + if (!(fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS)) + inode->i_block[0] = blk; + inode->i_size = fs->blocksize; + + retval = ext2fs_get_mem(fs->blocksize, &blk_buf); + if (retval) + goto out1; + + memset(blk_buf, 0, sizeof(fs->blocksize)); + if (LINUX_S_ISDIR(inode->i_mode)) { + /* set the final dir entry to cover the whole block */ + ext2fs_inline_data_finish_convert(fs, ino, blk_buf, backup_buf, + inline_size); + } else { + memcpy(blk_buf, backup_buf, inline_size); + } + + retval = ext2fs_write_dir_block4(fs, blk, blk_buf, 0, ino); + if (retval) + goto out2; + retval = ext2fs_write_inode_full(fs, ino, (void *)inode, + EXT2_INODE_SIZE(fs->super)); + if (retval) + goto out2; + + if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) { + retval = ext2fs_extent_open2(fs, ino, (void *)inode, &handle); + if (retval) + goto out2; + retval = ext2fs_extent_set_bmap(handle, 0, blk, 0); + ext2fs_extent_free(handle); + if (retval) + goto out2; + } + + ext2fs_block_alloc_stats2(fs, blk, +1); + +out2: + ext2fs_free_mem(&blk_buf); +out1: + ext2fs_free_mem(&backup_buf); +out: + ext2fs_free_mem(&inode); + + if (retval) { + es->err = retval; + } else { + es->done = 1; + es->newblocks++; + es->goal = blk; + } + return retval; +} + +errcode_t ext2fs_inline_data_create(ext2_filsys fs, + struct ext2_inode_large *inode, + unsigned int len) +{ + struct ext2_ext_attr_ibody_header *header; + struct ext2_ext_attr_search s = { + .not_found = ENODATA, + }; + struct ext2_ext_attr_info i = { + .name_index = EXT4_EXT_ATTR_INDEX_SYSTEM, + .name = EXT4_EXT_ATTR_SYSTEM_DATA, + }; + void *buf; + errcode_t retval; + + if (len > EXT4_MIN_INLINE_DATA_SIZE) { + i.value = EXT2_ZERO_EXT_ATTR_VALUE; + i.value_len = len - EXT4_MIN_INLINE_DATA_SIZE; + } else { + i.value = ""; + i.value_len = 0; + } + + retval = ext2fs_ext_attr_ibody_find(fs, inode, &i, &s); + if (retval) + return retval; + retval = ext2fs_ext_attr_set_entry(&i, &s); + if (retval) + return retval; + + header = IHDR(inode); + if (!EXT2_EXT_IS_LAST_ENTRY(s.first)) + header->h_magic = EXT2_EXT_ATTR_MAGIC; + else + header->h_magic = 0; + + return 0; +} diff --git a/lib/ext2fs/mkdir.c b/lib/ext2fs/mkdir.c index 4a85439..a6aeb0d 100644 --- a/lib/ext2fs/mkdir.c +++ b/lib/ext2fs/mkdir.c @@ -36,11 +36,13 @@ errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum, { ext2_extent_handle_t handle; errcode_t retval; - struct ext2_inode parent_inode, inode; + struct ext2_inode parent_inode, *inode = NULL; + struct ext2_inode_large *large_inode = NULL; ext2_ino_t ino = inum; ext2_ino_t scratch_ino; blk64_t blk; char *block = 0; + int inline_data = 0; EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); @@ -55,16 +57,38 @@ errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum, } /* + * We try to create a new directory with inline data if this feature + * is enabled. Here we don't try to do this if ino < first_ino or + * the directory name is 'lost+found'. + */ + if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_INLINE_DATA && + ino >= EXT2_FIRST_INO(fs->super) && strcmp("lost+found", name) != 0) + inline_data = 1; + + /* * Allocate a data block for the directory */ - retval = ext2fs_new_block2(fs, 0, 0, &blk); + if (!inline_data) { + retval = ext2fs_new_block2(fs, 0, 0, &blk); + if (retval) + goto cleanup; + } + + /* + * Allocate a new inode structuure + */ + retval = ext2fs_get_memzero(EXT2_INODE_SIZE(fs->super), &large_inode); if (retval) goto cleanup; + inode = (struct ext2_inode *) large_inode; /* * Create a scratch template for the directory */ - retval = ext2fs_new_dir_block(fs, ino, parent, &block); + if (inline_data) + retval = ext2fs_new_dir_inline_data(fs, ino, parent, inode); + else + retval = ext2fs_new_dir_block(fs, ino, parent, &block); if (retval) goto cleanup; @@ -81,37 +105,61 @@ errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum, /* * Create the inode structure.... */ - memset(&inode, 0, sizeof(struct ext2_inode)); - inode.i_mode = LINUX_S_IFDIR | (0777 & ~fs->umask); - inode.i_uid = inode.i_gid = 0; - ext2fs_iblk_set(fs, &inode, 1); - if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) - inode.i_flags |= EXT4_EXTENTS_FL; + inode->i_mode = LINUX_S_IFDIR | (0777 & ~fs->umask); + inode->i_uid = inode->i_gid = 0; + ext2fs_iblk_set(fs, inode, 1); + if (inline_data) + inode->i_flags |= EXT4_INLINE_DATA_FL; + else if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) + inode->i_flags |= EXT4_EXTENTS_FL; else - inode.i_block[0] = blk; - inode.i_links_count = 2; - inode.i_size = fs->blocksize; + inode->i_block[0] = blk; + inode->i_links_count = 2; /* * Write out the inode and inode data block. The inode generation * number is assigned by write_new_inode, which means that the call * to write_dir_block must come after that. + * + * If we try to create an new inode with inline data, we should call + * ext2fs_write_inode_full to avoid to initialize extra part. */ - retval = ext2fs_write_new_inode(fs, ino, &inode); - if (retval) - goto cleanup; - retval = ext2fs_write_dir_block4(fs, blk, block, 0, ino); - if (retval) - goto cleanup; + if (inline_data) { + __u32 t = fs->now ? fs->now : time(NULL); + + inode->i_size = EXT4_MIN_INLINE_DATA_SIZE; + inode->i_blocks = 0; + if (!inode->i_ctime) + inode->i_ctime = t; + if (!inode->i_mtime) + inode->i_mtime = t; + if (!inode->i_atime) + inode->i_atime = t; + if (!large_inode->i_crtime) + large_inode->i_crtime = t; + retval = ext2fs_write_inode_full(fs, ino, inode, + EXT2_INODE_SIZE(fs->super)); + if (retval) + goto cleanup; + } else { + inode->i_size = fs->blocksize; - if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) { - retval = ext2fs_extent_open2(fs, ino, &inode, &handle); + retval = ext2fs_write_new_inode(fs, ino, inode); if (retval) goto cleanup; - retval = ext2fs_extent_set_bmap(handle, 0, blk, 0); - ext2fs_extent_free(handle); + retval = ext2fs_write_dir_block4(fs, blk, block, 0, ino); if (retval) goto cleanup; + + if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) { + retval = ext2fs_extent_open2(fs, ino, inode, &handle); + if (retval) + goto cleanup; + retval = ext2fs_extent_set_bmap(handle, 0, blk, 0); + ext2fs_extent_free(handle); + if (retval) + goto cleanup; + } } /* @@ -136,6 +184,10 @@ errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum, * Update parent inode's counts */ if (parent != ino) { + /* Reload parent inode due to inline data */ + retval = ext2fs_read_inode(fs, parent, &parent_inode); + if (retval) + goto cleanup; parent_inode.i_links_count++; retval = ext2fs_write_inode(fs, parent, &parent_inode); if (retval) @@ -145,14 +197,16 @@ errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum, /* * Update accounting.... */ - ext2fs_block_alloc_stats2(fs, blk, +1); + if (!inline_data) + ext2fs_block_alloc_stats2(fs, blk, +1); ext2fs_inode_alloc_stats2(fs, ino, +1, 1); cleanup: + if (large_inode) + ext2fs_free_mem(&large_inode); if (block) ext2fs_free_mem(&block); return retval; - } diff --git a/lib/ext2fs/newdir.c b/lib/ext2fs/newdir.c index 2cd541d..cec99e9 100644 --- a/lib/ext2fs/newdir.c +++ b/lib/ext2fs/newdir.c @@ -87,3 +87,36 @@ errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino, *block = buf; return 0; } + +/* + * Create new directory in inode + */ +errcode_t ext2fs_new_dir_inline_data(ext2_filsys fs, + ext2_ino_t dir_ino, + ext2_ino_t parent_ino, + struct ext2_inode *inode) +{ + struct ext2_inode_large *large_inode; + struct ext2_dir_entry *dir = NULL; + int inline_size = EXT4_MIN_INLINE_DATA_SIZE; + errcode_t retval; + + EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); + + large_inode = (struct ext2_inode_large *) inode; + large_inode->i_extra_isize = sizeof(struct ext2_inode_large) - + EXT2_GOOD_OLD_INODE_SIZE; + retval = ext2fs_inline_data_create(fs, large_inode, inline_size); + if (retval) + return retval; + + dir = (struct ext2_dir_entry *) inode->i_block; + dir->inode = parent_ino; + + dir = (struct ext2_dir_entry *) ((char *) dir + + EXT4_INLINE_DATA_DOTDOT_SIZE); + dir->inode = 0; + dir->rec_len = inline_size - EXT4_INLINE_DATA_DOTDOT_SIZE; + + return retval; +}