LCOV - code coverage report
Current view: top level - fs/f2fs - dir.c (source / functions) Hit Total Coverage
Test: Real Lines: 0 379 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 26 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * fs/f2fs/dir.c
       4                 :            :  *
       5                 :            :  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
       6                 :            :  *             http://www.samsung.com/
       7                 :            :  */
       8                 :            : #include <linux/fs.h>
       9                 :            : #include <linux/f2fs_fs.h>
      10                 :            : #include <linux/sched/signal.h>
      11                 :            : #include <linux/unicode.h>
      12                 :            : #include "f2fs.h"
      13                 :            : #include "node.h"
      14                 :            : #include "acl.h"
      15                 :            : #include "xattr.h"
      16                 :            : #include <trace/events/f2fs.h>
      17                 :            : 
      18                 :            : static unsigned long dir_blocks(struct inode *inode)
      19                 :            : {
      20                 :          0 :         return ((unsigned long long) (i_size_read(inode) + PAGE_SIZE - 1))
      21                 :          0 :                                                         >> PAGE_SHIFT;
      22                 :            : }
      23                 :            : 
      24                 :            : static unsigned int dir_buckets(unsigned int level, int dir_level)
      25                 :            : {
      26                 :          0 :         if (level + dir_level < MAX_DIR_HASH_DEPTH / 2)
      27                 :          0 :                 return 1 << (level + dir_level);
      28                 :            :         else
      29                 :            :                 return MAX_DIR_BUCKETS;
      30                 :            : }
      31                 :            : 
      32                 :            : static unsigned int bucket_blocks(unsigned int level)
      33                 :            : {
      34                 :          0 :         if (level < MAX_DIR_HASH_DEPTH / 2)
      35                 :            :                 return 2;
      36                 :            :         else
      37                 :            :                 return 4;
      38                 :            : }
      39                 :            : 
      40                 :            : static unsigned char f2fs_filetype_table[F2FS_FT_MAX] = {
      41                 :            :         [F2FS_FT_UNKNOWN]       = DT_UNKNOWN,
      42                 :            :         [F2FS_FT_REG_FILE]      = DT_REG,
      43                 :            :         [F2FS_FT_DIR]           = DT_DIR,
      44                 :            :         [F2FS_FT_CHRDEV]        = DT_CHR,
      45                 :            :         [F2FS_FT_BLKDEV]        = DT_BLK,
      46                 :            :         [F2FS_FT_FIFO]          = DT_FIFO,
      47                 :            :         [F2FS_FT_SOCK]          = DT_SOCK,
      48                 :            :         [F2FS_FT_SYMLINK]       = DT_LNK,
      49                 :            : };
      50                 :            : 
      51                 :            : static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = {
      52                 :            :         [S_IFREG >> S_SHIFT]      = F2FS_FT_REG_FILE,
      53                 :            :         [S_IFDIR >> S_SHIFT]      = F2FS_FT_DIR,
      54                 :            :         [S_IFCHR >> S_SHIFT]      = F2FS_FT_CHRDEV,
      55                 :            :         [S_IFBLK >> S_SHIFT]      = F2FS_FT_BLKDEV,
      56                 :            :         [S_IFIFO >> S_SHIFT]      = F2FS_FT_FIFO,
      57                 :            :         [S_IFSOCK >> S_SHIFT]     = F2FS_FT_SOCK,
      58                 :            :         [S_IFLNK >> S_SHIFT]      = F2FS_FT_SYMLINK,
      59                 :            : };
      60                 :            : 
      61                 :            : static void set_de_type(struct f2fs_dir_entry *de, umode_t mode)
      62                 :            : {
      63                 :          0 :         de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];
      64                 :            : }
      65                 :            : 
      66                 :          0 : unsigned char f2fs_get_de_type(struct f2fs_dir_entry *de)
      67                 :            : {
      68                 :          0 :         if (de->file_type < F2FS_FT_MAX)
      69                 :          0 :                 return f2fs_filetype_table[de->file_type];
      70                 :            :         return DT_UNKNOWN;
      71                 :            : }
      72                 :            : 
      73                 :            : static unsigned long dir_block_index(unsigned int level,
      74                 :            :                                 int dir_level, unsigned int idx)
      75                 :            : {
      76                 :            :         unsigned long i;
      77                 :            :         unsigned long bidx = 0;
      78                 :            : 
      79                 :          0 :         for (i = 0; i < level; i++)
      80                 :          0 :                 bidx += dir_buckets(i, dir_level) * bucket_blocks(i);
      81                 :          0 :         bidx += idx * bucket_blocks(level);
      82                 :            :         return bidx;
      83                 :            : }
      84                 :            : 
      85                 :          0 : static struct f2fs_dir_entry *find_in_block(struct inode *dir,
      86                 :            :                                 struct page *dentry_page,
      87                 :            :                                 struct fscrypt_name *fname,
      88                 :            :                                 f2fs_hash_t namehash,
      89                 :            :                                 int *max_slots,
      90                 :            :                                 struct page **res_page)
      91                 :            : {
      92                 :            :         struct f2fs_dentry_block *dentry_blk;
      93                 :            :         struct f2fs_dir_entry *de;
      94                 :            :         struct f2fs_dentry_ptr d;
      95                 :            : 
      96                 :            :         dentry_blk = (struct f2fs_dentry_block *)page_address(dentry_page);
      97                 :            : 
      98                 :            :         make_dentry_ptr_block(dir, &d, dentry_blk);
      99                 :          0 :         de = f2fs_find_target_dentry(fname, namehash, max_slots, &d);
     100                 :          0 :         if (de)
     101                 :          0 :                 *res_page = dentry_page;
     102                 :            : 
     103                 :          0 :         return de;
     104                 :            : }
     105                 :            : 
     106                 :            : #ifdef CONFIG_UNICODE
     107                 :            : /*
     108                 :            :  * Test whether a case-insensitive directory entry matches the filename
     109                 :            :  * being searched for.
     110                 :            :  */
     111                 :            : static bool f2fs_match_ci_name(const struct inode *dir, const struct qstr *name,
     112                 :            :                                const struct qstr *entry, bool quick)
     113                 :            : {
     114                 :            :         const struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
     115                 :            :         const struct unicode_map *um = sbi->s_encoding;
     116                 :            :         int res;
     117                 :            : 
     118                 :            :         if (quick)
     119                 :            :                 res = utf8_strncasecmp_folded(um, name, entry);
     120                 :            :         else
     121                 :            :                 res = utf8_strncasecmp(um, name, entry);
     122                 :            :         if (res < 0) {
     123                 :            :                 /*
     124                 :            :                  * In strict mode, ignore invalid names.  In non-strict mode,
     125                 :            :                  * fall back to treating them as opaque byte sequences.
     126                 :            :                  */
     127                 :            :                 if (f2fs_has_strict_mode(sbi) || name->len != entry->len)
     128                 :            :                         return false;
     129                 :            :                 return !memcmp(name->name, entry->name, name->len);
     130                 :            :         }
     131                 :            :         return res == 0;
     132                 :            : }
     133                 :            : 
     134                 :            : static void f2fs_fname_setup_ci_filename(struct inode *dir,
     135                 :            :                                         const struct qstr *iname,
     136                 :            :                                         struct fscrypt_str *cf_name)
     137                 :            : {
     138                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     139                 :            : 
     140                 :            :         if (!IS_CASEFOLDED(dir)) {
     141                 :            :                 cf_name->name = NULL;
     142                 :            :                 return;
     143                 :            :         }
     144                 :            : 
     145                 :            :         cf_name->name = f2fs_kmalloc(sbi, F2FS_NAME_LEN, GFP_NOFS);
     146                 :            :         if (!cf_name->name)
     147                 :            :                 return;
     148                 :            : 
     149                 :            :         cf_name->len = utf8_casefold(sbi->s_encoding,
     150                 :            :                                         iname, cf_name->name,
     151                 :            :                                         F2FS_NAME_LEN);
     152                 :            :         if ((int)cf_name->len <= 0) {
     153                 :            :                 kvfree(cf_name->name);
     154                 :            :                 cf_name->name = NULL;
     155                 :            :         }
     156                 :            : }
     157                 :            : #endif
     158                 :            : 
     159                 :            : static inline bool f2fs_match_name(struct f2fs_dentry_ptr *d,
     160                 :            :                                         struct f2fs_dir_entry *de,
     161                 :            :                                         struct fscrypt_name *fname,
     162                 :            :                                         struct fscrypt_str *cf_str,
     163                 :            :                                         unsigned long bit_pos,
     164                 :            :                                         f2fs_hash_t namehash)
     165                 :            : {
     166                 :            : #ifdef CONFIG_UNICODE
     167                 :            :         struct inode *parent = d->inode;
     168                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(parent);
     169                 :            :         struct qstr entry;
     170                 :            : #endif
     171                 :            : 
     172                 :          0 :         if (de->hash_code != namehash)
     173                 :            :                 return false;
     174                 :            : 
     175                 :            : #ifdef CONFIG_UNICODE
     176                 :            :         entry.name = d->filename[bit_pos];
     177                 :            :         entry.len = de->name_len;
     178                 :            : 
     179                 :            :         if (sbi->s_encoding && IS_CASEFOLDED(parent)) {
     180                 :            :                 if (cf_str->name) {
     181                 :            :                         struct qstr cf = {.name = cf_str->name,
     182                 :            :                                           .len = cf_str->len};
     183                 :            :                         return f2fs_match_ci_name(parent, &cf, &entry, true);
     184                 :            :                 }
     185                 :            :                 return f2fs_match_ci_name(parent, fname->usr_fname, &entry,
     186                 :            :                                           false);
     187                 :            :         }
     188                 :            : #endif
     189                 :          0 :         if (fscrypt_match_name(fname, d->filename[bit_pos],
     190                 :            :                                 le16_to_cpu(de->name_len)))
     191                 :            :                 return true;
     192                 :            :         return false;
     193                 :            : }
     194                 :            : 
     195                 :          0 : struct f2fs_dir_entry *f2fs_find_target_dentry(struct fscrypt_name *fname,
     196                 :            :                         f2fs_hash_t namehash, int *max_slots,
     197                 :            :                         struct f2fs_dentry_ptr *d)
     198                 :            : {
     199                 :            :         struct f2fs_dir_entry *de;
     200                 :            :         struct fscrypt_str cf_str = { .name = NULL, .len = 0 };
     201                 :            :         unsigned long bit_pos = 0;
     202                 :            :         int max_len = 0;
     203                 :            : 
     204                 :            : #ifdef CONFIG_UNICODE
     205                 :            :         f2fs_fname_setup_ci_filename(d->inode, fname->usr_fname, &cf_str);
     206                 :            : #endif
     207                 :            : 
     208                 :          0 :         if (max_slots)
     209                 :          0 :                 *max_slots = 0;
     210                 :          0 :         while (bit_pos < d->max) {
     211                 :          0 :                 if (!test_bit_le(bit_pos, d->bitmap)) {
     212                 :          0 :                         bit_pos++;
     213                 :          0 :                         max_len++;
     214                 :          0 :                         continue;
     215                 :            :                 }
     216                 :            : 
     217                 :          0 :                 de = &d->dentry[bit_pos];
     218                 :            : 
     219                 :          0 :                 if (unlikely(!de->name_len)) {
     220                 :          0 :                         bit_pos++;
     221                 :          0 :                         continue;
     222                 :            :                 }
     223                 :            : 
     224                 :          0 :                 if (f2fs_match_name(d, de, fname, &cf_str, bit_pos, namehash))
     225                 :            :                         goto found;
     226                 :            : 
     227                 :          0 :                 if (max_slots && max_len > *max_slots)
     228                 :          0 :                         *max_slots = max_len;
     229                 :            :                 max_len = 0;
     230                 :            : 
     231                 :          0 :                 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
     232                 :            :         }
     233                 :            : 
     234                 :            :         de = NULL;
     235                 :            : found:
     236                 :          0 :         if (max_slots && max_len > *max_slots)
     237                 :          0 :                 *max_slots = max_len;
     238                 :            : 
     239                 :            : #ifdef CONFIG_UNICODE
     240                 :            :         kvfree(cf_str.name);
     241                 :            : #endif
     242                 :          0 :         return de;
     243                 :            : }
     244                 :            : 
     245                 :          0 : static struct f2fs_dir_entry *find_in_level(struct inode *dir,
     246                 :            :                                         unsigned int level,
     247                 :            :                                         struct fscrypt_name *fname,
     248                 :            :                                         struct page **res_page)
     249                 :            : {
     250                 :          0 :         struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
     251                 :          0 :         int s = GET_DENTRY_SLOTS(name.len);
     252                 :            :         unsigned int nbucket, nblock;
     253                 :            :         unsigned int bidx, end_block;
     254                 :            :         struct page *dentry_page;
     255                 :            :         struct f2fs_dir_entry *de = NULL;
     256                 :            :         bool room = false;
     257                 :            :         int max_slots;
     258                 :          0 :         f2fs_hash_t namehash = f2fs_dentry_hash(dir, &name, fname);
     259                 :            : 
     260                 :          0 :         nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
     261                 :            :         nblock = bucket_blocks(level);
     262                 :            : 
     263                 :          0 :         bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
     264                 :            :                                         le32_to_cpu(namehash) % nbucket);
     265                 :          0 :         end_block = bidx + nblock;
     266                 :            : 
     267                 :          0 :         for (; bidx < end_block; bidx++) {
     268                 :            :                 /* no need to allocate new dentry pages to all the indices */
     269                 :          0 :                 dentry_page = f2fs_find_data_page(dir, bidx);
     270                 :          0 :                 if (IS_ERR(dentry_page)) {
     271                 :          0 :                         if (PTR_ERR(dentry_page) == -ENOENT) {
     272                 :            :                                 room = true;
     273                 :          0 :                                 continue;
     274                 :            :                         } else {
     275                 :          0 :                                 *res_page = dentry_page;
     276                 :          0 :                                 break;
     277                 :            :                         }
     278                 :            :                 }
     279                 :            : 
     280                 :          0 :                 de = find_in_block(dir, dentry_page, fname, namehash,
     281                 :            :                                                         &max_slots, res_page);
     282                 :          0 :                 if (de)
     283                 :            :                         break;
     284                 :            : 
     285                 :          0 :                 if (max_slots >= s)
     286                 :            :                         room = true;
     287                 :          0 :                 f2fs_put_page(dentry_page, 0);
     288                 :            :         }
     289                 :            : 
     290                 :          0 :         if (!de && room && F2FS_I(dir)->chash != namehash) {
     291                 :          0 :                 F2FS_I(dir)->chash = namehash;
     292                 :          0 :                 F2FS_I(dir)->clevel = level;
     293                 :            :         }
     294                 :            : 
     295                 :          0 :         return de;
     296                 :            : }
     297                 :            : 
     298                 :          0 : struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir,
     299                 :            :                         struct fscrypt_name *fname, struct page **res_page)
     300                 :            : {
     301                 :            :         unsigned long npages = dir_blocks(dir);
     302                 :            :         struct f2fs_dir_entry *de = NULL;
     303                 :            :         unsigned int max_depth;
     304                 :            :         unsigned int level;
     305                 :            : 
     306                 :          0 :         if (f2fs_has_inline_dentry(dir)) {
     307                 :          0 :                 *res_page = NULL;
     308                 :          0 :                 de = f2fs_find_in_inline_dir(dir, fname, res_page);
     309                 :          0 :                 goto out;
     310                 :            :         }
     311                 :            : 
     312                 :          0 :         if (npages == 0) {
     313                 :          0 :                 *res_page = NULL;
     314                 :          0 :                 goto out;
     315                 :            :         }
     316                 :            : 
     317                 :          0 :         max_depth = F2FS_I(dir)->i_current_depth;
     318                 :          0 :         if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {
     319                 :          0 :                 f2fs_warn(F2FS_I_SB(dir), "Corrupted max_depth of %lu: %u",
     320                 :            :                           dir->i_ino, max_depth);
     321                 :            :                 max_depth = MAX_DIR_HASH_DEPTH;
     322                 :            :                 f2fs_i_depth_write(dir, max_depth);
     323                 :            :         }
     324                 :            : 
     325                 :          0 :         for (level = 0; level < max_depth; level++) {
     326                 :          0 :                 *res_page = NULL;
     327                 :          0 :                 de = find_in_level(dir, level, fname, res_page);
     328                 :          0 :                 if (de || IS_ERR(*res_page))
     329                 :            :                         break;
     330                 :            :         }
     331                 :            : out:
     332                 :            :         /* This is to increase the speed of f2fs_create */
     333                 :          0 :         if (!de)
     334                 :          0 :                 F2FS_I(dir)->task = current;
     335                 :          0 :         return de;
     336                 :            : }
     337                 :            : 
     338                 :            : /*
     339                 :            :  * Find an entry in the specified directory with the wanted name.
     340                 :            :  * It returns the page where the entry was found (as a parameter - res_page),
     341                 :            :  * and the entry itself. Page is returned mapped and unlocked.
     342                 :            :  * Entry is guaranteed to be valid.
     343                 :            :  */
     344                 :          0 : struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
     345                 :            :                         const struct qstr *child, struct page **res_page)
     346                 :            : {
     347                 :            :         struct f2fs_dir_entry *de = NULL;
     348                 :            :         struct fscrypt_name fname;
     349                 :            :         int err;
     350                 :            : 
     351                 :            : #ifdef CONFIG_UNICODE
     352                 :            :         if (f2fs_has_strict_mode(F2FS_I_SB(dir)) && IS_CASEFOLDED(dir) &&
     353                 :            :                         utf8_validate(F2FS_I_SB(dir)->s_encoding, child)) {
     354                 :            :                 *res_page = ERR_PTR(-EINVAL);
     355                 :            :                 return NULL;
     356                 :            :         }
     357                 :            : #endif
     358                 :            : 
     359                 :          0 :         err = fscrypt_setup_filename(dir, child, 1, &fname);
     360                 :          0 :         if (err) {
     361                 :          0 :                 if (err == -ENOENT)
     362                 :          0 :                         *res_page = NULL;
     363                 :            :                 else
     364                 :          0 :                         *res_page = ERR_PTR(err);
     365                 :            :                 return NULL;
     366                 :            :         }
     367                 :            : 
     368                 :          0 :         de = __f2fs_find_entry(dir, &fname, res_page);
     369                 :            : 
     370                 :            :         fscrypt_free_filename(&fname);
     371                 :          0 :         return de;
     372                 :            : }
     373                 :            : 
     374                 :          0 : struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p)
     375                 :            : {
     376                 :          0 :         struct qstr dotdot = QSTR_INIT("..", 2);
     377                 :            : 
     378                 :          0 :         return f2fs_find_entry(dir, &dotdot, p);
     379                 :            : }
     380                 :            : 
     381                 :          0 : ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr,
     382                 :            :                                                         struct page **page)
     383                 :            : {
     384                 :            :         ino_t res = 0;
     385                 :            :         struct f2fs_dir_entry *de;
     386                 :            : 
     387                 :          0 :         de = f2fs_find_entry(dir, qstr, page);
     388                 :          0 :         if (de) {
     389                 :          0 :                 res = le32_to_cpu(de->ino);
     390                 :          0 :                 f2fs_put_page(*page, 0);
     391                 :            :         }
     392                 :            : 
     393                 :          0 :         return res;
     394                 :            : }
     395                 :            : 
     396                 :          0 : void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
     397                 :            :                 struct page *page, struct inode *inode)
     398                 :            : {
     399                 :          0 :         enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA;
     400                 :          0 :         lock_page(page);
     401                 :          0 :         f2fs_wait_on_page_writeback(page, type, true, true);
     402                 :          0 :         de->ino = cpu_to_le32(inode->i_ino);
     403                 :          0 :         set_de_type(de, inode->i_mode);
     404                 :          0 :         set_page_dirty(page);
     405                 :            : 
     406                 :          0 :         dir->i_mtime = dir->i_ctime = current_time(dir);
     407                 :          0 :         f2fs_mark_inode_dirty_sync(dir, false);
     408                 :          0 :         f2fs_put_page(page, 1);
     409                 :          0 : }
     410                 :            : 
     411                 :          0 : static void init_dent_inode(const struct qstr *name, struct page *ipage)
     412                 :            : {
     413                 :            :         struct f2fs_inode *ri;
     414                 :            : 
     415                 :          0 :         f2fs_wait_on_page_writeback(ipage, NODE, true, true);
     416                 :            : 
     417                 :            :         /* copy name info. to this inode page */
     418                 :          0 :         ri = F2FS_INODE(ipage);
     419                 :          0 :         ri->i_namelen = cpu_to_le32(name->len);
     420                 :          0 :         memcpy(ri->i_name, name->name, name->len);
     421                 :          0 :         set_page_dirty(ipage);
     422                 :          0 : }
     423                 :            : 
     424                 :          0 : void f2fs_do_make_empty_dir(struct inode *inode, struct inode *parent,
     425                 :            :                                         struct f2fs_dentry_ptr *d)
     426                 :            : {
     427                 :          0 :         struct qstr dot = QSTR_INIT(".", 1);
     428                 :          0 :         struct qstr dotdot = QSTR_INIT("..", 2);
     429                 :            : 
     430                 :            :         /* update dirent of "." */
     431                 :          0 :         f2fs_update_dentry(inode->i_ino, inode->i_mode, d, &dot, 0, 0);
     432                 :            : 
     433                 :            :         /* update dirent of ".." */
     434                 :          0 :         f2fs_update_dentry(parent->i_ino, parent->i_mode, d, &dotdot, 0, 1);
     435                 :          0 : }
     436                 :            : 
     437                 :          0 : static int make_empty_dir(struct inode *inode,
     438                 :            :                 struct inode *parent, struct page *page)
     439                 :            : {
     440                 :            :         struct page *dentry_page;
     441                 :            :         struct f2fs_dentry_block *dentry_blk;
     442                 :            :         struct f2fs_dentry_ptr d;
     443                 :            : 
     444                 :          0 :         if (f2fs_has_inline_dentry(inode))
     445                 :          0 :                 return f2fs_make_empty_inline_dir(inode, parent, page);
     446                 :            : 
     447                 :          0 :         dentry_page = f2fs_get_new_data_page(inode, page, 0, true);
     448                 :          0 :         if (IS_ERR(dentry_page))
     449                 :          0 :                 return PTR_ERR(dentry_page);
     450                 :            : 
     451                 :            :         dentry_blk = page_address(dentry_page);
     452                 :            : 
     453                 :            :         make_dentry_ptr_block(NULL, &d, dentry_blk);
     454                 :          0 :         f2fs_do_make_empty_dir(inode, parent, &d);
     455                 :            : 
     456                 :          0 :         set_page_dirty(dentry_page);
     457                 :          0 :         f2fs_put_page(dentry_page, 1);
     458                 :          0 :         return 0;
     459                 :            : }
     460                 :            : 
     461                 :          0 : struct page *f2fs_init_inode_metadata(struct inode *inode, struct inode *dir,
     462                 :            :                         const struct qstr *new_name, const struct qstr *orig_name,
     463                 :            :                         struct page *dpage)
     464                 :            : {
     465                 :            :         struct page *page;
     466                 :          0 :         int dummy_encrypt = DUMMY_ENCRYPTION_ENABLED(F2FS_I_SB(dir));
     467                 :            :         int err;
     468                 :            : 
     469                 :          0 :         if (is_inode_flag_set(inode, FI_NEW_INODE)) {
     470                 :          0 :                 page = f2fs_new_inode_page(inode);
     471                 :          0 :                 if (IS_ERR(page))
     472                 :            :                         return page;
     473                 :            : 
     474                 :          0 :                 if (S_ISDIR(inode->i_mode)) {
     475                 :            :                         /* in order to handle error case */
     476                 :          0 :                         get_page(page);
     477                 :          0 :                         err = make_empty_dir(inode, dir, page);
     478                 :          0 :                         if (err) {
     479                 :          0 :                                 lock_page(page);
     480                 :          0 :                                 goto put_error;
     481                 :            :                         }
     482                 :          0 :                         put_page(page);
     483                 :            :                 }
     484                 :            : 
     485                 :          0 :                 err = f2fs_init_acl(inode, dir, page, dpage);
     486                 :          0 :                 if (err)
     487                 :            :                         goto put_error;
     488                 :            : 
     489                 :            :                 err = f2fs_init_security(inode, dir, orig_name, page);
     490                 :            :                 if (err)
     491                 :            :                         goto put_error;
     492                 :            : 
     493                 :          0 :                 if ((IS_ENCRYPTED(dir) || dummy_encrypt) &&
     494                 :            :                                         f2fs_may_encrypt(inode)) {
     495                 :          0 :                         err = fscrypt_inherit_context(dir, inode, page, false);
     496                 :          0 :                         if (err)
     497                 :            :                                 goto put_error;
     498                 :            :                 }
     499                 :            :         } else {
     500                 :          0 :                 page = f2fs_get_node_page(F2FS_I_SB(dir), inode->i_ino);
     501                 :          0 :                 if (IS_ERR(page))
     502                 :            :                         return page;
     503                 :            :         }
     504                 :            : 
     505                 :          0 :         if (new_name) {
     506                 :          0 :                 init_dent_inode(new_name, page);
     507                 :          0 :                 if (IS_ENCRYPTED(dir))
     508                 :            :                         file_set_enc_name(inode);
     509                 :            :         }
     510                 :            : 
     511                 :            :         /*
     512                 :            :          * This file should be checkpointed during fsync.
     513                 :            :          * We lost i_pino from now on.
     514                 :            :          */
     515                 :          0 :         if (is_inode_flag_set(inode, FI_INC_LINK)) {
     516                 :          0 :                 if (!S_ISDIR(inode->i_mode))
     517                 :            :                         file_lost_pino(inode);
     518                 :            :                 /*
     519                 :            :                  * If link the tmpfile to alias through linkat path,
     520                 :            :                  * we should remove this inode from orphan list.
     521                 :            :                  */
     522                 :          0 :                 if (inode->i_nlink == 0)
     523                 :          0 :                         f2fs_remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);
     524                 :          0 :                 f2fs_i_links_write(inode, true);
     525                 :            :         }
     526                 :          0 :         return page;
     527                 :            : 
     528                 :            : put_error:
     529                 :          0 :         clear_nlink(inode);
     530                 :          0 :         f2fs_update_inode(inode, page);
     531                 :          0 :         f2fs_put_page(page, 1);
     532                 :          0 :         return ERR_PTR(err);
     533                 :            : }
     534                 :            : 
     535                 :          0 : void f2fs_update_parent_metadata(struct inode *dir, struct inode *inode,
     536                 :            :                                                 unsigned int current_depth)
     537                 :            : {
     538                 :          0 :         if (inode && is_inode_flag_set(inode, FI_NEW_INODE)) {
     539                 :          0 :                 if (S_ISDIR(inode->i_mode))
     540                 :          0 :                         f2fs_i_links_write(dir, true);
     541                 :          0 :                 clear_inode_flag(inode, FI_NEW_INODE);
     542                 :            :         }
     543                 :          0 :         dir->i_mtime = dir->i_ctime = current_time(dir);
     544                 :          0 :         f2fs_mark_inode_dirty_sync(dir, false);
     545                 :            : 
     546                 :          0 :         if (F2FS_I(dir)->i_current_depth != current_depth)
     547                 :            :                 f2fs_i_depth_write(dir, current_depth);
     548                 :            : 
     549                 :          0 :         if (inode && is_inode_flag_set(inode, FI_INC_LINK))
     550                 :          0 :                 clear_inode_flag(inode, FI_INC_LINK);
     551                 :          0 : }
     552                 :            : 
     553                 :          0 : int f2fs_room_for_filename(const void *bitmap, int slots, int max_slots)
     554                 :            : {
     555                 :            :         int bit_start = 0;
     556                 :            :         int zero_start, zero_end;
     557                 :            : next:
     558                 :            :         zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start);
     559                 :          0 :         if (zero_start >= max_slots)
     560                 :            :                 return max_slots;
     561                 :            : 
     562                 :            :         zero_end = find_next_bit_le(bitmap, max_slots, zero_start);
     563                 :          0 :         if (zero_end - zero_start >= slots)
     564                 :          0 :                 return zero_start;
     565                 :            : 
     566                 :          0 :         bit_start = zero_end + 1;
     567                 :            : 
     568                 :          0 :         if (zero_end + 1 >= max_slots)
     569                 :            :                 return max_slots;
     570                 :            :         goto next;
     571                 :            : }
     572                 :            : 
     573                 :          0 : void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
     574                 :            :                                 const struct qstr *name, f2fs_hash_t name_hash,
     575                 :            :                                 unsigned int bit_pos)
     576                 :            : {
     577                 :            :         struct f2fs_dir_entry *de;
     578                 :          0 :         int slots = GET_DENTRY_SLOTS(name->len);
     579                 :            :         int i;
     580                 :            : 
     581                 :          0 :         de = &d->dentry[bit_pos];
     582                 :          0 :         de->hash_code = name_hash;
     583                 :          0 :         de->name_len = cpu_to_le16(name->len);
     584                 :          0 :         memcpy(d->filename[bit_pos], name->name, name->len);
     585                 :          0 :         de->ino = cpu_to_le32(ino);
     586                 :            :         set_de_type(de, mode);
     587                 :          0 :         for (i = 0; i < slots; i++) {
     588                 :          0 :                 __set_bit_le(bit_pos + i, (void *)d->bitmap);
     589                 :            :                 /* avoid wrong garbage data for readdir */
     590                 :          0 :                 if (i)
     591                 :          0 :                         (de + i)->name_len = 0;
     592                 :            :         }
     593                 :          0 : }
     594                 :            : 
     595                 :          0 : int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
     596                 :            :                                 const struct qstr *orig_name,
     597                 :            :                                 struct inode *inode, nid_t ino, umode_t mode)
     598                 :            : {
     599                 :            :         unsigned int bit_pos;
     600                 :            :         unsigned int level;
     601                 :            :         unsigned int current_depth;
     602                 :            :         unsigned long bidx, block;
     603                 :            :         f2fs_hash_t dentry_hash;
     604                 :            :         unsigned int nbucket, nblock;
     605                 :            :         struct page *dentry_page = NULL;
     606                 :            :         struct f2fs_dentry_block *dentry_blk = NULL;
     607                 :            :         struct f2fs_dentry_ptr d;
     608                 :            :         struct page *page = NULL;
     609                 :            :         int slots, err = 0;
     610                 :            : 
     611                 :            :         level = 0;
     612                 :          0 :         slots = GET_DENTRY_SLOTS(new_name->len);
     613                 :          0 :         dentry_hash = f2fs_dentry_hash(dir, new_name, NULL);
     614                 :            : 
     615                 :          0 :         current_depth = F2FS_I(dir)->i_current_depth;
     616                 :          0 :         if (F2FS_I(dir)->chash == dentry_hash) {
     617                 :          0 :                 level = F2FS_I(dir)->clevel;
     618                 :          0 :                 F2FS_I(dir)->chash = 0;
     619                 :            :         }
     620                 :            : 
     621                 :            : start:
     622                 :            :         if (time_to_inject(F2FS_I_SB(dir), FAULT_DIR_DEPTH)) {
     623                 :            :                 f2fs_show_injection_info(FAULT_DIR_DEPTH);
     624                 :            :                 return -ENOSPC;
     625                 :            :         }
     626                 :            : 
     627                 :          0 :         if (unlikely(current_depth == MAX_DIR_HASH_DEPTH))
     628                 :            :                 return -ENOSPC;
     629                 :            : 
     630                 :            :         /* Increase the depth, if required */
     631                 :          0 :         if (level == current_depth)
     632                 :          0 :                 ++current_depth;
     633                 :            : 
     634                 :          0 :         nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
     635                 :            :         nblock = bucket_blocks(level);
     636                 :            : 
     637                 :          0 :         bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
     638                 :            :                                 (le32_to_cpu(dentry_hash) % nbucket));
     639                 :            : 
     640                 :          0 :         for (block = bidx; block <= (bidx + nblock - 1); block++) {
     641                 :          0 :                 dentry_page = f2fs_get_new_data_page(dir, NULL, block, true);
     642                 :          0 :                 if (IS_ERR(dentry_page))
     643                 :          0 :                         return PTR_ERR(dentry_page);
     644                 :            : 
     645                 :            :                 dentry_blk = page_address(dentry_page);
     646                 :          0 :                 bit_pos = f2fs_room_for_filename(&dentry_blk->dentry_bitmap,
     647                 :            :                                                 slots, NR_DENTRY_IN_BLOCK);
     648                 :          0 :                 if (bit_pos < NR_DENTRY_IN_BLOCK)
     649                 :            :                         goto add_dentry;
     650                 :            : 
     651                 :          0 :                 f2fs_put_page(dentry_page, 1);
     652                 :            :         }
     653                 :            : 
     654                 :            :         /* Move to next level to find the empty slot for new dentry */
     655                 :          0 :         ++level;
     656                 :          0 :         goto start;
     657                 :            : add_dentry:
     658                 :          0 :         f2fs_wait_on_page_writeback(dentry_page, DATA, true, true);
     659                 :            : 
     660                 :          0 :         if (inode) {
     661                 :          0 :                 down_write(&F2FS_I(inode)->i_sem);
     662                 :          0 :                 page = f2fs_init_inode_metadata(inode, dir, new_name,
     663                 :            :                                                 orig_name, NULL);
     664                 :          0 :                 if (IS_ERR(page)) {
     665                 :            :                         err = PTR_ERR(page);
     666                 :          0 :                         goto fail;
     667                 :            :                 }
     668                 :            :         }
     669                 :            : 
     670                 :            :         make_dentry_ptr_block(NULL, &d, dentry_blk);
     671                 :          0 :         f2fs_update_dentry(ino, mode, &d, new_name, dentry_hash, bit_pos);
     672                 :            : 
     673                 :          0 :         set_page_dirty(dentry_page);
     674                 :            : 
     675                 :          0 :         if (inode) {
     676                 :          0 :                 f2fs_i_pino_write(inode, dir->i_ino);
     677                 :            : 
     678                 :            :                 /* synchronize inode page's data from inode cache */
     679                 :          0 :                 if (is_inode_flag_set(inode, FI_NEW_INODE))
     680                 :          0 :                         f2fs_update_inode(inode, page);
     681                 :            : 
     682                 :          0 :                 f2fs_put_page(page, 1);
     683                 :            :         }
     684                 :            : 
     685                 :          0 :         f2fs_update_parent_metadata(dir, inode, current_depth);
     686                 :            : fail:
     687                 :          0 :         if (inode)
     688                 :          0 :                 up_write(&F2FS_I(inode)->i_sem);
     689                 :            : 
     690                 :          0 :         f2fs_put_page(dentry_page, 1);
     691                 :            : 
     692                 :          0 :         return err;
     693                 :            : }
     694                 :            : 
     695                 :          0 : int f2fs_add_dentry(struct inode *dir, struct fscrypt_name *fname,
     696                 :            :                                 struct inode *inode, nid_t ino, umode_t mode)
     697                 :            : {
     698                 :            :         struct qstr new_name;
     699                 :            :         int err = -EAGAIN;
     700                 :            : 
     701                 :          0 :         new_name.name = fname_name(fname);
     702                 :          0 :         new_name.len = fname_len(fname);
     703                 :            : 
     704                 :          0 :         if (f2fs_has_inline_dentry(dir))
     705                 :          0 :                 err = f2fs_add_inline_entry(dir, &new_name, fname->usr_fname,
     706                 :            :                                                         inode, ino, mode);
     707                 :          0 :         if (err == -EAGAIN)
     708                 :          0 :                 err = f2fs_add_regular_entry(dir, &new_name, fname->usr_fname,
     709                 :            :                                                         inode, ino, mode);
     710                 :            : 
     711                 :            :         f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
     712                 :          0 :         return err;
     713                 :            : }
     714                 :            : 
     715                 :            : /*
     716                 :            :  * Caller should grab and release a rwsem by calling f2fs_lock_op() and
     717                 :            :  * f2fs_unlock_op().
     718                 :            :  */
     719                 :          0 : int f2fs_do_add_link(struct inode *dir, const struct qstr *name,
     720                 :            :                                 struct inode *inode, nid_t ino, umode_t mode)
     721                 :            : {
     722                 :            :         struct fscrypt_name fname;
     723                 :          0 :         struct page *page = NULL;
     724                 :            :         struct f2fs_dir_entry *de = NULL;
     725                 :            :         int err;
     726                 :            : 
     727                 :          0 :         err = fscrypt_setup_filename(dir, name, 0, &fname);
     728                 :          0 :         if (err)
     729                 :            :                 return err;
     730                 :            : 
     731                 :            :         /*
     732                 :            :          * An immature stakable filesystem shows a race condition between lookup
     733                 :            :          * and create. If we have same task when doing lookup and create, it's
     734                 :            :          * definitely fine as expected by VFS normally. Otherwise, let's just
     735                 :            :          * verify on-disk dentry one more time, which guarantees filesystem
     736                 :            :          * consistency more.
     737                 :            :          */
     738                 :          0 :         if (current != F2FS_I(dir)->task) {
     739                 :          0 :                 de = __f2fs_find_entry(dir, &fname, &page);
     740                 :          0 :                 F2FS_I(dir)->task = NULL;
     741                 :            :         }
     742                 :          0 :         if (de) {
     743                 :          0 :                 f2fs_put_page(page, 0);
     744                 :            :                 err = -EEXIST;
     745                 :          0 :         } else if (IS_ERR(page)) {
     746                 :            :                 err = PTR_ERR(page);
     747                 :            :         } else {
     748                 :          0 :                 err = f2fs_add_dentry(dir, &fname, inode, ino, mode);
     749                 :            :         }
     750                 :            :         fscrypt_free_filename(&fname);
     751                 :          0 :         return err;
     752                 :            : }
     753                 :            : 
     754                 :          0 : int f2fs_do_tmpfile(struct inode *inode, struct inode *dir)
     755                 :            : {
     756                 :            :         struct page *page;
     757                 :            :         int err = 0;
     758                 :            : 
     759                 :          0 :         down_write(&F2FS_I(inode)->i_sem);
     760                 :          0 :         page = f2fs_init_inode_metadata(inode, dir, NULL, NULL, NULL);
     761                 :          0 :         if (IS_ERR(page)) {
     762                 :            :                 err = PTR_ERR(page);
     763                 :          0 :                 goto fail;
     764                 :            :         }
     765                 :          0 :         f2fs_put_page(page, 1);
     766                 :            : 
     767                 :          0 :         clear_inode_flag(inode, FI_NEW_INODE);
     768                 :            :         f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
     769                 :            : fail:
     770                 :          0 :         up_write(&F2FS_I(inode)->i_sem);
     771                 :          0 :         return err;
     772                 :            : }
     773                 :            : 
     774                 :          0 : void f2fs_drop_nlink(struct inode *dir, struct inode *inode)
     775                 :            : {
     776                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     777                 :            : 
     778                 :          0 :         down_write(&F2FS_I(inode)->i_sem);
     779                 :            : 
     780                 :          0 :         if (S_ISDIR(inode->i_mode))
     781                 :          0 :                 f2fs_i_links_write(dir, false);
     782                 :          0 :         inode->i_ctime = current_time(inode);
     783                 :            : 
     784                 :          0 :         f2fs_i_links_write(inode, false);
     785                 :          0 :         if (S_ISDIR(inode->i_mode)) {
     786                 :          0 :                 f2fs_i_links_write(inode, false);
     787                 :          0 :                 f2fs_i_size_write(inode, 0);
     788                 :            :         }
     789                 :          0 :         up_write(&F2FS_I(inode)->i_sem);
     790                 :            : 
     791                 :          0 :         if (inode->i_nlink == 0)
     792                 :          0 :                 f2fs_add_orphan_inode(inode);
     793                 :            :         else
     794                 :          0 :                 f2fs_release_orphan_inode(sbi);
     795                 :          0 : }
     796                 :            : 
     797                 :            : /*
     798                 :            :  * It only removes the dentry from the dentry page, corresponding name
     799                 :            :  * entry in name page does not need to be touched during deletion.
     800                 :            :  */
     801                 :          0 : void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
     802                 :            :                                         struct inode *dir, struct inode *inode)
     803                 :            : {
     804                 :            :         struct  f2fs_dentry_block *dentry_blk;
     805                 :            :         unsigned int bit_pos;
     806                 :          0 :         int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
     807                 :            :         int i;
     808                 :            : 
     809                 :            :         f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
     810                 :            : 
     811                 :          0 :         if (F2FS_OPTION(F2FS_I_SB(dir)).fsync_mode == FSYNC_MODE_STRICT)
     812                 :          0 :                 f2fs_add_ino_entry(F2FS_I_SB(dir), dir->i_ino, TRANS_DIR_INO);
     813                 :            : 
     814                 :          0 :         if (f2fs_has_inline_dentry(dir))
     815                 :          0 :                 return f2fs_delete_inline_entry(dentry, page, dir, inode);
     816                 :            : 
     817                 :          0 :         lock_page(page);
     818                 :          0 :         f2fs_wait_on_page_writeback(page, DATA, true, true);
     819                 :            : 
     820                 :            :         dentry_blk = page_address(page);
     821                 :          0 :         bit_pos = dentry - dentry_blk->dentry;
     822                 :          0 :         for (i = 0; i < slots; i++)
     823                 :          0 :                 __clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
     824                 :            : 
     825                 :            :         /* Let's check and deallocate this dentry page */
     826                 :          0 :         bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
     827                 :            :                         NR_DENTRY_IN_BLOCK,
     828                 :            :                         0);
     829                 :          0 :         set_page_dirty(page);
     830                 :            : 
     831                 :          0 :         dir->i_ctime = dir->i_mtime = current_time(dir);
     832                 :          0 :         f2fs_mark_inode_dirty_sync(dir, false);
     833                 :            : 
     834                 :          0 :         if (inode)
     835                 :          0 :                 f2fs_drop_nlink(dir, inode);
     836                 :            : 
     837                 :          0 :         if (bit_pos == NR_DENTRY_IN_BLOCK &&
     838                 :          0 :                 !f2fs_truncate_hole(dir, page->index, page->index + 1)) {
     839                 :          0 :                 f2fs_clear_page_cache_dirty_tag(page);
     840                 :          0 :                 clear_page_dirty_for_io(page);
     841                 :          0 :                 f2fs_clear_page_private(page);
     842                 :            :                 ClearPageUptodate(page);
     843                 :            :                 clear_cold_data(page);
     844                 :          0 :                 inode_dec_dirty_pages(dir);
     845                 :          0 :                 f2fs_remove_dirty_inode(dir);
     846                 :            :         }
     847                 :          0 :         f2fs_put_page(page, 1);
     848                 :            : }
     849                 :            : 
     850                 :          0 : bool f2fs_empty_dir(struct inode *dir)
     851                 :            : {
     852                 :            :         unsigned long bidx;
     853                 :            :         struct page *dentry_page;
     854                 :            :         unsigned int bit_pos;
     855                 :            :         struct f2fs_dentry_block *dentry_blk;
     856                 :            :         unsigned long nblock = dir_blocks(dir);
     857                 :            : 
     858                 :          0 :         if (f2fs_has_inline_dentry(dir))
     859                 :          0 :                 return f2fs_empty_inline_dir(dir);
     860                 :            : 
     861                 :          0 :         for (bidx = 0; bidx < nblock; bidx++) {
     862                 :          0 :                 dentry_page = f2fs_get_lock_data_page(dir, bidx, false);
     863                 :          0 :                 if (IS_ERR(dentry_page)) {
     864                 :          0 :                         if (PTR_ERR(dentry_page) == -ENOENT)
     865                 :          0 :                                 continue;
     866                 :            :                         else
     867                 :            :                                 return false;
     868                 :            :                 }
     869                 :            : 
     870                 :            :                 dentry_blk = page_address(dentry_page);
     871                 :          0 :                 if (bidx == 0)
     872                 :            :                         bit_pos = 2;
     873                 :            :                 else
     874                 :            :                         bit_pos = 0;
     875                 :          0 :                 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
     876                 :            :                                                 NR_DENTRY_IN_BLOCK,
     877                 :            :                                                 bit_pos);
     878                 :            : 
     879                 :          0 :                 f2fs_put_page(dentry_page, 1);
     880                 :            : 
     881                 :          0 :                 if (bit_pos < NR_DENTRY_IN_BLOCK)
     882                 :            :                         return false;
     883                 :            :         }
     884                 :            :         return true;
     885                 :            : }
     886                 :            : 
     887                 :          0 : int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
     888                 :            :                         unsigned int start_pos, struct fscrypt_str *fstr)
     889                 :            : {
     890                 :            :         unsigned char d_type = DT_UNKNOWN;
     891                 :            :         unsigned int bit_pos;
     892                 :            :         struct f2fs_dir_entry *de = NULL;
     893                 :          0 :         struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
     894                 :          0 :         struct f2fs_sb_info *sbi = F2FS_I_SB(d->inode);
     895                 :            :         struct blk_plug plug;
     896                 :          0 :         bool readdir_ra = sbi->readdir_ra == 1;
     897                 :            :         int err = 0;
     898                 :            : 
     899                 :          0 :         bit_pos = ((unsigned long)ctx->pos % d->max);
     900                 :            : 
     901                 :          0 :         if (readdir_ra)
     902                 :          0 :                 blk_start_plug(&plug);
     903                 :            : 
     904                 :          0 :         while (bit_pos < d->max) {
     905                 :          0 :                 bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos);
     906                 :          0 :                 if (bit_pos >= d->max)
     907                 :            :                         break;
     908                 :            : 
     909                 :          0 :                 de = &d->dentry[bit_pos];
     910                 :          0 :                 if (de->name_len == 0) {
     911                 :          0 :                         bit_pos++;
     912                 :          0 :                         ctx->pos = start_pos + bit_pos;
     913                 :          0 :                         printk_ratelimited(
     914                 :            :                                 "%s, invalid namelen(0), ino:%u, run fsck to fix.",
     915                 :            :                                 KERN_WARNING, le32_to_cpu(de->ino));
     916                 :            :                         set_sbi_flag(sbi, SBI_NEED_FSCK);
     917                 :          0 :                         continue;
     918                 :            :                 }
     919                 :            : 
     920                 :            :                 d_type = f2fs_get_de_type(de);
     921                 :            : 
     922                 :          0 :                 de_name.name = d->filename[bit_pos];
     923                 :          0 :                 de_name.len = le16_to_cpu(de->name_len);
     924                 :            : 
     925                 :            :                 /* check memory boundary before moving forward */
     926                 :          0 :                 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
     927                 :          0 :                 if (unlikely(bit_pos > d->max ||
     928                 :            :                                 le16_to_cpu(de->name_len) > F2FS_NAME_LEN)) {
     929                 :          0 :                         f2fs_warn(sbi, "%s: corrupted namelen=%d, run fsck to fix.",
     930                 :            :                                   __func__, le16_to_cpu(de->name_len));
     931                 :            :                         set_sbi_flag(sbi, SBI_NEED_FSCK);
     932                 :            :                         err = -EFSCORRUPTED;
     933                 :          0 :                         goto out;
     934                 :            :                 }
     935                 :            : 
     936                 :          0 :                 if (IS_ENCRYPTED(d->inode)) {
     937                 :          0 :                         int save_len = fstr->len;
     938                 :            : 
     939                 :          0 :                         err = fscrypt_fname_disk_to_usr(d->inode,
     940                 :            :                                                 (u32)le32_to_cpu(de->hash_code),
     941                 :            :                                                 0, &de_name, fstr);
     942                 :          0 :                         if (err)
     943                 :            :                                 goto out;
     944                 :            : 
     945                 :          0 :                         de_name = *fstr;
     946                 :          0 :                         fstr->len = save_len;
     947                 :            :                 }
     948                 :            : 
     949                 :          0 :                 if (!dir_emit(ctx, de_name.name, de_name.len,
     950                 :          0 :                                         le32_to_cpu(de->ino), d_type)) {
     951                 :            :                         err = 1;
     952                 :            :                         goto out;
     953                 :            :                 }
     954                 :            : 
     955                 :          0 :                 if (readdir_ra)
     956                 :          0 :                         f2fs_ra_node_page(sbi, le32_to_cpu(de->ino));
     957                 :            : 
     958                 :          0 :                 ctx->pos = start_pos + bit_pos;
     959                 :            :         }
     960                 :            : out:
     961                 :          0 :         if (readdir_ra)
     962                 :          0 :                 blk_finish_plug(&plug);
     963                 :          0 :         return err;
     964                 :            : }
     965                 :            : 
     966                 :          0 : static int f2fs_readdir(struct file *file, struct dir_context *ctx)
     967                 :            : {
     968                 :            :         struct inode *inode = file_inode(file);
     969                 :            :         unsigned long npages = dir_blocks(inode);
     970                 :            :         struct f2fs_dentry_block *dentry_blk = NULL;
     971                 :            :         struct page *dentry_page = NULL;
     972                 :          0 :         struct file_ra_state *ra = &file->f_ra;
     973                 :          0 :         loff_t start_pos = ctx->pos;
     974                 :          0 :         unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
     975                 :            :         struct f2fs_dentry_ptr d;
     976                 :          0 :         struct fscrypt_str fstr = FSTR_INIT(NULL, 0);
     977                 :            :         int err = 0;
     978                 :            : 
     979                 :          0 :         if (IS_ENCRYPTED(inode)) {
     980                 :          0 :                 err = fscrypt_get_encryption_info(inode);
     981                 :          0 :                 if (err && err != -ENOKEY)
     982                 :            :                         goto out;
     983                 :            : 
     984                 :          0 :                 err = fscrypt_fname_alloc_buffer(inode, F2FS_NAME_LEN, &fstr);
     985                 :          0 :                 if (err < 0)
     986                 :            :                         goto out;
     987                 :            :         }
     988                 :            : 
     989                 :          0 :         if (f2fs_has_inline_dentry(inode)) {
     990                 :          0 :                 err = f2fs_read_inline_dir(file, ctx, &fstr);
     991                 :          0 :                 goto out_free;
     992                 :            :         }
     993                 :            : 
     994                 :          0 :         for (; n < npages; n++, ctx->pos = n * NR_DENTRY_IN_BLOCK) {
     995                 :            : 
     996                 :            :                 /* allow readdir() to be interrupted */
     997                 :          0 :                 if (fatal_signal_pending(current)) {
     998                 :            :                         err = -ERESTARTSYS;
     999                 :            :                         goto out_free;
    1000                 :            :                 }
    1001                 :          0 :                 cond_resched();
    1002                 :            : 
    1003                 :            :                 /* readahead for multi pages of dir */
    1004                 :          0 :                 if (npages - n > 1 && !ra_has_index(ra, n))
    1005                 :          0 :                         page_cache_sync_readahead(inode->i_mapping, ra, file, n,
    1006                 :          0 :                                 min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES));
    1007                 :            : 
    1008                 :          0 :                 dentry_page = f2fs_find_data_page(inode, n);
    1009                 :          0 :                 if (IS_ERR(dentry_page)) {
    1010                 :            :                         err = PTR_ERR(dentry_page);
    1011                 :          0 :                         if (err == -ENOENT) {
    1012                 :            :                                 err = 0;
    1013                 :          0 :                                 continue;
    1014                 :            :                         } else {
    1015                 :            :                                 goto out_free;
    1016                 :            :                         }
    1017                 :            :                 }
    1018                 :            : 
    1019                 :            :                 dentry_blk = page_address(dentry_page);
    1020                 :            : 
    1021                 :            :                 make_dentry_ptr_block(inode, &d, dentry_blk);
    1022                 :            : 
    1023                 :          0 :                 err = f2fs_fill_dentries(ctx, &d,
    1024                 :            :                                 n * NR_DENTRY_IN_BLOCK, &fstr);
    1025                 :          0 :                 if (err) {
    1026                 :          0 :                         f2fs_put_page(dentry_page, 0);
    1027                 :          0 :                         break;
    1028                 :            :                 }
    1029                 :            : 
    1030                 :          0 :                 f2fs_put_page(dentry_page, 0);
    1031                 :            :         }
    1032                 :            : out_free:
    1033                 :          0 :         fscrypt_fname_free_buffer(&fstr);
    1034                 :            : out:
    1035                 :          0 :         trace_f2fs_readdir(inode, start_pos, ctx->pos, err);
    1036                 :          0 :         return err < 0 ? err : 0;
    1037                 :            : }
    1038                 :            : 
    1039                 :          0 : static int f2fs_dir_open(struct inode *inode, struct file *filp)
    1040                 :            : {
    1041                 :          0 :         if (IS_ENCRYPTED(inode))
    1042                 :          0 :                 return fscrypt_get_encryption_info(inode) ? -EACCES : 0;
    1043                 :            :         return 0;
    1044                 :            : }
    1045                 :            : 
    1046                 :            : const struct file_operations f2fs_dir_operations = {
    1047                 :            :         .llseek         = generic_file_llseek,
    1048                 :            :         .read           = generic_read_dir,
    1049                 :            :         .iterate_shared = f2fs_readdir,
    1050                 :            :         .fsync          = f2fs_sync_file,
    1051                 :            :         .open           = f2fs_dir_open,
    1052                 :            :         .unlocked_ioctl = f2fs_ioctl,
    1053                 :            : #ifdef CONFIG_COMPAT
    1054                 :            :         .compat_ioctl   = f2fs_compat_ioctl,
    1055                 :            : #endif
    1056                 :            : };
    1057                 :            : 
    1058                 :            : #ifdef CONFIG_UNICODE
    1059                 :            : static int f2fs_d_compare(const struct dentry *dentry, unsigned int len,
    1060                 :            :                           const char *str, const struct qstr *name)
    1061                 :            : {
    1062                 :            :         const struct dentry *parent = READ_ONCE(dentry->d_parent);
    1063                 :            :         const struct inode *dir = READ_ONCE(parent->d_inode);
    1064                 :            :         const struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
    1065                 :            :         struct qstr entry = QSTR_INIT(str, len);
    1066                 :            :         char strbuf[DNAME_INLINE_LEN];
    1067                 :            :         int res;
    1068                 :            : 
    1069                 :            :         if (!dir || !IS_CASEFOLDED(dir))
    1070                 :            :                 goto fallback;
    1071                 :            : 
    1072                 :            :         /*
    1073                 :            :          * If the dentry name is stored in-line, then it may be concurrently
    1074                 :            :          * modified by a rename.  If this happens, the VFS will eventually retry
    1075                 :            :          * the lookup, so it doesn't matter what ->d_compare() returns.
    1076                 :            :          * However, it's unsafe to call utf8_strncasecmp() with an unstable
    1077                 :            :          * string.  Therefore, we have to copy the name into a temporary buffer.
    1078                 :            :          */
    1079                 :            :         if (len <= DNAME_INLINE_LEN - 1) {
    1080                 :            :                 memcpy(strbuf, str, len);
    1081                 :            :                 strbuf[len] = 0;
    1082                 :            :                 entry.name = strbuf;
    1083                 :            :                 /* prevent compiler from optimizing out the temporary buffer */
    1084                 :            :                 barrier();
    1085                 :            :         }
    1086                 :            : 
    1087                 :            :         res = utf8_strncasecmp(sbi->s_encoding, name, &entry);
    1088                 :            :         if (res >= 0)
    1089                 :            :                 return res;
    1090                 :            : 
    1091                 :            :         if (f2fs_has_strict_mode(sbi))
    1092                 :            :                 return -EINVAL;
    1093                 :            : fallback:
    1094                 :            :         if (len != name->len)
    1095                 :            :                 return 1;
    1096                 :            :         return !!memcmp(str, name->name, len);
    1097                 :            : }
    1098                 :            : 
    1099                 :            : static int f2fs_d_hash(const struct dentry *dentry, struct qstr *str)
    1100                 :            : {
    1101                 :            :         struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
    1102                 :            :         const struct unicode_map *um = sbi->s_encoding;
    1103                 :            :         const struct inode *inode = READ_ONCE(dentry->d_inode);
    1104                 :            :         unsigned char *norm;
    1105                 :            :         int len, ret = 0;
    1106                 :            : 
    1107                 :            :         if (!inode || !IS_CASEFOLDED(inode))
    1108                 :            :                 return 0;
    1109                 :            : 
    1110                 :            :         norm = f2fs_kmalloc(sbi, PATH_MAX, GFP_ATOMIC);
    1111                 :            :         if (!norm)
    1112                 :            :                 return -ENOMEM;
    1113                 :            : 
    1114                 :            :         len = utf8_casefold(um, str, norm, PATH_MAX);
    1115                 :            :         if (len < 0) {
    1116                 :            :                 if (f2fs_has_strict_mode(sbi))
    1117                 :            :                         ret = -EINVAL;
    1118                 :            :                 goto out;
    1119                 :            :         }
    1120                 :            :         str->hash = full_name_hash(dentry, norm, len);
    1121                 :            : out:
    1122                 :            :         kvfree(norm);
    1123                 :            :         return ret;
    1124                 :            : }
    1125                 :            : 
    1126                 :            : const struct dentry_operations f2fs_dentry_ops = {
    1127                 :            :         .d_hash = f2fs_d_hash,
    1128                 :            :         .d_compare = f2fs_d_compare,
    1129                 :            : };
    1130                 :            : #endif
    

Generated by: LCOV version 1.14