[Ocfs2-devel] [PATCH 3/7] ocfs2: Store dir index records inline
Mark Fasheh
mfasheh at suse.com
Fri Jan 30 13:42:29 PST 2009
Allow us to store a small number of directory index records in the
ocfs2_dx_root_block. This saves us a disk read on small to medium sized
directories (less than about 250 entries). The inline root is automatically
turned into a root block with extents if the directory size increases beyond
it's capacity.
Signed-off-by: Mark Fasheh <mfasheh at suse.com>
---
fs/ocfs2/dir.c | 574 ++++++++++++++++++++++++++++++++++++++-------------
fs/ocfs2/dir.h | 2 +
fs/ocfs2/journal.h | 10 +
fs/ocfs2/namei.c | 4 +-
fs/ocfs2/ocfs2_fs.h | 28 +++-
5 files changed, 469 insertions(+), 149 deletions(-)
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index b442d7a..ea40d4b 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -151,6 +151,7 @@ static void ocfs2_init_dir_trailer(struct inode *inode,
void ocfs2_free_dir_lookup_result(struct ocfs2_dir_lookup_result *res)
{
+ brelse(res->dl_dx_root_bh);
brelse(res->dl_leaf_bh);
brelse(res->dl_dx_leaf_bh);
}
@@ -162,6 +163,11 @@ static int ocfs2_dir_indexed(struct inode *inode)
return 0;
}
+static inline int ocfs2_dx_root_inline(struct ocfs2_dx_root_block *dx_root)
+{
+ return dx_root->dr_flags & OCFS2_DX_FLAG_INLINE;
+}
+
/*
* Hashing code adapted from ext3
*/
@@ -797,13 +803,18 @@ out:
* Returns the block index, from the start of the cluster which this
* hash belongs too.
*/
-static unsigned int ocfs2_dx_dir_hash_idx(struct ocfs2_super *osb,
- struct ocfs2_dx_hinfo *hinfo)
+static inline unsigned int __ocfs2_dx_dir_hash_idx(struct ocfs2_super *osb,
+ u32 minor_hash)
{
- u32 minor_hash = hinfo->minor_hash;
return minor_hash & osb->osb_dx_mask;
}
+static inline unsigned int ocfs2_dx_dir_hash_idx(struct ocfs2_super *osb,
+ struct ocfs2_dx_hinfo *hinfo)
+{
+ return __ocfs2_dx_dir_hash_idx(osb, hinfo->minor_hash);
+}
+
static int ocfs2_dx_dir_lookup(struct inode *inode,
struct ocfs2_extent_list *el,
struct ocfs2_dx_hinfo *hinfo,
@@ -853,7 +864,7 @@ out:
static int ocfs2_dx_dir_search(const char *name, int namelen,
struct inode *dir,
- struct ocfs2_extent_list *dr_el,
+ struct ocfs2_dx_root_block *dx_root,
struct ocfs2_dir_lookup_result *res)
{
int ret, i, found;
@@ -864,9 +875,18 @@ static int ocfs2_dx_dir_search(const char *name, int namelen,
struct buffer_head *dir_ent_bh = NULL;
struct ocfs2_dir_entry *dir_ent = NULL;
struct ocfs2_dx_hinfo *hinfo = &res->dl_hinfo;
+ struct ocfs2_extent_list *dr_el;
+ struct ocfs2_dx_entry_list *entry_list;
ocfs2_dx_dir_name_hash(dir, name, namelen, &res->dl_hinfo);
+ if (ocfs2_dx_root_inline(dx_root)) {
+ entry_list = &dx_root->dr_entries;
+ goto search;
+ }
+
+ dr_el = &dx_root->dr_list;
+
ret = ocfs2_dx_dir_lookup(dir, dr_el, hinfo, NULL, &phys);
if (ret) {
mlog_errno(ret);
@@ -891,12 +911,15 @@ static int ocfs2_dx_dir_search(const char *name, int namelen,
le16_to_cpu(dx_leaf->dl_list.de_num_used),
le16_to_cpu(dx_leaf->dl_list.de_count));
+ entry_list = &dx_leaf->dl_list;
+
+search:
/*
* Empty leaf is legal, so no need to check for that.
*/
found = 0;
- for (i = 0; i < le16_to_cpu(dx_leaf->dl_list.de_num_used); i++) {
- dx_entry = &dx_leaf->dl_list.de_entries[i];
+ for (i = 0; i < le16_to_cpu(entry_list->de_num_used); i++) {
+ dx_entry = &entry_list->de_entries[i];
if (hinfo->major_hash != le32_to_cpu(dx_entry->dx_major_hash)
|| hinfo->minor_hash != le32_to_cpu(dx_entry->dx_minor_hash))
@@ -980,14 +1003,15 @@ static int ocfs2_find_entry_dx(const char *name, int namelen,
}
dx_root = (struct ocfs2_dx_root_block *) dx_root_bh->b_data;
- ret = ocfs2_dx_dir_search(name, namelen, dir, &dx_root->dr_list,
- lookup);
+ ret = ocfs2_dx_dir_search(name, namelen, dir, dx_root, lookup);
if (ret) {
if (ret != -ENOENT)
mlog_errno(ret);
goto out;
}
+ lookup->dl_dx_root_bh = dx_root_bh;
+ dx_root_bh = NULL;
out:
brelse(di_bh);
brelse(dx_root_bh);
@@ -1124,64 +1148,88 @@ bail:
return status;
}
-static void ocfs2_dx_leaf_remove_entry(struct ocfs2_dx_leaf *dx_leaf, int index)
+static void ocfs2_dx_list_remove_entry(struct ocfs2_dx_entry_list *entry_list,
+ int index)
{
- struct ocfs2_dx_entry_list *dl_list = &dx_leaf->dl_list;
- int num_used = le16_to_cpu(dl_list->de_num_used);
+ int num_used = le16_to_cpu(entry_list->de_num_used);
if (num_used == 1 || index == (num_used - 1))
goto clear;
- memmove(&dl_list->de_entries[index], &dl_list->de_entries[index + 1],
+ memmove(&entry_list->de_entries[index],
+ &entry_list->de_entries[index + 1],
(num_used - index - 1)*sizeof(struct ocfs2_dx_entry));
clear:
num_used--;
- memset(&dl_list->de_entries[num_used], 0,
+ memset(&entry_list->de_entries[num_used], 0,
sizeof(struct ocfs2_dx_entry));
- dl_list->de_num_used = cpu_to_le16(num_used);
+ entry_list->de_num_used = cpu_to_le16(num_used);
}
static int ocfs2_delete_entry_dx(handle_t *handle, struct inode *dir,
struct ocfs2_dir_lookup_result *lookup)
{
int ret, index;
+ struct buffer_head *dx_root_bh = lookup->dl_dx_root_bh;
struct buffer_head *leaf_bh = lookup->dl_leaf_bh;
struct ocfs2_dx_leaf *dx_leaf;
struct ocfs2_dx_entry *dx_entry = lookup->dl_dx_entry;
+ struct ocfs2_dx_root_block *dx_root;
+ struct ocfs2_dx_entry_list *entry_list;
+
+ dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
+ if (ocfs2_dx_root_inline(dx_root)) {
+ entry_list = &dx_root->dr_entries;
+ } else {
+ dx_leaf = (struct ocfs2_dx_leaf *) lookup->dl_dx_leaf_bh->b_data;
+ entry_list = &dx_leaf->dl_list;
+ }
- dx_leaf = (struct ocfs2_dx_leaf *) lookup->dl_dx_leaf_bh->b_data;
/* Neither of these are a disk corruption - that should have
* been caught by lookup, before we got here. */
- BUG_ON(le16_to_cpu(dx_leaf->dl_list.de_count) <= 0);
- BUG_ON(le16_to_cpu(dx_leaf->dl_list.de_num_used) <= 0);
+ BUG_ON(le16_to_cpu(entry_list->de_count) <= 0);
+ BUG_ON(le16_to_cpu(entry_list->de_num_used) <= 0);
- index = (char *)dx_entry - (char *)dx_leaf->dl_list.de_entries;
+ index = (char *)dx_entry - (char *)entry_list->de_entries;
index /= sizeof(*dx_entry);
- if (index >= le16_to_cpu(dx_leaf->dl_list.de_num_used)) {
+ if (index >= le16_to_cpu(entry_list->de_num_used)) {
mlog(ML_ERROR, "Dir %llu: Bad dx_entry ptr idx %d, (%p, %p)\n",
- (unsigned long long)OCFS2_I(dir)->ip_blkno, index, dx_leaf,
- dx_entry);
+ (unsigned long long)OCFS2_I(dir)->ip_blkno, index,
+ entry_list, dx_entry);
return -EIO;
}
- mlog(0, "Dir %llu: delete entry at index: %d\n",
- (unsigned long long)OCFS2_I(dir)->ip_blkno, index);
-
/*
- * Add the index leaf into the journal before removing the
- * unindexed entry. If we get an error return from
- * __ocfs2_delete_entry(), then it hasn't removed the entry
- * yet. Likewise, successful return means we *must* remove the
- * indexed entry.
+ * Add the block holding our index into the journal before
+ * removing the unindexed entry. If we get an error return
+ * from __ocfs2_delete_entry(), then it hasn't removed the
+ * entry yet. Likewise, successful return means we *must*
+ * remove the indexed entry.
+ *
+ * We're also careful to journal the root tree block here if
+ * we're going to be adding to the start of the free list.
*/
- ret = ocfs2_journal_access_dl(handle, dir, lookup->dl_dx_leaf_bh,
- OCFS2_JOURNAL_ACCESS_WRITE);
- if (ret) {
- mlog_errno(ret);
- goto out;
+ if (ocfs2_dx_root_inline(dx_root)) {
+ ret = ocfs2_journal_access_dr(handle, dir, dx_root_bh,
+ OCFS2_JOURNAL_ACCESS_WRITE);
+ if (ret) {
+ mlog_errno(ret);
+ goto out;
+ }
+ } else {
+ ret = ocfs2_journal_access_dl(handle, dir,
+ lookup->dl_dx_leaf_bh,
+ OCFS2_JOURNAL_ACCESS_WRITE);
+ if (ret) {
+ mlog_errno(ret);
+ goto out;
+ }
}
+ mlog(0, "Dir %llu: delete entry at index: %d\n",
+ (unsigned long long)OCFS2_I(dir)->ip_blkno, index);
+
ret = __ocfs2_delete_entry(handle, dir, lookup->dl_entry,
leaf_bh, leaf_bh->b_data, leaf_bh->b_size);
if (ret) {
@@ -1189,9 +1237,12 @@ static int ocfs2_delete_entry_dx(handle_t *handle, struct inode *dir,
goto out;
}
- ocfs2_dx_leaf_remove_entry(dx_leaf, index);
+ ocfs2_dx_list_remove_entry(entry_list, index);
- ocfs2_journal_dirty(handle, lookup->dl_dx_leaf_bh);
+ if (ocfs2_dx_root_inline(dx_root))
+ ocfs2_journal_dirty(handle, dx_root_bh);
+ else
+ ocfs2_journal_dirty(handle, lookup->dl_dx_leaf_bh);
out:
return ret;
@@ -1288,13 +1339,30 @@ static void ocfs2_dx_dir_leaf_insert_tail(struct ocfs2_dx_leaf *dx_leaf,
le16_add_cpu(&dx_leaf->dl_list.de_num_used, 1);
}
+static void ocfs2_dx_entry_list_insert(struct ocfs2_dx_entry_list *entry_list,
+ struct ocfs2_dx_hinfo *hinfo,
+ u64 dirent_blk)
+{
+ int i;
+ struct ocfs2_dx_entry *dx_entry;
+
+ i = le16_to_cpu(entry_list->de_num_used);
+ dx_entry = &entry_list->de_entries[i];
+
+ memset(dx_entry, 0, sizeof(*dx_entry));
+ dx_entry->dx_major_hash = cpu_to_le32(hinfo->major_hash);
+ dx_entry->dx_minor_hash = cpu_to_le32(hinfo->minor_hash);
+ dx_entry->dx_dirent_blk = cpu_to_le64(dirent_blk);
+
+ le16_add_cpu(&entry_list->de_num_used, 1);
+}
+
static int __ocfs2_dx_dir_leaf_insert(struct inode *dir, handle_t *handle,
struct ocfs2_dx_hinfo *hinfo,
u64 dirent_blk,
struct buffer_head *dx_leaf_bh)
{
- int ret, i;
- struct ocfs2_dx_entry *dx_entry;
+ int ret;
struct ocfs2_dx_leaf *dx_leaf;
ret = ocfs2_journal_access_dl(handle, dir, dx_leaf_bh,
@@ -1305,25 +1373,48 @@ static int __ocfs2_dx_dir_leaf_insert(struct inode *dir, handle_t *handle,
}
dx_leaf = (struct ocfs2_dx_leaf *)dx_leaf_bh->b_data;
- i = le16_to_cpu(dx_leaf->dl_list.de_num_used);
- dx_entry = &dx_leaf->dl_list.de_entries[i];
+ ocfs2_dx_entry_list_insert(&dx_leaf->dl_list, hinfo, dirent_blk);
+ ocfs2_journal_dirty(handle, dx_leaf_bh);
- memset(dx_entry, 0, sizeof(*dx_entry));
- dx_entry->dx_major_hash = cpu_to_le32(hinfo->major_hash);
- dx_entry->dx_minor_hash = cpu_to_le32(hinfo->minor_hash);
- dx_entry->dx_dirent_blk = cpu_to_le64(dirent_blk);
+out:
+ return ret;
+}
- le16_add_cpu(&dx_leaf->dl_list.de_num_used, 1);
+static int ocfs2_dx_inline_root_insert(struct inode *dir, handle_t *handle,
+ struct ocfs2_dx_hinfo *hinfo,
+ u64 dirent_blk,
+ struct buffer_head *dx_root_bh)
+{
+ int ret;
+ struct ocfs2_dx_root_block *dx_root;
- ocfs2_journal_dirty(handle, dx_leaf_bh);
+ ret = ocfs2_journal_access_dr(handle, dir, dx_root_bh,
+ OCFS2_JOURNAL_ACCESS_WRITE);
+ if (ret) {
+ mlog_errno(ret);
+ goto out;
+ }
+
+ dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
+ ocfs2_dx_entry_list_insert(&dx_root->dr_entries, hinfo, dirent_blk);
+ ocfs2_journal_dirty(handle, dx_root_bh);
out:
return ret;
}
-static int ocfs2_dx_dir_leaf_insert(struct inode *dir, handle_t *handle,
- struct ocfs2_dir_lookup_result *lookup)
+static int ocfs2_dx_dir_insert(struct inode *dir, handle_t *handle,
+ struct ocfs2_dir_lookup_result *lookup)
{
+ struct ocfs2_dx_root_block *dx_root;
+
+ dx_root = (struct ocfs2_dx_root_block *)lookup->dl_dx_root_bh->b_data;
+ if (ocfs2_dx_root_inline(dx_root))
+ return ocfs2_dx_inline_root_insert(dir, handle,
+ &lookup->dl_hinfo,
+ lookup->dl_leaf_bh->b_blocknr,
+ lookup->dl_dx_root_bh);
+
return __ocfs2_dx_dir_leaf_insert(dir, handle, &lookup->dl_hinfo,
lookup->dl_leaf_bh->b_blocknr,
lookup->dl_dx_leaf_bh);
@@ -1407,14 +1498,14 @@ int __ocfs2_add_entry(handle_t *handle,
else {
status = ocfs2_journal_access_db(handle, dir,
insert_bh,
- OCFS2_JOURNAL_ACCESS_WRITE);
- if (ocfs2_dir_indexed(dir)) {
- status = ocfs2_dx_dir_leaf_insert(dir,
- handle,
- lookup);
- if (status) {
- mlog_errno(status);
- goto bail;
+ OCFS2_JOURNAL_ACCESS_WRITE);
+
+ if (ocfs2_dir_indexed(dir)) {
+ status = ocfs2_dx_dir_insert(dir, handle,
+ lookup);
+ if (status) {
+ mlog_errno(status);
+ goto bail;
}
}
}
@@ -2017,6 +2108,7 @@ static int ocfs2_dx_dir_attach_index(struct ocfs2_super *osb,
handle_t *handle, struct inode *dir,
struct buffer_head *di_bh,
struct ocfs2_alloc_context *meta_ac,
+ int dx_inline,
struct buffer_head **ret_dx_root_bh)
{
int ret;
@@ -2060,8 +2152,15 @@ static int ocfs2_dx_dir_attach_index(struct ocfs2_super *osb,
dx_root->dr_fs_generation = cpu_to_le32(osb->fs_generation);
dx_root->dr_blkno = cpu_to_le64(dr_blkno);
dx_root->dr_dir_blkno = cpu_to_le64(OCFS2_I(dir)->ip_blkno);
- dx_root->dr_list.l_count =
- cpu_to_le16(ocfs2_extent_recs_per_dx_root(osb->sb));
+
+ if (dx_inline) {
+ dx_root->dr_flags |= OCFS2_DX_FLAG_INLINE;
+ dx_root->dr_entries.de_count =
+ cpu_to_le16(ocfs2_dx_entries_per_root(osb->sb));
+ } else {
+ dx_root->dr_list.l_count =
+ cpu_to_le16(ocfs2_extent_recs_per_dx_root(osb->sb));
+ }
ret = ocfs2_journal_dirty(handle, dx_root_bh);
if (ret)
@@ -2234,20 +2333,12 @@ static int ocfs2_fill_new_dir_dx(struct ocfs2_super *osb,
struct ocfs2_alloc_context *data_ac,
struct ocfs2_alloc_context *meta_ac)
{
- int ret, num_dx_leaves, i;
+ int ret;
struct buffer_head *leaf_bh = NULL;
struct buffer_head *dx_root_bh = NULL;
- struct buffer_head **dx_leaves = NULL;
- struct ocfs2_extent_tree et;
struct ocfs2_dx_hinfo hinfo;
- u64 insert_blkno;
-
- dx_leaves = ocfs2_dx_dir_kmalloc_leaves(osb->sb, &num_dx_leaves);
- if (!dx_leaves) {
- ret = -ENOMEM;
- mlog_errno(ret);
- goto out;
- }
+ struct ocfs2_dx_root_block *dx_root;
+ struct ocfs2_dx_entry_list *entry_list;
/*
* Our strategy is to create the directory as though it were
@@ -2256,7 +2347,8 @@ static int ocfs2_fill_new_dir_dx(struct ocfs2_super *osb,
* very well known quantity.
*
* Essentially, we have two dirents ("." and ".."), in the 1st
- * block which need indexing.
+ * block which need indexing. These are easily inserted into
+ * the index block.
*/
ret = ocfs2_fill_new_dir_el(osb, handle, parent, inode, di_bh,
@@ -2266,61 +2358,22 @@ static int ocfs2_fill_new_dir_dx(struct ocfs2_super *osb,
goto out;
}
- /*
- * Allocate and format the index leaf first, before attaching
- * the index root. That way we're sure that the main bitmap
- * won't -enospc on us with a half-created dir index.
- *
- * The meta data allocation for our index block will not
- * -enospc on us unless there is a disk corruption.
- */
-
- ret = __ocfs2_dx_dir_new_cluster(inode, 0, handle, data_ac, dx_leaves,
- num_dx_leaves, &insert_blkno);
+ ret = ocfs2_dx_dir_attach_index(osb, handle, inode, di_bh,
+ meta_ac, 1, &dx_root_bh);
if (ret) {
mlog_errno(ret);
goto out;
}
+ dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
+ entry_list = &dx_root->dr_entries;
- ocfs2_dx_dir_name_hash(inode, ".", 1, &hinfo);
- i = ocfs2_dx_dir_hash_idx(osb, &hinfo);
- ret = __ocfs2_dx_dir_leaf_insert(inode, handle, &hinfo,
- leaf_bh->b_blocknr, dx_leaves[i]);
- if (ret) {
- mlog_errno(ret);
- goto out;
- }
+ /* Buffer has been journaled for us by ocfs2_dx_dir_attach_index */
+ ocfs2_dx_entry_list_insert(entry_list, &hinfo, leaf_bh->b_blocknr);
ocfs2_dx_dir_name_hash(inode, "..", 2, &hinfo);
- i = ocfs2_dx_dir_hash_idx(osb, &hinfo);
- ret = __ocfs2_dx_dir_leaf_insert(inode, handle, &hinfo,
- leaf_bh->b_blocknr, dx_leaves[i]);
- if (ret) {
- mlog_errno(ret);
- goto out;
- }
-
- ret = ocfs2_dx_dir_attach_index(osb, handle, inode, di_bh, meta_ac,
- &dx_root_bh);
- if (ret) {
- mlog_errno(ret);
- goto out;
- }
-
- /* This should never fail considering we start with an empty
- * dx_root. */
- ocfs2_init_dx_root_extent_tree(&et, inode, dx_root_bh);
- ret = ocfs2_insert_extent(osb, handle, inode, &et, 0,
- insert_blkno, 1, 0, NULL);
- if (ret)
- mlog_errno(ret);
+ ocfs2_dx_entry_list_insert(entry_list, &hinfo, leaf_bh->b_blocknr);
out:
- if (dx_leaves) {
- for (i = 0; i < num_dx_leaves; i++)
- brelse(dx_leaves[i]);
- kfree(dx_leaves);
- }
brelse(dx_root_bh);
brelse(leaf_bh);
return ret;
@@ -2390,6 +2443,74 @@ inc:
out:
return ret;
}
+ /*
+ * XXX: This expects dx_root_bh to already be part of the transaction.
+ */
+static void ocfs2_dx_dir_index_root_block(struct inode *dir,
+ struct buffer_head *dx_root_bh,
+ struct buffer_head *dirent_bh)
+{
+ char *de_buf, *limit;
+ struct ocfs2_dx_root_block *dx_root;
+ struct ocfs2_dir_entry *de;
+ struct ocfs2_dx_hinfo hinfo;
+ u64 dirent_blk = dirent_bh->b_blocknr;
+
+ dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
+
+ de_buf = dirent_bh->b_data;
+ limit = de_buf + dir->i_sb->s_blocksize;
+
+ while (de_buf < limit) {
+ de = (struct ocfs2_dir_entry *)de_buf;
+
+ if (!de->name_len || !de->inode)
+ goto inc;
+
+ ocfs2_dx_dir_name_hash(dir, de->name, de->name_len, &hinfo);
+
+ mlog(0,
+ "dir: %llu, major: 0x%x minor: 0x%x, index: %u, name: %.*s\n",
+ (unsigned long long)dir->i_ino, hinfo.major_hash,
+ hinfo.minor_hash,
+ le16_to_cpu(dx_root->dr_entries.de_num_used),
+ de->name_len, de->name);
+
+ ocfs2_dx_entry_list_insert(&dx_root->dr_entries, &hinfo,
+ dirent_blk);
+inc:
+ de_buf += le16_to_cpu(de->rec_len);
+ }
+}
+
+/*
+ * Count the number of inline directory entries in di_bh and compare
+ * them against the number of entries we can hold in an inline dx root
+ * block.
+ */
+static int ocfs2_new_dx_should_be_inline(struct inode *dir,
+ struct buffer_head *di_bh)
+{
+ int dirent_count = 0;
+ char *de_buf, *limit;
+ struct ocfs2_dir_entry *de;
+ struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+
+ de_buf = di->id2.i_data.id_data;
+ limit = de_buf + i_size_read(dir);
+
+ while (de_buf < limit) {
+ de = (struct ocfs2_dir_entry *)de_buf;
+
+ if (de->name_len && de->inode)
+ dirent_count++;
+
+ de_buf += le16_to_cpu(de->rec_len);
+ }
+
+ /* We are careful to leave room for one extra record. */
+ return dirent_count < ocfs2_dx_entries_per_root(dir->i_sb);
+}
/*
* Expand rec_len of the rightmost dirent in a directory block so that it
@@ -2440,7 +2561,7 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
{
u32 alloc, dx_alloc, bit_off, len;
struct super_block *sb = dir->i_sb;
- int ret, i, num_dx_leaves = 0,
+ int ret, i, num_dx_leaves = 0, dx_inline = 0,
credits = ocfs2_inline_to_extents_credits(sb);
u64 dx_insert_blkno, blkno,
bytes = blocks_wanted << sb->s_blocksize_bits;
@@ -2463,15 +2584,19 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
dx_alloc = 0;
if (ocfs2_supports_indexed_dirs(osb)) {
- /* Add one more cluster for an index leaf */
- dx_alloc++;
credits += ocfs2_add_dir_index_credits(sb);
- dx_leaves = ocfs2_dx_dir_kmalloc_leaves(sb, &num_dx_leaves);
- if (!dx_leaves) {
- ret = -ENOMEM;
- mlog_errno(ret);
- goto out;
+ dx_inline = ocfs2_new_dx_should_be_inline(dir, di_bh);
+ if (!dx_inline) {
+ /* Add one more cluster for an index leaf */
+ dx_alloc++;
+ dx_leaves = ocfs2_dx_dir_kmalloc_leaves(sb,
+ &num_dx_leaves);
+ if (!dx_leaves) {
+ ret = -ENOMEM;
+ mlog_errno(ret);
+ goto out;
+ }
}
/* This gets us the dx_root */
@@ -2522,7 +2647,7 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
}
did_quota = 1;
- if (ocfs2_supports_indexed_dirs(osb)) {
+ if (ocfs2_supports_indexed_dirs(osb) && !dx_inline) {
/*
* Allocate our index cluster first, to maximize the
* possibility that unindexed leaves grow
@@ -2585,7 +2710,12 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
goto out_commit;
}
- if (ocfs2_supports_indexed_dirs(osb)) {
+ if (ocfs2_supports_indexed_dirs(osb) && !dx_inline) {
+ /*
+ * Dx dirs with an external cluster need to do this up
+ * front. Inline dx root's get handled later, after
+ * we've allocated our root block.
+ */
ret = ocfs2_dx_dir_index_block(dir, handle, dx_leaves,
num_dx_leaves, dirdata_bh);
if (ret) {
@@ -2648,17 +2778,23 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
if (ocfs2_supports_indexed_dirs(osb)) {
ret = ocfs2_dx_dir_attach_index(osb, handle, dir, di_bh,
- meta_ac, &dx_root_bh);
+ meta_ac, dx_inline,
+ &dx_root_bh);
if (ret) {
mlog_errno(ret);
goto out_commit;
}
- ocfs2_init_dx_root_extent_tree(&dx_et, dir, dx_root_bh);
- ret = ocfs2_insert_extent(osb, handle, dir, &dx_et, 0,
- dx_insert_blkno, 1, 0, NULL);
- if (ret)
- mlog_errno(ret);
+ if (dx_inline) {
+ ocfs2_dx_dir_index_root_block(dir, dx_root_bh,
+ dirdata_bh);
+ } else {
+ ocfs2_init_dx_root_extent_tree(&dx_et, dir, dx_root_bh);
+ ret = ocfs2_insert_extent(osb, handle, dir, &dx_et, 0,
+ dx_insert_blkno, 1, 0, NULL);
+ if (ret)
+ mlog_errno(ret);
+ }
}
/*
@@ -2688,14 +2824,18 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
if (ocfs2_supports_indexed_dirs(osb)) {
unsigned int off;
- /*
- * We need to return the correct block within the
- * cluster which should hold our entry.
- */
- off = ocfs2_dx_dir_hash_idx(OCFS2_SB(dir->i_sb),
- &lookup->dl_hinfo);
- get_bh(dx_leaves[off]);
- lookup->dl_dx_leaf_bh = dx_leaves[off];
+ if (!dx_inline) {
+ /*
+ * We need to return the correct block within the
+ * cluster which should hold our entry.
+ */
+ off = ocfs2_dx_dir_hash_idx(OCFS2_SB(dir->i_sb),
+ &lookup->dl_hinfo);
+ get_bh(dx_leaves[off]);
+ lookup->dl_dx_leaf_bh = dx_leaves[off];
+ }
+ lookup->dl_dx_root_bh = dx_root_bh;
+ dx_root_bh = NULL;
}
out_commit:
@@ -3504,6 +3644,133 @@ out:
return ret;
}
+static int ocfs2_expand_inline_dx_root(struct inode *dir,
+ struct buffer_head *dx_root_bh)
+{
+ int ret, num_dx_leaves, i, j, did_quota = 0;
+ struct buffer_head **dx_leaves = NULL;
+ struct ocfs2_extent_tree et;
+ u64 insert_blkno;
+ struct ocfs2_alloc_context *data_ac = NULL;
+ struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
+ handle_t *handle = NULL;
+ struct ocfs2_dx_root_block *dx_root;
+ struct ocfs2_dx_entry_list *entry_list;
+ struct ocfs2_dx_entry *dx_entry;
+ struct ocfs2_dx_leaf *target_leaf;
+
+ ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
+ if (ret) {
+ mlog_errno(ret);
+ goto out;
+ }
+
+ dx_leaves = ocfs2_dx_dir_kmalloc_leaves(osb->sb, &num_dx_leaves);
+ if (!dx_leaves) {
+ ret = -ENOMEM;
+ mlog_errno(ret);
+ goto out;
+ }
+
+ handle = ocfs2_start_trans(osb, ocfs2_calc_dxi_expand_credits(osb->sb));
+ if (IS_ERR(handle)) {
+ ret = PTR_ERR(handle);
+ mlog_errno(ret);
+ goto out;
+ }
+
+ if (vfs_dq_alloc_space_nodirty(dir,
+ ocfs2_clusters_to_bytes(osb->sb, 1))) {
+ ret = -EDQUOT;
+ goto out_commit;
+ }
+ did_quota = 1;
+
+ ret = __ocfs2_dx_dir_new_cluster(dir, 0, handle, data_ac, dx_leaves,
+ num_dx_leaves, &insert_blkno);
+ if (ret) {
+ mlog_errno(ret);
+ goto out_commit;
+ }
+
+ /*
+ * Transfer the entries from our dx_root into the appropriate
+ * block
+ */
+ dx_root = (struct ocfs2_dx_root_block *) dx_root_bh->b_data;
+ entry_list = &dx_root->dr_entries;
+
+ for (i = 0; i < le16_to_cpu(entry_list->de_num_used); i++) {
+ dx_entry = &entry_list->de_entries[i];
+
+ j = __ocfs2_dx_dir_hash_idx(osb,
+ le32_to_cpu(dx_entry->dx_minor_hash));
+ target_leaf = (struct ocfs2_dx_leaf *)dx_leaves[j]->b_data;
+
+ ocfs2_dx_dir_leaf_insert_tail(target_leaf, dx_entry);
+
+ /* Each leaf has been passed to the journal already
+ * via __ocfs2_dx_dir_new_cluster() */
+ }
+
+ ret = ocfs2_journal_access_dr(handle, dir, dx_root_bh,
+ OCFS2_JOURNAL_ACCESS_WRITE);
+ if (ret) {
+ mlog_errno(ret);
+ goto out_commit;
+ }
+
+ dx_root->dr_flags &= ~OCFS2_DX_FLAG_INLINE;
+ memset(&dx_root->dr_list, 0, osb->sb->s_blocksize -
+ offsetof(struct ocfs2_dx_root_block, dr_list));
+ dx_root->dr_list.l_count =
+ cpu_to_le16(ocfs2_extent_recs_per_dx_root(osb->sb));
+
+ /* This should never fail considering we start with an empty
+ * dx_root. */
+ ocfs2_init_dx_root_extent_tree(&et, dir, dx_root_bh);
+ ret = ocfs2_insert_extent(osb, handle, dir, &et, 0,
+ insert_blkno, 1, 0, NULL);
+ if (ret)
+ mlog_errno(ret);
+ did_quota = 0;
+
+ ocfs2_journal_dirty(handle, dx_root_bh);
+
+out_commit:
+ if (ret < 0 && did_quota)
+ vfs_dq_free_space_nodirty(dir,
+ ocfs2_clusters_to_bytes(dir->i_sb, 1));
+
+ ocfs2_commit_trans(osb, handle);
+
+out:
+ if (data_ac)
+ ocfs2_free_alloc_context(data_ac);
+
+ if (dx_leaves) {
+ for (i = 0; i < num_dx_leaves; i++)
+ brelse(dx_leaves[i]);
+ kfree(dx_leaves);
+ }
+ return ret;
+}
+
+static int ocfs2_inline_dx_has_space(struct buffer_head *dx_root_bh)
+{
+ struct ocfs2_dx_root_block *dx_root;
+ struct ocfs2_dx_entry_list *entry_list;
+
+ dx_root = (struct ocfs2_dx_root_block *) dx_root_bh->b_data;
+ entry_list = &dx_root->dr_entries;
+
+ if (le16_to_cpu(entry_list->de_num_used) >=
+ le16_to_cpu(entry_list->de_count))
+ return -ENOSPC;
+
+ return 0;
+}
+
static int ocfs2_find_dir_space_dx(struct ocfs2_super *osb, struct inode *dir,
struct buffer_head *di_bh, const char *name,
int namelen,
@@ -3525,6 +3792,23 @@ static int ocfs2_find_dir_space_dx(struct ocfs2_super *osb, struct inode *dir,
}
dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
+ if (ocfs2_dx_root_inline(dx_root)) {
+ ret = ocfs2_inline_dx_has_space(dx_root_bh);
+
+ if (ret == 0)
+ goto search_el;
+
+ /*
+ * We ran out of room in the root block. Expand it to
+ * an extent, then allow ocfs2_find_dir_space_dx to do
+ * the rest.
+ */
+ ret = ocfs2_expand_inline_dx_root(dir, dx_root_bh);
+ if (ret) {
+ mlog_errno(ret);
+ goto out;
+ }
+ }
restart_search:
ret = ocfs2_dx_dir_lookup(dir, &dx_root->dr_list, &lookup->dl_hinfo,
@@ -3576,8 +3860,11 @@ restart_search:
goto restart_search;
}
+search_el:
lookup->dl_dx_leaf_bh = dx_leaf_bh;
dx_leaf_bh = NULL;
+ lookup->dl_dx_root_bh = dx_root_bh;
+ dx_root_bh = NULL;
out:
brelse(dx_leaf_bh);
@@ -3772,10 +4059,12 @@ int ocfs2_dx_dir_truncate(struct inode *dir, struct buffer_head *di_bh)
mlog_errno(ret);
goto out;
}
+ dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
- ocfs2_init_dx_root_extent_tree(&et, dir, dx_root_bh);
+ if (ocfs2_dx_root_inline(dx_root))
+ goto remove_index;
- dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
+ ocfs2_init_dx_root_extent_tree(&et, dir, dx_root_bh);
/* XXX: What if dr_clusters is too large? */
while (le32_to_cpu(dx_root->dr_clusters)) {
@@ -3801,6 +4090,7 @@ int ocfs2_dx_dir_truncate(struct inode *dir, struct buffer_head *di_bh)
major_hash = cpos - 1;
}
+remove_index:
ret = ocfs2_dx_dir_remove_index(dir, di_bh, dx_root_bh);
if (ret) {
mlog_errno(ret);
diff --git a/fs/ocfs2/dir.h b/fs/ocfs2/dir.h
index d273aae..07b0416 100644
--- a/fs/ocfs2/dir.h
+++ b/fs/ocfs2/dir.h
@@ -37,6 +37,8 @@ struct ocfs2_dir_lookup_result {
struct ocfs2_dir_entry *dl_entry; /* Target dirent in
* unindexed leaf */
+ struct buffer_head *dl_dx_root_bh; /* Root of indexed
+ * tree */
struct buffer_head *dl_dx_leaf_bh; /* Indexed leaf block */
struct ocfs2_dx_entry *dl_dx_entry; /* Target dx_entry in
* indexed leaf */
diff --git a/fs/ocfs2/journal.h b/fs/ocfs2/journal.h
index 1d7c5ec..04b222c 100644
--- a/fs/ocfs2/journal.h
+++ b/fs/ocfs2/journal.h
@@ -447,6 +447,16 @@ static inline int ocfs2_rename_credits(struct super_block *sb)
#define OCFS2_DX_ROOT_REMOVE_CREDITS (OCFS2_INODE_UPDATE_CREDITS + \
OCFS2_SUBALLOC_FREE)
+static inline int ocfs2_calc_dxi_expand_credits(struct super_block *sb)
+{
+ int credits = 1 + OCFS2_SUBALLOC_ALLOC;
+
+ credits += ocfs2_clusters_to_blocks(sb, 1);
+ credits += ocfs2_quota_trans_credits(sb);
+
+ return credits;
+}
+
/*
* Please note that the caller must make sure that root_el is the root
* of extent tree. So for an inode, it should be &fe->id2.i_list. Otherwise
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index bd31222..9b198ec 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -321,10 +321,8 @@ static int ocfs2_mknod(struct inode *dir,
want_clusters += 1;
/* Dir indexing requires extra space as well */
- if (ocfs2_supports_indexed_dirs(osb)) {
- want_clusters++;
+ if (ocfs2_supports_indexed_dirs(osb))
want_meta++;
- }
}
status = ocfs2_reserve_new_metadata_blocks(osb, want_meta, &meta_ac);
diff --git a/fs/ocfs2/ocfs2_fs.h b/fs/ocfs2/ocfs2_fs.h
index 77b532c..09ab57e 100644
--- a/fs/ocfs2/ocfs2_fs.h
+++ b/fs/ocfs2/ocfs2_fs.h
@@ -815,6 +815,8 @@ struct ocfs2_dx_entry_list {
* length de_num_used */
};
+#define OCFS2_DX_FLAG_INLINE 0x01
+
/*
* A directory indexing block. Each indexed directory has one of these,
* pointed to by ocfs2_dinode.
@@ -835,13 +837,21 @@ struct ocfs2_dx_root_block {
* extent block */
__le32 dr_clusters; /* Clusters allocated
* to the indexed tree. */
- __le32 dr_reserved1;
+ __u8 dr_flags; /* OCFS2_DX_FLAG_* flags */
+ __u8 dr_reserved0;
+ __le16 dr_reserved1;
__le64 dr_dir_blkno; /* Pointer to parent inode */
__le64 dr_reserved2;
__le64 dr_reserved3[16];
- struct ocfs2_extent_list dr_list; /* Keep this aligned to 128
- * bits for maximum space
- * efficiency. */
+ union {
+ struct ocfs2_extent_list dr_list; /* Keep this aligned to 128
+ * bits for maximum space
+ * efficiency. */
+ struct ocfs2_dx_entry_list dr_entries; /* In-root-block list of
+ * entries. We grow out
+ * to extents if this
+ * gets too big. */
+ };
};
/*
@@ -1234,6 +1244,16 @@ static inline int ocfs2_dx_entries_per_leaf(struct super_block *sb)
return size / sizeof(struct ocfs2_dx_entry);
}
+static inline int ocfs2_dx_entries_per_root(struct super_block *sb)
+{
+ int size;
+
+ size = sb->s_blocksize -
+ offsetof(struct ocfs2_dx_root_block, dr_entries.de_entries);
+
+ return size / sizeof(struct ocfs2_dx_entry);
+}
+
static inline u16 ocfs2_local_alloc_size(struct super_block *sb)
{
u16 size;
--
1.5.6
More information about the Ocfs2-devel
mailing list