+#include <linux/module.h>

+#include <linux/fdtable.h>

+#include <linux/ratelimit.h>

+static bool __read_mostly ovl_check_copy_up;

+module_param_named(check_copy_up, ovl_check_copy_up, bool,

+ S_IWUSR | S_IRUGO);

+MODULE_PARM_DESC(ovl_check_copy_up,

+ "Warn on copy-up when causing process also has a R/O fd open");

+

+static int ovl_check_fd(const void *data, struct file *f, unsigned int fd)

+{

+ const struct dentry *dentry = data;

+

+ if (f->f_inode == d_inode(dentry))

+ pr_warn_ratelimited("overlayfs: Warning: Copying up %pD, but open R/O on fd %u which will cease to be coherent [pid=%d %s]\n",

+ f, fd, current->pid, current->comm);

+ return 0;

+}

+

+/*

+ * Check the fds open by this process and warn if something like the following

+ * scenario is about to occur:

+ *

+ * fd1 = open("foo", O_RDONLY);

+ * fd2 = open("foo", O_RDWR);

+ */

+static void ovl_do_check_copy_up(struct dentry *dentry)

+{

+ if (ovl_check_copy_up)

+ iterate_fd(current->files, 0, ovl_check_fd, dentry);

+}

+

+

+ ovl_do_check_copy_up(lowerpath->dentry);

+

+ old_cred = ovl_override_creds(dentry->d_sb);

+ old_cred = ovl_override_creds(dentry->d_sb);

+

+ if (override_cred) {

+ override_cred->fsuid = old_cred->fsuid;

+ override_cred->fsgid = old_cred->fsgid;

+ put_cred(override_creds(override_cred));

+ put_cred(override_cred);

+

+ err = ovl_create_over_whiteout(dentry, inode, &stat,

+ link, hardlink);

+ }

+ struct dentry *upper;

+ upper = lookup_one_len(dentry->d_name.name, upperdir,

+ dentry->d_name.len);

+ err = PTR_ERR(upper);

+ if (IS_ERR(upper))

+ goto out_unlock;

+

