f2fs: update f2fs documentation for inline dir support

[deliverable/linux.git] / fs / f2fs / dir.c

diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index b54f87149c09a5a0ecc6e96d72af9096362573a6..cc6474a85d6c5c8bc149600d18630a4b8b1af999 100644 (file)
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -37,7 +37,7 @@ static unsigned int bucket_blocks(unsigned int level)
                return 4;
 }
 
-static unsigned char f2fs_filetype_table[F2FS_FT_MAX] = {
+unsigned char f2fs_filetype_table[F2FS_FT_MAX] = {
        [F2FS_FT_UNKNOWN]       = DT_UNKNOWN,
        [F2FS_FT_REG_FILE]      = DT_REG,
        [F2FS_FT_DIR]           = DT_DIR,
@@ -59,7 +59,7 @@ static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = {
        [S_IFLNK >> S_SHIFT]    = F2FS_FT_SYMLINK,
 };
 
-static void set_de_type(struct f2fs_dir_entry *de, struct inode *inode)
+void set_de_type(struct f2fs_dir_entry *de, struct inode *inode)
 {
        umode_t mode = inode->i_mode;
        de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];
@@ -77,7 +77,7 @@ static unsigned long dir_block_index(unsigned int level,
        return bidx;
 }
 
-static bool early_match_name(size_t namelen, f2fs_hash_t namehash,
+bool early_match_name(size_t namelen, f2fs_hash_t namehash,
                                struct f2fs_dir_entry *de)
 {
        if (le16_to_cpu(de->name_len) != namelen)
@@ -201,6 +201,9 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
        unsigned int max_depth;
        unsigned int level;
 
+       if (f2fs_has_inline_dentry(dir))
+               return find_in_inline_dir(dir, child, res_page);
+
        if (npages == 0)
                return NULL;
 
@@ -227,6 +230,9 @@ struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p)
        struct f2fs_dir_entry *de;
        struct f2fs_dentry_block *dentry_blk;
 
+       if (f2fs_has_inline_dentry(dir))
+               return f2fs_parent_inline_dir(dir, p);
+
        page = get_lock_data_page(dir, 0);
        if (IS_ERR(page))
                return NULL;
@@ -247,7 +253,8 @@ ino_t f2fs_inode_by_name(struct inode *dir, struct qstr *qstr)
        de = f2fs_find_entry(dir, qstr, &page);
        if (de) {
                res = le32_to_cpu(de->ino);
-               kunmap(page);
+               if (!f2fs_has_inline_dentry(dir))
+                       kunmap(page);
                f2fs_put_page(page, 0);
        }
 
@@ -261,7 +268,8 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
        f2fs_wait_on_page_writeback(page, DATA);
        de->ino = cpu_to_le32(inode->i_ino);
        set_de_type(de, inode);
-       kunmap(page);
+       if (!f2fs_has_inline_dentry(dir))
+               kunmap(page);
        set_page_dirty(page);
        dir->i_mtime = dir->i_ctime = CURRENT_TIME;
        mark_inode_dirty(dir);
@@ -303,11 +311,13 @@ static int make_empty_dir(struct inode *inode,
        struct f2fs_dentry_block *dentry_blk;
        struct f2fs_dir_entry *de;
 
+       if (f2fs_has_inline_dentry(inode))
+               return make_empty_inline_dir(inode, parent, page);
+
        dentry_page = get_new_data_page(inode, page, 0, true);
        if (IS_ERR(dentry_page))
                return PTR_ERR(dentry_page);
 
-
        dentry_blk = kmap_atomic(dentry_page);
 
        de = &dentry_blk->dentry[0];
@@ -333,7 +343,7 @@ static int make_empty_dir(struct inode *inode,
        return 0;
 }
 
-static struct page *init_inode_metadata(struct inode *inode,
+struct page *init_inode_metadata(struct inode *inode,
                struct inode *dir, const struct qstr *name)
 {
        struct page *page;
@@ -395,7 +405,7 @@ error:
        return ERR_PTR(err);
 }
 
-static void update_parent_metadata(struct inode *dir, struct inode *inode,
+void update_parent_metadata(struct inode *dir, struct inode *inode,
                                                unsigned int current_depth)
 {
        if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {
@@ -463,6 +473,14 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name,
        int err = 0;
        int i;
 
+       if (f2fs_has_inline_dentry(dir)) {
+               err = f2fs_add_inline_entry(dir, name, inode);
+               if (!err || err != -EAGAIN)
+                       return err;
+               else
+                       err = 0;
+       }
+
        dentry_hash = f2fs_dentry_hash(name);
        level = 0;
        current_depth = F2FS_I(dir)->i_current_depth;
@@ -560,19 +578,50 @@ fail:
        return err;
 }
 
+void f2fs_drop_nlink(struct inode *dir, struct inode *inode, struct page *page)
+{
+       struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
+
+       down_write(&F2FS_I(inode)->i_sem);
+
+       if (S_ISDIR(inode->i_mode)) {
+               drop_nlink(dir);
+               if (page)
+                       update_inode(dir, page);
+               else
+                       update_inode_page(dir);
+       }
+       inode->i_ctime = CURRENT_TIME;
+
+       drop_nlink(inode);
+       if (S_ISDIR(inode->i_mode)) {
+               drop_nlink(inode);
+               i_size_write(inode, 0);
+       }
+       up_write(&F2FS_I(inode)->i_sem);
+       update_inode_page(inode);
+
+       if (inode->i_nlink == 0)
+               add_orphan_inode(sbi, inode->i_ino);
+       else
+               release_orphan_inode(sbi);
+}
+
 /*
  * It only removes the dentry from the dentry page, corresponding name
  * entry in name page does not need to be touched during deletion.
  */
 void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
-                                               struct inode *inode)
+                                       struct inode *dir, struct inode *inode)
 {
        struct  f2fs_dentry_block *dentry_blk;
        unsigned int bit_pos;
-       struct inode *dir = page->mapping->host;
        int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
        int i;
 
+       if (f2fs_has_inline_dentry(dir))
+               return f2fs_delete_inline_entry(dentry, page, dir, inode);
+
        lock_page(page);
        f2fs_wait_on_page_writeback(page, DATA);
 
@@ -590,29 +639,8 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
 
        dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 
-       if (inode) {
-               struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
-
-               down_write(&F2FS_I(inode)->i_sem);
-
-               if (S_ISDIR(inode->i_mode)) {
-                       drop_nlink(dir);
-                       update_inode_page(dir);
-               }
-               inode->i_ctime = CURRENT_TIME;
-               drop_nlink(inode);
-               if (S_ISDIR(inode->i_mode)) {
-                       drop_nlink(inode);
-                       i_size_write(inode, 0);
-               }
-               up_write(&F2FS_I(inode)->i_sem);
-               update_inode_page(inode);
-
-               if (inode->i_nlink == 0)
-                       add_orphan_inode(sbi, inode->i_ino);
-               else
-                       release_orphan_inode(sbi);
-       }
+       if (inode)
+               f2fs_drop_nlink(dir, inode, NULL);
 
        if (bit_pos == NR_DENTRY_IN_BLOCK) {
                truncate_hole(dir, page->index, page->index + 1);
@@ -628,9 +656,12 @@ bool f2fs_empty_dir(struct inode *dir)
        unsigned long bidx;
        struct page *dentry_page;
        unsigned int bit_pos;
-       struct  f2fs_dentry_block *dentry_blk;
+       struct f2fs_dentry_block *dentry_blk;
        unsigned long nblock = dir_blocks(dir);
 
+       if (f2fs_has_inline_dentry(dir))
+               return f2fs_empty_inline_dir(dir);
+
        for (bidx = 0; bidx < nblock; bidx++) {
                dentry_page = get_lock_data_page(dir, bidx);
                if (IS_ERR(dentry_page)) {
@@ -640,7 +671,6 @@ bool f2fs_empty_dir(struct inode *dir)
                                return false;
                }
 
-
                dentry_blk = kmap_atomic(dentry_page);
                if (bidx == 0)
                        bit_pos = 2;
@@ -671,6 +701,9 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx)
        unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
        unsigned char d_type = DT_UNKNOWN;
 
+       if (f2fs_has_inline_dentry(inode))
+               return f2fs_read_inline_dir(file, ctx);
+
        bit_pos = ((unsigned long)ctx->pos % NR_DENTRY_IN_BLOCK);
 
        /* readahead for multi pages of dir */