fs/nilfs2/namei.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * NILFS pathname lookup operations.
0004  *
0005  * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
0006  *
0007  * Modified for NILFS by Amagai Yoshiji and Ryusuke Konishi.
0008  */
0009 /*
0010  *  linux/fs/ext2/namei.c
0011  *
0012  * Copyright (C) 1992, 1993, 1994, 1995
0013  * Remy Card (card@masi.ibp.fr)
0014  * Laboratoire MASI - Institut Blaise Pascal
0015  * Universite Pierre et Marie Curie (Paris VI)
0016  *
0017  *  from
0018  *
0019  *  linux/fs/minix/namei.c
0020  *
0021  *  Copyright (C) 1991, 1992  Linus Torvalds
0022  *
0023  *  Big-endian to little-endian byte-swapping/bitmaps by
0024  *        David S. Miller (davem@caip.rutgers.edu), 1995
0025  */
0026
0027 #include <linux/pagemap.h>
0028 #include "nilfs.h"
0029 #include "export.h"
0030
0031 #define NILFS_FID_SIZE_NON_CONNECTABLE \
0032     (offsetof(struct nilfs_fid, parent_gen) / 4)
0033 #define NILFS_FID_SIZE_CONNECTABLE  (sizeof(struct nilfs_fid) / 4)
0034
0035 static inline int nilfs_add_nondir(struct dentry *dentry, struct inode *inode)
0036 {
0037     int err = nilfs_add_link(dentry, inode);
0038
0039     if (!err) {
0040         d_instantiate_new(dentry, inode);
0041         return 0;
0042     }
0043     inode_dec_link_count(inode);
0044     unlock_new_inode(inode);
0045     iput(inode);
0046     return err;
0047 }
0048
0049 /*
0050  * Methods themselves.
0051  */
0052
0053 static struct dentry *
0054 nilfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
0055 {
0056     struct inode *inode;
0057     ino_t ino;
0058
0059     if (dentry->d_name.len > NILFS_NAME_LEN)
0060         return ERR_PTR(-ENAMETOOLONG);
0061
0062     ino = nilfs_inode_by_name(dir, &dentry->d_name);
0063     inode = ino ? nilfs_iget(dir->i_sb, NILFS_I(dir)->i_root, ino) : NULL;
0064     return d_splice_alias(inode, dentry);
0065 }
0066
0067 /*
0068  * By the time this is called, we already have created
0069  * the directory cache entry for the new file, but it
0070  * is so far negative - it has no inode.
0071  *
0072  * If the create succeeds, we fill in the inode information
0073  * with d_instantiate().
0074  */
0075 static int nilfs_create(struct user_namespace *mnt_userns, struct inode *dir,
0076             struct dentry *dentry, umode_t mode, bool excl)
0077 {
0078     struct inode *inode;
0079     struct nilfs_transaction_info ti;
0080     int err;
0081
0082     err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
0083     if (err)
0084         return err;
0085     inode = nilfs_new_inode(dir, mode);
0086     err = PTR_ERR(inode);
0087     if (!IS_ERR(inode)) {
0088         inode->i_op = &nilfs_file_inode_operations;
0089         inode->i_fop = &nilfs_file_operations;
0090         inode->i_mapping->a_ops = &nilfs_aops;
0091         nilfs_mark_inode_dirty(inode);
0092         err = nilfs_add_nondir(dentry, inode);
0093     }
0094     if (!err)
0095         err = nilfs_transaction_commit(dir->i_sb);
0096     else
0097         nilfs_transaction_abort(dir->i_sb);
0098
0099     return err;
0100 }
0101
0102 static int
0103 nilfs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
0104         struct dentry *dentry, umode_t mode, dev_t rdev)
0105 {
0106     struct inode *inode;
0107     struct nilfs_transaction_info ti;
0108     int err;
0109
0110     err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
0111     if (err)
0112         return err;
0113     inode = nilfs_new_inode(dir, mode);
0114     err = PTR_ERR(inode);
0115     if (!IS_ERR(inode)) {
0116         init_special_inode(inode, inode->i_mode, rdev);
0117         nilfs_mark_inode_dirty(inode);
0118         err = nilfs_add_nondir(dentry, inode);
0119     }
0120     if (!err)
0121         err = nilfs_transaction_commit(dir->i_sb);
0122     else
0123         nilfs_transaction_abort(dir->i_sb);
0124
0125     return err;
0126 }
0127
0128 static int nilfs_symlink(struct user_namespace *mnt_userns, struct inode *dir,
0129              struct dentry *dentry, const char *symname)
0130 {
0131     struct nilfs_transaction_info ti;
0132     struct super_block *sb = dir->i_sb;
0133     unsigned int l = strlen(symname) + 1;
0134     struct inode *inode;
0135     int err;
0136
0137     if (l > sb->s_blocksize)
0138         return -ENAMETOOLONG;
0139
0140     err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
0141     if (err)
0142         return err;
0143
0144     inode = nilfs_new_inode(dir, S_IFLNK | 0777);
0145     err = PTR_ERR(inode);
0146     if (IS_ERR(inode))
0147         goto out;
0148
0149     /* slow symlink */
0150     inode->i_op = &nilfs_symlink_inode_operations;
0151     inode_nohighmem(inode);
0152     inode->i_mapping->a_ops = &nilfs_aops;
0153     err = page_symlink(inode, symname, l);
0154     if (err)
0155         goto out_fail;
0156
0157     /* mark_inode_dirty(inode); */
0158     /* page_symlink() do this */
0159
0160     err = nilfs_add_nondir(dentry, inode);
0161 out:
0162     if (!err)
0163         err = nilfs_transaction_commit(dir->i_sb);
0164     else
0165         nilfs_transaction_abort(dir->i_sb);
0166
0167     return err;
0168
0169 out_fail:
0170     drop_nlink(inode);
0171     nilfs_mark_inode_dirty(inode);
0172     unlock_new_inode(inode);
0173     iput(inode);
0174     goto out;
0175 }
0176
0177 static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
0178               struct dentry *dentry)
0179 {
0180     struct inode *inode = d_inode(old_dentry);
0181     struct nilfs_transaction_info ti;
0182     int err;
0183
0184     err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
0185     if (err)
0186         return err;
0187
0188     inode->i_ctime = current_time(inode);
0189     inode_inc_link_count(inode);
0190     ihold(inode);
0191
0192     err = nilfs_add_link(dentry, inode);
0193     if (!err) {
0194         d_instantiate(dentry, inode);
0195         err = nilfs_transaction_commit(dir->i_sb);
0196     } else {
0197         inode_dec_link_count(inode);
0198         iput(inode);
0199         nilfs_transaction_abort(dir->i_sb);
0200     }
0201
0202     return err;
0203 }
0204
0205 static int nilfs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
0206                struct dentry *dentry, umode_t mode)
0207 {
0208     struct inode *inode;
0209     struct nilfs_transaction_info ti;
0210     int err;
0211
0212     err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
0213     if (err)
0214         return err;
0215
0216     inc_nlink(dir);
0217
0218     inode = nilfs_new_inode(dir, S_IFDIR | mode);
0219     err = PTR_ERR(inode);
0220     if (IS_ERR(inode))
0221         goto out_dir;
0222
0223     inode->i_op = &nilfs_dir_inode_operations;
0224     inode->i_fop = &nilfs_dir_operations;
0225     inode->i_mapping->a_ops = &nilfs_aops;
0226
0227     inc_nlink(inode);
0228
0229     err = nilfs_make_empty(inode, dir);
0230     if (err)
0231         goto out_fail;
0232
0233     err = nilfs_add_link(dentry, inode);
0234     if (err)
0235         goto out_fail;
0236
0237     nilfs_mark_inode_dirty(inode);
0238     d_instantiate_new(dentry, inode);
0239 out:
0240     if (!err)
0241         err = nilfs_transaction_commit(dir->i_sb);
0242     else
0243         nilfs_transaction_abort(dir->i_sb);
0244
0245     return err;
0246
0247 out_fail:
0248     drop_nlink(inode);
0249     drop_nlink(inode);
0250     nilfs_mark_inode_dirty(inode);
0251     unlock_new_inode(inode);
0252     iput(inode);
0253 out_dir:
0254     drop_nlink(dir);
0255     nilfs_mark_inode_dirty(dir);
0256     goto out;
0257 }
0258
0259 static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry)
0260 {
0261     struct inode *inode;
0262     struct nilfs_dir_entry *de;
0263     struct page *page;
0264     int err;
0265
0266     err = -ENOENT;
0267     de = nilfs_find_entry(dir, &dentry->d_name, &page);
0268     if (!de)
0269         goto out;
0270
0271     inode = d_inode(dentry);
0272     err = -EIO;
0273     if (le64_to_cpu(de->inode) != inode->i_ino)
0274         goto out;
0275
0276     if (!inode->i_nlink) {
0277         nilfs_warn(inode->i_sb,
0278                "deleting nonexistent file (ino=%lu), %d",
0279                inode->i_ino, inode->i_nlink);
0280         set_nlink(inode, 1);
0281     }
0282     err = nilfs_delete_entry(de, page);
0283     if (err)
0284         goto out;
0285
0286     inode->i_ctime = dir->i_ctime;
0287     drop_nlink(inode);
0288     err = 0;
0289 out:
0290     return err;
0291 }
0292
0293 static int nilfs_unlink(struct inode *dir, struct dentry *dentry)
0294 {
0295     struct nilfs_transaction_info ti;
0296     int err;
0297
0298     err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
0299     if (err)
0300         return err;
0301
0302     err = nilfs_do_unlink(dir, dentry);
0303
0304     if (!err) {
0305         nilfs_mark_inode_dirty(dir);
0306         nilfs_mark_inode_dirty(d_inode(dentry));
0307         err = nilfs_transaction_commit(dir->i_sb);
0308     } else
0309         nilfs_transaction_abort(dir->i_sb);
0310
0311     return err;
0312 }
0313
0314 static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
0315 {
0316     struct inode *inode = d_inode(dentry);
0317     struct nilfs_transaction_info ti;
0318     int err;
0319
0320     err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
0321     if (err)
0322         return err;
0323
0324     err = -ENOTEMPTY;
0325     if (nilfs_empty_dir(inode)) {
0326         err = nilfs_do_unlink(dir, dentry);
0327         if (!err) {
0328             inode->i_size = 0;
0329             drop_nlink(inode);
0330             nilfs_mark_inode_dirty(inode);
0331             drop_nlink(dir);
0332             nilfs_mark_inode_dirty(dir);
0333         }
0334     }
0335     if (!err)
0336         err = nilfs_transaction_commit(dir->i_sb);
0337     else
0338         nilfs_transaction_abort(dir->i_sb);
0339
0340     return err;
0341 }
0342
0343 static int nilfs_rename(struct user_namespace *mnt_userns,
0344             struct inode *old_dir, struct dentry *old_dentry,
0345             struct inode *new_dir, struct dentry *new_dentry,
0346             unsigned int flags)
0347 {
0348     struct inode *old_inode = d_inode(old_dentry);
0349     struct inode *new_inode = d_inode(new_dentry);
0350     struct page *dir_page = NULL;
0351     struct nilfs_dir_entry *dir_de = NULL;
0352     struct page *old_page;
0353     struct nilfs_dir_entry *old_de;
0354     struct nilfs_transaction_info ti;
0355     int err;
0356
0357     if (flags & ~RENAME_NOREPLACE)
0358         return -EINVAL;
0359
0360     err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1);
0361     if (unlikely(err))
0362         return err;
0363
0364     err = -ENOENT;
0365     old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page);
0366     if (!old_de)
0367         goto out;
0368
0369     if (S_ISDIR(old_inode->i_mode)) {
0370         err = -EIO;
0371         dir_de = nilfs_dotdot(old_inode, &dir_page);
0372         if (!dir_de)
0373             goto out_old;
0374     }
0375
0376     if (new_inode) {
0377         struct page *new_page;
0378         struct nilfs_dir_entry *new_de;
0379
0380         err = -ENOTEMPTY;
0381         if (dir_de && !nilfs_empty_dir(new_inode))
0382             goto out_dir;
0383
0384         err = -ENOENT;
0385         new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page);
0386         if (!new_de)
0387             goto out_dir;
0388         nilfs_set_link(new_dir, new_de, new_page, old_inode);
0389         nilfs_mark_inode_dirty(new_dir);
0390         new_inode->i_ctime = current_time(new_inode);
0391         if (dir_de)
0392             drop_nlink(new_inode);
0393         drop_nlink(new_inode);
0394         nilfs_mark_inode_dirty(new_inode);
0395     } else {
0396         err = nilfs_add_link(new_dentry, old_inode);
0397         if (err)
0398             goto out_dir;
0399         if (dir_de) {
0400             inc_nlink(new_dir);
0401             nilfs_mark_inode_dirty(new_dir);
0402         }
0403     }
0404
0405     /*
0406      * Like most other Unix systems, set the ctime for inodes on a
0407      * rename.
0408      */
0409     old_inode->i_ctime = current_time(old_inode);
0410
0411     nilfs_delete_entry(old_de, old_page);
0412
0413     if (dir_de) {
0414         nilfs_set_link(old_inode, dir_de, dir_page, new_dir);
0415         drop_nlink(old_dir);
0416     }
0417     nilfs_mark_inode_dirty(old_dir);
0418     nilfs_mark_inode_dirty(old_inode);
0419
0420     err = nilfs_transaction_commit(old_dir->i_sb);
0421     return err;
0422
0423 out_dir:
0424     if (dir_de) {
0425         kunmap(dir_page);
0426         put_page(dir_page);
0427     }
0428 out_old:
0429     kunmap(old_page);
0430     put_page(old_page);
0431 out:
0432     nilfs_transaction_abort(old_dir->i_sb);
0433     return err;
0434 }
0435
0436 /*
0437  * Export operations
0438  */
0439 static struct dentry *nilfs_get_parent(struct dentry *child)
0440 {
0441     unsigned long ino;
0442     struct inode *inode;
0443     struct nilfs_root *root;
0444
0445     ino = nilfs_inode_by_name(d_inode(child), &dotdot_name);
0446     if (!ino)
0447         return ERR_PTR(-ENOENT);
0448
0449     root = NILFS_I(d_inode(child))->i_root;
0450
0451     inode = nilfs_iget(child->d_sb, root, ino);
0452     if (IS_ERR(inode))
0453         return ERR_CAST(inode);
0454
0455     return d_obtain_alias(inode);
0456 }
0457
0458 static struct dentry *nilfs_get_dentry(struct super_block *sb, u64 cno,
0459                        u64 ino, u32 gen)
0460 {
0461     struct nilfs_root *root;
0462     struct inode *inode;
0463
0464     if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO)
0465         return ERR_PTR(-ESTALE);
0466
0467     root = nilfs_lookup_root(sb->s_fs_info, cno);
0468     if (!root)
0469         return ERR_PTR(-ESTALE);
0470
0471     inode = nilfs_iget(sb, root, ino);
0472     nilfs_put_root(root);
0473
0474     if (IS_ERR(inode))
0475         return ERR_CAST(inode);
0476     if (gen && inode->i_generation != gen) {
0477         iput(inode);
0478         return ERR_PTR(-ESTALE);
0479     }
0480     return d_obtain_alias(inode);
0481 }
0482
0483 static struct dentry *nilfs_fh_to_dentry(struct super_block *sb, struct fid *fh,
0484                      int fh_len, int fh_type)
0485 {
0486     struct nilfs_fid *fid = (struct nilfs_fid *)fh;
0487
0488     if (fh_len < NILFS_FID_SIZE_NON_CONNECTABLE ||
0489         (fh_type != FILEID_NILFS_WITH_PARENT &&
0490          fh_type != FILEID_NILFS_WITHOUT_PARENT))
0491         return NULL;
0492
0493     return nilfs_get_dentry(sb, fid->cno, fid->ino, fid->gen);
0494 }
0495
0496 static struct dentry *nilfs_fh_to_parent(struct super_block *sb, struct fid *fh,
0497                      int fh_len, int fh_type)
0498 {
0499     struct nilfs_fid *fid = (struct nilfs_fid *)fh;
0500
0501     if (fh_len < NILFS_FID_SIZE_CONNECTABLE ||
0502         fh_type != FILEID_NILFS_WITH_PARENT)
0503         return NULL;
0504
0505     return nilfs_get_dentry(sb, fid->cno, fid->parent_ino, fid->parent_gen);
0506 }
0507
0508 static int nilfs_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
0509                struct inode *parent)
0510 {
0511     struct nilfs_fid *fid = (struct nilfs_fid *)fh;
0512     struct nilfs_root *root = NILFS_I(inode)->i_root;
0513     int type;
0514
0515     if (parent && *lenp < NILFS_FID_SIZE_CONNECTABLE) {
0516         *lenp = NILFS_FID_SIZE_CONNECTABLE;
0517         return FILEID_INVALID;
0518     }
0519     if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE) {
0520         *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
0521         return FILEID_INVALID;
0522     }
0523
0524     fid->cno = root->cno;
0525     fid->ino = inode->i_ino;
0526     fid->gen = inode->i_generation;
0527
0528     if (parent) {
0529         fid->parent_ino = parent->i_ino;
0530         fid->parent_gen = parent->i_generation;
0531         type = FILEID_NILFS_WITH_PARENT;
0532         *lenp = NILFS_FID_SIZE_CONNECTABLE;
0533     } else {
0534         type = FILEID_NILFS_WITHOUT_PARENT;
0535         *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
0536     }
0537
0538     return type;
0539 }
0540
0541 const struct inode_operations nilfs_dir_inode_operations = {
0542     .create     = nilfs_create,
0543     .lookup     = nilfs_lookup,
0544     .link       = nilfs_link,
0545     .unlink     = nilfs_unlink,
0546     .symlink    = nilfs_symlink,
0547     .mkdir      = nilfs_mkdir,
0548     .rmdir      = nilfs_rmdir,
0549     .mknod      = nilfs_mknod,
0550     .rename     = nilfs_rename,
0551     .setattr    = nilfs_setattr,
0552     .permission = nilfs_permission,
0553     .fiemap     = nilfs_fiemap,
0554     .fileattr_get   = nilfs_fileattr_get,
0555     .fileattr_set   = nilfs_fileattr_set,
0556 };
0557
0558 const struct inode_operations nilfs_special_inode_operations = {
0559     .setattr    = nilfs_setattr,
0560     .permission = nilfs_permission,
0561 };
0562
0563 const struct inode_operations nilfs_symlink_inode_operations = {
0564     .get_link   = page_get_link,
0565     .permission     = nilfs_permission,
0566 };
0567
0568 const struct export_operations nilfs_export_ops = {
0569     .encode_fh = nilfs_encode_fh,
0570     .fh_to_dentry = nilfs_fh_to_dentry,
0571     .fh_to_parent = nilfs_fh_to_parent,
0572     .get_parent = nilfs_get_parent,
0573 };