f2fs: introduce f2fs_dentry_ptr structure for code clean-up

This patch introduces f2fs_dentry_ptr structure for the use of a function
parameter in inline_dentry operations.

Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

1 files changed, 29 insertions, 32 deletions

diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index 23a5da88ba66..4f029a1b0cf0 100644
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -95,13 +95,13 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
 {
         struct f2fs_dentry_block *dentry_blk;
         struct f2fs_dir_entry *de;
-
-        *max_slots = NR_DENTRY_IN_BLOCK;
+        struct f2fs_dentry_ptr d;
 
         dentry_blk = (struct f2fs_dentry_block *)kmap(dentry_page);
-        de = find_target_dentry(name, max_slots, &dentry_blk->dentry_bitmap,
-                                                dentry_blk->dentry,
-                                                dentry_blk->filename);
+
+        make_dentry_ptr(&d, (void *)dentry_blk, 1);
+        de = find_target_dentry(name, max_slots, &d);
+
         if (de)
                 *res_page = dentry_page;
         else
@@ -111,50 +111,49 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
          * For the most part, it should be a bug when name_len is zero.
          * We stop here for figuring out where the bugs has occurred.
          */
-        f2fs_bug_on(F2FS_P_SB(dentry_page), *max_slots < 0);
+        f2fs_bug_on(F2FS_P_SB(dentry_page), d.max < 0);
         return de;
 }
 
 struct f2fs_dir_entry *find_target_dentry(struct qstr *name, int *max_slots,
-                        const void *bitmap, struct f2fs_dir_entry *dentry,
-                        __u8 (*filenames)[F2FS_SLOT_LEN])
+                                                struct f2fs_dentry_ptr *d)
 {
         struct f2fs_dir_entry *de;
         unsigned long bit_pos = 0;
         f2fs_hash_t namehash = f2fs_dentry_hash(name);
-        int max_bits = *max_slots;
         int max_len = 0;
 
-        *max_slots = 0;
-        while (bit_pos < max_bits) {
-                if (!test_bit_le(bit_pos, bitmap)) {
+        if (max_slots)
+                *max_slots = 0;
+        while (bit_pos < d->max) {
+                if (!test_bit_le(bit_pos, d->bitmap)) {
                         if (bit_pos == 0)
                                 max_len = 1;
-                        else if (!test_bit_le(bit_pos - 1, bitmap))
+                        else if (!test_bit_le(bit_pos - 1, d->bitmap))
                                 max_len++;
                         bit_pos++;
                         continue;
                 }
-                de = &dentry[bit_pos];
+                de = &d->dentry[bit_pos];
                 if (early_match_name(name->len, namehash, de) &&
-                        !memcmp(filenames[bit_pos], name->name, name->len))
+                        !memcmp(d->filename[bit_pos], name->name, name->len))
                         goto found;
 
-                if (*max_slots >= 0 && max_len > *max_slots) {
+                if (max_slots && *max_slots >= 0 && max_len > *max_slots) {
                         *max_slots = max_len;
                         max_len = 0;
                 }
 
                 /* remain bug on condition */
                 if (unlikely(!de->name_len))
-                        *max_slots = -1;
+                        d->max = -1;
 
                 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
         }
 
         de = NULL;
 found:
-        if (max_len > *max_slots)
+        if (max_slots && max_len > *max_slots)
                 *max_slots = max_len;
         return de;
 }
@@ -706,28 +705,26 @@ bool f2fs_empty_dir(struct inode *dir)
         return true;
 }
 
-bool f2fs_fill_dentries(struct dir_context *ctx,
-                        const void *bitmap, struct f2fs_dir_entry *dentry,
-                        __u8 (*filenames)[F2FS_SLOT_LEN], int max,
-                        unsigned int start_pos)
+bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
+                                                unsigned int start_pos)
 {
         unsigned char d_type = DT_UNKNOWN;
         unsigned int bit_pos;
         struct f2fs_dir_entry *de = NULL;
 
-        bit_pos = ((unsigned long)ctx->pos % max);
+        bit_pos = ((unsigned long)ctx->pos % d->max);
 
-        while (bit_pos < max) {
-                bit_pos = find_next_bit_le(bitmap, max, bit_pos);
-                if (bit_pos >= max)
+        while (bit_pos < d->max) {
+                bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos);
+                if (bit_pos >= d->max)
                         break;
 
-                de = &dentry[bit_pos];
+                de = &d->dentry[bit_pos];
                 if (de->file_type < F2FS_FT_MAX)
                         d_type = f2fs_filetype_table[de->file_type];
                 else
                         d_type = DT_UNKNOWN;
-                if (!dir_emit(ctx, filenames[bit_pos],
+                if (!dir_emit(ctx, d->filename[bit_pos],
                                         le16_to_cpu(de->name_len),
                                         le32_to_cpu(de->ino), d_type))
                         return true;
@@ -746,6 +743,7 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx)
         struct page *dentry_page = NULL;
         struct file_ra_state *ra = &file->f_ra;
         unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
+        struct f2fs_dentry_ptr d;
 
         if (f2fs_has_inline_dentry(inode))
                 return f2fs_read_inline_dir(file, ctx);
@@ -762,10 +760,9 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx)
 
                 dentry_blk = kmap(dentry_page);
 
-                if (f2fs_fill_dentries(ctx,
-                                &dentry_blk->dentry_bitmap, dentry_blk->dentry,
-                                dentry_blk->filename,
-                                NR_DENTRY_IN_BLOCK, n * NR_DENTRY_IN_BLOCK))
+                make_dentry_ptr(&d, (void *)dentry_blk, 1);
+
+                if (f2fs_fill_dentries(ctx, &d, n * NR_DENTRY_IN_BLOCK))
                         goto stop;
 
                 ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK;