LCOV - code coverage report
Current view: top level - fs/f2fs - namei.c (source / functions) Hit Total Coverage
Test: Real Lines: 0 539 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 22 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/namei.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/pagemap.h>
      11                 :            : #include <linux/sched.h>
      12                 :            : #include <linux/ctype.h>
      13                 :            : #include <linux/random.h>
      14                 :            : #include <linux/dcache.h>
      15                 :            : #include <linux/namei.h>
      16                 :            : #include <linux/quotaops.h>
      17                 :            : 
      18                 :            : #include "f2fs.h"
      19                 :            : #include "node.h"
      20                 :            : #include "segment.h"
      21                 :            : #include "xattr.h"
      22                 :            : #include "acl.h"
      23                 :            : #include <trace/events/f2fs.h>
      24                 :            : 
      25                 :          0 : static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
      26                 :            : {
      27                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
      28                 :            :         nid_t ino;
      29                 :            :         struct inode *inode;
      30                 :            :         bool nid_free = false;
      31                 :            :         int xattr_size = 0;
      32                 :            :         int err;
      33                 :            : 
      34                 :          0 :         inode = new_inode(dir->i_sb);
      35                 :          0 :         if (!inode)
      36                 :            :                 return ERR_PTR(-ENOMEM);
      37                 :            : 
      38                 :            :         f2fs_lock_op(sbi);
      39                 :          0 :         if (!f2fs_alloc_nid(sbi, &ino)) {
      40                 :            :                 f2fs_unlock_op(sbi);
      41                 :            :                 err = -ENOSPC;
      42                 :          0 :                 goto fail;
      43                 :            :         }
      44                 :            :         f2fs_unlock_op(sbi);
      45                 :            : 
      46                 :            :         nid_free = true;
      47                 :            : 
      48                 :          0 :         inode_init_owner(inode, dir, mode);
      49                 :            : 
      50                 :          0 :         inode->i_ino = ino;
      51                 :          0 :         inode->i_blocks = 0;
      52                 :          0 :         inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
      53                 :          0 :         F2FS_I(inode)->i_crtime = inode->i_mtime;
      54                 :          0 :         inode->i_generation = prandom_u32();
      55                 :            : 
      56                 :          0 :         if (S_ISDIR(inode->i_mode))
      57                 :          0 :                 F2FS_I(inode)->i_current_depth = 1;
      58                 :            : 
      59                 :          0 :         err = insert_inode_locked(inode);
      60                 :          0 :         if (err) {
      61                 :            :                 err = -EINVAL;
      62                 :            :                 goto fail;
      63                 :            :         }
      64                 :            : 
      65                 :          0 :         if (f2fs_sb_has_project_quota(sbi) &&
      66                 :          0 :                 (F2FS_I(dir)->i_flags & F2FS_PROJINHERIT_FL))
      67                 :          0 :                 F2FS_I(inode)->i_projid = F2FS_I(dir)->i_projid;
      68                 :            :         else
      69                 :          0 :                 F2FS_I(inode)->i_projid = make_kprojid(&init_user_ns,
      70                 :            :                                                         F2FS_DEF_PROJID);
      71                 :            : 
      72                 :          0 :         err = dquot_initialize(inode);
      73                 :          0 :         if (err)
      74                 :            :                 goto fail_drop;
      75                 :            : 
      76                 :          0 :         set_inode_flag(inode, FI_NEW_INODE);
      77                 :            : 
      78                 :            :         /* If the directory encrypted, then we should encrypt the inode. */
      79                 :          0 :         if ((IS_ENCRYPTED(dir) || DUMMY_ENCRYPTION_ENABLED(sbi)) &&
      80                 :            :                                 f2fs_may_encrypt(inode))
      81                 :          0 :                 f2fs_set_encrypted_inode(inode);
      82                 :            : 
      83                 :          0 :         if (f2fs_sb_has_extra_attr(sbi)) {
      84                 :          0 :                 set_inode_flag(inode, FI_EXTRA_ATTR);
      85                 :          0 :                 F2FS_I(inode)->i_extra_isize = F2FS_TOTAL_EXTRA_ATTR_SIZE;
      86                 :            :         }
      87                 :            : 
      88                 :          0 :         if (test_opt(sbi, INLINE_XATTR))
      89                 :          0 :                 set_inode_flag(inode, FI_INLINE_XATTR);
      90                 :            : 
      91                 :          0 :         if (test_opt(sbi, INLINE_DATA) && f2fs_may_inline_data(inode))
      92                 :          0 :                 set_inode_flag(inode, FI_INLINE_DATA);
      93                 :          0 :         if (f2fs_may_inline_dentry(inode))
      94                 :          0 :                 set_inode_flag(inode, FI_INLINE_DENTRY);
      95                 :            : 
      96                 :          0 :         if (f2fs_sb_has_flexible_inline_xattr(sbi)) {
      97                 :          0 :                 f2fs_bug_on(sbi, !f2fs_has_extra_attr(inode));
      98                 :          0 :                 if (f2fs_has_inline_xattr(inode))
      99                 :          0 :                         xattr_size = F2FS_OPTION(sbi).inline_xattr_size;
     100                 :            :                 /* Otherwise, will be 0 */
     101                 :          0 :         } else if (f2fs_has_inline_xattr(inode) ||
     102                 :            :                                 f2fs_has_inline_dentry(inode)) {
     103                 :            :                 xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
     104                 :            :         }
     105                 :          0 :         F2FS_I(inode)->i_inline_xattr_size = xattr_size;
     106                 :            : 
     107                 :          0 :         f2fs_init_extent_tree(inode, NULL);
     108                 :            : 
     109                 :          0 :         stat_inc_inline_xattr(inode);
     110                 :          0 :         stat_inc_inline_inode(inode);
     111                 :          0 :         stat_inc_inline_dir(inode);
     112                 :            : 
     113                 :          0 :         F2FS_I(inode)->i_flags =
     114                 :          0 :                 f2fs_mask_flags(mode, F2FS_I(dir)->i_flags & F2FS_FL_INHERITED);
     115                 :            : 
     116                 :          0 :         if (S_ISDIR(inode->i_mode))
     117                 :          0 :                 F2FS_I(inode)->i_flags |= F2FS_INDEX_FL;
     118                 :            : 
     119                 :          0 :         if (F2FS_I(inode)->i_flags & F2FS_PROJINHERIT_FL)
     120                 :          0 :                 set_inode_flag(inode, FI_PROJ_INHERIT);
     121                 :            : 
     122                 :          0 :         f2fs_set_inode_flags(inode);
     123                 :            : 
     124                 :          0 :         trace_f2fs_new_inode(inode, 0);
     125                 :          0 :         return inode;
     126                 :            : 
     127                 :            : fail:
     128                 :          0 :         trace_f2fs_new_inode(inode, err);
     129                 :          0 :         make_bad_inode(inode);
     130                 :          0 :         if (nid_free)
     131                 :          0 :                 set_inode_flag(inode, FI_FREE_NID);
     132                 :          0 :         iput(inode);
     133                 :          0 :         return ERR_PTR(err);
     134                 :            : fail_drop:
     135                 :          0 :         trace_f2fs_new_inode(inode, err);
     136                 :          0 :         dquot_drop(inode);
     137                 :          0 :         inode->i_flags |= S_NOQUOTA;
     138                 :            :         if (nid_free)
     139                 :          0 :                 set_inode_flag(inode, FI_FREE_NID);
     140                 :          0 :         clear_nlink(inode);
     141                 :          0 :         unlock_new_inode(inode);
     142                 :          0 :         iput(inode);
     143                 :          0 :         return ERR_PTR(err);
     144                 :            : }
     145                 :            : 
     146                 :          0 : static inline int is_extension_exist(const unsigned char *s, const char *sub)
     147                 :            : {
     148                 :          0 :         size_t slen = strlen(s);
     149                 :          0 :         size_t sublen = strlen(sub);
     150                 :            :         int i;
     151                 :            : 
     152                 :            :         /*
     153                 :            :          * filename format of multimedia file should be defined as:
     154                 :            :          * "filename + '.' + extension + (optional: '.' + temp extension)".
     155                 :            :          */
     156                 :          0 :         if (slen < sublen + 2)
     157                 :            :                 return 0;
     158                 :            : 
     159                 :          0 :         for (i = 1; i < slen - sublen; i++) {
     160                 :          0 :                 if (s[i] != '.')
     161                 :          0 :                         continue;
     162                 :          0 :                 if (!strncasecmp(s + i + 1, sub, sublen))
     163                 :            :                         return 1;
     164                 :            :         }
     165                 :            : 
     166                 :            :         return 0;
     167                 :            : }
     168                 :            : 
     169                 :            : /*
     170                 :            :  * Set multimedia files as cold files for hot/cold data separation
     171                 :            :  */
     172                 :          0 : static inline void set_file_temperature(struct f2fs_sb_info *sbi, struct inode *inode,
     173                 :            :                 const unsigned char *name)
     174                 :            : {
     175                 :          0 :         __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
     176                 :            :         int i, cold_count, hot_count;
     177                 :            : 
     178                 :          0 :         down_read(&sbi->sb_lock);
     179                 :            : 
     180                 :          0 :         cold_count = le32_to_cpu(sbi->raw_super->extension_count);
     181                 :          0 :         hot_count = sbi->raw_super->hot_ext_count;
     182                 :            : 
     183                 :          0 :         for (i = 0; i < cold_count + hot_count; i++) {
     184                 :          0 :                 if (is_extension_exist(name, extlist[i]))
     185                 :            :                         break;
     186                 :            :         }
     187                 :            : 
     188                 :          0 :         up_read(&sbi->sb_lock);
     189                 :            : 
     190                 :          0 :         if (i == cold_count + hot_count)
     191                 :          0 :                 return;
     192                 :            : 
     193                 :          0 :         if (i < cold_count)
     194                 :            :                 file_set_cold(inode);
     195                 :            :         else
     196                 :            :                 file_set_hot(inode);
     197                 :            : }
     198                 :            : 
     199                 :          0 : int f2fs_update_extension_list(struct f2fs_sb_info *sbi, const char *name,
     200                 :            :                                                         bool hot, bool set)
     201                 :            : {
     202                 :          0 :         __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
     203                 :          0 :         int cold_count = le32_to_cpu(sbi->raw_super->extension_count);
     204                 :          0 :         int hot_count = sbi->raw_super->hot_ext_count;
     205                 :          0 :         int total_count = cold_count + hot_count;
     206                 :            :         int start, count;
     207                 :            :         int i;
     208                 :            : 
     209                 :          0 :         if (set) {
     210                 :          0 :                 if (total_count == F2FS_MAX_EXTENSION)
     211                 :            :                         return -EINVAL;
     212                 :            :         } else {
     213                 :          0 :                 if (!hot && !cold_count)
     214                 :            :                         return -EINVAL;
     215                 :          0 :                 if (hot && !hot_count)
     216                 :            :                         return -EINVAL;
     217                 :            :         }
     218                 :            : 
     219                 :          0 :         if (hot) {
     220                 :            :                 start = cold_count;
     221                 :            :                 count = total_count;
     222                 :            :         } else {
     223                 :            :                 start = 0;
     224                 :            :                 count = cold_count;
     225                 :            :         }
     226                 :            : 
     227                 :          0 :         for (i = start; i < count; i++) {
     228                 :          0 :                 if (strcmp(name, extlist[i]))
     229                 :          0 :                         continue;
     230                 :            : 
     231                 :          0 :                 if (set)
     232                 :            :                         return -EINVAL;
     233                 :            : 
     234                 :          0 :                 memcpy(extlist[i], extlist[i + 1],
     235                 :          0 :                                 F2FS_EXTENSION_LEN * (total_count - i - 1));
     236                 :          0 :                 memset(extlist[total_count - 1], 0, F2FS_EXTENSION_LEN);
     237                 :          0 :                 if (hot)
     238                 :          0 :                         sbi->raw_super->hot_ext_count = hot_count - 1;
     239                 :            :                 else
     240                 :          0 :                         sbi->raw_super->extension_count =
     241                 :          0 :                                                 cpu_to_le32(cold_count - 1);
     242                 :            :                 return 0;
     243                 :            :         }
     244                 :            : 
     245                 :          0 :         if (!set)
     246                 :            :                 return -EINVAL;
     247                 :            : 
     248                 :          0 :         if (hot) {
     249                 :          0 :                 memcpy(extlist[count], name, strlen(name));
     250                 :          0 :                 sbi->raw_super->hot_ext_count = hot_count + 1;
     251                 :            :         } else {
     252                 :            :                 char buf[F2FS_MAX_EXTENSION][F2FS_EXTENSION_LEN];
     253                 :            : 
     254                 :          0 :                 memcpy(buf, &extlist[cold_count],
     255                 :          0 :                                 F2FS_EXTENSION_LEN * hot_count);
     256                 :          0 :                 memset(extlist[cold_count], 0, F2FS_EXTENSION_LEN);
     257                 :          0 :                 memcpy(extlist[cold_count], name, strlen(name));
     258                 :          0 :                 memcpy(&extlist[cold_count + 1], buf,
     259                 :            :                                 F2FS_EXTENSION_LEN * hot_count);
     260                 :          0 :                 sbi->raw_super->extension_count = cpu_to_le32(cold_count + 1);
     261                 :            :         }
     262                 :            :         return 0;
     263                 :            : }
     264                 :            : 
     265                 :          0 : static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
     266                 :            :                                                 bool excl)
     267                 :            : {
     268                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     269                 :            :         struct inode *inode;
     270                 :            :         nid_t ino = 0;
     271                 :            :         int err;
     272                 :            : 
     273                 :          0 :         if (unlikely(f2fs_cp_error(sbi)))
     274                 :            :                 return -EIO;
     275                 :          0 :         if (!f2fs_is_checkpoint_ready(sbi))
     276                 :            :                 return -ENOSPC;
     277                 :            : 
     278                 :          0 :         err = dquot_initialize(dir);
     279                 :          0 :         if (err)
     280                 :            :                 return err;
     281                 :            : 
     282                 :          0 :         inode = f2fs_new_inode(dir, mode);
     283                 :          0 :         if (IS_ERR(inode))
     284                 :          0 :                 return PTR_ERR(inode);
     285                 :            : 
     286                 :          0 :         if (!test_opt(sbi, DISABLE_EXT_IDENTIFY))
     287                 :          0 :                 set_file_temperature(sbi, inode, dentry->d_name.name);
     288                 :            : 
     289                 :          0 :         inode->i_op = &f2fs_file_inode_operations;
     290                 :          0 :         inode->i_fop = &f2fs_file_operations;
     291                 :          0 :         inode->i_mapping->a_ops = &f2fs_dblock_aops;
     292                 :          0 :         ino = inode->i_ino;
     293                 :            : 
     294                 :            :         f2fs_lock_op(sbi);
     295                 :          0 :         err = f2fs_add_link(dentry, inode);
     296                 :          0 :         if (err)
     297                 :            :                 goto out;
     298                 :            :         f2fs_unlock_op(sbi);
     299                 :            : 
     300                 :          0 :         f2fs_alloc_nid_done(sbi, ino);
     301                 :            : 
     302                 :          0 :         d_instantiate_new(dentry, inode);
     303                 :            : 
     304                 :          0 :         if (IS_DIRSYNC(dir))
     305                 :          0 :                 f2fs_sync_fs(sbi->sb, 1);
     306                 :            : 
     307                 :          0 :         f2fs_balance_fs(sbi, true);
     308                 :          0 :         return 0;
     309                 :            : out:
     310                 :          0 :         f2fs_handle_failed_inode(inode);
     311                 :          0 :         return err;
     312                 :            : }
     313                 :            : 
     314                 :          0 : static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
     315                 :            :                 struct dentry *dentry)
     316                 :            : {
     317                 :            :         struct inode *inode = d_inode(old_dentry);
     318                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     319                 :            :         int err;
     320                 :            : 
     321                 :          0 :         if (unlikely(f2fs_cp_error(sbi)))
     322                 :            :                 return -EIO;
     323                 :          0 :         if (!f2fs_is_checkpoint_ready(sbi))
     324                 :            :                 return -ENOSPC;
     325                 :            : 
     326                 :            :         err = fscrypt_prepare_link(old_dentry, dir, dentry);
     327                 :          0 :         if (err)
     328                 :            :                 return err;
     329                 :            : 
     330                 :          0 :         if (is_inode_flag_set(dir, FI_PROJ_INHERIT) &&
     331                 :            :                         (!projid_eq(F2FS_I(dir)->i_projid,
     332                 :          0 :                         F2FS_I(old_dentry->d_inode)->i_projid)))
     333                 :            :                 return -EXDEV;
     334                 :            : 
     335                 :          0 :         err = dquot_initialize(dir);
     336                 :          0 :         if (err)
     337                 :            :                 return err;
     338                 :            : 
     339                 :          0 :         f2fs_balance_fs(sbi, true);
     340                 :            : 
     341                 :          0 :         inode->i_ctime = current_time(inode);
     342                 :          0 :         ihold(inode);
     343                 :            : 
     344                 :          0 :         set_inode_flag(inode, FI_INC_LINK);
     345                 :            :         f2fs_lock_op(sbi);
     346                 :          0 :         err = f2fs_add_link(dentry, inode);
     347                 :          0 :         if (err)
     348                 :            :                 goto out;
     349                 :            :         f2fs_unlock_op(sbi);
     350                 :            : 
     351                 :          0 :         d_instantiate(dentry, inode);
     352                 :            : 
     353                 :          0 :         if (IS_DIRSYNC(dir))
     354                 :          0 :                 f2fs_sync_fs(sbi->sb, 1);
     355                 :            :         return 0;
     356                 :            : out:
     357                 :          0 :         clear_inode_flag(inode, FI_INC_LINK);
     358                 :          0 :         iput(inode);
     359                 :            :         f2fs_unlock_op(sbi);
     360                 :          0 :         return err;
     361                 :            : }
     362                 :            : 
     363                 :          0 : struct dentry *f2fs_get_parent(struct dentry *child)
     364                 :            : {
     365                 :          0 :         struct qstr dotdot = QSTR_INIT("..", 2);
     366                 :            :         struct page *page;
     367                 :          0 :         unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot, &page);
     368                 :          0 :         if (!ino) {
     369                 :          0 :                 if (IS_ERR(page))
     370                 :          0 :                         return ERR_CAST(page);
     371                 :            :                 return ERR_PTR(-ENOENT);
     372                 :            :         }
     373                 :          0 :         return d_obtain_alias(f2fs_iget(child->d_sb, ino));
     374                 :            : }
     375                 :            : 
     376                 :          0 : static int __recover_dot_dentries(struct inode *dir, nid_t pino)
     377                 :            : {
     378                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     379                 :          0 :         struct qstr dot = QSTR_INIT(".", 1);
     380                 :          0 :         struct qstr dotdot = QSTR_INIT("..", 2);
     381                 :            :         struct f2fs_dir_entry *de;
     382                 :            :         struct page *page;
     383                 :            :         int err = 0;
     384                 :            : 
     385                 :          0 :         if (f2fs_readonly(sbi->sb)) {
     386                 :          0 :                 f2fs_info(sbi, "skip recovering inline_dots inode (ino:%lu, pino:%u) in readonly mountpoint",
     387                 :            :                           dir->i_ino, pino);
     388                 :          0 :                 return 0;
     389                 :            :         }
     390                 :            : 
     391                 :          0 :         err = dquot_initialize(dir);
     392                 :          0 :         if (err)
     393                 :            :                 return err;
     394                 :            : 
     395                 :          0 :         f2fs_balance_fs(sbi, true);
     396                 :            : 
     397                 :            :         f2fs_lock_op(sbi);
     398                 :            : 
     399                 :          0 :         de = f2fs_find_entry(dir, &dot, &page);
     400                 :          0 :         if (de) {
     401                 :          0 :                 f2fs_put_page(page, 0);
     402                 :          0 :         } else if (IS_ERR(page)) {
     403                 :            :                 err = PTR_ERR(page);
     404                 :          0 :                 goto out;
     405                 :            :         } else {
     406                 :          0 :                 err = f2fs_do_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
     407                 :          0 :                 if (err)
     408                 :            :                         goto out;
     409                 :            :         }
     410                 :            : 
     411                 :          0 :         de = f2fs_find_entry(dir, &dotdot, &page);
     412                 :          0 :         if (de)
     413                 :          0 :                 f2fs_put_page(page, 0);
     414                 :          0 :         else if (IS_ERR(page))
     415                 :            :                 err = PTR_ERR(page);
     416                 :            :         else
     417                 :          0 :                 err = f2fs_do_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
     418                 :            : out:
     419                 :          0 :         if (!err)
     420                 :          0 :                 clear_inode_flag(dir, FI_INLINE_DOTS);
     421                 :            : 
     422                 :            :         f2fs_unlock_op(sbi);
     423                 :          0 :         return err;
     424                 :            : }
     425                 :            : 
     426                 :          0 : static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
     427                 :            :                 unsigned int flags)
     428                 :            : {
     429                 :            :         struct inode *inode = NULL;
     430                 :            :         struct f2fs_dir_entry *de;
     431                 :            :         struct page *page;
     432                 :            :         struct dentry *new;
     433                 :            :         nid_t ino = -1;
     434                 :            :         int err = 0;
     435                 :          0 :         unsigned int root_ino = F2FS_ROOT_INO(F2FS_I_SB(dir));
     436                 :            :         struct fscrypt_name fname;
     437                 :            : 
     438                 :          0 :         trace_f2fs_lookup_start(dir, dentry, flags);
     439                 :            : 
     440                 :          0 :         if (dentry->d_name.len > F2FS_NAME_LEN) {
     441                 :            :                 err = -ENAMETOOLONG;
     442                 :            :                 goto out;
     443                 :            :         }
     444                 :            : 
     445                 :          0 :         err = fscrypt_prepare_lookup(dir, dentry, &fname);
     446                 :          0 :         if (err == -ENOENT)
     447                 :            :                 goto out_splice;
     448                 :          0 :         if (err)
     449                 :            :                 goto out;
     450                 :          0 :         de = __f2fs_find_entry(dir, &fname, &page);
     451                 :            :         fscrypt_free_filename(&fname);
     452                 :            : 
     453                 :          0 :         if (!de) {
     454                 :          0 :                 if (IS_ERR(page)) {
     455                 :            :                         err = PTR_ERR(page);
     456                 :          0 :                         goto out;
     457                 :            :                 }
     458                 :            :                 goto out_splice;
     459                 :            :         }
     460                 :            : 
     461                 :          0 :         ino = le32_to_cpu(de->ino);
     462                 :          0 :         f2fs_put_page(page, 0);
     463                 :            : 
     464                 :          0 :         inode = f2fs_iget(dir->i_sb, ino);
     465                 :          0 :         if (IS_ERR(inode)) {
     466                 :            :                 err = PTR_ERR(inode);
     467                 :          0 :                 goto out;
     468                 :            :         }
     469                 :            : 
     470                 :          0 :         if ((dir->i_ino == root_ino) && f2fs_has_inline_dots(dir)) {
     471                 :          0 :                 err = __recover_dot_dentries(dir, root_ino);
     472                 :          0 :                 if (err)
     473                 :            :                         goto out_iput;
     474                 :            :         }
     475                 :            : 
     476                 :          0 :         if (f2fs_has_inline_dots(inode)) {
     477                 :          0 :                 err = __recover_dot_dentries(inode, dir->i_ino);
     478                 :          0 :                 if (err)
     479                 :            :                         goto out_iput;
     480                 :            :         }
     481                 :          0 :         if (IS_ENCRYPTED(dir) &&
     482                 :          0 :             (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
     483                 :          0 :             !fscrypt_has_permitted_context(dir, inode)) {
     484                 :          0 :                 f2fs_warn(F2FS_I_SB(inode), "Inconsistent encryption contexts: %lu/%lu",
     485                 :            :                           dir->i_ino, inode->i_ino);
     486                 :            :                 err = -EPERM;
     487                 :          0 :                 goto out_iput;
     488                 :            :         }
     489                 :            : out_splice:
     490                 :            : #ifdef CONFIG_UNICODE
     491                 :            :         if (!inode && IS_CASEFOLDED(dir)) {
     492                 :            :                 /* Eventually we want to call d_add_ci(dentry, NULL)
     493                 :            :                  * for negative dentries in the encoding case as
     494                 :            :                  * well.  For now, prevent the negative dentry
     495                 :            :                  * from being cached.
     496                 :            :                  */
     497                 :            :                 trace_f2fs_lookup_end(dir, dentry, ino, err);
     498                 :            :                 return NULL;
     499                 :            :         }
     500                 :            : #endif
     501                 :          0 :         new = d_splice_alias(inode, dentry);
     502                 :            :         err = PTR_ERR_OR_ZERO(new);
     503                 :          0 :         trace_f2fs_lookup_end(dir, dentry, ino, err);
     504                 :          0 :         return new;
     505                 :            : out_iput:
     506                 :          0 :         iput(inode);
     507                 :            : out:
     508                 :          0 :         trace_f2fs_lookup_end(dir, dentry, ino, err);
     509                 :          0 :         return ERR_PTR(err);
     510                 :            : }
     511                 :            : 
     512                 :          0 : static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
     513                 :            : {
     514                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     515                 :            :         struct inode *inode = d_inode(dentry);
     516                 :            :         struct f2fs_dir_entry *de;
     517                 :            :         struct page *page;
     518                 :            :         int err = -ENOENT;
     519                 :            : 
     520                 :          0 :         trace_f2fs_unlink_enter(dir, dentry);
     521                 :            : 
     522                 :          0 :         if (unlikely(f2fs_cp_error(sbi)))
     523                 :            :                 return -EIO;
     524                 :            : 
     525                 :          0 :         err = dquot_initialize(dir);
     526                 :          0 :         if (err)
     527                 :            :                 return err;
     528                 :          0 :         err = dquot_initialize(inode);
     529                 :          0 :         if (err)
     530                 :            :                 return err;
     531                 :            : 
     532                 :          0 :         de = f2fs_find_entry(dir, &dentry->d_name, &page);
     533                 :          0 :         if (!de) {
     534                 :          0 :                 if (IS_ERR(page))
     535                 :            :                         err = PTR_ERR(page);
     536                 :            :                 goto fail;
     537                 :            :         }
     538                 :            : 
     539                 :          0 :         f2fs_balance_fs(sbi, true);
     540                 :            : 
     541                 :            :         f2fs_lock_op(sbi);
     542                 :          0 :         err = f2fs_acquire_orphan_inode(sbi);
     543                 :          0 :         if (err) {
     544                 :            :                 f2fs_unlock_op(sbi);
     545                 :          0 :                 f2fs_put_page(page, 0);
     546                 :          0 :                 goto fail;
     547                 :            :         }
     548                 :          0 :         f2fs_delete_entry(de, page, dir, inode);
     549                 :            : #ifdef CONFIG_UNICODE
     550                 :            :         /* VFS negative dentries are incompatible with Encoding and
     551                 :            :          * Case-insensitiveness. Eventually we'll want avoid
     552                 :            :          * invalidating the dentries here, alongside with returning the
     553                 :            :          * negative dentries at f2fs_lookup(), when it is  better
     554                 :            :          * supported by the VFS for the CI case.
     555                 :            :          */
     556                 :            :         if (IS_CASEFOLDED(dir))
     557                 :            :                 d_invalidate(dentry);
     558                 :            : #endif
     559                 :            :         f2fs_unlock_op(sbi);
     560                 :            : 
     561                 :          0 :         if (IS_DIRSYNC(dir))
     562                 :          0 :                 f2fs_sync_fs(sbi->sb, 1);
     563                 :            : fail:
     564                 :          0 :         trace_f2fs_unlink_exit(inode, err);
     565                 :          0 :         return err;
     566                 :            : }
     567                 :            : 
     568                 :          0 : static const char *f2fs_get_link(struct dentry *dentry,
     569                 :            :                                  struct inode *inode,
     570                 :            :                                  struct delayed_call *done)
     571                 :            : {
     572                 :          0 :         const char *link = page_get_link(dentry, inode, done);
     573                 :          0 :         if (!IS_ERR(link) && !*link) {
     574                 :            :                 /* this is broken symlink case */
     575                 :            :                 do_delayed_call(done);
     576                 :            :                 clear_delayed_call(done);
     577                 :            :                 link = ERR_PTR(-ENOENT);
     578                 :            :         }
     579                 :          0 :         return link;
     580                 :            : }
     581                 :            : 
     582                 :          0 : static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
     583                 :            :                                         const char *symname)
     584                 :            : {
     585                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     586                 :            :         struct inode *inode;
     587                 :          0 :         size_t len = strlen(symname);
     588                 :            :         struct fscrypt_str disk_link;
     589                 :            :         int err;
     590                 :            : 
     591                 :          0 :         if (unlikely(f2fs_cp_error(sbi)))
     592                 :            :                 return -EIO;
     593                 :          0 :         if (!f2fs_is_checkpoint_ready(sbi))
     594                 :            :                 return -ENOSPC;
     595                 :            : 
     596                 :          0 :         err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
     597                 :            :                                       &disk_link);
     598                 :          0 :         if (err)
     599                 :            :                 return err;
     600                 :            : 
     601                 :          0 :         err = dquot_initialize(dir);
     602                 :          0 :         if (err)
     603                 :            :                 return err;
     604                 :            : 
     605                 :          0 :         inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO);
     606                 :          0 :         if (IS_ERR(inode))
     607                 :          0 :                 return PTR_ERR(inode);
     608                 :            : 
     609                 :          0 :         if (IS_ENCRYPTED(inode))
     610                 :          0 :                 inode->i_op = &f2fs_encrypted_symlink_inode_operations;
     611                 :            :         else
     612                 :          0 :                 inode->i_op = &f2fs_symlink_inode_operations;
     613                 :          0 :         inode_nohighmem(inode);
     614                 :          0 :         inode->i_mapping->a_ops = &f2fs_dblock_aops;
     615                 :            : 
     616                 :            :         f2fs_lock_op(sbi);
     617                 :          0 :         err = f2fs_add_link(dentry, inode);
     618                 :          0 :         if (err)
     619                 :            :                 goto out_f2fs_handle_failed_inode;
     620                 :            :         f2fs_unlock_op(sbi);
     621                 :          0 :         f2fs_alloc_nid_done(sbi, inode->i_ino);
     622                 :            : 
     623                 :            :         err = fscrypt_encrypt_symlink(inode, symname, len, &disk_link);
     624                 :          0 :         if (err)
     625                 :            :                 goto err_out;
     626                 :            : 
     627                 :          0 :         err = page_symlink(inode, disk_link.name, disk_link.len);
     628                 :            : 
     629                 :            : err_out:
     630                 :          0 :         d_instantiate_new(dentry, inode);
     631                 :            : 
     632                 :            :         /*
     633                 :            :          * Let's flush symlink data in order to avoid broken symlink as much as
     634                 :            :          * possible. Nevertheless, fsyncing is the best way, but there is no
     635                 :            :          * way to get a file descriptor in order to flush that.
     636                 :            :          *
     637                 :            :          * Note that, it needs to do dir->fsync to make this recoverable.
     638                 :            :          * If the symlink path is stored into inline_data, there is no
     639                 :            :          * performance regression.
     640                 :            :          */
     641                 :          0 :         if (!err) {
     642                 :          0 :                 filemap_write_and_wait_range(inode->i_mapping, 0,
     643                 :          0 :                                                         disk_link.len - 1);
     644                 :            : 
     645                 :          0 :                 if (IS_DIRSYNC(dir))
     646                 :          0 :                         f2fs_sync_fs(sbi->sb, 1);
     647                 :            :         } else {
     648                 :          0 :                 f2fs_unlink(dir, dentry);
     649                 :            :         }
     650                 :            : 
     651                 :          0 :         f2fs_balance_fs(sbi, true);
     652                 :          0 :         goto out_free_encrypted_link;
     653                 :            : 
     654                 :            : out_f2fs_handle_failed_inode:
     655                 :          0 :         f2fs_handle_failed_inode(inode);
     656                 :            : out_free_encrypted_link:
     657                 :          0 :         if (disk_link.name != (unsigned char *)symname)
     658                 :          0 :                 kvfree(disk_link.name);
     659                 :          0 :         return err;
     660                 :            : }
     661                 :            : 
     662                 :          0 : static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
     663                 :            : {
     664                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     665                 :            :         struct inode *inode;
     666                 :            :         int err;
     667                 :            : 
     668                 :          0 :         if (unlikely(f2fs_cp_error(sbi)))
     669                 :            :                 return -EIO;
     670                 :            : 
     671                 :          0 :         err = dquot_initialize(dir);
     672                 :          0 :         if (err)
     673                 :            :                 return err;
     674                 :            : 
     675                 :          0 :         inode = f2fs_new_inode(dir, S_IFDIR | mode);
     676                 :          0 :         if (IS_ERR(inode))
     677                 :          0 :                 return PTR_ERR(inode);
     678                 :            : 
     679                 :          0 :         inode->i_op = &f2fs_dir_inode_operations;
     680                 :          0 :         inode->i_fop = &f2fs_dir_operations;
     681                 :          0 :         inode->i_mapping->a_ops = &f2fs_dblock_aops;
     682                 :          0 :         inode_nohighmem(inode);
     683                 :            : 
     684                 :          0 :         set_inode_flag(inode, FI_INC_LINK);
     685                 :            :         f2fs_lock_op(sbi);
     686                 :          0 :         err = f2fs_add_link(dentry, inode);
     687                 :          0 :         if (err)
     688                 :            :                 goto out_fail;
     689                 :            :         f2fs_unlock_op(sbi);
     690                 :            : 
     691                 :          0 :         f2fs_alloc_nid_done(sbi, inode->i_ino);
     692                 :            : 
     693                 :          0 :         d_instantiate_new(dentry, inode);
     694                 :            : 
     695                 :          0 :         if (IS_DIRSYNC(dir))
     696                 :          0 :                 f2fs_sync_fs(sbi->sb, 1);
     697                 :            : 
     698                 :          0 :         f2fs_balance_fs(sbi, true);
     699                 :          0 :         return 0;
     700                 :            : 
     701                 :            : out_fail:
     702                 :          0 :         clear_inode_flag(inode, FI_INC_LINK);
     703                 :          0 :         f2fs_handle_failed_inode(inode);
     704                 :          0 :         return err;
     705                 :            : }
     706                 :            : 
     707                 :          0 : static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
     708                 :            : {
     709                 :            :         struct inode *inode = d_inode(dentry);
     710                 :          0 :         if (f2fs_empty_dir(inode))
     711                 :          0 :                 return f2fs_unlink(dir, dentry);
     712                 :            :         return -ENOTEMPTY;
     713                 :            : }
     714                 :            : 
     715                 :          0 : static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
     716                 :            :                                 umode_t mode, dev_t rdev)
     717                 :            : {
     718                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     719                 :            :         struct inode *inode;
     720                 :            :         int err = 0;
     721                 :            : 
     722                 :          0 :         if (unlikely(f2fs_cp_error(sbi)))
     723                 :            :                 return -EIO;
     724                 :          0 :         if (!f2fs_is_checkpoint_ready(sbi))
     725                 :            :                 return -ENOSPC;
     726                 :            : 
     727                 :          0 :         err = dquot_initialize(dir);
     728                 :          0 :         if (err)
     729                 :            :                 return err;
     730                 :            : 
     731                 :          0 :         inode = f2fs_new_inode(dir, mode);
     732                 :          0 :         if (IS_ERR(inode))
     733                 :          0 :                 return PTR_ERR(inode);
     734                 :            : 
     735                 :          0 :         init_special_inode(inode, inode->i_mode, rdev);
     736                 :          0 :         inode->i_op = &f2fs_special_inode_operations;
     737                 :            : 
     738                 :            :         f2fs_lock_op(sbi);
     739                 :          0 :         err = f2fs_add_link(dentry, inode);
     740                 :          0 :         if (err)
     741                 :            :                 goto out;
     742                 :            :         f2fs_unlock_op(sbi);
     743                 :            : 
     744                 :          0 :         f2fs_alloc_nid_done(sbi, inode->i_ino);
     745                 :            : 
     746                 :          0 :         d_instantiate_new(dentry, inode);
     747                 :            : 
     748                 :          0 :         if (IS_DIRSYNC(dir))
     749                 :          0 :                 f2fs_sync_fs(sbi->sb, 1);
     750                 :            : 
     751                 :          0 :         f2fs_balance_fs(sbi, true);
     752                 :          0 :         return 0;
     753                 :            : out:
     754                 :          0 :         f2fs_handle_failed_inode(inode);
     755                 :          0 :         return err;
     756                 :            : }
     757                 :            : 
     758                 :          0 : static int __f2fs_tmpfile(struct inode *dir, struct dentry *dentry,
     759                 :            :                                         umode_t mode, struct inode **whiteout)
     760                 :            : {
     761                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     762                 :            :         struct inode *inode;
     763                 :            :         int err;
     764                 :            : 
     765                 :          0 :         err = dquot_initialize(dir);
     766                 :          0 :         if (err)
     767                 :            :                 return err;
     768                 :            : 
     769                 :          0 :         inode = f2fs_new_inode(dir, mode);
     770                 :          0 :         if (IS_ERR(inode))
     771                 :          0 :                 return PTR_ERR(inode);
     772                 :            : 
     773                 :          0 :         if (whiteout) {
     774                 :          0 :                 init_special_inode(inode, inode->i_mode, WHITEOUT_DEV);
     775                 :          0 :                 inode->i_op = &f2fs_special_inode_operations;
     776                 :            :         } else {
     777                 :          0 :                 inode->i_op = &f2fs_file_inode_operations;
     778                 :          0 :                 inode->i_fop = &f2fs_file_operations;
     779                 :          0 :                 inode->i_mapping->a_ops = &f2fs_dblock_aops;
     780                 :            :         }
     781                 :            : 
     782                 :            :         f2fs_lock_op(sbi);
     783                 :          0 :         err = f2fs_acquire_orphan_inode(sbi);
     784                 :          0 :         if (err)
     785                 :            :                 goto out;
     786                 :            : 
     787                 :          0 :         err = f2fs_do_tmpfile(inode, dir);
     788                 :          0 :         if (err)
     789                 :            :                 goto release_out;
     790                 :            : 
     791                 :            :         /*
     792                 :            :          * add this non-linked tmpfile to orphan list, in this way we could
     793                 :            :          * remove all unused data of tmpfile after abnormal power-off.
     794                 :            :          */
     795                 :          0 :         f2fs_add_orphan_inode(inode);
     796                 :          0 :         f2fs_alloc_nid_done(sbi, inode->i_ino);
     797                 :            : 
     798                 :          0 :         if (whiteout) {
     799                 :          0 :                 f2fs_i_links_write(inode, false);
     800                 :          0 :                 inode->i_state |= I_LINKABLE;
     801                 :          0 :                 *whiteout = inode;
     802                 :            :         } else {
     803                 :          0 :                 d_tmpfile(dentry, inode);
     804                 :            :         }
     805                 :            :         /* link_count was changed by d_tmpfile as well. */
     806                 :            :         f2fs_unlock_op(sbi);
     807                 :          0 :         unlock_new_inode(inode);
     808                 :            : 
     809                 :          0 :         f2fs_balance_fs(sbi, true);
     810                 :          0 :         return 0;
     811                 :            : 
     812                 :            : release_out:
     813                 :          0 :         f2fs_release_orphan_inode(sbi);
     814                 :            : out:
     815                 :          0 :         f2fs_handle_failed_inode(inode);
     816                 :          0 :         return err;
     817                 :            : }
     818                 :            : 
     819                 :          0 : static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
     820                 :            : {
     821                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
     822                 :            : 
     823                 :          0 :         if (unlikely(f2fs_cp_error(sbi)))
     824                 :            :                 return -EIO;
     825                 :          0 :         if (!f2fs_is_checkpoint_ready(sbi))
     826                 :            :                 return -ENOSPC;
     827                 :            : 
     828                 :          0 :         if (IS_ENCRYPTED(dir) || DUMMY_ENCRYPTION_ENABLED(sbi)) {
     829                 :          0 :                 int err = fscrypt_get_encryption_info(dir);
     830                 :          0 :                 if (err)
     831                 :            :                         return err;
     832                 :            :         }
     833                 :            : 
     834                 :          0 :         return __f2fs_tmpfile(dir, dentry, mode, NULL);
     835                 :            : }
     836                 :            : 
     837                 :          0 : static int f2fs_create_whiteout(struct inode *dir, struct inode **whiteout)
     838                 :            : {
     839                 :          0 :         if (unlikely(f2fs_cp_error(F2FS_I_SB(dir))))
     840                 :            :                 return -EIO;
     841                 :            : 
     842                 :          0 :         return __f2fs_tmpfile(dir, NULL, S_IFCHR | WHITEOUT_MODE, whiteout);
     843                 :            : }
     844                 :            : 
     845                 :          0 : static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
     846                 :            :                         struct inode *new_dir, struct dentry *new_dentry,
     847                 :            :                         unsigned int flags)
     848                 :            : {
     849                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
     850                 :            :         struct inode *old_inode = d_inode(old_dentry);
     851                 :            :         struct inode *new_inode = d_inode(new_dentry);
     852                 :          0 :         struct inode *whiteout = NULL;
     853                 :            :         struct page *old_dir_page;
     854                 :          0 :         struct page *old_page, *new_page = NULL;
     855                 :            :         struct f2fs_dir_entry *old_dir_entry = NULL;
     856                 :            :         struct f2fs_dir_entry *old_entry;
     857                 :            :         struct f2fs_dir_entry *new_entry;
     858                 :            :         bool is_old_inline = f2fs_has_inline_dentry(old_dir);
     859                 :            :         int err;
     860                 :            : 
     861                 :          0 :         if (unlikely(f2fs_cp_error(sbi)))
     862                 :            :                 return -EIO;
     863                 :          0 :         if (!f2fs_is_checkpoint_ready(sbi))
     864                 :            :                 return -ENOSPC;
     865                 :            : 
     866                 :          0 :         if (is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
     867                 :            :                         (!projid_eq(F2FS_I(new_dir)->i_projid,
     868                 :          0 :                         F2FS_I(old_dentry->d_inode)->i_projid)))
     869                 :            :                 return -EXDEV;
     870                 :            : 
     871                 :          0 :         if (flags & RENAME_WHITEOUT) {
     872                 :          0 :                 err = f2fs_create_whiteout(old_dir, &whiteout);
     873                 :          0 :                 if (err)
     874                 :            :                         return err;
     875                 :            :         }
     876                 :            : 
     877                 :          0 :         err = dquot_initialize(old_dir);
     878                 :          0 :         if (err)
     879                 :            :                 goto out;
     880                 :            : 
     881                 :          0 :         err = dquot_initialize(new_dir);
     882                 :          0 :         if (err)
     883                 :            :                 goto out;
     884                 :            : 
     885                 :          0 :         if (new_inode) {
     886                 :          0 :                 err = dquot_initialize(new_inode);
     887                 :          0 :                 if (err)
     888                 :            :                         goto out;
     889                 :            :         }
     890                 :            : 
     891                 :            :         err = -ENOENT;
     892                 :          0 :         old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
     893                 :          0 :         if (!old_entry) {
     894                 :          0 :                 if (IS_ERR(old_page))
     895                 :            :                         err = PTR_ERR(old_page);
     896                 :            :                 goto out;
     897                 :            :         }
     898                 :            : 
     899                 :          0 :         if (S_ISDIR(old_inode->i_mode)) {
     900                 :          0 :                 old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);
     901                 :          0 :                 if (!old_dir_entry) {
     902                 :          0 :                         if (IS_ERR(old_dir_page))
     903                 :            :                                 err = PTR_ERR(old_dir_page);
     904                 :            :                         goto out_old;
     905                 :            :                 }
     906                 :            :         }
     907                 :            : 
     908                 :          0 :         if (new_inode) {
     909                 :            : 
     910                 :            :                 err = -ENOTEMPTY;
     911                 :          0 :                 if (old_dir_entry && !f2fs_empty_dir(new_inode))
     912                 :            :                         goto out_dir;
     913                 :            : 
     914                 :            :                 err = -ENOENT;
     915                 :          0 :                 new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,
     916                 :            :                                                 &new_page);
     917                 :          0 :                 if (!new_entry) {
     918                 :          0 :                         if (IS_ERR(new_page))
     919                 :            :                                 err = PTR_ERR(new_page);
     920                 :            :                         goto out_dir;
     921                 :            :                 }
     922                 :            : 
     923                 :          0 :                 f2fs_balance_fs(sbi, true);
     924                 :            : 
     925                 :            :                 f2fs_lock_op(sbi);
     926                 :            : 
     927                 :          0 :                 err = f2fs_acquire_orphan_inode(sbi);
     928                 :          0 :                 if (err)
     929                 :            :                         goto put_out_dir;
     930                 :            : 
     931                 :          0 :                 f2fs_set_link(new_dir, new_entry, new_page, old_inode);
     932                 :            : 
     933                 :          0 :                 new_inode->i_ctime = current_time(new_inode);
     934                 :          0 :                 down_write(&F2FS_I(new_inode)->i_sem);
     935                 :          0 :                 if (old_dir_entry)
     936                 :          0 :                         f2fs_i_links_write(new_inode, false);
     937                 :          0 :                 f2fs_i_links_write(new_inode, false);
     938                 :          0 :                 up_write(&F2FS_I(new_inode)->i_sem);
     939                 :            : 
     940                 :          0 :                 if (!new_inode->i_nlink)
     941                 :          0 :                         f2fs_add_orphan_inode(new_inode);
     942                 :            :                 else
     943                 :          0 :                         f2fs_release_orphan_inode(sbi);
     944                 :            :         } else {
     945                 :          0 :                 f2fs_balance_fs(sbi, true);
     946                 :            : 
     947                 :            :                 f2fs_lock_op(sbi);
     948                 :            : 
     949                 :          0 :                 err = f2fs_add_link(new_dentry, old_inode);
     950                 :          0 :                 if (err) {
     951                 :            :                         f2fs_unlock_op(sbi);
     952                 :            :                         goto out_dir;
     953                 :            :                 }
     954                 :            : 
     955                 :          0 :                 if (old_dir_entry)
     956                 :          0 :                         f2fs_i_links_write(new_dir, true);
     957                 :            : 
     958                 :            :                 /*
     959                 :            :                  * old entry and new entry can locate in the same inline
     960                 :            :                  * dentry in inode, when attaching new entry in inline dentry,
     961                 :            :                  * it could force inline dentry conversion, after that,
     962                 :            :                  * old_entry and old_page will point to wrong address, in
     963                 :            :                  * order to avoid this, let's do the check and update here.
     964                 :            :                  */
     965                 :          0 :                 if (is_old_inline && !f2fs_has_inline_dentry(old_dir)) {
     966                 :          0 :                         f2fs_put_page(old_page, 0);
     967                 :          0 :                         old_page = NULL;
     968                 :            : 
     969                 :          0 :                         old_entry = f2fs_find_entry(old_dir,
     970                 :            :                                                 &old_dentry->d_name, &old_page);
     971                 :          0 :                         if (!old_entry) {
     972                 :            :                                 err = -ENOENT;
     973                 :          0 :                                 if (IS_ERR(old_page))
     974                 :            :                                         err = PTR_ERR(old_page);
     975                 :            :                                 f2fs_unlock_op(sbi);
     976                 :            :                                 goto out_dir;
     977                 :            :                         }
     978                 :            :                 }
     979                 :            :         }
     980                 :            : 
     981                 :          0 :         down_write(&F2FS_I(old_inode)->i_sem);
     982                 :          0 :         if (!old_dir_entry || whiteout)
     983                 :            :                 file_lost_pino(old_inode);
     984                 :            :         else
     985                 :            :                 /* adjust dir's i_pino to pass fsck check */
     986                 :          0 :                 f2fs_i_pino_write(old_inode, new_dir->i_ino);
     987                 :          0 :         up_write(&F2FS_I(old_inode)->i_sem);
     988                 :            : 
     989                 :          0 :         old_inode->i_ctime = current_time(old_inode);
     990                 :          0 :         f2fs_mark_inode_dirty_sync(old_inode, false);
     991                 :            : 
     992                 :          0 :         f2fs_delete_entry(old_entry, old_page, old_dir, NULL);
     993                 :            : 
     994                 :          0 :         if (whiteout) {
     995                 :          0 :                 set_inode_flag(whiteout, FI_INC_LINK);
     996                 :          0 :                 err = f2fs_add_link(old_dentry, whiteout);
     997                 :          0 :                 if (err)
     998                 :            :                         goto put_out_dir;
     999                 :          0 :                 whiteout->i_state &= ~I_LINKABLE;
    1000                 :          0 :                 iput(whiteout);
    1001                 :            :         }
    1002                 :            : 
    1003                 :          0 :         if (old_dir_entry) {
    1004                 :          0 :                 if (old_dir != new_dir && !whiteout)
    1005                 :          0 :                         f2fs_set_link(old_inode, old_dir_entry,
    1006                 :            :                                                 old_dir_page, new_dir);
    1007                 :            :                 else
    1008                 :          0 :                         f2fs_put_page(old_dir_page, 0);
    1009                 :          0 :                 f2fs_i_links_write(old_dir, false);
    1010                 :            :         }
    1011                 :          0 :         if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT) {
    1012                 :          0 :                 f2fs_add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
    1013                 :          0 :                 if (S_ISDIR(old_inode->i_mode))
    1014                 :          0 :                         f2fs_add_ino_entry(sbi, old_inode->i_ino,
    1015                 :            :                                                         TRANS_DIR_INO);
    1016                 :            :         }
    1017                 :            : 
    1018                 :            :         f2fs_unlock_op(sbi);
    1019                 :            : 
    1020                 :          0 :         if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
    1021                 :          0 :                 f2fs_sync_fs(sbi->sb, 1);
    1022                 :            : 
    1023                 :            :         f2fs_update_time(sbi, REQ_TIME);
    1024                 :          0 :         return 0;
    1025                 :            : 
    1026                 :            : put_out_dir:
    1027                 :            :         f2fs_unlock_op(sbi);
    1028                 :          0 :         if (new_page)
    1029                 :          0 :                 f2fs_put_page(new_page, 0);
    1030                 :            : out_dir:
    1031                 :          0 :         if (old_dir_entry)
    1032                 :          0 :                 f2fs_put_page(old_dir_page, 0);
    1033                 :            : out_old:
    1034                 :          0 :         f2fs_put_page(old_page, 0);
    1035                 :            : out:
    1036                 :          0 :         if (whiteout)
    1037                 :          0 :                 iput(whiteout);
    1038                 :          0 :         return err;
    1039                 :            : }
    1040                 :            : 
    1041                 :          0 : static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
    1042                 :            :                              struct inode *new_dir, struct dentry *new_dentry)
    1043                 :            : {
    1044                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
    1045                 :            :         struct inode *old_inode = d_inode(old_dentry);
    1046                 :            :         struct inode *new_inode = d_inode(new_dentry);
    1047                 :            :         struct page *old_dir_page, *new_dir_page;
    1048                 :            :         struct page *old_page, *new_page;
    1049                 :            :         struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;
    1050                 :            :         struct f2fs_dir_entry *old_entry, *new_entry;
    1051                 :            :         int old_nlink = 0, new_nlink = 0;
    1052                 :            :         int err;
    1053                 :            : 
    1054                 :          0 :         if (unlikely(f2fs_cp_error(sbi)))
    1055                 :            :                 return -EIO;
    1056                 :          0 :         if (!f2fs_is_checkpoint_ready(sbi))
    1057                 :            :                 return -ENOSPC;
    1058                 :            : 
    1059                 :          0 :         if ((is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
    1060                 :            :                         !projid_eq(F2FS_I(new_dir)->i_projid,
    1061                 :          0 :                         F2FS_I(old_dentry->d_inode)->i_projid)) ||
    1062                 :          0 :             (is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
    1063                 :            :                         !projid_eq(F2FS_I(old_dir)->i_projid,
    1064                 :          0 :                         F2FS_I(new_dentry->d_inode)->i_projid)))
    1065                 :            :                 return -EXDEV;
    1066                 :            : 
    1067                 :          0 :         err = dquot_initialize(old_dir);
    1068                 :          0 :         if (err)
    1069                 :            :                 goto out;
    1070                 :            : 
    1071                 :          0 :         err = dquot_initialize(new_dir);
    1072                 :          0 :         if (err)
    1073                 :            :                 goto out;
    1074                 :            : 
    1075                 :            :         err = -ENOENT;
    1076                 :          0 :         old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
    1077                 :          0 :         if (!old_entry) {
    1078                 :          0 :                 if (IS_ERR(old_page))
    1079                 :            :                         err = PTR_ERR(old_page);
    1080                 :            :                 goto out;
    1081                 :            :         }
    1082                 :            : 
    1083                 :          0 :         new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, &new_page);
    1084                 :          0 :         if (!new_entry) {
    1085                 :          0 :                 if (IS_ERR(new_page))
    1086                 :            :                         err = PTR_ERR(new_page);
    1087                 :            :                 goto out_old;
    1088                 :            :         }
    1089                 :            : 
    1090                 :            :         /* prepare for updating ".." directory entry info later */
    1091                 :          0 :         if (old_dir != new_dir) {
    1092                 :          0 :                 if (S_ISDIR(old_inode->i_mode)) {
    1093                 :          0 :                         old_dir_entry = f2fs_parent_dir(old_inode,
    1094                 :            :                                                         &old_dir_page);
    1095                 :          0 :                         if (!old_dir_entry) {
    1096                 :          0 :                                 if (IS_ERR(old_dir_page))
    1097                 :            :                                         err = PTR_ERR(old_dir_page);
    1098                 :            :                                 goto out_new;
    1099                 :            :                         }
    1100                 :            :                 }
    1101                 :            : 
    1102                 :          0 :                 if (S_ISDIR(new_inode->i_mode)) {
    1103                 :          0 :                         new_dir_entry = f2fs_parent_dir(new_inode,
    1104                 :            :                                                         &new_dir_page);
    1105                 :          0 :                         if (!new_dir_entry) {
    1106                 :          0 :                                 if (IS_ERR(new_dir_page))
    1107                 :            :                                         err = PTR_ERR(new_dir_page);
    1108                 :            :                                 goto out_old_dir;
    1109                 :            :                         }
    1110                 :            :                 }
    1111                 :            :         }
    1112                 :            : 
    1113                 :            :         /*
    1114                 :            :          * If cross rename between file and directory those are not
    1115                 :            :          * in the same directory, we will inc nlink of file's parent
    1116                 :            :          * later, so we should check upper boundary of its nlink.
    1117                 :            :          */
    1118                 :          0 :         if ((!old_dir_entry || !new_dir_entry) &&
    1119                 :            :                                 old_dir_entry != new_dir_entry) {
    1120                 :          0 :                 old_nlink = old_dir_entry ? -1 : 1;
    1121                 :          0 :                 new_nlink = -old_nlink;
    1122                 :            :                 err = -EMLINK;
    1123                 :          0 :                 if ((old_nlink > 0 && old_dir->i_nlink >= F2FS_LINK_MAX) ||
    1124                 :          0 :                         (new_nlink > 0 && new_dir->i_nlink >= F2FS_LINK_MAX))
    1125                 :            :                         goto out_new_dir;
    1126                 :            :         }
    1127                 :            : 
    1128                 :          0 :         f2fs_balance_fs(sbi, true);
    1129                 :            : 
    1130                 :            :         f2fs_lock_op(sbi);
    1131                 :            : 
    1132                 :            :         /* update ".." directory entry info of old dentry */
    1133                 :          0 :         if (old_dir_entry)
    1134                 :          0 :                 f2fs_set_link(old_inode, old_dir_entry, old_dir_page, new_dir);
    1135                 :            : 
    1136                 :            :         /* update ".." directory entry info of new dentry */
    1137                 :          0 :         if (new_dir_entry)
    1138                 :          0 :                 f2fs_set_link(new_inode, new_dir_entry, new_dir_page, old_dir);
    1139                 :            : 
    1140                 :            :         /* update directory entry info of old dir inode */
    1141                 :          0 :         f2fs_set_link(old_dir, old_entry, old_page, new_inode);
    1142                 :            : 
    1143                 :          0 :         down_write(&F2FS_I(old_inode)->i_sem);
    1144                 :          0 :         if (!old_dir_entry)
    1145                 :            :                 file_lost_pino(old_inode);
    1146                 :            :         else
    1147                 :            :                 /* adjust dir's i_pino to pass fsck check */
    1148                 :          0 :                 f2fs_i_pino_write(old_inode, new_dir->i_ino);
    1149                 :          0 :         up_write(&F2FS_I(old_inode)->i_sem);
    1150                 :            : 
    1151                 :          0 :         old_dir->i_ctime = current_time(old_dir);
    1152                 :          0 :         if (old_nlink) {
    1153                 :          0 :                 down_write(&F2FS_I(old_dir)->i_sem);
    1154                 :          0 :                 f2fs_i_links_write(old_dir, old_nlink > 0);
    1155                 :          0 :                 up_write(&F2FS_I(old_dir)->i_sem);
    1156                 :            :         }
    1157                 :          0 :         f2fs_mark_inode_dirty_sync(old_dir, false);
    1158                 :            : 
    1159                 :            :         /* update directory entry info of new dir inode */
    1160                 :          0 :         f2fs_set_link(new_dir, new_entry, new_page, old_inode);
    1161                 :            : 
    1162                 :          0 :         down_write(&F2FS_I(new_inode)->i_sem);
    1163                 :          0 :         if (!new_dir_entry)
    1164                 :            :                 file_lost_pino(new_inode);
    1165                 :            :         else
    1166                 :            :                 /* adjust dir's i_pino to pass fsck check */
    1167                 :          0 :                 f2fs_i_pino_write(new_inode, old_dir->i_ino);
    1168                 :          0 :         up_write(&F2FS_I(new_inode)->i_sem);
    1169                 :            : 
    1170                 :          0 :         new_dir->i_ctime = current_time(new_dir);
    1171                 :          0 :         if (new_nlink) {
    1172                 :          0 :                 down_write(&F2FS_I(new_dir)->i_sem);
    1173                 :          0 :                 f2fs_i_links_write(new_dir, new_nlink > 0);
    1174                 :          0 :                 up_write(&F2FS_I(new_dir)->i_sem);
    1175                 :            :         }
    1176                 :          0 :         f2fs_mark_inode_dirty_sync(new_dir, false);
    1177                 :            : 
    1178                 :          0 :         if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT) {
    1179                 :          0 :                 f2fs_add_ino_entry(sbi, old_dir->i_ino, TRANS_DIR_INO);
    1180                 :          0 :                 f2fs_add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
    1181                 :            :         }
    1182                 :            : 
    1183                 :            :         f2fs_unlock_op(sbi);
    1184                 :            : 
    1185                 :          0 :         if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
    1186                 :          0 :                 f2fs_sync_fs(sbi->sb, 1);
    1187                 :            : 
    1188                 :            :         f2fs_update_time(sbi, REQ_TIME);
    1189                 :          0 :         return 0;
    1190                 :            : out_new_dir:
    1191                 :          0 :         if (new_dir_entry) {
    1192                 :          0 :                 f2fs_put_page(new_dir_page, 0);
    1193                 :            :         }
    1194                 :            : out_old_dir:
    1195                 :          0 :         if (old_dir_entry) {
    1196                 :          0 :                 f2fs_put_page(old_dir_page, 0);
    1197                 :            :         }
    1198                 :            : out_new:
    1199                 :          0 :         f2fs_put_page(new_page, 0);
    1200                 :            : out_old:
    1201                 :          0 :         f2fs_put_page(old_page, 0);
    1202                 :            : out:
    1203                 :          0 :         return err;
    1204                 :            : }
    1205                 :            : 
    1206                 :          0 : static int f2fs_rename2(struct inode *old_dir, struct dentry *old_dentry,
    1207                 :            :                         struct inode *new_dir, struct dentry *new_dentry,
    1208                 :            :                         unsigned int flags)
    1209                 :            : {
    1210                 :            :         int err;
    1211                 :            : 
    1212                 :          0 :         if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
    1213                 :            :                 return -EINVAL;
    1214                 :            : 
    1215                 :          0 :         err = fscrypt_prepare_rename(old_dir, old_dentry, new_dir, new_dentry,
    1216                 :            :                                      flags);
    1217                 :          0 :         if (err)
    1218                 :            :                 return err;
    1219                 :            : 
    1220                 :          0 :         if (flags & RENAME_EXCHANGE) {
    1221                 :          0 :                 return f2fs_cross_rename(old_dir, old_dentry,
    1222                 :            :                                          new_dir, new_dentry);
    1223                 :            :         }
    1224                 :            :         /*
    1225                 :            :          * VFS has already handled the new dentry existence case,
    1226                 :            :          * here, we just deal with "RENAME_NOREPLACE" as regular rename.
    1227                 :            :          */
    1228                 :          0 :         return f2fs_rename(old_dir, old_dentry, new_dir, new_dentry, flags);
    1229                 :            : }
    1230                 :            : 
    1231                 :          0 : static const char *f2fs_encrypted_get_link(struct dentry *dentry,
    1232                 :            :                                            struct inode *inode,
    1233                 :            :                                            struct delayed_call *done)
    1234                 :            : {
    1235                 :            :         struct page *page;
    1236                 :            :         const char *target;
    1237                 :            : 
    1238                 :          0 :         if (!dentry)
    1239                 :            :                 return ERR_PTR(-ECHILD);
    1240                 :            : 
    1241                 :          0 :         page = read_mapping_page(inode->i_mapping, 0, NULL);
    1242                 :          0 :         if (IS_ERR(page))
    1243                 :            :                 return ERR_CAST(page);
    1244                 :            : 
    1245                 :          0 :         target = fscrypt_get_symlink(inode, page_address(page),
    1246                 :          0 :                                      inode->i_sb->s_blocksize, done);
    1247                 :          0 :         put_page(page);
    1248                 :          0 :         return target;
    1249                 :            : }
    1250                 :            : 
    1251                 :            : const struct inode_operations f2fs_encrypted_symlink_inode_operations = {
    1252                 :            :         .get_link       = f2fs_encrypted_get_link,
    1253                 :            :         .getattr        = f2fs_getattr,
    1254                 :            :         .setattr        = f2fs_setattr,
    1255                 :            : #ifdef CONFIG_F2FS_FS_XATTR
    1256                 :            :         .listxattr      = f2fs_listxattr,
    1257                 :            : #endif
    1258                 :            : };
    1259                 :            : 
    1260                 :            : const struct inode_operations f2fs_dir_inode_operations = {
    1261                 :            :         .create         = f2fs_create,
    1262                 :            :         .lookup         = f2fs_lookup,
    1263                 :            :         .link           = f2fs_link,
    1264                 :            :         .unlink         = f2fs_unlink,
    1265                 :            :         .symlink        = f2fs_symlink,
    1266                 :            :         .mkdir          = f2fs_mkdir,
    1267                 :            :         .rmdir          = f2fs_rmdir,
    1268                 :            :         .mknod          = f2fs_mknod,
    1269                 :            :         .rename         = f2fs_rename2,
    1270                 :            :         .tmpfile        = f2fs_tmpfile,
    1271                 :            :         .getattr        = f2fs_getattr,
    1272                 :            :         .setattr        = f2fs_setattr,
    1273                 :            :         .get_acl        = f2fs_get_acl,
    1274                 :            :         .set_acl        = f2fs_set_acl,
    1275                 :            : #ifdef CONFIG_F2FS_FS_XATTR
    1276                 :            :         .listxattr      = f2fs_listxattr,
    1277                 :            : #endif
    1278                 :            :         .fiemap         = f2fs_fiemap,
    1279                 :            : };
    1280                 :            : 
    1281                 :            : const struct inode_operations f2fs_symlink_inode_operations = {
    1282                 :            :         .get_link       = f2fs_get_link,
    1283                 :            :         .getattr        = f2fs_getattr,
    1284                 :            :         .setattr        = f2fs_setattr,
    1285                 :            : #ifdef CONFIG_F2FS_FS_XATTR
    1286                 :            :         .listxattr      = f2fs_listxattr,
    1287                 :            : #endif
    1288                 :            : };
    1289                 :            : 
    1290                 :            : const struct inode_operations f2fs_special_inode_operations = {
    1291                 :            :         .getattr        = f2fs_getattr,
    1292                 :            :         .setattr        = f2fs_setattr,
    1293                 :            :         .get_acl        = f2fs_get_acl,
    1294                 :            :         .set_acl        = f2fs_set_acl,
    1295                 :            : #ifdef CONFIG_F2FS_FS_XATTR
    1296                 :            :         .listxattr      = f2fs_listxattr,
    1297                 :            : #endif
    1298                 :            : };
    

Generated by: LCOV version 1.14