Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *
0004  * Copyright (C) 2011 Novell Inc.
0005  */
0006 
0007 #include <linux/fs.h>
0008 #include <linux/namei.h>
0009 #include <linux/xattr.h>
0010 #include <linux/security.h>
0011 #include <linux/cred.h>
0012 #include <linux/module.h>
0013 #include <linux/posix_acl.h>
0014 #include <linux/posix_acl_xattr.h>
0015 #include <linux/atomic.h>
0016 #include <linux/ratelimit.h>
0017 #include "overlayfs.h"
0018 
0019 static unsigned short ovl_redirect_max = 256;
0020 module_param_named(redirect_max, ovl_redirect_max, ushort, 0644);
0021 MODULE_PARM_DESC(redirect_max,
0022          "Maximum length of absolute redirect xattr value");
0023 
0024 static int ovl_set_redirect(struct dentry *dentry, bool samedir);
0025 
0026 int ovl_cleanup(struct ovl_fs *ofs, struct inode *wdir, struct dentry *wdentry)
0027 {
0028     int err;
0029 
0030     dget(wdentry);
0031     if (d_is_dir(wdentry))
0032         err = ovl_do_rmdir(ofs, wdir, wdentry);
0033     else
0034         err = ovl_do_unlink(ofs, wdir, wdentry);
0035     dput(wdentry);
0036 
0037     if (err) {
0038         pr_err("cleanup of '%pd2' failed (%i)\n",
0039                wdentry, err);
0040     }
0041 
0042     return err;
0043 }
0044 
0045 struct dentry *ovl_lookup_temp(struct ovl_fs *ofs, struct dentry *workdir)
0046 {
0047     struct dentry *temp;
0048     char name[20];
0049     static atomic_t temp_id = ATOMIC_INIT(0);
0050 
0051     /* counter is allowed to wrap, since temp dentries are ephemeral */
0052     snprintf(name, sizeof(name), "#%x", atomic_inc_return(&temp_id));
0053 
0054     temp = ovl_lookup_upper(ofs, name, workdir, strlen(name));
0055     if (!IS_ERR(temp) && temp->d_inode) {
0056         pr_err("workdir/%s already exists\n", name);
0057         dput(temp);
0058         temp = ERR_PTR(-EIO);
0059     }
0060 
0061     return temp;
0062 }
0063 
0064 /* caller holds i_mutex on workdir */
0065 static struct dentry *ovl_whiteout(struct ovl_fs *ofs)
0066 {
0067     int err;
0068     struct dentry *whiteout;
0069     struct dentry *workdir = ofs->workdir;
0070     struct inode *wdir = workdir->d_inode;
0071 
0072     if (!ofs->whiteout) {
0073         whiteout = ovl_lookup_temp(ofs, workdir);
0074         if (IS_ERR(whiteout))
0075             goto out;
0076 
0077         err = ovl_do_whiteout(ofs, wdir, whiteout);
0078         if (err) {
0079             dput(whiteout);
0080             whiteout = ERR_PTR(err);
0081             goto out;
0082         }
0083         ofs->whiteout = whiteout;
0084     }
0085 
0086     if (ofs->share_whiteout) {
0087         whiteout = ovl_lookup_temp(ofs, workdir);
0088         if (IS_ERR(whiteout))
0089             goto out;
0090 
0091         err = ovl_do_link(ofs, ofs->whiteout, wdir, whiteout);
0092         if (!err)
0093             goto out;
0094 
0095         if (err != -EMLINK) {
0096             pr_warn("Failed to link whiteout - disabling whiteout inode sharing(nlink=%u, err=%i)\n",
0097                 ofs->whiteout->d_inode->i_nlink, err);
0098             ofs->share_whiteout = false;
0099         }
0100         dput(whiteout);
0101     }
0102     whiteout = ofs->whiteout;
0103     ofs->whiteout = NULL;
0104 out:
0105     return whiteout;
0106 }
0107 
0108 /* Caller must hold i_mutex on both workdir and dir */
0109 int ovl_cleanup_and_whiteout(struct ovl_fs *ofs, struct inode *dir,
0110                  struct dentry *dentry)
0111 {
0112     struct inode *wdir = ofs->workdir->d_inode;
0113     struct dentry *whiteout;
0114     int err;
0115     int flags = 0;
0116 
0117     whiteout = ovl_whiteout(ofs);
0118     err = PTR_ERR(whiteout);
0119     if (IS_ERR(whiteout))
0120         return err;
0121 
0122     if (d_is_dir(dentry))
0123         flags = RENAME_EXCHANGE;
0124 
0125     err = ovl_do_rename(ofs, wdir, whiteout, dir, dentry, flags);
0126     if (err)
0127         goto kill_whiteout;
0128     if (flags)
0129         ovl_cleanup(ofs, wdir, dentry);
0130 
0131 out:
0132     dput(whiteout);
0133     return err;
0134 
0135 kill_whiteout:
0136     ovl_cleanup(ofs, wdir, whiteout);
0137     goto out;
0138 }
0139 
0140 int ovl_mkdir_real(struct ovl_fs *ofs, struct inode *dir,
0141            struct dentry **newdentry, umode_t mode)
0142 {
0143     int err;
0144     struct dentry *d, *dentry = *newdentry;
0145 
0146     err = ovl_do_mkdir(ofs, dir, dentry, mode);
0147     if (err)
0148         return err;
0149 
0150     if (likely(!d_unhashed(dentry)))
0151         return 0;
0152 
0153     /*
0154      * vfs_mkdir() may succeed and leave the dentry passed
0155      * to it unhashed and negative. If that happens, try to
0156      * lookup a new hashed and positive dentry.
0157      */
0158     d = ovl_lookup_upper(ofs, dentry->d_name.name, dentry->d_parent,
0159                  dentry->d_name.len);
0160     if (IS_ERR(d)) {
0161         pr_warn("failed lookup after mkdir (%pd2, err=%i).\n",
0162             dentry, err);
0163         return PTR_ERR(d);
0164     }
0165     dput(dentry);
0166     *newdentry = d;
0167 
0168     return 0;
0169 }
0170 
0171 struct dentry *ovl_create_real(struct ovl_fs *ofs, struct inode *dir,
0172                    struct dentry *newdentry, struct ovl_cattr *attr)
0173 {
0174     int err;
0175 
0176     if (IS_ERR(newdentry))
0177         return newdentry;
0178 
0179     err = -ESTALE;
0180     if (newdentry->d_inode)
0181         goto out;
0182 
0183     if (attr->hardlink) {
0184         err = ovl_do_link(ofs, attr->hardlink, dir, newdentry);
0185     } else {
0186         switch (attr->mode & S_IFMT) {
0187         case S_IFREG:
0188             err = ovl_do_create(ofs, dir, newdentry, attr->mode);
0189             break;
0190 
0191         case S_IFDIR:
0192             /* mkdir is special... */
0193             err =  ovl_mkdir_real(ofs, dir, &newdentry, attr->mode);
0194             break;
0195 
0196         case S_IFCHR:
0197         case S_IFBLK:
0198         case S_IFIFO:
0199         case S_IFSOCK:
0200             err = ovl_do_mknod(ofs, dir, newdentry, attr->mode,
0201                        attr->rdev);
0202             break;
0203 
0204         case S_IFLNK:
0205             err = ovl_do_symlink(ofs, dir, newdentry, attr->link);
0206             break;
0207 
0208         default:
0209             err = -EPERM;
0210         }
0211     }
0212     if (!err && WARN_ON(!newdentry->d_inode)) {
0213         /*
0214          * Not quite sure if non-instantiated dentry is legal or not.
0215          * VFS doesn't seem to care so check and warn here.
0216          */
0217         err = -EIO;
0218     }
0219 out:
0220     if (err) {
0221         dput(newdentry);
0222         return ERR_PTR(err);
0223     }
0224     return newdentry;
0225 }
0226 
0227 struct dentry *ovl_create_temp(struct ovl_fs *ofs, struct dentry *workdir,
0228                    struct ovl_cattr *attr)
0229 {
0230     return ovl_create_real(ofs, d_inode(workdir),
0231                    ovl_lookup_temp(ofs, workdir), attr);
0232 }
0233 
0234 static int ovl_set_opaque_xerr(struct dentry *dentry, struct dentry *upper,
0235                    int xerr)
0236 {
0237     struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
0238     int err;
0239 
0240     err = ovl_check_setxattr(ofs, upper, OVL_XATTR_OPAQUE, "y", 1, xerr);
0241     if (!err)
0242         ovl_dentry_set_opaque(dentry);
0243 
0244     return err;
0245 }
0246 
0247 static int ovl_set_opaque(struct dentry *dentry, struct dentry *upperdentry)
0248 {
0249     /*
0250      * Fail with -EIO when trying to create opaque dir and upper doesn't
0251      * support xattrs. ovl_rename() calls ovl_set_opaque_xerr(-EXDEV) to
0252      * return a specific error for noxattr case.
0253      */
0254     return ovl_set_opaque_xerr(dentry, upperdentry, -EIO);
0255 }
0256 
0257 /*
0258  * Common operations required to be done after creation of file on upper.
0259  * If @hardlink is false, then @inode is a pre-allocated inode, we may or
0260  * may not use to instantiate the new dentry.
0261  */
0262 static int ovl_instantiate(struct dentry *dentry, struct inode *inode,
0263                struct dentry *newdentry, bool hardlink)
0264 {
0265     struct ovl_inode_params oip = {
0266         .upperdentry = newdentry,
0267         .newinode = inode,
0268     };
0269 
0270     ovl_dir_modified(dentry->d_parent, false);
0271     ovl_dentry_set_upper_alias(dentry);
0272     ovl_dentry_update_reval(dentry, newdentry,
0273             DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE);
0274 
0275     if (!hardlink) {
0276         /*
0277          * ovl_obtain_alias() can be called after ovl_create_real()
0278          * and before we get here, so we may get an inode from cache
0279          * with the same real upperdentry that is not the inode we
0280          * pre-allocated.  In this case we will use the cached inode
0281          * to instantiate the new dentry.
0282          *
0283          * XXX: if we ever use ovl_obtain_alias() to decode directory
0284          * file handles, need to use ovl_get_inode_locked() and
0285          * d_instantiate_new() here to prevent from creating two
0286          * hashed directory inode aliases.
0287          */
0288         inode = ovl_get_inode(dentry->d_sb, &oip);
0289         if (IS_ERR(inode))
0290             return PTR_ERR(inode);
0291         if (inode == oip.newinode)
0292             ovl_set_flag(OVL_UPPERDATA, inode);
0293     } else {
0294         WARN_ON(ovl_inode_real(inode) != d_inode(newdentry));
0295         dput(newdentry);
0296         inc_nlink(inode);
0297     }
0298 
0299     d_instantiate(dentry, inode);
0300     if (inode != oip.newinode) {
0301         pr_warn_ratelimited("newly created inode found in cache (%pd2)\n",
0302                     dentry);
0303     }
0304 
0305     /* Force lookup of new upper hardlink to find its lower */
0306     if (hardlink)
0307         d_drop(dentry);
0308 
0309     return 0;
0310 }
0311 
0312 static bool ovl_type_merge(struct dentry *dentry)
0313 {
0314     return OVL_TYPE_MERGE(ovl_path_type(dentry));
0315 }
0316 
0317 static bool ovl_type_origin(struct dentry *dentry)
0318 {
0319     return OVL_TYPE_ORIGIN(ovl_path_type(dentry));
0320 }
0321 
0322 static int ovl_create_upper(struct dentry *dentry, struct inode *inode,
0323                 struct ovl_cattr *attr)
0324 {
0325     struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
0326     struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
0327     struct inode *udir = upperdir->d_inode;
0328     struct dentry *newdentry;
0329     int err;
0330 
0331     if (!attr->hardlink && !IS_POSIXACL(udir))
0332         attr->mode &= ~current_umask();
0333 
0334     inode_lock_nested(udir, I_MUTEX_PARENT);
0335     newdentry = ovl_create_real(ofs, udir,
0336                     ovl_lookup_upper(ofs, dentry->d_name.name,
0337                              upperdir, dentry->d_name.len),
0338                     attr);
0339     err = PTR_ERR(newdentry);
0340     if (IS_ERR(newdentry))
0341         goto out_unlock;
0342 
0343     if (ovl_type_merge(dentry->d_parent) && d_is_dir(newdentry) &&
0344         !ovl_allow_offline_changes(ofs)) {
0345         /* Setting opaque here is just an optimization, allow to fail */
0346         ovl_set_opaque(dentry, newdentry);
0347     }
0348 
0349     err = ovl_instantiate(dentry, inode, newdentry, !!attr->hardlink);
0350     if (err)
0351         goto out_cleanup;
0352 out_unlock:
0353     inode_unlock(udir);
0354     return err;
0355 
0356 out_cleanup:
0357     ovl_cleanup(ofs, udir, newdentry);
0358     dput(newdentry);
0359     goto out_unlock;
0360 }
0361 
0362 static struct dentry *ovl_clear_empty(struct dentry *dentry,
0363                       struct list_head *list)
0364 {
0365     struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
0366     struct dentry *workdir = ovl_workdir(dentry);
0367     struct inode *wdir = workdir->d_inode;
0368     struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
0369     struct inode *udir = upperdir->d_inode;
0370     struct path upperpath;
0371     struct dentry *upper;
0372     struct dentry *opaquedir;
0373     struct kstat stat;
0374     int err;
0375 
0376     if (WARN_ON(!workdir))
0377         return ERR_PTR(-EROFS);
0378 
0379     err = ovl_lock_rename_workdir(workdir, upperdir);
0380     if (err)
0381         goto out;
0382 
0383     ovl_path_upper(dentry, &upperpath);
0384     err = vfs_getattr(&upperpath, &stat,
0385               STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
0386     if (err)
0387         goto out_unlock;
0388 
0389     err = -ESTALE;
0390     if (!S_ISDIR(stat.mode))
0391         goto out_unlock;
0392     upper = upperpath.dentry;
0393     if (upper->d_parent->d_inode != udir)
0394         goto out_unlock;
0395 
0396     opaquedir = ovl_create_temp(ofs, workdir, OVL_CATTR(stat.mode));
0397     err = PTR_ERR(opaquedir);
0398     if (IS_ERR(opaquedir))
0399         goto out_unlock;
0400 
0401     err = ovl_copy_xattr(dentry->d_sb, &upperpath, opaquedir);
0402     if (err)
0403         goto out_cleanup;
0404 
0405     err = ovl_set_opaque(dentry, opaquedir);
0406     if (err)
0407         goto out_cleanup;
0408 
0409     inode_lock(opaquedir->d_inode);
0410     err = ovl_set_attr(ofs, opaquedir, &stat);
0411     inode_unlock(opaquedir->d_inode);
0412     if (err)
0413         goto out_cleanup;
0414 
0415     err = ovl_do_rename(ofs, wdir, opaquedir, udir, upper, RENAME_EXCHANGE);
0416     if (err)
0417         goto out_cleanup;
0418 
0419     ovl_cleanup_whiteouts(ofs, upper, list);
0420     ovl_cleanup(ofs, wdir, upper);
0421     unlock_rename(workdir, upperdir);
0422 
0423     /* dentry's upper doesn't match now, get rid of it */
0424     d_drop(dentry);
0425 
0426     return opaquedir;
0427 
0428 out_cleanup:
0429     ovl_cleanup(ofs, wdir, opaquedir);
0430     dput(opaquedir);
0431 out_unlock:
0432     unlock_rename(workdir, upperdir);
0433 out:
0434     return ERR_PTR(err);
0435 }
0436 
0437 static int ovl_set_upper_acl(struct ovl_fs *ofs, struct dentry *upperdentry,
0438                  const char *name, const struct posix_acl *acl)
0439 {
0440     void *buffer;
0441     size_t size;
0442     int err;
0443 
0444     if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !acl)
0445         return 0;
0446 
0447     size = posix_acl_xattr_size(acl->a_count);
0448     buffer = kmalloc(size, GFP_KERNEL);
0449     if (!buffer)
0450         return -ENOMEM;
0451 
0452     err = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
0453     if (err < 0)
0454         goto out_free;
0455 
0456     err = ovl_do_setxattr(ofs, upperdentry, name, buffer, size, XATTR_CREATE);
0457 out_free:
0458     kfree(buffer);
0459     return err;
0460 }
0461 
0462 static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,
0463                     struct ovl_cattr *cattr)
0464 {
0465     struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
0466     struct dentry *workdir = ovl_workdir(dentry);
0467     struct inode *wdir = workdir->d_inode;
0468     struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
0469     struct inode *udir = upperdir->d_inode;
0470     struct dentry *upper;
0471     struct dentry *newdentry;
0472     int err;
0473     struct posix_acl *acl, *default_acl;
0474     bool hardlink = !!cattr->hardlink;
0475 
0476     if (WARN_ON(!workdir))
0477         return -EROFS;
0478 
0479     if (!hardlink) {
0480         err = posix_acl_create(dentry->d_parent->d_inode,
0481                        &cattr->mode, &default_acl, &acl);
0482         if (err)
0483             return err;
0484     }
0485 
0486     err = ovl_lock_rename_workdir(workdir, upperdir);
0487     if (err)
0488         goto out;
0489 
0490     upper = ovl_lookup_upper(ofs, dentry->d_name.name, upperdir,
0491                  dentry->d_name.len);
0492     err = PTR_ERR(upper);
0493     if (IS_ERR(upper))
0494         goto out_unlock;
0495 
0496     err = -ESTALE;
0497     if (d_is_negative(upper) || !IS_WHITEOUT(d_inode(upper)))
0498         goto out_dput;
0499 
0500     newdentry = ovl_create_temp(ofs, workdir, cattr);
0501     err = PTR_ERR(newdentry);
0502     if (IS_ERR(newdentry))
0503         goto out_dput;
0504 
0505     /*
0506      * mode could have been mutilated due to umask (e.g. sgid directory)
0507      */
0508     if (!hardlink &&
0509         !S_ISLNK(cattr->mode) &&
0510         newdentry->d_inode->i_mode != cattr->mode) {
0511         struct iattr attr = {
0512             .ia_valid = ATTR_MODE,
0513             .ia_mode = cattr->mode,
0514         };
0515         inode_lock(newdentry->d_inode);
0516         err = ovl_do_notify_change(ofs, newdentry, &attr);
0517         inode_unlock(newdentry->d_inode);
0518         if (err)
0519             goto out_cleanup;
0520     }
0521     if (!hardlink) {
0522         err = ovl_set_upper_acl(ofs, newdentry,
0523                     XATTR_NAME_POSIX_ACL_ACCESS, acl);
0524         if (err)
0525             goto out_cleanup;
0526 
0527         err = ovl_set_upper_acl(ofs, newdentry,
0528                     XATTR_NAME_POSIX_ACL_DEFAULT, default_acl);
0529         if (err)
0530             goto out_cleanup;
0531     }
0532 
0533     if (!hardlink && S_ISDIR(cattr->mode)) {
0534         err = ovl_set_opaque(dentry, newdentry);
0535         if (err)
0536             goto out_cleanup;
0537 
0538         err = ovl_do_rename(ofs, wdir, newdentry, udir, upper,
0539                     RENAME_EXCHANGE);
0540         if (err)
0541             goto out_cleanup;
0542 
0543         ovl_cleanup(ofs, wdir, upper);
0544     } else {
0545         err = ovl_do_rename(ofs, wdir, newdentry, udir, upper, 0);
0546         if (err)
0547             goto out_cleanup;
0548     }
0549     err = ovl_instantiate(dentry, inode, newdentry, hardlink);
0550     if (err) {
0551         ovl_cleanup(ofs, udir, newdentry);
0552         dput(newdentry);
0553     }
0554 out_dput:
0555     dput(upper);
0556 out_unlock:
0557     unlock_rename(workdir, upperdir);
0558 out:
0559     if (!hardlink) {
0560         posix_acl_release(acl);
0561         posix_acl_release(default_acl);
0562     }
0563     return err;
0564 
0565 out_cleanup:
0566     ovl_cleanup(ofs, wdir, newdentry);
0567     dput(newdentry);
0568     goto out_dput;
0569 }
0570 
0571 static int ovl_create_or_link(struct dentry *dentry, struct inode *inode,
0572                   struct ovl_cattr *attr, bool origin)
0573 {
0574     int err;
0575     const struct cred *old_cred;
0576     struct cred *override_cred;
0577     struct dentry *parent = dentry->d_parent;
0578 
0579     err = ovl_copy_up(parent);
0580     if (err)
0581         return err;
0582 
0583     old_cred = ovl_override_creds(dentry->d_sb);
0584 
0585     /*
0586      * When linking a file with copy up origin into a new parent, mark the
0587      * new parent dir "impure".
0588      */
0589     if (origin) {
0590         err = ovl_set_impure(parent, ovl_dentry_upper(parent));
0591         if (err)
0592             goto out_revert_creds;
0593     }
0594 
0595     err = -ENOMEM;
0596     override_cred = prepare_creds();
0597     if (override_cred) {
0598         override_cred->fsuid = inode->i_uid;
0599         override_cred->fsgid = inode->i_gid;
0600         if (!attr->hardlink) {
0601             err = security_dentry_create_files_as(dentry,
0602                     attr->mode, &dentry->d_name, old_cred,
0603                     override_cred);
0604             if (err) {
0605                 put_cred(override_cred);
0606                 goto out_revert_creds;
0607             }
0608         }
0609         put_cred(override_creds(override_cred));
0610         put_cred(override_cred);
0611 
0612         if (!ovl_dentry_is_whiteout(dentry))
0613             err = ovl_create_upper(dentry, inode, attr);
0614         else
0615             err = ovl_create_over_whiteout(dentry, inode, attr);
0616     }
0617 out_revert_creds:
0618     revert_creds(old_cred);
0619     return err;
0620 }
0621 
0622 static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev,
0623                  const char *link)
0624 {
0625     int err;
0626     struct inode *inode;
0627     struct ovl_cattr attr = {
0628         .rdev = rdev,
0629         .link = link,
0630     };
0631 
0632     err = ovl_want_write(dentry);
0633     if (err)
0634         goto out;
0635 
0636     /* Preallocate inode to be used by ovl_get_inode() */
0637     err = -ENOMEM;
0638     inode = ovl_new_inode(dentry->d_sb, mode, rdev);
0639     if (!inode)
0640         goto out_drop_write;
0641 
0642     spin_lock(&inode->i_lock);
0643     inode->i_state |= I_CREATING;
0644     spin_unlock(&inode->i_lock);
0645 
0646     inode_init_owner(&init_user_ns, inode, dentry->d_parent->d_inode, mode);
0647     attr.mode = inode->i_mode;
0648 
0649     err = ovl_create_or_link(dentry, inode, &attr, false);
0650     /* Did we end up using the preallocated inode? */
0651     if (inode != d_inode(dentry))
0652         iput(inode);
0653 
0654 out_drop_write:
0655     ovl_drop_write(dentry);
0656 out:
0657     return err;
0658 }
0659 
0660 static int ovl_create(struct user_namespace *mnt_userns, struct inode *dir,
0661               struct dentry *dentry, umode_t mode, bool excl)
0662 {
0663     return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL);
0664 }
0665 
0666 static int ovl_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
0667              struct dentry *dentry, umode_t mode)
0668 {
0669     return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL);
0670 }
0671 
0672 static int ovl_mknod(struct user_namespace *mnt_userns, struct inode *dir,
0673              struct dentry *dentry, umode_t mode, dev_t rdev)
0674 {
0675     /* Don't allow creation of "whiteout" on overlay */
0676     if (S_ISCHR(mode) && rdev == WHITEOUT_DEV)
0677         return -EPERM;
0678 
0679     return ovl_create_object(dentry, mode, rdev, NULL);
0680 }
0681 
0682 static int ovl_symlink(struct user_namespace *mnt_userns, struct inode *dir,
0683                struct dentry *dentry, const char *link)
0684 {
0685     return ovl_create_object(dentry, S_IFLNK, 0, link);
0686 }
0687 
0688 static int ovl_set_link_redirect(struct dentry *dentry)
0689 {
0690     const struct cred *old_cred;
0691     int err;
0692 
0693     old_cred = ovl_override_creds(dentry->d_sb);
0694     err = ovl_set_redirect(dentry, false);
0695     revert_creds(old_cred);
0696 
0697     return err;
0698 }
0699 
0700 static int ovl_link(struct dentry *old, struct inode *newdir,
0701             struct dentry *new)
0702 {
0703     int err;
0704     struct inode *inode;
0705 
0706     err = ovl_want_write(old);
0707     if (err)
0708         goto out;
0709 
0710     err = ovl_copy_up(old);
0711     if (err)
0712         goto out_drop_write;
0713 
0714     err = ovl_copy_up(new->d_parent);
0715     if (err)
0716         goto out_drop_write;
0717 
0718     if (ovl_is_metacopy_dentry(old)) {
0719         err = ovl_set_link_redirect(old);
0720         if (err)
0721             goto out_drop_write;
0722     }
0723 
0724     err = ovl_nlink_start(old);
0725     if (err)
0726         goto out_drop_write;
0727 
0728     inode = d_inode(old);
0729     ihold(inode);
0730 
0731     err = ovl_create_or_link(new, inode,
0732             &(struct ovl_cattr) {.hardlink = ovl_dentry_upper(old)},
0733             ovl_type_origin(old));
0734     if (err)
0735         iput(inode);
0736 
0737     ovl_nlink_end(old);
0738 out_drop_write:
0739     ovl_drop_write(old);
0740 out:
0741     return err;
0742 }
0743 
0744 static bool ovl_matches_upper(struct dentry *dentry, struct dentry *upper)
0745 {
0746     return d_inode(ovl_dentry_upper(dentry)) == d_inode(upper);
0747 }
0748 
0749 static int ovl_remove_and_whiteout(struct dentry *dentry,
0750                    struct list_head *list)
0751 {
0752     struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
0753     struct dentry *workdir = ovl_workdir(dentry);
0754     struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
0755     struct dentry *upper;
0756     struct dentry *opaquedir = NULL;
0757     int err;
0758 
0759     if (WARN_ON(!workdir))
0760         return -EROFS;
0761 
0762     if (!list_empty(list)) {
0763         opaquedir = ovl_clear_empty(dentry, list);
0764         err = PTR_ERR(opaquedir);
0765         if (IS_ERR(opaquedir))
0766             goto out;
0767     }
0768 
0769     err = ovl_lock_rename_workdir(workdir, upperdir);
0770     if (err)
0771         goto out_dput;
0772 
0773     upper = ovl_lookup_upper(ofs, dentry->d_name.name, upperdir,
0774                  dentry->d_name.len);
0775     err = PTR_ERR(upper);
0776     if (IS_ERR(upper))
0777         goto out_unlock;
0778 
0779     err = -ESTALE;
0780     if ((opaquedir && upper != opaquedir) ||
0781         (!opaquedir && ovl_dentry_upper(dentry) &&
0782          !ovl_matches_upper(dentry, upper))) {
0783         goto out_dput_upper;
0784     }
0785 
0786     err = ovl_cleanup_and_whiteout(ofs, d_inode(upperdir), upper);
0787     if (err)
0788         goto out_d_drop;
0789 
0790     ovl_dir_modified(dentry->d_parent, true);
0791 out_d_drop:
0792     d_drop(dentry);
0793 out_dput_upper:
0794     dput(upper);
0795 out_unlock:
0796     unlock_rename(workdir, upperdir);
0797 out_dput:
0798     dput(opaquedir);
0799 out:
0800     return err;
0801 }
0802 
0803 static int ovl_remove_upper(struct dentry *dentry, bool is_dir,
0804                 struct list_head *list)
0805 {
0806     struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
0807     struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
0808     struct inode *dir = upperdir->d_inode;
0809     struct dentry *upper;
0810     struct dentry *opaquedir = NULL;
0811     int err;
0812 
0813     if (!list_empty(list)) {
0814         opaquedir = ovl_clear_empty(dentry, list);
0815         err = PTR_ERR(opaquedir);
0816         if (IS_ERR(opaquedir))
0817             goto out;
0818     }
0819 
0820     inode_lock_nested(dir, I_MUTEX_PARENT);
0821     upper = ovl_lookup_upper(ofs, dentry->d_name.name, upperdir,
0822                  dentry->d_name.len);
0823     err = PTR_ERR(upper);
0824     if (IS_ERR(upper))
0825         goto out_unlock;
0826 
0827     err = -ESTALE;
0828     if ((opaquedir && upper != opaquedir) ||
0829         (!opaquedir && !ovl_matches_upper(dentry, upper)))
0830         goto out_dput_upper;
0831 
0832     if (is_dir)
0833         err = ovl_do_rmdir(ofs, dir, upper);
0834     else
0835         err = ovl_do_unlink(ofs, dir, upper);
0836     ovl_dir_modified(dentry->d_parent, ovl_type_origin(dentry));
0837 
0838     /*
0839      * Keeping this dentry hashed would mean having to release
0840      * upperpath/lowerpath, which could only be done if we are the
0841      * sole user of this dentry.  Too tricky...  Just unhash for
0842      * now.
0843      */
0844     if (!err)
0845         d_drop(dentry);
0846 out_dput_upper:
0847     dput(upper);
0848 out_unlock:
0849     inode_unlock(dir);
0850     dput(opaquedir);
0851 out:
0852     return err;
0853 }
0854 
0855 static bool ovl_pure_upper(struct dentry *dentry)
0856 {
0857     return !ovl_dentry_lower(dentry) &&
0858            !ovl_test_flag(OVL_WHITEOUTS, d_inode(dentry));
0859 }
0860 
0861 static void ovl_drop_nlink(struct dentry *dentry)
0862 {
0863     struct inode *inode = d_inode(dentry);
0864     struct dentry *alias;
0865 
0866     /* Try to find another, hashed alias */
0867     spin_lock(&inode->i_lock);
0868     hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
0869         if (alias != dentry && !d_unhashed(alias))
0870             break;
0871     }
0872     spin_unlock(&inode->i_lock);
0873 
0874     /*
0875      * Changes to underlying layers may cause i_nlink to lose sync with
0876      * reality.  In this case prevent the link count from going to zero
0877      * prematurely.
0878      */
0879     if (inode->i_nlink > !!alias)
0880         drop_nlink(inode);
0881 }
0882 
0883 static int ovl_do_remove(struct dentry *dentry, bool is_dir)
0884 {
0885     int err;
0886     const struct cred *old_cred;
0887     bool lower_positive = ovl_lower_positive(dentry);
0888     LIST_HEAD(list);
0889 
0890     /* No need to clean pure upper removed by vfs_rmdir() */
0891     if (is_dir && (lower_positive || !ovl_pure_upper(dentry))) {
0892         err = ovl_check_empty_dir(dentry, &list);
0893         if (err)
0894             goto out;
0895     }
0896 
0897     err = ovl_want_write(dentry);
0898     if (err)
0899         goto out;
0900 
0901     err = ovl_copy_up(dentry->d_parent);
0902     if (err)
0903         goto out_drop_write;
0904 
0905     err = ovl_nlink_start(dentry);
0906     if (err)
0907         goto out_drop_write;
0908 
0909     old_cred = ovl_override_creds(dentry->d_sb);
0910     if (!lower_positive)
0911         err = ovl_remove_upper(dentry, is_dir, &list);
0912     else
0913         err = ovl_remove_and_whiteout(dentry, &list);
0914     revert_creds(old_cred);
0915     if (!err) {
0916         if (is_dir)
0917             clear_nlink(dentry->d_inode);
0918         else
0919             ovl_drop_nlink(dentry);
0920     }
0921     ovl_nlink_end(dentry);
0922 
0923     /*
0924      * Copy ctime
0925      *
0926      * Note: we fail to update ctime if there was no copy-up, only a
0927      * whiteout
0928      */
0929     if (ovl_dentry_upper(dentry))
0930         ovl_copyattr(d_inode(dentry));
0931 
0932 out_drop_write:
0933     ovl_drop_write(dentry);
0934 out:
0935     ovl_cache_free(&list);
0936     return err;
0937 }
0938 
0939 static int ovl_unlink(struct inode *dir, struct dentry *dentry)
0940 {
0941     return ovl_do_remove(dentry, false);
0942 }
0943 
0944 static int ovl_rmdir(struct inode *dir, struct dentry *dentry)
0945 {
0946     return ovl_do_remove(dentry, true);
0947 }
0948 
0949 static bool ovl_type_merge_or_lower(struct dentry *dentry)
0950 {
0951     enum ovl_path_type type = ovl_path_type(dentry);
0952 
0953     return OVL_TYPE_MERGE(type) || !OVL_TYPE_UPPER(type);
0954 }
0955 
0956 static bool ovl_can_move(struct dentry *dentry)
0957 {
0958     return ovl_redirect_dir(dentry->d_sb) ||
0959         !d_is_dir(dentry) || !ovl_type_merge_or_lower(dentry);
0960 }
0961 
0962 static char *ovl_get_redirect(struct dentry *dentry, bool abs_redirect)
0963 {
0964     char *buf, *ret;
0965     struct dentry *d, *tmp;
0966     int buflen = ovl_redirect_max + 1;
0967 
0968     if (!abs_redirect) {
0969         ret = kstrndup(dentry->d_name.name, dentry->d_name.len,
0970                    GFP_KERNEL);
0971         goto out;
0972     }
0973 
0974     buf = ret = kmalloc(buflen, GFP_KERNEL);
0975     if (!buf)
0976         goto out;
0977 
0978     buflen--;
0979     buf[buflen] = '\0';
0980     for (d = dget(dentry); !IS_ROOT(d);) {
0981         const char *name;
0982         int thislen;
0983 
0984         spin_lock(&d->d_lock);
0985         name = ovl_dentry_get_redirect(d);
0986         if (name) {
0987             thislen = strlen(name);
0988         } else {
0989             name = d->d_name.name;
0990             thislen = d->d_name.len;
0991         }
0992 
0993         /* If path is too long, fall back to userspace move */
0994         if (thislen + (name[0] != '/') > buflen) {
0995             ret = ERR_PTR(-EXDEV);
0996             spin_unlock(&d->d_lock);
0997             goto out_put;
0998         }
0999 
1000         buflen -= thislen;
1001         memcpy(&buf[buflen], name, thislen);
1002         spin_unlock(&d->d_lock);
1003         tmp = dget_parent(d);
1004 
1005         dput(d);
1006         d = tmp;
1007 
1008         /* Absolute redirect: finished */
1009         if (buf[buflen] == '/')
1010             break;
1011         buflen--;
1012         buf[buflen] = '/';
1013     }
1014     ret = kstrdup(&buf[buflen], GFP_KERNEL);
1015 out_put:
1016     dput(d);
1017     kfree(buf);
1018 out:
1019     return ret ? ret : ERR_PTR(-ENOMEM);
1020 }
1021 
1022 static bool ovl_need_absolute_redirect(struct dentry *dentry, bool samedir)
1023 {
1024     struct dentry *lowerdentry;
1025 
1026     if (!samedir)
1027         return true;
1028 
1029     if (d_is_dir(dentry))
1030         return false;
1031 
1032     /*
1033      * For non-dir hardlinked files, we need absolute redirects
1034      * in general as two upper hardlinks could be in different
1035      * dirs. We could put a relative redirect now and convert
1036      * it to absolute redirect later. But when nlink > 1 and
1037      * indexing is on, that means relative redirect needs to be
1038      * converted to absolute during copy up of another lower
1039      * hardllink as well.
1040      *
1041      * So without optimizing too much, just check if lower is
1042      * a hard link or not. If lower is hard link, put absolute
1043      * redirect.
1044      */
1045     lowerdentry = ovl_dentry_lower(dentry);
1046     return (d_inode(lowerdentry)->i_nlink > 1);
1047 }
1048 
1049 static int ovl_set_redirect(struct dentry *dentry, bool samedir)
1050 {
1051     int err;
1052     struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
1053     const char *redirect = ovl_dentry_get_redirect(dentry);
1054     bool absolute_redirect = ovl_need_absolute_redirect(dentry, samedir);
1055 
1056     if (redirect && (!absolute_redirect || redirect[0] == '/'))
1057         return 0;
1058 
1059     redirect = ovl_get_redirect(dentry, absolute_redirect);
1060     if (IS_ERR(redirect))
1061         return PTR_ERR(redirect);
1062 
1063     err = ovl_check_setxattr(ofs, ovl_dentry_upper(dentry),
1064                  OVL_XATTR_REDIRECT,
1065                  redirect, strlen(redirect), -EXDEV);
1066     if (!err) {
1067         spin_lock(&dentry->d_lock);
1068         ovl_dentry_set_redirect(dentry, redirect);
1069         spin_unlock(&dentry->d_lock);
1070     } else {
1071         kfree(redirect);
1072         pr_warn_ratelimited("failed to set redirect (%i)\n",
1073                     err);
1074         /* Fall back to userspace copy-up */
1075         err = -EXDEV;
1076     }
1077     return err;
1078 }
1079 
1080 static int ovl_rename(struct user_namespace *mnt_userns, struct inode *olddir,
1081               struct dentry *old, struct inode *newdir,
1082               struct dentry *new, unsigned int flags)
1083 {
1084     int err;
1085     struct dentry *old_upperdir;
1086     struct dentry *new_upperdir;
1087     struct dentry *olddentry;
1088     struct dentry *newdentry;
1089     struct dentry *trap;
1090     bool old_opaque;
1091     bool new_opaque;
1092     bool cleanup_whiteout = false;
1093     bool update_nlink = false;
1094     bool overwrite = !(flags & RENAME_EXCHANGE);
1095     bool is_dir = d_is_dir(old);
1096     bool new_is_dir = d_is_dir(new);
1097     bool samedir = olddir == newdir;
1098     struct dentry *opaquedir = NULL;
1099     const struct cred *old_cred = NULL;
1100     struct ovl_fs *ofs = OVL_FS(old->d_sb);
1101     LIST_HEAD(list);
1102 
1103     err = -EINVAL;
1104     if (flags & ~(RENAME_EXCHANGE | RENAME_NOREPLACE))
1105         goto out;
1106 
1107     flags &= ~RENAME_NOREPLACE;
1108 
1109     /* Don't copy up directory trees */
1110     err = -EXDEV;
1111     if (!ovl_can_move(old))
1112         goto out;
1113     if (!overwrite && !ovl_can_move(new))
1114         goto out;
1115 
1116     if (overwrite && new_is_dir && !ovl_pure_upper(new)) {
1117         err = ovl_check_empty_dir(new, &list);
1118         if (err)
1119             goto out;
1120     }
1121 
1122     if (overwrite) {
1123         if (ovl_lower_positive(old)) {
1124             if (!ovl_dentry_is_whiteout(new)) {
1125                 /* Whiteout source */
1126                 flags |= RENAME_WHITEOUT;
1127             } else {
1128                 /* Switch whiteouts */
1129                 flags |= RENAME_EXCHANGE;
1130             }
1131         } else if (is_dir && ovl_dentry_is_whiteout(new)) {
1132             flags |= RENAME_EXCHANGE;
1133             cleanup_whiteout = true;
1134         }
1135     }
1136 
1137     err = ovl_want_write(old);
1138     if (err)
1139         goto out;
1140 
1141     err = ovl_copy_up(old);
1142     if (err)
1143         goto out_drop_write;
1144 
1145     err = ovl_copy_up(new->d_parent);
1146     if (err)
1147         goto out_drop_write;
1148     if (!overwrite) {
1149         err = ovl_copy_up(new);
1150         if (err)
1151             goto out_drop_write;
1152     } else if (d_inode(new)) {
1153         err = ovl_nlink_start(new);
1154         if (err)
1155             goto out_drop_write;
1156 
1157         update_nlink = true;
1158     }
1159 
1160     old_cred = ovl_override_creds(old->d_sb);
1161 
1162     if (!list_empty(&list)) {
1163         opaquedir = ovl_clear_empty(new, &list);
1164         err = PTR_ERR(opaquedir);
1165         if (IS_ERR(opaquedir)) {
1166             opaquedir = NULL;
1167             goto out_revert_creds;
1168         }
1169     }
1170 
1171     old_upperdir = ovl_dentry_upper(old->d_parent);
1172     new_upperdir = ovl_dentry_upper(new->d_parent);
1173 
1174     if (!samedir) {
1175         /*
1176          * When moving a merge dir or non-dir with copy up origin into
1177          * a new parent, we are marking the new parent dir "impure".
1178          * When ovl_iterate() iterates an "impure" upper dir, it will
1179          * lookup the origin inodes of the entries to fill d_ino.
1180          */
1181         if (ovl_type_origin(old)) {
1182             err = ovl_set_impure(new->d_parent, new_upperdir);
1183             if (err)
1184                 goto out_revert_creds;
1185         }
1186         if (!overwrite && ovl_type_origin(new)) {
1187             err = ovl_set_impure(old->d_parent, old_upperdir);
1188             if (err)
1189                 goto out_revert_creds;
1190         }
1191     }
1192 
1193     trap = lock_rename(new_upperdir, old_upperdir);
1194 
1195     olddentry = ovl_lookup_upper(ofs, old->d_name.name, old_upperdir,
1196                      old->d_name.len);
1197     err = PTR_ERR(olddentry);
1198     if (IS_ERR(olddentry))
1199         goto out_unlock;
1200 
1201     err = -ESTALE;
1202     if (!ovl_matches_upper(old, olddentry))
1203         goto out_dput_old;
1204 
1205     newdentry = ovl_lookup_upper(ofs, new->d_name.name, new_upperdir,
1206                      new->d_name.len);
1207     err = PTR_ERR(newdentry);
1208     if (IS_ERR(newdentry))
1209         goto out_dput_old;
1210 
1211     old_opaque = ovl_dentry_is_opaque(old);
1212     new_opaque = ovl_dentry_is_opaque(new);
1213 
1214     err = -ESTALE;
1215     if (d_inode(new) && ovl_dentry_upper(new)) {
1216         if (opaquedir) {
1217             if (newdentry != opaquedir)
1218                 goto out_dput;
1219         } else {
1220             if (!ovl_matches_upper(new, newdentry))
1221                 goto out_dput;
1222         }
1223     } else {
1224         if (!d_is_negative(newdentry)) {
1225             if (!new_opaque || !ovl_is_whiteout(newdentry))
1226                 goto out_dput;
1227         } else {
1228             if (flags & RENAME_EXCHANGE)
1229                 goto out_dput;
1230         }
1231     }
1232 
1233     if (olddentry == trap)
1234         goto out_dput;
1235     if (newdentry == trap)
1236         goto out_dput;
1237 
1238     if (olddentry->d_inode == newdentry->d_inode)
1239         goto out_dput;
1240 
1241     err = 0;
1242     if (ovl_type_merge_or_lower(old))
1243         err = ovl_set_redirect(old, samedir);
1244     else if (is_dir && !old_opaque && ovl_type_merge(new->d_parent))
1245         err = ovl_set_opaque_xerr(old, olddentry, -EXDEV);
1246     if (err)
1247         goto out_dput;
1248 
1249     if (!overwrite && ovl_type_merge_or_lower(new))
1250         err = ovl_set_redirect(new, samedir);
1251     else if (!overwrite && new_is_dir && !new_opaque &&
1252          ovl_type_merge(old->d_parent))
1253         err = ovl_set_opaque_xerr(new, newdentry, -EXDEV);
1254     if (err)
1255         goto out_dput;
1256 
1257     err = ovl_do_rename(ofs, old_upperdir->d_inode, olddentry,
1258                 new_upperdir->d_inode, newdentry, flags);
1259     if (err)
1260         goto out_dput;
1261 
1262     if (cleanup_whiteout)
1263         ovl_cleanup(ofs, old_upperdir->d_inode, newdentry);
1264 
1265     if (overwrite && d_inode(new)) {
1266         if (new_is_dir)
1267             clear_nlink(d_inode(new));
1268         else
1269             ovl_drop_nlink(new);
1270     }
1271 
1272     ovl_dir_modified(old->d_parent, ovl_type_origin(old) ||
1273              (!overwrite && ovl_type_origin(new)));
1274     ovl_dir_modified(new->d_parent, ovl_type_origin(old) ||
1275              (d_inode(new) && ovl_type_origin(new)));
1276 
1277     /* copy ctime: */
1278     ovl_copyattr(d_inode(old));
1279     if (d_inode(new) && ovl_dentry_upper(new))
1280         ovl_copyattr(d_inode(new));
1281 
1282 out_dput:
1283     dput(newdentry);
1284 out_dput_old:
1285     dput(olddentry);
1286 out_unlock:
1287     unlock_rename(new_upperdir, old_upperdir);
1288 out_revert_creds:
1289     revert_creds(old_cred);
1290     if (update_nlink)
1291         ovl_nlink_end(new);
1292 out_drop_write:
1293     ovl_drop_write(old);
1294 out:
1295     dput(opaquedir);
1296     ovl_cache_free(&list);
1297     return err;
1298 }
1299 
1300 const struct inode_operations ovl_dir_inode_operations = {
1301     .lookup     = ovl_lookup,
1302     .mkdir      = ovl_mkdir,
1303     .symlink    = ovl_symlink,
1304     .unlink     = ovl_unlink,
1305     .rmdir      = ovl_rmdir,
1306     .rename     = ovl_rename,
1307     .link       = ovl_link,
1308     .setattr    = ovl_setattr,
1309     .create     = ovl_create,
1310     .mknod      = ovl_mknod,
1311     .permission = ovl_permission,
1312     .getattr    = ovl_getattr,
1313     .listxattr  = ovl_listxattr,
1314     .get_acl    = ovl_get_acl,
1315     .update_time    = ovl_update_time,
1316     .fileattr_get   = ovl_fileattr_get,
1317     .fileattr_set   = ovl_fileattr_set,
1318 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!