Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * fs/f2fs/dir.c
0004  *
0005  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
0006  *             http://www.samsung.com/
0007  */
0008 #include <asm/unaligned.h>
0009 #include <linux/fs.h>
0010 #include <linux/f2fs_fs.h>
0011 #include <linux/sched/signal.h>
0012 #include <linux/unicode.h>
0013 #include "f2fs.h"
0014 #include "node.h"
0015 #include "acl.h"
0016 #include "xattr.h"
0017 #include <trace/events/f2fs.h>
0018 
0019 #if IS_ENABLED(CONFIG_UNICODE)
0020 extern struct kmem_cache *f2fs_cf_name_slab;
0021 #endif
0022 
0023 static unsigned long dir_blocks(struct inode *inode)
0024 {
0025     return ((unsigned long long) (i_size_read(inode) + PAGE_SIZE - 1))
0026                             >> PAGE_SHIFT;
0027 }
0028 
0029 static unsigned int dir_buckets(unsigned int level, int dir_level)
0030 {
0031     if (level + dir_level < MAX_DIR_HASH_DEPTH / 2)
0032         return 1 << (level + dir_level);
0033     else
0034         return MAX_DIR_BUCKETS;
0035 }
0036 
0037 static unsigned int bucket_blocks(unsigned int level)
0038 {
0039     if (level < MAX_DIR_HASH_DEPTH / 2)
0040         return 2;
0041     else
0042         return 4;
0043 }
0044 
0045 static unsigned char f2fs_filetype_table[F2FS_FT_MAX] = {
0046     [F2FS_FT_UNKNOWN]   = DT_UNKNOWN,
0047     [F2FS_FT_REG_FILE]  = DT_REG,
0048     [F2FS_FT_DIR]       = DT_DIR,
0049     [F2FS_FT_CHRDEV]    = DT_CHR,
0050     [F2FS_FT_BLKDEV]    = DT_BLK,
0051     [F2FS_FT_FIFO]      = DT_FIFO,
0052     [F2FS_FT_SOCK]      = DT_SOCK,
0053     [F2FS_FT_SYMLINK]   = DT_LNK,
0054 };
0055 
0056 static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = {
0057     [S_IFREG >> S_SHIFT]    = F2FS_FT_REG_FILE,
0058     [S_IFDIR >> S_SHIFT]    = F2FS_FT_DIR,
0059     [S_IFCHR >> S_SHIFT]    = F2FS_FT_CHRDEV,
0060     [S_IFBLK >> S_SHIFT]    = F2FS_FT_BLKDEV,
0061     [S_IFIFO >> S_SHIFT]    = F2FS_FT_FIFO,
0062     [S_IFSOCK >> S_SHIFT]   = F2FS_FT_SOCK,
0063     [S_IFLNK >> S_SHIFT]    = F2FS_FT_SYMLINK,
0064 };
0065 
0066 static void set_de_type(struct f2fs_dir_entry *de, umode_t mode)
0067 {
0068     de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];
0069 }
0070 
0071 unsigned char f2fs_get_de_type(struct f2fs_dir_entry *de)
0072 {
0073     if (de->file_type < F2FS_FT_MAX)
0074         return f2fs_filetype_table[de->file_type];
0075     return DT_UNKNOWN;
0076 }
0077 
0078 /* If @dir is casefolded, initialize @fname->cf_name from @fname->usr_fname. */
0079 int f2fs_init_casefolded_name(const struct inode *dir,
0080                   struct f2fs_filename *fname)
0081 {
0082 #if IS_ENABLED(CONFIG_UNICODE)
0083     struct super_block *sb = dir->i_sb;
0084 
0085     if (IS_CASEFOLDED(dir) &&
0086         !is_dot_dotdot(fname->usr_fname->name, fname->usr_fname->len)) {
0087         fname->cf_name.name = f2fs_kmem_cache_alloc(f2fs_cf_name_slab,
0088                     GFP_NOFS, false, F2FS_SB(sb));
0089         if (!fname->cf_name.name)
0090             return -ENOMEM;
0091         fname->cf_name.len = utf8_casefold(sb->s_encoding,
0092                            fname->usr_fname,
0093                            fname->cf_name.name,
0094                            F2FS_NAME_LEN);
0095         if ((int)fname->cf_name.len <= 0) {
0096             kmem_cache_free(f2fs_cf_name_slab, fname->cf_name.name);
0097             fname->cf_name.name = NULL;
0098             if (sb_has_strict_encoding(sb))
0099                 return -EINVAL;
0100             /* fall back to treating name as opaque byte sequence */
0101         }
0102     }
0103 #endif
0104     return 0;
0105 }
0106 
0107 static int __f2fs_setup_filename(const struct inode *dir,
0108                  const struct fscrypt_name *crypt_name,
0109                  struct f2fs_filename *fname)
0110 {
0111     int err;
0112 
0113     memset(fname, 0, sizeof(*fname));
0114 
0115     fname->usr_fname = crypt_name->usr_fname;
0116     fname->disk_name = crypt_name->disk_name;
0117 #ifdef CONFIG_FS_ENCRYPTION
0118     fname->crypto_buf = crypt_name->crypto_buf;
0119 #endif
0120     if (crypt_name->is_nokey_name) {
0121         /* hash was decoded from the no-key name */
0122         fname->hash = cpu_to_le32(crypt_name->hash);
0123     } else {
0124         err = f2fs_init_casefolded_name(dir, fname);
0125         if (err) {
0126             f2fs_free_filename(fname);
0127             return err;
0128         }
0129         f2fs_hash_filename(dir, fname);
0130     }
0131     return 0;
0132 }
0133 
0134 /*
0135  * Prepare to search for @iname in @dir.  This is similar to
0136  * fscrypt_setup_filename(), but this also handles computing the casefolded name
0137  * and the f2fs dirhash if needed, then packing all the information about this
0138  * filename up into a 'struct f2fs_filename'.
0139  */
0140 int f2fs_setup_filename(struct inode *dir, const struct qstr *iname,
0141             int lookup, struct f2fs_filename *fname)
0142 {
0143     struct fscrypt_name crypt_name;
0144     int err;
0145 
0146     err = fscrypt_setup_filename(dir, iname, lookup, &crypt_name);
0147     if (err)
0148         return err;
0149 
0150     return __f2fs_setup_filename(dir, &crypt_name, fname);
0151 }
0152 
0153 /*
0154  * Prepare to look up @dentry in @dir.  This is similar to
0155  * fscrypt_prepare_lookup(), but this also handles computing the casefolded name
0156  * and the f2fs dirhash if needed, then packing all the information about this
0157  * filename up into a 'struct f2fs_filename'.
0158  */
0159 int f2fs_prepare_lookup(struct inode *dir, struct dentry *dentry,
0160             struct f2fs_filename *fname)
0161 {
0162     struct fscrypt_name crypt_name;
0163     int err;
0164 
0165     err = fscrypt_prepare_lookup(dir, dentry, &crypt_name);
0166     if (err)
0167         return err;
0168 
0169     return __f2fs_setup_filename(dir, &crypt_name, fname);
0170 }
0171 
0172 void f2fs_free_filename(struct f2fs_filename *fname)
0173 {
0174 #ifdef CONFIG_FS_ENCRYPTION
0175     kfree(fname->crypto_buf.name);
0176     fname->crypto_buf.name = NULL;
0177 #endif
0178 #if IS_ENABLED(CONFIG_UNICODE)
0179     if (fname->cf_name.name) {
0180         kmem_cache_free(f2fs_cf_name_slab, fname->cf_name.name);
0181         fname->cf_name.name = NULL;
0182     }
0183 #endif
0184 }
0185 
0186 static unsigned long dir_block_index(unsigned int level,
0187                 int dir_level, unsigned int idx)
0188 {
0189     unsigned long i;
0190     unsigned long bidx = 0;
0191 
0192     for (i = 0; i < level; i++)
0193         bidx += dir_buckets(i, dir_level) * bucket_blocks(i);
0194     bidx += idx * bucket_blocks(level);
0195     return bidx;
0196 }
0197 
0198 static struct f2fs_dir_entry *find_in_block(struct inode *dir,
0199                 struct page *dentry_page,
0200                 const struct f2fs_filename *fname,
0201                 int *max_slots)
0202 {
0203     struct f2fs_dentry_block *dentry_blk;
0204     struct f2fs_dentry_ptr d;
0205 
0206     dentry_blk = (struct f2fs_dentry_block *)page_address(dentry_page);
0207 
0208     make_dentry_ptr_block(dir, &d, dentry_blk);
0209     return f2fs_find_target_dentry(&d, fname, max_slots);
0210 }
0211 
0212 #if IS_ENABLED(CONFIG_UNICODE)
0213 /*
0214  * Test whether a case-insensitive directory entry matches the filename
0215  * being searched for.
0216  *
0217  * Returns 1 for a match, 0 for no match, and -errno on an error.
0218  */
0219 static int f2fs_match_ci_name(const struct inode *dir, const struct qstr *name,
0220                    const u8 *de_name, u32 de_name_len)
0221 {
0222     const struct super_block *sb = dir->i_sb;
0223     const struct unicode_map *um = sb->s_encoding;
0224     struct fscrypt_str decrypted_name = FSTR_INIT(NULL, de_name_len);
0225     struct qstr entry = QSTR_INIT(de_name, de_name_len);
0226     int res;
0227 
0228     if (IS_ENCRYPTED(dir)) {
0229         const struct fscrypt_str encrypted_name =
0230             FSTR_INIT((u8 *)de_name, de_name_len);
0231 
0232         if (WARN_ON_ONCE(!fscrypt_has_encryption_key(dir)))
0233             return -EINVAL;
0234 
0235         decrypted_name.name = kmalloc(de_name_len, GFP_KERNEL);
0236         if (!decrypted_name.name)
0237             return -ENOMEM;
0238         res = fscrypt_fname_disk_to_usr(dir, 0, 0, &encrypted_name,
0239                         &decrypted_name);
0240         if (res < 0)
0241             goto out;
0242         entry.name = decrypted_name.name;
0243         entry.len = decrypted_name.len;
0244     }
0245 
0246     res = utf8_strncasecmp_folded(um, name, &entry);
0247     /*
0248      * In strict mode, ignore invalid names.  In non-strict mode,
0249      * fall back to treating them as opaque byte sequences.
0250      */
0251     if (res < 0 && !sb_has_strict_encoding(sb)) {
0252         res = name->len == entry.len &&
0253                 memcmp(name->name, entry.name, name->len) == 0;
0254     } else {
0255         /* utf8_strncasecmp_folded returns 0 on match */
0256         res = (res == 0);
0257     }
0258 out:
0259     kfree(decrypted_name.name);
0260     return res;
0261 }
0262 #endif /* CONFIG_UNICODE */
0263 
0264 static inline int f2fs_match_name(const struct inode *dir,
0265                    const struct f2fs_filename *fname,
0266                    const u8 *de_name, u32 de_name_len)
0267 {
0268     struct fscrypt_name f;
0269 
0270 #if IS_ENABLED(CONFIG_UNICODE)
0271     if (fname->cf_name.name) {
0272         struct qstr cf = FSTR_TO_QSTR(&fname->cf_name);
0273 
0274         return f2fs_match_ci_name(dir, &cf, de_name, de_name_len);
0275     }
0276 #endif
0277     f.usr_fname = fname->usr_fname;
0278     f.disk_name = fname->disk_name;
0279 #ifdef CONFIG_FS_ENCRYPTION
0280     f.crypto_buf = fname->crypto_buf;
0281 #endif
0282     return fscrypt_match_name(&f, de_name, de_name_len);
0283 }
0284 
0285 struct f2fs_dir_entry *f2fs_find_target_dentry(const struct f2fs_dentry_ptr *d,
0286             const struct f2fs_filename *fname, int *max_slots)
0287 {
0288     struct f2fs_dir_entry *de;
0289     unsigned long bit_pos = 0;
0290     int max_len = 0;
0291     int res = 0;
0292 
0293     if (max_slots)
0294         *max_slots = 0;
0295     while (bit_pos < d->max) {
0296         if (!test_bit_le(bit_pos, d->bitmap)) {
0297             bit_pos++;
0298             max_len++;
0299             continue;
0300         }
0301 
0302         de = &d->dentry[bit_pos];
0303 
0304         if (unlikely(!de->name_len)) {
0305             bit_pos++;
0306             continue;
0307         }
0308 
0309         if (de->hash_code == fname->hash) {
0310             res = f2fs_match_name(d->inode, fname,
0311                           d->filename[bit_pos],
0312                           le16_to_cpu(de->name_len));
0313             if (res < 0)
0314                 return ERR_PTR(res);
0315             if (res)
0316                 goto found;
0317         }
0318 
0319         if (max_slots && max_len > *max_slots)
0320             *max_slots = max_len;
0321         max_len = 0;
0322 
0323         bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
0324     }
0325 
0326     de = NULL;
0327 found:
0328     if (max_slots && max_len > *max_slots)
0329         *max_slots = max_len;
0330     return de;
0331 }
0332 
0333 static struct f2fs_dir_entry *find_in_level(struct inode *dir,
0334                     unsigned int level,
0335                     const struct f2fs_filename *fname,
0336                     struct page **res_page)
0337 {
0338     int s = GET_DENTRY_SLOTS(fname->disk_name.len);
0339     unsigned int nbucket, nblock;
0340     unsigned int bidx, end_block;
0341     struct page *dentry_page;
0342     struct f2fs_dir_entry *de = NULL;
0343     bool room = false;
0344     int max_slots;
0345 
0346     nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
0347     nblock = bucket_blocks(level);
0348 
0349     bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
0350                    le32_to_cpu(fname->hash) % nbucket);
0351     end_block = bidx + nblock;
0352 
0353     for (; bidx < end_block; bidx++) {
0354         /* no need to allocate new dentry pages to all the indices */
0355         dentry_page = f2fs_find_data_page(dir, bidx);
0356         if (IS_ERR(dentry_page)) {
0357             if (PTR_ERR(dentry_page) == -ENOENT) {
0358                 room = true;
0359                 continue;
0360             } else {
0361                 *res_page = dentry_page;
0362                 break;
0363             }
0364         }
0365 
0366         de = find_in_block(dir, dentry_page, fname, &max_slots);
0367         if (IS_ERR(de)) {
0368             *res_page = ERR_CAST(de);
0369             de = NULL;
0370             break;
0371         } else if (de) {
0372             *res_page = dentry_page;
0373             break;
0374         }
0375 
0376         if (max_slots >= s)
0377             room = true;
0378         f2fs_put_page(dentry_page, 0);
0379     }
0380 
0381     if (!de && room && F2FS_I(dir)->chash != fname->hash) {
0382         F2FS_I(dir)->chash = fname->hash;
0383         F2FS_I(dir)->clevel = level;
0384     }
0385 
0386     return de;
0387 }
0388 
0389 struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir,
0390                      const struct f2fs_filename *fname,
0391                      struct page **res_page)
0392 {
0393     unsigned long npages = dir_blocks(dir);
0394     struct f2fs_dir_entry *de = NULL;
0395     unsigned int max_depth;
0396     unsigned int level;
0397 
0398     *res_page = NULL;
0399 
0400     if (f2fs_has_inline_dentry(dir)) {
0401         de = f2fs_find_in_inline_dir(dir, fname, res_page);
0402         goto out;
0403     }
0404 
0405     if (npages == 0)
0406         goto out;
0407 
0408     max_depth = F2FS_I(dir)->i_current_depth;
0409     if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {
0410         f2fs_warn(F2FS_I_SB(dir), "Corrupted max_depth of %lu: %u",
0411               dir->i_ino, max_depth);
0412         max_depth = MAX_DIR_HASH_DEPTH;
0413         f2fs_i_depth_write(dir, max_depth);
0414     }
0415 
0416     for (level = 0; level < max_depth; level++) {
0417         de = find_in_level(dir, level, fname, res_page);
0418         if (de || IS_ERR(*res_page))
0419             break;
0420     }
0421 out:
0422     /* This is to increase the speed of f2fs_create */
0423     if (!de)
0424         F2FS_I(dir)->task = current;
0425     return de;
0426 }
0427 
0428 /*
0429  * Find an entry in the specified directory with the wanted name.
0430  * It returns the page where the entry was found (as a parameter - res_page),
0431  * and the entry itself. Page is returned mapped and unlocked.
0432  * Entry is guaranteed to be valid.
0433  */
0434 struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
0435             const struct qstr *child, struct page **res_page)
0436 {
0437     struct f2fs_dir_entry *de = NULL;
0438     struct f2fs_filename fname;
0439     int err;
0440 
0441     err = f2fs_setup_filename(dir, child, 1, &fname);
0442     if (err) {
0443         if (err == -ENOENT)
0444             *res_page = NULL;
0445         else
0446             *res_page = ERR_PTR(err);
0447         return NULL;
0448     }
0449 
0450     de = __f2fs_find_entry(dir, &fname, res_page);
0451 
0452     f2fs_free_filename(&fname);
0453     return de;
0454 }
0455 
0456 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p)
0457 {
0458     return f2fs_find_entry(dir, &dotdot_name, p);
0459 }
0460 
0461 ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr,
0462                             struct page **page)
0463 {
0464     ino_t res = 0;
0465     struct f2fs_dir_entry *de;
0466 
0467     de = f2fs_find_entry(dir, qstr, page);
0468     if (de) {
0469         res = le32_to_cpu(de->ino);
0470         f2fs_put_page(*page, 0);
0471     }
0472 
0473     return res;
0474 }
0475 
0476 void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
0477         struct page *page, struct inode *inode)
0478 {
0479     enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA;
0480 
0481     lock_page(page);
0482     f2fs_wait_on_page_writeback(page, type, true, true);
0483     de->ino = cpu_to_le32(inode->i_ino);
0484     set_de_type(de, inode->i_mode);
0485     set_page_dirty(page);
0486 
0487     dir->i_mtime = dir->i_ctime = current_time(dir);
0488     f2fs_mark_inode_dirty_sync(dir, false);
0489     f2fs_put_page(page, 1);
0490 }
0491 
0492 static void init_dent_inode(struct inode *dir, struct inode *inode,
0493                 const struct f2fs_filename *fname,
0494                 struct page *ipage)
0495 {
0496     struct f2fs_inode *ri;
0497 
0498     if (!fname) /* tmpfile case? */
0499         return;
0500 
0501     f2fs_wait_on_page_writeback(ipage, NODE, true, true);
0502 
0503     /* copy name info. to this inode page */
0504     ri = F2FS_INODE(ipage);
0505     ri->i_namelen = cpu_to_le32(fname->disk_name.len);
0506     memcpy(ri->i_name, fname->disk_name.name, fname->disk_name.len);
0507     if (IS_ENCRYPTED(dir)) {
0508         file_set_enc_name(inode);
0509         /*
0510          * Roll-forward recovery doesn't have encryption keys available,
0511          * so it can't compute the dirhash for encrypted+casefolded
0512          * filenames.  Append it to i_name if possible.  Else, disable
0513          * roll-forward recovery of the dentry (i.e., make fsync'ing the
0514          * file force a checkpoint) by setting LOST_PINO.
0515          */
0516         if (IS_CASEFOLDED(dir)) {
0517             if (fname->disk_name.len + sizeof(f2fs_hash_t) <=
0518                 F2FS_NAME_LEN)
0519                 put_unaligned(fname->hash, (f2fs_hash_t *)
0520                     &ri->i_name[fname->disk_name.len]);
0521             else
0522                 file_lost_pino(inode);
0523         }
0524     }
0525     set_page_dirty(ipage);
0526 }
0527 
0528 void f2fs_do_make_empty_dir(struct inode *inode, struct inode *parent,
0529                     struct f2fs_dentry_ptr *d)
0530 {
0531     struct fscrypt_str dot = FSTR_INIT(".", 1);
0532     struct fscrypt_str dotdot = FSTR_INIT("..", 2);
0533 
0534     /* update dirent of "." */
0535     f2fs_update_dentry(inode->i_ino, inode->i_mode, d, &dot, 0, 0);
0536 
0537     /* update dirent of ".." */
0538     f2fs_update_dentry(parent->i_ino, parent->i_mode, d, &dotdot, 0, 1);
0539 }
0540 
0541 static int make_empty_dir(struct inode *inode,
0542         struct inode *parent, struct page *page)
0543 {
0544     struct page *dentry_page;
0545     struct f2fs_dentry_block *dentry_blk;
0546     struct f2fs_dentry_ptr d;
0547 
0548     if (f2fs_has_inline_dentry(inode))
0549         return f2fs_make_empty_inline_dir(inode, parent, page);
0550 
0551     dentry_page = f2fs_get_new_data_page(inode, page, 0, true);
0552     if (IS_ERR(dentry_page))
0553         return PTR_ERR(dentry_page);
0554 
0555     dentry_blk = page_address(dentry_page);
0556 
0557     make_dentry_ptr_block(NULL, &d, dentry_blk);
0558     f2fs_do_make_empty_dir(inode, parent, &d);
0559 
0560     set_page_dirty(dentry_page);
0561     f2fs_put_page(dentry_page, 1);
0562     return 0;
0563 }
0564 
0565 struct page *f2fs_init_inode_metadata(struct inode *inode, struct inode *dir,
0566             const struct f2fs_filename *fname, struct page *dpage)
0567 {
0568     struct page *page;
0569     int err;
0570 
0571     if (is_inode_flag_set(inode, FI_NEW_INODE)) {
0572         page = f2fs_new_inode_page(inode);
0573         if (IS_ERR(page))
0574             return page;
0575 
0576         if (S_ISDIR(inode->i_mode)) {
0577             /* in order to handle error case */
0578             get_page(page);
0579             err = make_empty_dir(inode, dir, page);
0580             if (err) {
0581                 lock_page(page);
0582                 goto put_error;
0583             }
0584             put_page(page);
0585         }
0586 
0587         err = f2fs_init_acl(inode, dir, page, dpage);
0588         if (err)
0589             goto put_error;
0590 
0591         err = f2fs_init_security(inode, dir,
0592                      fname ? fname->usr_fname : NULL, page);
0593         if (err)
0594             goto put_error;
0595 
0596         if (IS_ENCRYPTED(inode)) {
0597             err = fscrypt_set_context(inode, page);
0598             if (err)
0599                 goto put_error;
0600         }
0601     } else {
0602         page = f2fs_get_node_page(F2FS_I_SB(dir), inode->i_ino);
0603         if (IS_ERR(page))
0604             return page;
0605     }
0606 
0607     init_dent_inode(dir, inode, fname, page);
0608 
0609     /*
0610      * This file should be checkpointed during fsync.
0611      * We lost i_pino from now on.
0612      */
0613     if (is_inode_flag_set(inode, FI_INC_LINK)) {
0614         if (!S_ISDIR(inode->i_mode))
0615             file_lost_pino(inode);
0616         /*
0617          * If link the tmpfile to alias through linkat path,
0618          * we should remove this inode from orphan list.
0619          */
0620         if (inode->i_nlink == 0)
0621             f2fs_remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);
0622         f2fs_i_links_write(inode, true);
0623     }
0624     return page;
0625 
0626 put_error:
0627     clear_nlink(inode);
0628     f2fs_update_inode(inode, page);
0629     f2fs_put_page(page, 1);
0630     return ERR_PTR(err);
0631 }
0632 
0633 void f2fs_update_parent_metadata(struct inode *dir, struct inode *inode,
0634                         unsigned int current_depth)
0635 {
0636     if (inode && is_inode_flag_set(inode, FI_NEW_INODE)) {
0637         if (S_ISDIR(inode->i_mode))
0638             f2fs_i_links_write(dir, true);
0639         clear_inode_flag(inode, FI_NEW_INODE);
0640     }
0641     dir->i_mtime = dir->i_ctime = current_time(dir);
0642     f2fs_mark_inode_dirty_sync(dir, false);
0643 
0644     if (F2FS_I(dir)->i_current_depth != current_depth)
0645         f2fs_i_depth_write(dir, current_depth);
0646 
0647     if (inode && is_inode_flag_set(inode, FI_INC_LINK))
0648         clear_inode_flag(inode, FI_INC_LINK);
0649 }
0650 
0651 int f2fs_room_for_filename(const void *bitmap, int slots, int max_slots)
0652 {
0653     int bit_start = 0;
0654     int zero_start, zero_end;
0655 next:
0656     zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start);
0657     if (zero_start >= max_slots)
0658         return max_slots;
0659 
0660     zero_end = find_next_bit_le(bitmap, max_slots, zero_start);
0661     if (zero_end - zero_start >= slots)
0662         return zero_start;
0663 
0664     bit_start = zero_end + 1;
0665 
0666     if (zero_end + 1 >= max_slots)
0667         return max_slots;
0668     goto next;
0669 }
0670 
0671 bool f2fs_has_enough_room(struct inode *dir, struct page *ipage,
0672               const struct f2fs_filename *fname)
0673 {
0674     struct f2fs_dentry_ptr d;
0675     unsigned int bit_pos;
0676     int slots = GET_DENTRY_SLOTS(fname->disk_name.len);
0677 
0678     make_dentry_ptr_inline(dir, &d, inline_data_addr(dir, ipage));
0679 
0680     bit_pos = f2fs_room_for_filename(d.bitmap, slots, d.max);
0681 
0682     return bit_pos < d.max;
0683 }
0684 
0685 void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
0686             const struct fscrypt_str *name, f2fs_hash_t name_hash,
0687             unsigned int bit_pos)
0688 {
0689     struct f2fs_dir_entry *de;
0690     int slots = GET_DENTRY_SLOTS(name->len);
0691     int i;
0692 
0693     de = &d->dentry[bit_pos];
0694     de->hash_code = name_hash;
0695     de->name_len = cpu_to_le16(name->len);
0696     memcpy(d->filename[bit_pos], name->name, name->len);
0697     de->ino = cpu_to_le32(ino);
0698     set_de_type(de, mode);
0699     for (i = 0; i < slots; i++) {
0700         __set_bit_le(bit_pos + i, (void *)d->bitmap);
0701         /* avoid wrong garbage data for readdir */
0702         if (i)
0703             (de + i)->name_len = 0;
0704     }
0705 }
0706 
0707 int f2fs_add_regular_entry(struct inode *dir, const struct f2fs_filename *fname,
0708                struct inode *inode, nid_t ino, umode_t mode)
0709 {
0710     unsigned int bit_pos;
0711     unsigned int level;
0712     unsigned int current_depth;
0713     unsigned long bidx, block;
0714     unsigned int nbucket, nblock;
0715     struct page *dentry_page = NULL;
0716     struct f2fs_dentry_block *dentry_blk = NULL;
0717     struct f2fs_dentry_ptr d;
0718     struct page *page = NULL;
0719     int slots, err = 0;
0720 
0721     level = 0;
0722     slots = GET_DENTRY_SLOTS(fname->disk_name.len);
0723 
0724     current_depth = F2FS_I(dir)->i_current_depth;
0725     if (F2FS_I(dir)->chash == fname->hash) {
0726         level = F2FS_I(dir)->clevel;
0727         F2FS_I(dir)->chash = 0;
0728     }
0729 
0730 start:
0731     if (time_to_inject(F2FS_I_SB(dir), FAULT_DIR_DEPTH)) {
0732         f2fs_show_injection_info(F2FS_I_SB(dir), FAULT_DIR_DEPTH);
0733         return -ENOSPC;
0734     }
0735 
0736     if (unlikely(current_depth == MAX_DIR_HASH_DEPTH))
0737         return -ENOSPC;
0738 
0739     /* Increase the depth, if required */
0740     if (level == current_depth)
0741         ++current_depth;
0742 
0743     nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
0744     nblock = bucket_blocks(level);
0745 
0746     bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
0747                 (le32_to_cpu(fname->hash) % nbucket));
0748 
0749     for (block = bidx; block <= (bidx + nblock - 1); block++) {
0750         dentry_page = f2fs_get_new_data_page(dir, NULL, block, true);
0751         if (IS_ERR(dentry_page))
0752             return PTR_ERR(dentry_page);
0753 
0754         dentry_blk = page_address(dentry_page);
0755         bit_pos = f2fs_room_for_filename(&dentry_blk->dentry_bitmap,
0756                         slots, NR_DENTRY_IN_BLOCK);
0757         if (bit_pos < NR_DENTRY_IN_BLOCK)
0758             goto add_dentry;
0759 
0760         f2fs_put_page(dentry_page, 1);
0761     }
0762 
0763     /* Move to next level to find the empty slot for new dentry */
0764     ++level;
0765     goto start;
0766 add_dentry:
0767     f2fs_wait_on_page_writeback(dentry_page, DATA, true, true);
0768 
0769     if (inode) {
0770         f2fs_down_write(&F2FS_I(inode)->i_sem);
0771         page = f2fs_init_inode_metadata(inode, dir, fname, NULL);
0772         if (IS_ERR(page)) {
0773             err = PTR_ERR(page);
0774             goto fail;
0775         }
0776     }
0777 
0778     make_dentry_ptr_block(NULL, &d, dentry_blk);
0779     f2fs_update_dentry(ino, mode, &d, &fname->disk_name, fname->hash,
0780                bit_pos);
0781 
0782     set_page_dirty(dentry_page);
0783 
0784     if (inode) {
0785         f2fs_i_pino_write(inode, dir->i_ino);
0786 
0787         /* synchronize inode page's data from inode cache */
0788         if (is_inode_flag_set(inode, FI_NEW_INODE))
0789             f2fs_update_inode(inode, page);
0790 
0791         f2fs_put_page(page, 1);
0792     }
0793 
0794     f2fs_update_parent_metadata(dir, inode, current_depth);
0795 fail:
0796     if (inode)
0797         f2fs_up_write(&F2FS_I(inode)->i_sem);
0798 
0799     f2fs_put_page(dentry_page, 1);
0800 
0801     return err;
0802 }
0803 
0804 int f2fs_add_dentry(struct inode *dir, const struct f2fs_filename *fname,
0805             struct inode *inode, nid_t ino, umode_t mode)
0806 {
0807     int err = -EAGAIN;
0808 
0809     if (f2fs_has_inline_dentry(dir))
0810         err = f2fs_add_inline_entry(dir, fname, inode, ino, mode);
0811     if (err == -EAGAIN)
0812         err = f2fs_add_regular_entry(dir, fname, inode, ino, mode);
0813 
0814     f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
0815     return err;
0816 }
0817 
0818 /*
0819  * Caller should grab and release a rwsem by calling f2fs_lock_op() and
0820  * f2fs_unlock_op().
0821  */
0822 int f2fs_do_add_link(struct inode *dir, const struct qstr *name,
0823                 struct inode *inode, nid_t ino, umode_t mode)
0824 {
0825     struct f2fs_filename fname;
0826     struct page *page = NULL;
0827     struct f2fs_dir_entry *de = NULL;
0828     int err;
0829 
0830     err = f2fs_setup_filename(dir, name, 0, &fname);
0831     if (err)
0832         return err;
0833 
0834     /*
0835      * An immature stackable filesystem shows a race condition between lookup
0836      * and create. If we have same task when doing lookup and create, it's
0837      * definitely fine as expected by VFS normally. Otherwise, let's just
0838      * verify on-disk dentry one more time, which guarantees filesystem
0839      * consistency more.
0840      */
0841     if (current != F2FS_I(dir)->task) {
0842         de = __f2fs_find_entry(dir, &fname, &page);
0843         F2FS_I(dir)->task = NULL;
0844     }
0845     if (de) {
0846         f2fs_put_page(page, 0);
0847         err = -EEXIST;
0848     } else if (IS_ERR(page)) {
0849         err = PTR_ERR(page);
0850     } else {
0851         err = f2fs_add_dentry(dir, &fname, inode, ino, mode);
0852     }
0853     f2fs_free_filename(&fname);
0854     return err;
0855 }
0856 
0857 int f2fs_do_tmpfile(struct inode *inode, struct inode *dir)
0858 {
0859     struct page *page;
0860     int err = 0;
0861 
0862     f2fs_down_write(&F2FS_I(inode)->i_sem);
0863     page = f2fs_init_inode_metadata(inode, dir, NULL, NULL);
0864     if (IS_ERR(page)) {
0865         err = PTR_ERR(page);
0866         goto fail;
0867     }
0868     f2fs_put_page(page, 1);
0869 
0870     clear_inode_flag(inode, FI_NEW_INODE);
0871     f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
0872 fail:
0873     f2fs_up_write(&F2FS_I(inode)->i_sem);
0874     return err;
0875 }
0876 
0877 void f2fs_drop_nlink(struct inode *dir, struct inode *inode)
0878 {
0879     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0880 
0881     f2fs_down_write(&F2FS_I(inode)->i_sem);
0882 
0883     if (S_ISDIR(inode->i_mode))
0884         f2fs_i_links_write(dir, false);
0885     inode->i_ctime = current_time(inode);
0886 
0887     f2fs_i_links_write(inode, false);
0888     if (S_ISDIR(inode->i_mode)) {
0889         f2fs_i_links_write(inode, false);
0890         f2fs_i_size_write(inode, 0);
0891     }
0892     f2fs_up_write(&F2FS_I(inode)->i_sem);
0893 
0894     if (inode->i_nlink == 0)
0895         f2fs_add_orphan_inode(inode);
0896     else
0897         f2fs_release_orphan_inode(sbi);
0898 }
0899 
0900 /*
0901  * It only removes the dentry from the dentry page, corresponding name
0902  * entry in name page does not need to be touched during deletion.
0903  */
0904 void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
0905                     struct inode *dir, struct inode *inode)
0906 {
0907     struct  f2fs_dentry_block *dentry_blk;
0908     unsigned int bit_pos;
0909     int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
0910     int i;
0911 
0912     f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
0913 
0914     if (F2FS_OPTION(F2FS_I_SB(dir)).fsync_mode == FSYNC_MODE_STRICT)
0915         f2fs_add_ino_entry(F2FS_I_SB(dir), dir->i_ino, TRANS_DIR_INO);
0916 
0917     if (f2fs_has_inline_dentry(dir))
0918         return f2fs_delete_inline_entry(dentry, page, dir, inode);
0919 
0920     lock_page(page);
0921     f2fs_wait_on_page_writeback(page, DATA, true, true);
0922 
0923     dentry_blk = page_address(page);
0924     bit_pos = dentry - dentry_blk->dentry;
0925     for (i = 0; i < slots; i++)
0926         __clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
0927 
0928     /* Let's check and deallocate this dentry page */
0929     bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
0930             NR_DENTRY_IN_BLOCK,
0931             0);
0932     set_page_dirty(page);
0933 
0934     if (bit_pos == NR_DENTRY_IN_BLOCK &&
0935         !f2fs_truncate_hole(dir, page->index, page->index + 1)) {
0936         f2fs_clear_page_cache_dirty_tag(page);
0937         clear_page_dirty_for_io(page);
0938         ClearPageUptodate(page);
0939 
0940         clear_page_private_gcing(page);
0941 
0942         inode_dec_dirty_pages(dir);
0943         f2fs_remove_dirty_inode(dir);
0944 
0945         detach_page_private(page);
0946         set_page_private(page, 0);
0947     }
0948     f2fs_put_page(page, 1);
0949 
0950     dir->i_ctime = dir->i_mtime = current_time(dir);
0951     f2fs_mark_inode_dirty_sync(dir, false);
0952 
0953     if (inode)
0954         f2fs_drop_nlink(dir, inode);
0955 }
0956 
0957 bool f2fs_empty_dir(struct inode *dir)
0958 {
0959     unsigned long bidx;
0960     struct page *dentry_page;
0961     unsigned int bit_pos;
0962     struct f2fs_dentry_block *dentry_blk;
0963     unsigned long nblock = dir_blocks(dir);
0964 
0965     if (f2fs_has_inline_dentry(dir))
0966         return f2fs_empty_inline_dir(dir);
0967 
0968     for (bidx = 0; bidx < nblock; bidx++) {
0969         dentry_page = f2fs_get_lock_data_page(dir, bidx, false);
0970         if (IS_ERR(dentry_page)) {
0971             if (PTR_ERR(dentry_page) == -ENOENT)
0972                 continue;
0973             else
0974                 return false;
0975         }
0976 
0977         dentry_blk = page_address(dentry_page);
0978         if (bidx == 0)
0979             bit_pos = 2;
0980         else
0981             bit_pos = 0;
0982         bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
0983                         NR_DENTRY_IN_BLOCK,
0984                         bit_pos);
0985 
0986         f2fs_put_page(dentry_page, 1);
0987 
0988         if (bit_pos < NR_DENTRY_IN_BLOCK)
0989             return false;
0990     }
0991     return true;
0992 }
0993 
0994 int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
0995             unsigned int start_pos, struct fscrypt_str *fstr)
0996 {
0997     unsigned char d_type = DT_UNKNOWN;
0998     unsigned int bit_pos;
0999     struct f2fs_dir_entry *de = NULL;
1000     struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
1001     struct f2fs_sb_info *sbi = F2FS_I_SB(d->inode);
1002     struct blk_plug plug;
1003     bool readdir_ra = sbi->readdir_ra == 1;
1004     bool found_valid_dirent = false;
1005     int err = 0;
1006 
1007     bit_pos = ((unsigned long)ctx->pos % d->max);
1008 
1009     if (readdir_ra)
1010         blk_start_plug(&plug);
1011 
1012     while (bit_pos < d->max) {
1013         bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos);
1014         if (bit_pos >= d->max)
1015             break;
1016 
1017         de = &d->dentry[bit_pos];
1018         if (de->name_len == 0) {
1019             if (found_valid_dirent || !bit_pos) {
1020                 printk_ratelimited(
1021                     "%sF2FS-fs (%s): invalid namelen(0), ino:%u, run fsck to fix.",
1022                     KERN_WARNING, sbi->sb->s_id,
1023                     le32_to_cpu(de->ino));
1024                 set_sbi_flag(sbi, SBI_NEED_FSCK);
1025             }
1026             bit_pos++;
1027             ctx->pos = start_pos + bit_pos;
1028             continue;
1029         }
1030 
1031         d_type = f2fs_get_de_type(de);
1032 
1033         de_name.name = d->filename[bit_pos];
1034         de_name.len = le16_to_cpu(de->name_len);
1035 
1036         /* check memory boundary before moving forward */
1037         bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
1038         if (unlikely(bit_pos > d->max ||
1039                 le16_to_cpu(de->name_len) > F2FS_NAME_LEN)) {
1040             f2fs_warn(sbi, "%s: corrupted namelen=%d, run fsck to fix.",
1041                   __func__, le16_to_cpu(de->name_len));
1042             set_sbi_flag(sbi, SBI_NEED_FSCK);
1043             err = -EFSCORRUPTED;
1044             goto out;
1045         }
1046 
1047         if (IS_ENCRYPTED(d->inode)) {
1048             int save_len = fstr->len;
1049 
1050             err = fscrypt_fname_disk_to_usr(d->inode,
1051                         (u32)le32_to_cpu(de->hash_code),
1052                         0, &de_name, fstr);
1053             if (err)
1054                 goto out;
1055 
1056             de_name = *fstr;
1057             fstr->len = save_len;
1058         }
1059 
1060         if (!dir_emit(ctx, de_name.name, de_name.len,
1061                     le32_to_cpu(de->ino), d_type)) {
1062             err = 1;
1063             goto out;
1064         }
1065 
1066         if (readdir_ra)
1067             f2fs_ra_node_page(sbi, le32_to_cpu(de->ino));
1068 
1069         ctx->pos = start_pos + bit_pos;
1070         found_valid_dirent = true;
1071     }
1072 out:
1073     if (readdir_ra)
1074         blk_finish_plug(&plug);
1075     return err;
1076 }
1077 
1078 static int f2fs_readdir(struct file *file, struct dir_context *ctx)
1079 {
1080     struct inode *inode = file_inode(file);
1081     unsigned long npages = dir_blocks(inode);
1082     struct f2fs_dentry_block *dentry_blk = NULL;
1083     struct page *dentry_page = NULL;
1084     struct file_ra_state *ra = &file->f_ra;
1085     loff_t start_pos = ctx->pos;
1086     unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
1087     struct f2fs_dentry_ptr d;
1088     struct fscrypt_str fstr = FSTR_INIT(NULL, 0);
1089     int err = 0;
1090 
1091     if (IS_ENCRYPTED(inode)) {
1092         err = fscrypt_prepare_readdir(inode);
1093         if (err)
1094             goto out;
1095 
1096         err = fscrypt_fname_alloc_buffer(F2FS_NAME_LEN, &fstr);
1097         if (err < 0)
1098             goto out;
1099     }
1100 
1101     if (f2fs_has_inline_dentry(inode)) {
1102         err = f2fs_read_inline_dir(file, ctx, &fstr);
1103         goto out_free;
1104     }
1105 
1106     for (; n < npages; n++, ctx->pos = n * NR_DENTRY_IN_BLOCK) {
1107 
1108         /* allow readdir() to be interrupted */
1109         if (fatal_signal_pending(current)) {
1110             err = -ERESTARTSYS;
1111             goto out_free;
1112         }
1113         cond_resched();
1114 
1115         /* readahead for multi pages of dir */
1116         if (npages - n > 1 && !ra_has_index(ra, n))
1117             page_cache_sync_readahead(inode->i_mapping, ra, file, n,
1118                 min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES));
1119 
1120         dentry_page = f2fs_find_data_page(inode, n);
1121         if (IS_ERR(dentry_page)) {
1122             err = PTR_ERR(dentry_page);
1123             if (err == -ENOENT) {
1124                 err = 0;
1125                 continue;
1126             } else {
1127                 goto out_free;
1128             }
1129         }
1130 
1131         dentry_blk = page_address(dentry_page);
1132 
1133         make_dentry_ptr_block(inode, &d, dentry_blk);
1134 
1135         err = f2fs_fill_dentries(ctx, &d,
1136                 n * NR_DENTRY_IN_BLOCK, &fstr);
1137         if (err) {
1138             f2fs_put_page(dentry_page, 0);
1139             break;
1140         }
1141 
1142         f2fs_put_page(dentry_page, 0);
1143     }
1144 out_free:
1145     fscrypt_fname_free_buffer(&fstr);
1146 out:
1147     trace_f2fs_readdir(inode, start_pos, ctx->pos, err);
1148     return err < 0 ? err : 0;
1149 }
1150 
1151 const struct file_operations f2fs_dir_operations = {
1152     .llseek     = generic_file_llseek,
1153     .read       = generic_read_dir,
1154     .iterate_shared = f2fs_readdir,
1155     .fsync      = f2fs_sync_file,
1156     .unlocked_ioctl = f2fs_ioctl,
1157 #ifdef CONFIG_COMPAT
1158     .compat_ioctl   = f2fs_compat_ioctl,
1159 #endif
1160 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!