+ if (upper == ovl_dentry_upper(dentry)) {

+ dput(upper);

+out_unlock:

+ const struct cred *old_cred = ovl_override_creds(dentry->d_sb);

+ if (old_opaque || new_opaque)

+ old_cred = ovl_override_creds(old->d_sb);

+

+ olddentry = lookup_one_len(old->d_name.name, old_upperdir,

+ old->d_name.len);

+ err = PTR_ERR(olddentry);

+ if (IS_ERR(olddentry))

+ goto out_unlock;

+

+ err = -ESTALE;

+ if (olddentry != ovl_dentry_upper(old))

+ goto out_dput_old;

+

+ newdentry = lookup_one_len(new->d_name.name, new_upperdir,

+ new->d_name.len);

+ err = PTR_ERR(newdentry);

+ if (IS_ERR(newdentry))

+ goto out_dput_old;

+

+ err = -ESTALE;

+ if (ovl_dentry_upper(new)) {

+ if (newdentry != opaquedir)

+ goto out_dput;

+ if (newdentry != ovl_dentry_upper(new))

+ goto out_dput;

+ if (!d_is_negative(newdentry) &&

+ (!new_opaque || !ovl_is_whiteout(newdentry)))

+ goto out_dput;

+out_dput_old:

+ dput(olddentry);

+ if (old_opaque || new_opaque)

+int ovl_setxattr(struct dentry *dentry, struct inode *inode,

+ const char *name, const void *value,

+ size_t size, int flags)

+ssize_t ovl_getxattr(struct dentry *dentry, struct inode *inode,

+ const char *name, void *value, size_t size)

+ struct dentry *realdentry = ovl_dentry_real(dentry);

+ if (ovl_is_private_xattr(name))

+ return vfs_getxattr(realdentry, name, value, size);

+ struct dentry *realdentry = ovl_dentry_real(dentry);

+ res = vfs_listxattr(realdentry, list, size);

+ if (ovl_is_private_xattr(name))

+const struct cred *ovl_override_creds(struct super_block *sb);

+int ovl_check_d_type_supported(struct path *realpath);

+int ovl_setxattr(struct dentry *dentry, struct inode *inode,

+ const char *name, const void *value,

+ size_t size, int flags);

+ssize_t ovl_getxattr(struct dentry *dentry, struct inode *inode,

+ const char *name, void *value, size_t size);

+ struct dentry *dentry;

+ bool is_lowest;

+ bool d_type_supported;

+static int ovl_fill_lowest(struct ovl_readdir_data *rdd,

+ const char *name, int namelen,

+ loff_t offset, u64 ino, unsigned int d_type)

+ if (!rdd->is_lowest)

+ return ovl_fill_lowest(rdd, name, namelen, offset, ino, d_type);

+ old_cred = ovl_override_creds(rdd->dentry->d_sb);

+ err = down_write_killable(&dir->d_inode->i_rwsem);

+ .dentry = dentry,

+ .is_lowest = false,

+ rdd.is_lowest = true;

+

+static int ovl_check_d_type(struct dir_context *ctx, const char *name,

+ int namelen, loff_t offset, u64 ino,

+ unsigned int d_type)

+{

+ struct ovl_readdir_data *rdd =

+ container_of(ctx, struct ovl_readdir_data, ctx);

+

+ /* Even if d_type is not supported, DT_DIR is returned for . and .. */

+ if (!strncmp(name, ".", namelen) || !strncmp(name, "..", namelen))

+ return 0;

+

+ if (d_type != DT_UNKNOWN)

+ rdd->d_type_supported = true;

+

+ return 0;

+}

+

+/*

+ * Returns 1 if d_type is supported, 0 not supported/unknown. Negative values

+ * if error is encountered.

+ */

+int ovl_check_d_type_supported(struct path *realpath)

+{

+ int err;

+ struct ovl_readdir_data rdd = {

+ .ctx.actor = ovl_check_d_type,

+ .d_type_supported = false,

+ };

+

+ err = ovl_dir_read(realpath, &rdd);

+ if (err)

+ return err;

+

+ return rdd.d_type_supported;

+}

+ /* creds of process who forced instantiation of super block */

+ const struct cred *creator_cred;

+const struct cred *ovl_override_creds(struct super_block *sb)

+{

+ struct ovl_fs *ofs = sb->s_fs_info;

+

+ return override_creds(ofs->creator_cred);

+}

+

+ res = inode->i_op->getxattr(dentry, inode, OVL_XATTR_OPAQUE, &val, 1);

+static struct dentry *ovl_d_real(struct dentry *dentry, struct inode *inode)

+{

+ struct dentry *real;

+

+ if (d_is_dir(dentry)) {

+ if (!inode || inode == d_inode(dentry))

+ return dentry;

+ goto bug;

+ }

+

+ real = ovl_dentry_upper(dentry);

+ if (real && (!inode || inode == d_inode(real)))

+ return real;

+

+ real = ovl_dentry_lower(dentry);

+ if (!real)

+ goto bug;

+

+ if (!inode || inode == d_inode(real))

+ return real;

+

+ /* Handle recursion */

+ if (real->d_flags & DCACHE_OP_REAL)

+ return real->d_op->d_real(real, inode);

+

+bug:

+ WARN(1, "ovl_d_real(%pd4, %s:%lu\n): real dentry not found\n", dentry,

+ inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0);

+ return dentry;

+}

+

+ .d_real = ovl_d_real,

+ .d_real = ovl_d_real,

+ dentry = lookup_hash(name, dir);

+ put_cred(ufs->creator_cred);

+ if (!silent)

+ pr_err("overlayfs: missing 'lowerdir'\n");

+

+ /*

+ * Upper should support d_type, else whiteouts are visible.

+ * Given workdir and upper are on same fs, we can do

+ * iterate_dir() on workdir. This check requires successful

+ * creation of workdir in previous step.

+ */

+ if (ufs->workdir) {

+ err = ovl_check_d_type_supported(&workpath);

+ if (err < 0)

+ goto out_put_workdir;

+

+ if (!err) {

+ pr_err("overlayfs: upper fs needs to support d_type.\n");

+ err = -EINVAL;

+ goto out_put_workdir;

+ }

+ }

+ ufs->creator_cred = prepare_creds();

+ if (!ufs->creator_cred)

+ goto out_put_lower_mnt;

+

+ goto out_put_cred;

+out_put_cred:

+ put_cred(ufs->creator_cred);